Added/fixed some documentation reported by winapi_check.

dlls/avifil32/avifile.c

@@ -99,6 +99,9 @@ typedef struct IAVIStreamImpl {
 	    LPVOID	lpPrevFormat; /* pointer to decompressed info later */
 } IAVIStreamImpl;
 
+/***********************************************************************
+ *		AVIFileInit
+ */
 void WINAPI
 AVIFileInit(void) {
 	FIXME("(),stub!\n");
@@ -202,6 +205,9 @@ static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG
 	return E_FAIL;
 }
 
+/***********************************************************************
+ *		AVIFileOpenA
+ */
 HRESULT WINAPI AVIFileOpenA(
 	PAVIFILE * ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler
 ) {
@@ -267,8 +273,8 @@ static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID f
 	return E_FAIL;
 }
 
-/*****************************************************************************
+/***********************************************************************
- *						[IAVIStream::SetFormat]
+ *		IAVIStream::SetFormat
  */
 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
 	IAVIStreamImpl	*as = (IAVIStreamImpl*)iface;
@@ -357,6 +363,9 @@ static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,
 	return E_FAIL;
 }
 
+/***********************************************************************
+ *		AVIFileCreateStreamA
+ */
 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE iface,PAVISTREAM *ppavi,AVISTREAMINFOA * psi) {
 	AVISTREAMINFOW	psiw;
 	
@@ -366,15 +375,24 @@ HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE iface,PAVISTREAM *ppavi,AVISTREAMIN
 	return IAVIFile_CreateStream(iface,ppavi,&psiw);
 }
 
+/***********************************************************************
+ *		AVIFileCreateStreamW
+ */
 HRESULT WINAPI AVIFileCreateStreamW(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi) {
 	return IAVIFile_CreateStream(iface,avis,asi);
 }
 
 
+/***********************************************************************
+ *		AVIFileGetStream
+ */
 HRESULT WINAPI AVIFileGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam) {
 	return IAVIFile_GetStream(iface,avis,fccType,lParam);
 }
 
+/***********************************************************************
+ *		AVIFileInfoA
+ */
 HRESULT WINAPI AVIFileInfoA(PAVIFILE iface,LPAVIFILEINFOA afi,LONG size) {
 	AVIFILEINFOW	afiw;
 	HRESULT		hres;
@@ -387,11 +405,17 @@ HRESULT WINAPI AVIFileInfoA(PAVIFILE iface,LPAVIFILEINFOA afi,LONG size) {
 	return hres;
 }
 
+/***********************************************************************
+ *		AVIStreamInfoW
+ */
 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM iface,AVISTREAMINFOW *asi,LONG
  size) {
  	return IAVIFile_Info(iface,asi,size);
 }
 
+/***********************************************************************
+ *		AVIStreamInfoA
+ */
 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG
  size) {
  	AVISTREAMINFOW	asiw;
@@ -405,10 +429,16 @@ HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG
 	return hres;
 }
 
+/***********************************************************************
+ *		AVIFileInfoW
+ */
 HRESULT WINAPI AVIFileInfoW(PAVIFILE iface,LPAVIFILEINFOW afi,LONG size) {
 	return IAVIFile_Info(iface,afi,size);
 }
 
+/***********************************************************************
+ *		AVIMakeCompressedStream
+ */
 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler) {
 	char			fcc[5];
 	IAVIStreamImpl	*as;
@@ -452,30 +482,51 @@ HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsS
 	return S_OK;
 }
 
+/***********************************************************************
+ *		AVIStreamSetFormat
+ */
 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG formatsize) {
 	return IAVIStream_SetFormat(iface,pos,format,formatsize);
 }
 
+/***********************************************************************
+ *		AVIStreamReadFormat
+ */
 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG *formatsize) {
 	return IAVIStream_ReadFormat(iface,pos,format,formatsize);
 }
 
+/***********************************************************************
+ *		AVIStreamWrite(
+ */
 HRESULT WINAPI AVIStreamWrite(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
 	return IAVIStream_Write(iface,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
 }
 
+/***********************************************************************
+ *		AVIStreamRead
+ */
 HRESULT WINAPI AVIStreamRead(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
 	return IAVIStream_Read(iface,start,samples,buffer,buffersize,bytesread,samplesread);
 }
 
+/***********************************************************************
+ *		AVIStreamWriteData
+ */
 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG size) {
 	return IAVIStream_WriteData(iface,fcc,lp,size);
 }
 
+/***********************************************************************
+ *		AVIStreamReadData
+ */
 HRESULT WINAPI AVIStreamReadData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG *lpread) {
 	return IAVIStream_ReadData(iface,fcc,lp,lpread);
 }
 
+/***********************************************************************
+ *		AVIStreamStart
+ */
 LONG WINAPI AVIStreamStart(PAVISTREAM iface) {
 	AVISTREAMINFOW	si;
 
@@ -483,6 +534,9 @@ LONG WINAPI AVIStreamStart(PAVISTREAM iface) {
 	return si.dwStart;
 }
 
+/***********************************************************************
+ *		AVIStreamLength
+ */
 LONG WINAPI AVIStreamLength(PAVISTREAM iface) {
 	AVISTREAMINFOW	si;
 	HRESULT			ret;
@@ -493,28 +547,46 @@ LONG WINAPI AVIStreamLength(PAVISTREAM iface) {
 	return si.dwLength;
 }
 
+/***********************************************************************
+ *		AVIStreamRelease
+ */
 ULONG WINAPI AVIStreamRelease(PAVISTREAM iface) {
 	return IAVIStream_Release(iface);
 }
 
+/***********************************************************************
+ *		AVIStreamGetFrameOpen
+ */
 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM iface,LPBITMAPINFOHEADER bmi) {
 	FIXME("(%p)->(%p),stub!\n",iface,bmi);
 	return NULL;
 }
 
+/***********************************************************************
+ *		AVIStreamGetFrame
+ */
 LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg,LONG pos) {
 	return IGetFrame_GetFrame(pg,pos);
 }
 
+/***********************************************************************
+ *		AVIStreamGetFrameClose
+ */
 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg) {
 	if (pg) IGetFrame_Release(pg);
 	return 0;
 }
 
+/***********************************************************************
+ *		AVIFileRelease
+ */
 ULONG WINAPI AVIFileRelease(PAVIFILE iface) {
 	return IAVIFile_Release(iface);
 }
 
+/***********************************************************************
+ *		AVIFileExit
+ */
 void WINAPI AVIFileExit(void) {
 	FIXME("(), stub.\n");
 }

dlls/comctl32/comctl32undoc.c

@@ -609,6 +609,9 @@ FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
     return 0;
 }
 
+/**************************************************************************
+ *                  CreateMRUListLazyA [COMCTL32.157]
+ */
 HANDLE WINAPI
 CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
 {

dlls/comctl32/draglist.c

@@ -20,7 +20,9 @@ DEFAULT_DEBUG_CHANNEL(commctrl)
 
 static DWORD dwLastScrollTime = 0;
 
-
+/***********************************************************************
+ *		MakeDragList
+ */
 BOOL WINAPI MakeDragList (HWND hwndLB)
 {
     FIXME("(0x%x)\n", hwndLB);
@@ -29,7 +31,9 @@ BOOL WINAPI MakeDragList (HWND hwndLB)
     return FALSE;
 }
 
-
+/***********************************************************************
+ *		DrawInsert
+ */
 VOID WINAPI DrawInsert (HWND hwndParent, HWND hwndLB, INT nItem)
 {
     FIXME("(0x%x 0x%x %d)\n", hwndParent, hwndLB, nItem);
@@ -37,7 +41,9 @@ VOID WINAPI DrawInsert (HWND hwndParent, HWND hwndLB, INT nItem)
 
 }
 
-
+/***********************************************************************
+ *		LBItemFromPt
+ */
 INT WINAPI LBItemFromPt (HWND hwndLB, POINT pt, BOOL bAutoScroll)
 {
     RECT rcClient;

dlls/comctl32/flatsb.c

@@ -26,6 +26,9 @@ DEFAULT_DEBUG_CHANNEL(commctrl)
 #define FlatSB_GetInfoPtr(hwnd) ((FLATSB_INFO*)GetWindowLongA (hwnd, 0))
 
 
+/***********************************************************************
+ *		FlatSB_EnableScrollBar
+ */
 BOOL WINAPI 
 FlatSB_EnableScrollBar(HWND hwnd, INT dummy, UINT dummy2)
 {
@@ -33,6 +36,9 @@ FlatSB_EnableScrollBar(HWND hwnd, INT dummy, UINT dummy2)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_ShowScrollBar
+ */
 BOOL WINAPI 
 FlatSB_ShowScrollBar(HWND hwnd, INT code, BOOL flag)
 {
@@ -40,6 +46,9 @@ FlatSB_ShowScrollBar(HWND hwnd, INT code, BOOL flag)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_GetScrollRange
+ */
 BOOL WINAPI 
 FlatSB_GetScrollRange(HWND hwnd, INT code, LPINT min, LPINT max)
 {
@@ -47,6 +56,9 @@ FlatSB_GetScrollRange(HWND hwnd, INT code, LPINT min, LPINT max)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_GetScrollInfo
+ */
 BOOL WINAPI 
 FlatSB_GetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info)
 {
@@ -54,6 +66,9 @@ FlatSB_GetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_GetScrollPos
+ */
 INT WINAPI 
 FlatSB_GetScrollPos(HWND hwnd, INT code)
 {
@@ -61,6 +76,9 @@ FlatSB_GetScrollPos(HWND hwnd, INT code)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_GetScrollProp
+ */
 BOOL WINAPI 
 FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
 {
@@ -68,7 +86,9 @@ FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
     return 0;
 }
 
-
+/***********************************************************************
+ *		FlatSB_SetScrollPos
+ */
 INT WINAPI 
 FlatSB_SetScrollPos(HWND hwnd, INT code, INT pos, BOOL fRedraw)
 {
@@ -76,6 +96,9 @@ FlatSB_SetScrollPos(HWND hwnd, INT code, INT pos, BOOL fRedraw)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_SetScrollInfo
+ */
 INT WINAPI 
 FlatSB_SetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info, BOOL fRedraw)
 {
@@ -83,6 +106,9 @@ FlatSB_SetScrollInfo(HWND hwnd, INT code, LPSCROLLINFO info, BOOL fRedraw)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_SetScrollRange
+ */
 INT WINAPI 
 FlatSB_SetScrollRange(HWND hwnd, INT code, INT min, INT max, BOOL fRedraw)
 {
@@ -90,6 +116,9 @@ FlatSB_SetScrollRange(HWND hwnd, INT code, INT min, INT max, BOOL fRedraw)
     return 0;
 }
 
+/***********************************************************************
+ *		FlatSB_SetScrollProp
+ */
 BOOL WINAPI 
 FlatSB_SetScrollProp(HWND hwnd, UINT index, INT newValue, BOOL flag)
 {
@@ -97,13 +126,18 @@ FlatSB_SetScrollProp(HWND hwnd, UINT index, INT newValue, BOOL flag)
     return 0;
 }
 
-
+/***********************************************************************
+ *		InitializeFlatSB
+ */
 BOOL WINAPI InitializeFlatSB(HWND hwnd)
 {
     FIXME("stub\n");
     return 0;
 }
 
+/***********************************************************************
+ *		UninitializeFlatSB
+ */
 HRESULT WINAPI UninitializeFlatSB(HWND hwnd)
 {
     FIXME("stub\n");

dlls/commdlg/finddlg32.c

@@ -464,7 +464,7 @@ HWND WINAPI ReplaceTextA(
 }
 
 /***********************************************************************
- *	FinfText32W 				[COMDLG32.7]
+ *	FindText32W 				[COMDLG32.7]
  *	RETURNS
  *		Window handle to created dialog: Succes
  *		NULL: Failure

dlls/ddraw/ddraw_main.c

@@ -5723,52 +5723,79 @@ typedef void *LPDDENUMCALLBACKEXA;
 typedef void *LPDDENUMCALLBACKEXW;
 typedef void *LPDDENUMCALLBACKW;
 
+/***********************************************************************
+ *		DSoundHelp
+ */
 HRESULT WINAPI DSoundHelp(DWORD x, DWORD y, DWORD z) 
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawCreate
+ */
 HRESULT WINAPI DirectDrawCreate(
   LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) 
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawCreateClipper
+ */
 HRESULT WINAPI DirectDrawCreateClipper(
   DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, LPUNKNOWN pUnkOuter)
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawEnumerateA
+ */
 HRESULT WINAPI DirectDrawEnumerateA(
   LPDDENUMCALLBACKA lpCallback, LPVOID lpContext) 
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawEnumerateExA
+ */
 HRESULT WINAPI DirectDrawEnumerateExA(
   LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawEnumerateExW
+ */
 HRESULT WINAPI DirectDrawEnumerateExW(
   LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DirectDrawEnumerateW
+ */
 HRESULT WINAPI DirectDrawEnumerateW(
   LPDDENUMCALLBACKW lpCallback, LPVOID lpContext) 
 {
   return DD_OK;
 }
 
+/***********************************************************************
+ *		DDRAW_DllGetClassObject
+ */
 DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 {
     return CLASS_E_CLASSNOTAVAILABLE;
 }
 
+/***********************************************************************
+ *		DDRAW_DllCanUnloadNow
+ */
 DWORD WINAPI DDRAW_DllCanUnloadNow(void)
 {
     return DD_OK;

dlls/dplayx/dpclassfactory.c

@@ -79,7 +79,7 @@ static IClassFactoryImpl DP_and_DPL_CF = {&DP_and_DPL_Vtbl, 1 };
 
 
 /*******************************************************************************
- * DllGetClassObject [DPLAYX.?]
+ * DP_and_DPL_DllGetClassObject [DPLAYX.?]
  * Retrieves DP or DPL class object from a DLL object
  *
  * NOTES

dlls/dsound/dsound_main.c

@@ -201,7 +201,9 @@ static void DSOUND_CloseAudio(void);
 
 #endif
 
-
+/*******************************************************************************
+ *		DirectSoundEnumerateA
+ */
 HRESULT WINAPI DirectSoundEnumerateA(
 	LPDSENUMCALLBACKA enumcb,
 	LPVOID context)
@@ -2259,6 +2261,9 @@ static DWORD WINAPI DSOUND_thread(LPVOID arg)
 
 #endif /* HAVE_OSS */
 
+/*******************************************************************************
+ *		DirectSoundCreate
+ */
 HRESULT WINAPI DirectSoundCreate(REFGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter )
 {
 	IDirectSoundImpl** ippDS=(IDirectSoundImpl**)ppDS;

dlls/icmp/icmp_main.c

@@ -157,6 +157,9 @@ static int in_cksum(u_short *addr, int len)
  * Exported Routines.
  */
 
+/***********************************************************************
+ *		IcmpCreateFile
+ */
 HANDLE WINAPI IcmpCreateFile(VOID)
 {
     icmp_t* icp;
@@ -194,6 +197,9 @@ BOOL WINAPI IcmpCloseHandle(HANDLE  IcmpHandle)
 }
 
 
+/***********************************************************************
+ *		IcmpSendEcho
+ */
 DWORD WINAPI IcmpSendEcho(
     HANDLE                   IcmpHandle,
     IPAddr                   DestinationAddress,

dlls/mpr/mpr_main.c

@@ -44,7 +44,7 @@ BOOL WINAPI MPR_Free( LPVOID lpMem )
 }
 
 /*****************************************************************
- *  [MPR.25]
+ *  _MPR_25  [MPR.25]
  */
 BOOL WINAPI _MPR_25( LPBYTE lpMem, INT len )
 {

dlls/msvideo/msvideo_main.c

@@ -15,7 +15,7 @@
 
 DEFAULT_DEBUG_CHANNEL(msvideo)
 
-/****************************************************************************
+/***********************************************************************
  *		VideoForWindowsVersion		[MSVFW.2][MSVIDEO.2]
  * Returns the version in major.minor form.
  * In Windows95 this returns 0x040003b6 (4.950)
@@ -25,7 +25,7 @@ VideoForWindowsVersion(void) {
 	return 0x040003B6; /* 4.950 */
 }
 
-/****************************************************************************
+/***********************************************************************
  *		VideoCapDriverDescAndVer	[MSVIDEO.22]
  */
 DWORD WINAPI
@@ -36,7 +36,7 @@ VideoCapDriverDescAndVer(WORD nr,LPVOID buf1,WORD buf1len,LPVOID buf2,WORD buf2l
 
 /* system.ini: [drivers] */
 
-/**************************************************************************
+/***********************************************************************
  *		ICInfo				[MSVFW.33]
  * Get information about an installable compressor. Return TRUE if there
  * is one.
@@ -70,7 +70,7 @@ ICInfo(
 	return FALSE;
 }
 
-/**************************************************************************
+/***********************************************************************
  *		ICOpen				[MSVFW.37]
  * Opens an installable compressor. Return special handle.
  */
@@ -110,6 +110,10 @@ ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
 	whic->private	= ICSendMessage((HIC)whic,DRV_OPEN,0,(LPARAM)&icopen);
 	return (HIC)whic;
 }
+
+/***********************************************************************
+ *		ICOpenFunction			[MSVFW.38]
+ */
 HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
 FARPROC lpfnHandler) {
 	char		type[5],handler[5];
@@ -128,6 +132,9 @@ FARPROC lpfnHandler) {
 }
 
 
+/***********************************************************************
+ *		ICGetInfo			[MSVFW.30]
+ */
 LRESULT WINAPI
 ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
 	LRESULT		ret;
@@ -138,6 +145,9 @@ ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
 	return ret;
 }
 
+/***********************************************************************
+ *		ICLocate			[MSVFW.35]
+ */
 HIC  VFWAPI
 ICLocate(
 	DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
@@ -182,6 +192,9 @@ ICLocate(
 	return 0;
 }
 
+/***********************************************************************
+ *		ICGetDisplayFormat			[MSVFW.29]
+ */
 HIC VFWAPI ICGetDisplayFormat(
 	HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
 	INT depth,INT dx,INT dy
@@ -225,6 +238,9 @@ errout:
 	return 0;
 }
 
+/***********************************************************************
+ *		ICCompress			[MSVFW.23]
+ */
 DWORD VFWAPIV
 ICCompress(
 	HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
@@ -251,6 +267,9 @@ ICCompress(
 	return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
 }
 
+/***********************************************************************
+ *		ICDecompress			[MSVFW.26]
+ */
 DWORD VFWAPIV 
 ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits) {
 	ICDECOMPRESS	icd;
@@ -265,6 +284,9 @@ ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,L
 	return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
 }
 
+/***********************************************************************
+ *		ICSendMessage			[MSVFW.40]
+ */
 LRESULT VFWAPI
 ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
 	LRESULT		ret;
@@ -327,6 +349,9 @@ ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
 	return ret;
 }
 
+/***********************************************************************
+ *		ICDrawBegin		[MSVFW.28]
+ */
 DWORD	VFWAPIV	ICDrawBegin(
         HIC			hic,
         DWORD			dwFlags,/* flags */
@@ -364,6 +389,9 @@ DWORD	VFWAPIV	ICDrawBegin(
 	return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
 }
 
+/***********************************************************************
+ *		ICDraw			[MSVFW.27]
+ */
 DWORD VFWAPIV ICDraw(
 	HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
 	LONG lTime
@@ -378,6 +406,9 @@ DWORD VFWAPIV ICDraw(
 	return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
 }
 
+/***********************************************************************
+ *		ICClose			[MSVFW.22]
+ */
 LRESULT WINAPI ICClose(HIC hic) {
 	WINE_HIC	*whic = (WINE_HIC*)hic;
 	TRACE("(%d).\n",hic);
@@ -387,18 +418,27 @@ LRESULT WINAPI ICClose(HIC hic) {
 	return 0;
 }
 
+/***********************************************************************
+ *		DrawDibOpen		[MSVFW.10]
+ */
 HANDLE /* HDRAWDIB */ WINAPI
 DrawDibOpen( void ) {
 	FIXME("stub!\n");
 	return 0xdead;
 }
 
+/***********************************************************************
+ *		DrawDibClose		[MSVFW.5]
+ */
 BOOL WINAPI
 DrawDibClose( HANDLE /*HDRAWDIB*/ hDib ) {
        FIXME("stub!\n");
        return TRUE;
 }
 
+/***********************************************************************
+ *		DrawDibBegin		[MSVFW.3]
+ */
 BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
                                     HDC      hdc,
                                     INT      dxDst,
@@ -414,28 +454,44 @@ BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
 }
 
 
+/***********************************************************************
+ *		DrawDibSetPalette	[MSVFW.13]
+ */
 BOOL VFWAPI
 DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal) {
 	FIXME("(%d,%d),stub!\n",hdd,hpal);
 	return TRUE;
 }
 
+/***********************************************************************
+ *		DrawDibRealize		[MSVFW.12]
+ */
 UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground) {
 	FIXME("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground);
 	return 0;
 }
 
-
+/***********************************************************************
+ *		MCIWndCreate		[MSVFW.44]
+ */
 HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
                       DWORD dwStyle,LPVOID szFile)
 {	FIXME("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile);
 	return 0;
 }
+
+/***********************************************************************
+ *		MCIWndCreateA		[MSVFW.45]
+ */
 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
                       DWORD dwStyle,LPCSTR szFile)
 {	FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
 	return 0;
 }
+
+/***********************************************************************
+ *		MCIWndCreateW		[MSVFW.46]
+ */
 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
                       DWORD dwStyle,LPCWSTR szFile)
 {	FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));

dlls/ntdll/nt.c

@@ -501,7 +501,7 @@ NTSTATUS WINAPI NtQueryPerformanceCounter(
 }
 
 /******************************************************************************
- *  NtCreateMailSlotFile	[NTDLL] 
+ *  NtCreateMailslotFile	[NTDLL] 
  */
 NTSTATUS WINAPI NtCreateMailslotFile(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6,DWORD x7,DWORD x8) 
 {

dlls/ntdll/rtl.c

@@ -392,7 +392,7 @@ INT WINAPI RtlExtendedLargeIntegerDivide(
 }
 
 /******************************************************************************
- * RtlExtendedLargeIntegerMultiply [NTDLL.359]
+ * RtlExtendedIntegerMultiply [NTDLL.359]
  * Note: This even works, since gcc returns 64bit values in eax/edx just like
  * the caller expects. However... The relay code won't grok this I think.
  */

dlls/ntdll/sec.c

@@ -647,6 +647,9 @@ RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
 	return TRUE;
 }
 
+/******************************************************************************
+ *  NtAccessCheck		[NTDLL]
+ */
 NTSTATUS WINAPI 
 NtAccessCheck(
 	IN PSECURITY_DESCRIPTOR SecurityDescriptor,
@@ -665,6 +668,9 @@ NtAccessCheck(
 	return STATUS_SUCCESS;
 }
 
+/******************************************************************************
+ *  NtSetSecurityObject		[NTDLL]
+ */
 NTSTATUS WINAPI
 NtSetSecurityObject(
         IN HANDLE Handle,

dlls/ntdll/time.c

@@ -179,7 +179,7 @@ VOID WINAPI RtlSystemTimeToLocalTime(
 	memcpy (LocalTime, SystemTime, sizeof (PLARGE_INTEGER));
 }
 /******************************************************************************
- *  RtlToTimeInSecondsSince1980		[NTDLL] 
+ *  RtlTimeToSecondsSince1980		[NTDLL] 
  */
 BOOLEAN WINAPI RtlTimeToSecondsSince1980(
 	LPFILETIME ft,
@@ -191,7 +191,7 @@ BOOLEAN WINAPI RtlTimeToSecondsSince1980(
 }
 
 /******************************************************************************
- *  RtlToTimeInSecondsSince1970		[NTDLL] 
+ *  RtlTimeToSecondsSince1970		[NTDLL] 
  */
 BOOLEAN WINAPI RtlTimeToSecondsSince1970(
 	LPFILETIME ft,

dlls/odbc32/proxyodbc.c

@@ -1002,7 +1002,7 @@ SQLRETURNTYPE  SQLGetInfo(SQLHDBC ConnectionHandle,
 
 
 /*************************************************************************
- *				SQLiGetStmtAttr           [ODBC32.038]
+ *				SQLGetStmtAttr           [ODBC32.038]
  */
 SQLRETURNTYPE  SQLGetStmtAttr(SQLHSTMT StatementHandle,
              SQLINTEGER Attribute, SQLPOINTER Value,
@@ -1036,7 +1036,7 @@ SQLRETURNTYPE  SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, S
 
 
 /*************************************************************************
- *				SQLgetTypeInfo           [ODBC32.047]
+ *				SQLGetTypeInfo           [ODBC32.047]
  */
 SQLRETURNTYPE  SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
 {
@@ -1315,7 +1315,7 @@ SQLRETURNTYPE  SQLSpecialColumns(SQLHSTMT StatementHandle,
 
 
 /*************************************************************************
- *				SQLStatisitics           [ODBC32.053]
+ *				SQLStatistics           [ODBC32.053]
  */
 SQLRETURNTYPE  SQLStatistics(SQLHSTMT StatementHandle,
              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,

dlls/ole32/compositemoniker.c

@@ -1636,7 +1636,7 @@ HRESULT WINAPI EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker,
 }
 
 /******************************************************************************
- *        CreateCompositeMoniker	[OLE.55]
+ *        CreateGenericComposite	[OLE.55]
  ******************************************************************************/
 HRESULT WINAPI CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite)
 {

dlls/oleaut32/oleaut.c

@@ -20,6 +20,9 @@ DEFAULT_DEBUG_CHANNEL(ole);
 static WCHAR	_delimiter[2] = {'!',0}; /* default delimiter apparently */
 static WCHAR	*pdelimiter = &_delimiter[0];
 
+/***********************************************************************
+ *		RegisterActiveObject
+ */
 HRESULT WINAPI RegisterActiveObject(
 	LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
 ) {
@@ -43,6 +46,9 @@ HRESULT WINAPI RegisterActiveObject(
 	return ret;
 }
 
+/***********************************************************************
+ *		RevokeActiveObject
+ */
 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
 {
 	LPRUNNINGOBJECTTABLE	runobtable;
@@ -56,6 +62,9 @@ HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
 	return ret;
 }
 
+/***********************************************************************
+ *		GetActiveObject
+ */
 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
 {
 	WCHAR 			guidbuf[80];

dlls/oleaut32/safearray.c

@@ -103,6 +103,7 @@ const static int LAST_VARTYPE = sizeof(VARTYPE_SIZE)/sizeof(ULONG);
 
 
 /*************************************************************************
+ *		SafeArrayAllocDescriptor
  * Allocate the appropriate amount of memory for the SafeArray descriptor
  */
 HRESULT WINAPI SafeArrayAllocDescriptor( 
@@ -127,6 +128,7 @@ HRESULT WINAPI SafeArrayAllocDescriptor(
 }
 
 /*************************************************************************
+ *		SafeArrayAllocData
  * Allocate the appropriate amount of data for the SafeArray data
  */
 HRESULT WINAPI SafeArrayAllocData(
@@ -151,6 +153,7 @@ HRESULT WINAPI SafeArrayAllocData(
 }
 
 /*************************************************************************
+ *		SafeArrayCreate
  * Create a SafeArray object by encapsulating AllocDescriptor and AllocData 
  */
 SAFEARRAY* WINAPI SafeArrayCreate(
@@ -195,6 +198,7 @@ SAFEARRAY* WINAPI SafeArrayCreate(
 }
 
 /*************************************************************************
+ *		SafeArrayDestroyDescriptor
  * Frees the memory associated with the descriptor.
  */
 HRESULT WINAPI SafeArrayDestroyDescriptor(
@@ -213,6 +217,7 @@ HRESULT WINAPI SafeArrayDestroyDescriptor(
 
 
 /*************************************************************************
+ *		SafeArrayLock
  * Increment the lock counter
  *
  * Doc says (MSDN Library ) that psa->pvData should be made available (!= NULL)
@@ -231,6 +236,7 @@ HRESULT WINAPI SafeArrayLock(
 }
 
 /*************************************************************************
+ *		SafeArrayUnlock
  * Decrement the lock counter
  */
 HRESULT WINAPI SafeArrayUnlock(
@@ -247,6 +253,7 @@ HRESULT WINAPI SafeArrayUnlock(
 
 
 /*************************************************************************
+ *		SafeArrayPutElement
  * Set the data at the given coordinate
  */
 HRESULT WINAPI SafeArrayPutElement(
@@ -303,6 +310,7 @@ HRESULT WINAPI SafeArrayPutElement(
 
 
 /*************************************************************************
+ *		SafeArrayGetElement
  * Return the data element corresponding the the given coordinate
  */
 HRESULT WINAPI SafeArrayGetElement(
@@ -351,6 +359,7 @@ HRESULT WINAPI SafeArrayGetElement(
 }
 
 /*************************************************************************
+ *		SafeArrayGetUBound
  * return the UP bound for a given array dimension
  */
 HRESULT WINAPI SafeArrayGetUBound(
@@ -371,6 +380,7 @@ HRESULT WINAPI SafeArrayGetUBound(
 }
 
 /*************************************************************************
+ *		SafeArrayGetLBound
  * Return the LO bound for a given array dimension 
  */
 HRESULT WINAPI SafeArrayGetLBound(
@@ -389,6 +399,7 @@ HRESULT WINAPI SafeArrayGetLBound(
 }
 
 /*************************************************************************
+ *		SafeArrayGetDim
  * returns the number of dimension in the array
  */
 UINT WINAPI SafeArrayGetDim(
@@ -405,6 +416,7 @@ UINT WINAPI SafeArrayGetDim(
 }
 
 /*************************************************************************
+ *		SafeArrayGetElemsize
  * Return the size of the element in the array
  */
 UINT WINAPI SafeArrayGetElemsize(
@@ -421,6 +433,7 @@ UINT WINAPI SafeArrayGetElemsize(
 }
 
 /*************************************************************************
+ *		SafeArrayAccessData
  * increment the access count and return the data 
  */
 HRESULT WINAPI SafeArrayAccessData(
@@ -448,6 +461,7 @@ HRESULT WINAPI SafeArrayAccessData(
 
 
 /*************************************************************************
+ *		SafeArrayUnaccessData
  * Decrement the access count
  */
 HRESULT WINAPI SafeArrayUnaccessData(
@@ -460,6 +474,7 @@ HRESULT WINAPI SafeArrayUnaccessData(
 }
 
 /************************************************************************ 
+ *		SafeArrayPtrOfIndex
  * Return a pointer to the element at rgIndices
  */
 HRESULT WINAPI SafeArrayPtrOfIndex(
@@ -485,6 +500,7 @@ HRESULT WINAPI SafeArrayPtrOfIndex(
 }
 
 /************************************************************************ 
+ *		SafeArrayDestroyData
  * Frees the memory data bloc
  */
 HRESULT WINAPI SafeArrayDestroyData(
@@ -539,6 +555,7 @@ HRESULT WINAPI SafeArrayDestroyData(
 }
 
 /************************************************************************ 
+ *		SafeArrayCopyData
  * Copy the psaSource's data block into psaTarget if dimension and size
  * permits it.
  */
@@ -591,6 +608,7 @@ HRESULT WINAPI SafeArrayCopyData(
 }
 
 /************************************************************************ 
+ *		SafeArrayDestroy
  * Deallocates all memory reserved for the SafeArray
  */
 HRESULT WINAPI SafeArrayDestroy(
@@ -612,6 +630,7 @@ HRESULT WINAPI SafeArrayDestroy(
 }
 
 /************************************************************************ 
+ *		SafeArrayCopy
  * Make a dupplicate of a SafeArray
  */
 HRESULT WINAPI SafeArrayCopy(
@@ -658,6 +677,7 @@ HRESULT WINAPI SafeArrayCopy(
 }
 
 /************************************************************************ 
+ *		SafeArrayCreateVector
  * Creates a one dimension safearray where the data is next to the 
  * SAFEARRAY structure.
  */
@@ -694,6 +714,7 @@ SAFEARRAY* WINAPI SafeArrayCreateVector(
 } 
 
 /************************************************************************ 
+ *		SafeArrayRedim
  * Changes the caracteristics of the last dimension of the SafeArray
  */
 HRESULT WINAPI SafeArrayRedim(

dlls/oleaut32/variant.c

@@ -4242,7 +4242,7 @@ HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
 }
 
 /**********************************************************************
- *              VarCyFromDate32 [OLEAUT32.104]
+ *              VarCyFromStr [OLEAUT32.104]
  */
 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
 				/* FIXME */

dlls/olepro32/olepro32stubs.c

@@ -12,24 +12,36 @@
 
 DEFAULT_DEBUG_CHANNEL(ole);
 
+/***********************************************************************
+ *		OLEPRO32_DllUnregisterServer
+ */
 HRESULT WINAPI OLEPRO32_DllUnregisterServer()
 {
 	FIXME("not implemented (olepro32.dll) \n");
 	return S_OK;
 }
 
+/***********************************************************************
+ *		OLEPRO32_DllRegisterServer
+ */
 HRESULT WINAPI OLEPRO32_DllRegisterServer()
 {
 	FIXME("not implemented (olepro32.dll) \n");
 	return S_OK;
 }
 
+/***********************************************************************
+ *		OLEPRO32_DllCanUnloadNow
+ */
 HRESULT WINAPI OLEPRO32_DllCanUnloadNow( )
 {
 	FIXME("not implemented (olepro32.dll) \n");
 	return S_OK;
 }
 
+/***********************************************************************
+ *		OLEPRO32_DllGetClassObject
+ */
 HRESULT WINAPI OLEPRO32_DllGetClassObject( REFCLSID rclsid, REFIID riid, LPVOID* ppv )
 {
 	FIXME("not implemented (olepro32.dll) \n");

dlls/shell32/changenotify.c

@@ -227,6 +227,9 @@ void WINAPI SHChangeNotifyW (LONG wEventId, UINT  uFlags, LPCVOID dwItem1, LPCVO
 	}
 }
 
+/*************************************************************************
+ * SHChangeNotify				[SHELL32.239]
+ */
 void WINAPI SHChangeNotifyA (LONG wEventId, UINT  uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
 {
 	LPITEMIDLIST Pidls[2];
@@ -271,6 +274,9 @@ void WINAPI SHChangeNotifyA (LONG wEventId, UINT  uFlags, LPCVOID dwItem1, LPCVO
 	}
 }
 
+/*************************************************************************
+ * SHChangeNotifyAW				[SHELL32.239]
+ */
 void WINAPI SHChangeNotifyAW (LONG wEventId, UINT  uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
 {
 	if(VERSION_OsIsUnicode())

dlls/shell32/iconcache.c

@@ -785,7 +785,7 @@ INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulat
 }
 
 /*************************************************************************
- * ExtracticonExAW			[shell32.189]
+ * ExtractIconEx			[shell32.189]
  */
 HICON WINAPI ExtractIconExAW ( LPCVOID lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons )
 {	if (VERSION_OsIsUnicode())
@@ -793,7 +793,7 @@ HICON WINAPI ExtractIconExAW ( LPCVOID lpszFile, INT nIconIndex, HICON * phiconL
 	return ExtractIconExA ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 }
 /*************************************************************************
- * ExtracticonExA			[shell32.190]
+ * ExtractIconExA			[shell32.190]
  * RETURNS
  *  0 no icon found 
  *  1 file is not valid
@@ -829,7 +829,7 @@ HICON WINAPI ExtractIconExA ( LPCSTR lpszFile, INT nIconIndex, HICON * phiconLar
 	return ret;
 }
 /*************************************************************************
- * ExtracticonExW			[shell32.191]
+ * ExtractIconExW			[shell32.191]
  */
 HICON WINAPI ExtractIconExW ( LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons )
 {	LPSTR sFile;

dlls/shell32/shell.c

@@ -1086,7 +1086,7 @@ HICON16 WINAPI ExtractIconEx16(
 }
 
 /*************************************************************************
- *				ExtractAssociatedIcon	[SHELL.36]
+ *				ExtractAssociatedIconA	[SHELL.36]
  * 
  * Return icon for given file (either from file itself or from associated
  * executable) and patch parameters if needed.

dlls/shell32/shellord.c

@@ -24,7 +24,7 @@
 DEFAULT_DEBUG_CHANNEL(shell);
 
 /*************************************************************************
- * ParseField					[SHELL32.58]
+ * ParseFieldA					[SHELL32.58]
  *
  * copys a field from a ',' delimited string
  * 
@@ -885,8 +885,11 @@ HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserv
 	return ret;
 }
 
- /* SHGetValue: Gets a value from the registry */
+/*************************************************************************
-
+ * SHGetValueA
+ *
+ * Gets a value from the registry
+ */
 DWORD WINAPI SHGetValueA(
     HKEY     hkey,
     LPCSTR   pSubKey,
@@ -901,6 +904,11 @@ DWORD WINAPI SHGetValueA(
 	return ERROR_SUCCESS;  /* return success */
 }
 
+/*************************************************************************
+ * SHGetValueW
+ *
+ * Gets a value from the registry
+ */
 DWORD WINAPI SHGetValueW(
     HKEY     hkey,
     LPCWSTR  pSubKey,
@@ -915,8 +923,11 @@ DWORD WINAPI SHGetValueW(
 	return ERROR_SUCCESS;  /* return success */
 }
 
-/* gets a user-specific registry value. */
+/*************************************************************************
-
+ * SHRegGetUSValueA
+ *
+ * Gets a user-specific registry value
+ */
 LONG WINAPI SHRegGetUSValueA(
     LPCSTR   pSubKey,
     LPCSTR   pValue,
@@ -933,6 +944,11 @@ LONG WINAPI SHRegGetUSValueA(
 	return ERROR_SUCCESS;  /* return success */
 }
 
+/*************************************************************************
+ * SHRegGetUSValueW
+ *
+ * Gets a user-specific registry value
+ */
 LONG WINAPI SHRegGetUSValueW(
     LPCWSTR  pSubKey,
     LPCWSTR  pValue,
@@ -998,8 +1014,9 @@ HRESULT WINAPI IsUserAdmin(void)
 {	FIXME("stub\n");
 	return TRUE;
 }
+
 /*************************************************************************
- * StrRetToStrN					[SHELL32.96]
+ * StrRetToBufA					[SHLWAPI.@]
  * 
  * converts a STRRET to a normal string
  *
@@ -1011,6 +1028,27 @@ HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD
 	return StrRetToStrNA(dest, len, src, pidl);
 }
 
+/*************************************************************************
+ * StrRetToBufW					[SHLWAPI.@]
+ * 
+ * converts a STRRET to a normal string
+ *
+ * NOTES
+ *  the pidl is for STRRET OFFSET
+ */
+HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
+{
+	return StrRetToStrNW(dest, len, src, pidl);
+}
+
+/*************************************************************************
+ * StrRetToStrN					[SHELL32.96]
+ * 
+ * converts a STRRET to a normal string
+ *
+ * NOTES
+ *  the pidl is for STRRET OFFSET
+ */
 HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
 {
 	TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
@@ -1041,11 +1079,6 @@ HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST
 	return S_OK;
 }
 
-HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
-{
-	return StrRetToStrNW(dest, len, src, pidl);
-}
-
 HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
 {
 	TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
@@ -1219,8 +1252,8 @@ HRESULT WINAPI SHFlushClipboard(void)
 }
 
 /*************************************************************************
-* StrFormatByteSize				[SHLWAPI]
+ * StrFormatByteSizeA				[SHLWAPI]
-*/
+ */
 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
 {	char buf[64];
 	TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
@@ -1239,6 +1272,10 @@ LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
 	lstrcpynA (pszBuf, buf, cchBuf);
 	return pszBuf;	
 }
+
+/*************************************************************************
+ * StrFormatByteSizeW				[SHLWAPI]
+ */
 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
 {	char buf[64];
 	TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
@@ -1346,7 +1383,7 @@ HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
 }
 
 /************************************************************************
- *	DoEnvironmentSubstW			[SHELL32.53]
+ *	DoEnvironmentSubstA			[SHELL32.1222]
  *
  */
 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
@@ -1355,12 +1392,20 @@ HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
 	return 0;
 }
 
+/************************************************************************
+ *	DoEnvironmentSubstW			[SHELL32.1223]
+ *
+ */
 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
 {
 	FIXME("(%p %s, %p %s) stub\n", x, debugstr_w(x), y, debugstr_w(y));
 	return 0;
 }
 
+/************************************************************************
+ *	DoEnvironmentSubst			[SHELL32.53]
+ *
+ */
 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
 {
 	if (VERSION_OsIsUnicode())

dlls/shell32/shellpath.c

@@ -24,7 +24,7 @@ DEFAULT_DEBUG_CHANNEL(shell)
 LPSTR SupportedProtocol[] = {"http","https","ftp","gopher","file","mailto",""};
 
 /*************************************************************************
- * PathIsRoot [SHELL32.29]
+ * PathIsRootA
  */
 BOOL WINAPI PathIsRootA(LPCSTR x)
 {	TRACE("%s\n",x);
@@ -44,6 +44,10 @@ BOOL WINAPI PathIsRootA(LPCSTR x)
 	}
 	return 0;
 }
+
+/*************************************************************************
+ * PathIsRootW
+ */
 BOOL WINAPI PathIsRootW(LPCWSTR x) 
 {	TRACE("%s\n",debugstr_w(x));
 	if (*(x+1)==':' && *(x+2)=='\\')		/* "X:\" */
@@ -62,14 +66,19 @@ BOOL WINAPI PathIsRootW(LPCWSTR x)
 	}
 	return 0;
 }
+
+/*************************************************************************
+ * PathIsRoot [SHELL32.29]
+ */
 BOOL WINAPI PathIsRootAW(LPCVOID x) 
 {	if (VERSION_OsIsUnicode())
 	  return PathIsRootW(x);
 	return PathIsRootA(x);
 
 }
+
 /*************************************************************************
- * PathBuildRoot [SHELL32.30]
+ * PathBuildRootA [SHELL32.30]
  */
 LPSTR WINAPI PathBuildRootA(LPSTR root,BYTE drive) {
   TRACE("%p %i\n",root, drive);
@@ -79,7 +88,7 @@ LPSTR WINAPI PathBuildRootA(LPSTR root,BYTE drive) {
 }
 
 /*************************************************************************
- * PathFindExtension [SHELL32.31]
+ * PathFindExtensionA
  *
  * NOTES
  *     returns pointer to last . in last pathcomponent or at \0.
@@ -96,6 +105,13 @@ LPCSTR WINAPI PathFindExtensionA(LPCSTR path)
 	}
 	return lastpoint?lastpoint:path;
 }
+
+/*************************************************************************
+ * PathFindExtensionW
+ *
+ * NOTES
+ *     returns pointer to last . in last pathcomponent or at \0.
+ */
 LPCWSTR WINAPI PathFindExtensionW(LPCWSTR path) 
 {	LPCWSTR   lastpoint = NULL;
 	TRACE("(%p %s)\n",path,debugstr_w(path));
@@ -108,6 +124,13 @@ LPCWSTR WINAPI PathFindExtensionW(LPCWSTR path)
 	}
 	return lastpoint?lastpoint:path;
 }
+
+/*************************************************************************
+ * PathFindExtension [SHELL32.31]
+ *
+ * NOTES
+ *     returns pointer to last . in last pathcomponent or at \0.
+ */
 LPCVOID WINAPI PathFindExtensionAW(LPCVOID path) 
 {	if (VERSION_OsIsUnicode())
 	  return PathFindExtensionW(path);
@@ -116,7 +139,7 @@ LPCVOID WINAPI PathFindExtensionAW(LPCVOID path)
 }
 
 /*************************************************************************
- * PathAddBackslash [SHELL32.32]
+ * PathAddBackslashA
  * 
  * NOTES
  *     append \ if there is none
@@ -133,6 +156,13 @@ LPSTR WINAPI PathAddBackslashA(LPSTR path)
 	}
 	return path+len;
 }
+
+/*************************************************************************
+ * PathAddBackslashW
+ * 
+ * NOTES
+ *     append \ if there is none
+ */
 LPWSTR WINAPI PathAddBackslashW(LPWSTR path)
 {	int len;
 	TRACE("%p->%s\n",path,debugstr_w(path));
@@ -145,6 +175,13 @@ LPWSTR WINAPI PathAddBackslashW(LPWSTR path)
 	}
 	return path+len;
 }
+
+/*************************************************************************
+ * PathAddBackslash [SHELL32.32]
+ * 
+ * NOTES
+ *     append \ if there is none
+ */
 LPVOID WINAPI PathAddBackslashAW(LPVOID path)
 {	if(VERSION_OsIsUnicode())
 	  return PathAddBackslashW(path);
@@ -152,7 +189,7 @@ LPVOID WINAPI PathAddBackslashAW(LPVOID path)
 }
 
 /*************************************************************************
- * PathRemoveBlanks [SHELL32.33]
+ * PathRemoveBlanksA
  * 
  * NOTES
  *     remove spaces from beginning and end of passed string
@@ -172,6 +209,13 @@ LPSTR WINAPI PathRemoveBlanksA(LPSTR str)
 	  *x='\0';
 	return x;
 }
+
+/*************************************************************************
+ * PathRemoveBlanksW
+ * 
+ * NOTES
+ *     remove spaces from beginning and end of passed string
+ */
 LPWSTR WINAPI PathRemoveBlanksW(LPWSTR str)
 {	LPWSTR x = str;
 	TRACE("%s\n",debugstr_w(str));
@@ -187,16 +231,21 @@ LPWSTR WINAPI PathRemoveBlanksW(LPWSTR str)
 	  *x='\0';
 	return x;
 }
+
+/*************************************************************************
+ * PathRemoveBlanks [SHELL32.33]
+ * 
+ * NOTES
+ *     remove spaces from beginning and end of passed string
+ */
 LPVOID WINAPI PathRemoveBlanksAW(LPVOID str)
 {	if(VERSION_OsIsUnicode())
 	  return PathRemoveBlanksW(str);
 	return PathRemoveBlanksA(str);
 }
 
-
-
 /*************************************************************************
- * PathFindFilename [SHELL32.34]
+ * PathFindFilenameA
  * 
  * NOTES
  *     basename(char *fn);
@@ -214,6 +263,13 @@ LPCSTR WINAPI PathFindFilenameA(LPCSTR aptr)
 	return aslash;
 
 }
+
+/*************************************************************************
+ * PathFindFilenameW
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
 LPCWSTR WINAPI PathFindFilenameW(LPCWSTR wptr)
 {	LPCWSTR wslash;
 	wslash = wptr;
@@ -226,6 +282,13 @@ LPCWSTR WINAPI PathFindFilenameW(LPCWSTR wptr)
 	}
 	return wslash;	
 }
+
+/*************************************************************************
+ * PathFindFilename [SHELL32.34]
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
 LPCVOID WINAPI PathFindFilenameAW(LPCVOID fn)
 {
 	if(VERSION_OsIsUnicode())
@@ -234,7 +297,7 @@ LPCVOID WINAPI PathFindFilenameAW(LPCVOID fn)
 }
 
 /*************************************************************************
- * PathRemoveFileSpec [SHELL32.35]
+ * PathRemoveFileSpecA [SHELL32.35]
  * 
  * NOTES
  *     bool getpath(char *pathname); truncates passed argument to a valid path
@@ -278,7 +341,7 @@ DWORD WINAPI PathRemoveFileSpecA(LPSTR fn) {
 }
 
 /*************************************************************************
- * PathAppend [SHELL32.36]
+ * PathAppendA [SHELL32.36]
  * 
  * NOTES
  *     concat_paths(char*target,const char*add);
@@ -291,7 +354,7 @@ LPSTR WINAPI PathAppendA(LPSTR x1,LPSTR x2) {
 }
 
 /*************************************************************************
- * PathCombine [SHELL32.37]
+ * PathCombineA
  * 
  * NOTES
  *  if lpszFile='.' skip it
@@ -319,6 +382,14 @@ LPSTR WINAPI PathCombineA(LPSTR szDest, LPCSTR lpszDir, LPCSTR lpszFile)
 	}
 	return szDest;
 }
+
+/*************************************************************************
+ * PathCombineW
+ * 
+ * NOTES
+ *  if lpszFile='.' skip it
+ *  szDest can be equal to lpszFile. Thats why we use sTemp
+ */
 LPWSTR WINAPI PathCombineW(LPWSTR szDest, LPCWSTR lpszDir, LPCWSTR lpszFile) 
 {	WCHAR sTemp[MAX_PATH];
 	TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
@@ -342,6 +413,14 @@ LPWSTR WINAPI PathCombineW(LPWSTR szDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
 	}
 	return szDest;
 }
+
+/*************************************************************************
+ * PathCombine [SHELL32.37]
+ * 
+ * NOTES
+ *  if lpszFile='.' skip it
+ *  szDest can be equal to lpszFile. Thats why we use sTemp
+ */
 LPVOID WINAPI PathCombineAW(LPVOID szDest, LPCVOID lpszDir, LPCVOID lpszFile) 
 {	if (VERSION_OsIsUnicode())
 	  return PathCombineW( szDest, lpszDir, lpszFile );
@@ -349,7 +428,7 @@ LPVOID WINAPI PathCombineAW(LPVOID szDest, LPCVOID lpszDir, LPCVOID lpszFile)
 }
 
 /*************************************************************************
- * PathIsUNC [SHELL32.39]
+ * PathIsUNCA
  * 
  * NOTES
  *     PathIsUNC(char*path);
@@ -361,6 +440,13 @@ BOOL WINAPI PathIsUNCA(LPCSTR path)
 	  return TRUE;
 	return FALSE;
 }
+
+/*************************************************************************
+ * PathIsUNCW
+ * 
+ * NOTES
+ *     PathIsUNC(char*path);
+ */
 BOOL WINAPI PathIsUNCW(LPCWSTR path) 
 {	TRACE("%s\n",debugstr_w(path));
 
@@ -368,13 +454,21 @@ BOOL WINAPI PathIsUNCW(LPCWSTR path)
 	  return TRUE;
 	return FALSE;
 }
+
+/*************************************************************************
+ * PathIsUNC [SHELL32.39]
+ * 
+ * NOTES
+ *     PathIsUNC(char*path);
+ */
 BOOL WINAPI PathIsUNCAW (LPCVOID path)
 {	if (VERSION_OsIsUnicode())
 	  return PathIsUNCW( path );
 	return PathIsUNCA( path );  
 }
+
 /*************************************************************************
- *  PathIsRelativ [SHELL32.40]
+ *  PathIsRelativeA
  * 
  */
 BOOL WINAPI PathIsRelativeA (LPCSTR path)
@@ -384,6 +478,11 @@ BOOL WINAPI PathIsRelativeA (LPCSTR path)
 	  return TRUE;
 	return FALSE;    
 }
+
+/*************************************************************************
+ *  PathIsRelativeW
+ * 
+ */
 BOOL WINAPI PathIsRelativeW (LPCWSTR path)
 {	TRACE("path=%s\n",debugstr_w(path));
 
@@ -391,23 +490,39 @@ BOOL WINAPI PathIsRelativeW (LPCWSTR path)
 	  return TRUE;
 	return FALSE;    
 }
+
+/*************************************************************************
+ *  PathIsRelative [SHELL32.40]
+ * 
+ */
 BOOL WINAPI PathIsRelativeAW (LPCVOID path)
 {	if (VERSION_OsIsUnicode())
 	  return PathIsRelativeW( path );
 	return PathIsRelativeA( path );  
 }
+
 /*************************************************************************
- *  PathIsExe [SHELL32.43]
+ *  PathIsExeA
  * 
  */
 BOOL WINAPI PathIsExeA (LPCSTR path)
 {	FIXME("path=%s\n",path);
 	return FALSE;
 }
+
+/*************************************************************************
+ *  PathIsExeW
+ * 
+ */
 BOOL WINAPI PathIsExeW (LPCWSTR path)
 {	FIXME("path=%s\n",debugstr_w(path));
 	return FALSE;
 }
+
+/*************************************************************************
+ *  PathIsExe [SHELL32.43]
+ * 
+ */
 BOOL WINAPI PathIsExeAW (LPCVOID path)
 {	if (VERSION_OsIsUnicode())
 	  return PathIsExeW (path);
@@ -415,7 +530,7 @@ BOOL WINAPI PathIsExeAW (LPCVOID path)
 }
 
 /*************************************************************************
- * PathFileExists [SHELL32.45]
+ * PathFileExistsA [SHELL32.45]
  * 
  * NOTES
  *     file_exists(char *fn);
@@ -471,8 +586,9 @@ static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
   }
   return 0;
 }
+
 /*************************************************************************
- * PathMatchSpec [SHELL32.46]
+ * PathMatchSpecA
  * 
  * NOTES
  *     used from COMDLG32
@@ -493,6 +609,13 @@ BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
 	}
   return 0;
 }
+
+/*************************************************************************
+ * PathMatchSpecW
+ * 
+ * NOTES
+ *     used from COMDLG32
+ */
 BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask) 
 {
   WCHAR stemp[4];
@@ -511,25 +634,43 @@ BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
 	}
   return 0;
 }
+
+/*************************************************************************
+ * PathMatchSpec [SHELL32.46]
+ * 
+ * NOTES
+ *     used from COMDLG32
+ */
 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask) 
 {	if (VERSION_OsIsUnicode())
 	  return PathMatchSpecW( name, mask );
 	return PathMatchSpecA( name, mask );
 }
 /*************************************************************************
- * PathSetDlgItemPathAW [SHELL32.48]
+ * PathSetDlgItemPathA
  * NOTES
  *  use PathCompactPath to make sure, the path fits into the control
  */
-
 BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath) 
 {	TRACE("%x %x %s\n",hDlg, id, pszPath);
 	return SetDlgItemTextA(hDlg, id, pszPath);
 }
+
+/*************************************************************************
+ * PathSetDlgItemPathW
+ * NOTES
+ *  use PathCompactPath to make sure, the path fits into the control
+ */
 BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath) 
 {	TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
 	return SetDlgItemTextW(hDlg, id, pszPath);
 }
+
+/*************************************************************************
+ * PathSetDlgItemPath [SHELL32.48]
+ * NOTES
+ *  use PathCompactPath to make sure, the path fits into the control
+ */
 BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath) 
 {	if (VERSION_OsIsUnicode())
 	  return PathSetDlgItemPathW(hDlg, id, pszPath);
@@ -537,17 +678,24 @@ BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
 }
 
 /*************************************************************************
- * PathQualifyAW [SHELL32.49]
+ * PathQualifyA
  */
-
 BOOL WINAPI PathQualifyA(LPCSTR pszPath) 
 {	FIXME("%s\n",pszPath);
 	return 0;
 }
+
+/*************************************************************************
+ * PathQualifyW
+ */
 BOOL WINAPI PathQualifyW(LPCWSTR pszPath) 
 {	FIXME("%s\n",debugstr_w(pszPath));
 	return 0;
 }
+
+/*************************************************************************
+ * PathQualify [SHELL32.49]
+ */
 BOOL WINAPI PathQualifyAW(LPCVOID pszPath) 
 {	if (VERSION_OsIsUnicode())
 	  return PathQualifyW(pszPath);
@@ -563,7 +711,7 @@ DWORD WINAPI PathResolve(LPCSTR s,DWORD x2,DWORD x3) {
 }
 
 /*************************************************************************
- * PathGetArgs [SHELL32.52]
+ * PathGetArgsA
  *
  * NOTES
  *     look for next arg in string. handle "quoted" strings
@@ -584,6 +732,14 @@ LPCSTR WINAPI PathGetArgsA(LPCSTR cmdline)
 	return cmdline;
 
 }
+
+/*************************************************************************
+ * PathGetArgsW
+ *
+ * NOTES
+ *     look for next arg in string. handle "quoted" strings
+ *     returns pointer to argument *AFTER* the space. Or to the \0.
+ */
 LPCWSTR WINAPI PathGetArgsW(LPCWSTR cmdline) 
 {	BOOL	qflag = FALSE;
 
@@ -598,13 +754,22 @@ LPCWSTR WINAPI PathGetArgsW(LPCWSTR cmdline)
 	}
 	return cmdline;
 }
+
+/*************************************************************************
+ * PathGetArgs [SHELL32.52]
+ *
+ * NOTES
+ *     look for next arg in string. handle "quoted" strings
+ *     returns pointer to argument *AFTER* the space. Or to the \0.
+ */
 LPCVOID WINAPI PathGetArgsAW(LPVOID cmdline) 
 {	if (VERSION_OsIsUnicode())
 	  return PathGetArgsW(cmdline);
 	return PathGetArgsA(cmdline);
 }
+
 /*************************************************************************
- * PathQuoteSpaces [SHELL32.55]
+ * PathQuoteSpacesA
  * 
  * NOTES
  *     basename(char *fn);
@@ -614,10 +779,24 @@ LPSTR WINAPI PathQuoteSpacesA(LPCSTR aptr)
 	return 0;
 
 }
+
+/*************************************************************************
+ * PathQuoteSpacesW
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
 LPWSTR WINAPI PathQuoteSpacesW(LPCWSTR wptr)
 {	FIXME("%s\n",debugstr_w(wptr));
 	return 0;	
 }
+
+/*************************************************************************
+ * PathQuoteSpaces [SHELL32.55]
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
 LPVOID WINAPI PathQuoteSpacesAW (LPCVOID fn)
 {	if(VERSION_OsIsUnicode())
 	  return PathQuoteSpacesW(fn);
@@ -626,7 +805,7 @@ LPVOID WINAPI PathQuoteSpacesAW (LPCVOID fn)
 
 
 /*************************************************************************
- * PathUnquoteSpaces [SHELL32.56]
+ * PathUnquoteSpacesA
  * 
  * NOTES
  *     unquote string (remove ")
@@ -642,6 +821,13 @@ VOID WINAPI PathUnquoteSpacesA(LPSTR str)
 	lstrcpyA(str,str+1);
 	return;
 }
+
+/*************************************************************************
+ * PathUnquoteSpacesW
+ * 
+ * NOTES
+ *     unquote string (remove ")
+ */
 VOID WINAPI PathUnquoteSpacesW(LPWSTR str) 
 {	DWORD len = CRTDLL_wcslen(str);
 
@@ -655,6 +841,13 @@ VOID WINAPI PathUnquoteSpacesW(LPWSTR str)
 	CRTDLL_wcscpy(str,str+1);
 	return;
 }
+
+/*************************************************************************
+ * PathUnquoteSpaces [SHELL32.56]
+ * 
+ * NOTES
+ *     unquote string (remove ")
+ */
 VOID WINAPI PathUnquoteSpacesAW(LPVOID str) 
 {
 	if(VERSION_OsIsUnicode())
@@ -674,7 +867,7 @@ HRESULT WINAPI PathGetDriveNumber(LPSTR u)
 }
 
 /*************************************************************************
- * PathYetAnotherMakeUniqueName [SHELL32.75]
+ * PathYetAnotherMakeUniqueNameA [SHELL32.75]
  * 
  * NOTES
  *     exported by ordinal
@@ -685,7 +878,7 @@ BOOL WINAPI PathYetAnotherMakeUniqueNameA(LPDWORD x,LPDWORD y) {
 }
 
 /*************************************************************************
- * IsLFNDrive [SHELL32.119]
+ * IsLFNDriveA [SHELL32.119]
  * 
  * NOTES
  *     exported by ordinal Name
@@ -697,17 +890,26 @@ BOOL WINAPI IsLFNDriveA(LPCSTR path) {
 	return FALSE;
     return fnlen>12;
 }
+
 /*************************************************************************
- * PathFindOnPath [SHELL32.145]
+ * PathFindOnPathA
  */
 BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR sOtherDirs)
 {	FIXME("%s %s\n",sFile, sOtherDirs);
 	return FALSE;
 }
+
+/*************************************************************************
+ * PathFindOnPathW
+ */
 BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR sOtherDirs)
 {	FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
 	return FALSE;
 }
+
+/*************************************************************************
+ * PathFindOnPath [SHELL32.145]
+ */
 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID sOtherDirs)
 {	if (VERSION_OsIsUnicode())
 	  return PathFindOnPathW(sFile, sOtherDirs);
@@ -803,7 +1005,7 @@ HRESULT WINAPI PathProcessCommandAW (LPVOID lpCommand, LPSTR v, DWORD w, DWORD x
 }
 
 /*************************************************************************
- * SHGetSpecialFolderPath [SHELL32.175]
+ * SHGetSpecialFolderPathA
  * 
  * converts csidl to path
  * 
@@ -981,6 +1183,13 @@ BOOL WINAPI SHGetSpecialFolderPathA (
 
 	return TRUE;
 }
+
+/*************************************************************************
+ * SHGetSpecialFolderPathW
+ * 
+ * converts csidl to path
+ * 
+ */
 BOOL WINAPI SHGetSpecialFolderPathW (
 	HWND hwndOwner,
 	LPWSTR szPath,
@@ -998,6 +1207,13 @@ BOOL WINAPI SHGetSpecialFolderPathW (
 
 	return TRUE;
 }
+
+/*************************************************************************
+ * SHGetSpecialFolderPath [SHELL32.175]
+ * 
+ * converts csidl to path
+ * 
+ */
 BOOL WINAPI SHGetSpecialFolderPathAW (
 	HWND hwndOwner,
 	LPVOID szPath,
@@ -1010,7 +1226,8 @@ BOOL WINAPI SHGetSpecialFolderPathAW (
 	return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate);
 }
 
-/* PathRemoveBackslash
+/*************************************************************************
+ * PathRemoveBackslashA
  *
  * If the path ends in a backslash it is replaced by a NULL
  * and the address of the NULL is returned
@@ -1018,7 +1235,6 @@ BOOL WINAPI SHGetSpecialFolderPathAW (
  * the address of the last character is returned.
  *
  */
-
 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpPath )
 {
 	LPSTR p = lpPath;
@@ -1028,6 +1244,10 @@ LPSTR WINAPI PathRemoveBackslashA( LPSTR lpPath )
 	return p;
 }
 
+/*************************************************************************
+ * PathRemoveBackslashW
+ *
+ */
 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpPath )
 {
 	LPWSTR p = lpPath;
@@ -1037,6 +1257,10 @@ LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpPath )
 	return p;
 }
 
+/*************************************************************************
+ * PathIsURLA
+ *
+ */
 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
 {
   LPSTR lpstrRes;
@@ -1069,7 +1293,7 @@ BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
 }  
 
 /*************************************************************************
- * PathIsDirectory
+ * PathIsDirectoryA
  *
  */
 BOOL WINAPI PathIsDirectoryA(LPCSTR pszPath)
@@ -1077,11 +1301,20 @@ BOOL WINAPI PathIsDirectoryA(LPCSTR pszPath)
 	FIXME("%s\n", debugstr_a(pszPath));
 	return TRUE;
 }
+
+/*************************************************************************
+ * PathIsDirectoryW
+ *
+ */
 BOOL WINAPI PathIsDirectoryW(LPCWSTR pszPath)
 {
 	FIXME("%s\n", debugstr_w(pszPath));
 	return TRUE;
 }
+/*************************************************************************
+ * PathIsDirectory
+ *
+ */
 BOOL WINAPI PathIsDirectoryAW (LPCVOID pszPath)
 {
 	if (VERSION_OsIsUnicode())

dlls/shell32/systray.c

@@ -493,7 +493,7 @@ BOOL WINAPI Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATAA pnid )
 }
 
 /*************************************************************************
- * Shell_NotifyIconA			[SHELL32.297]
+ * Shell_NotifyIconW			[SHELL32.297]
  */
 BOOL WINAPI Shell_NotifyIconW (DWORD dwMessage, PNOTIFYICONDATAW pnid )
 {

dlls/tapi32/assisted.c

@@ -9,8 +9,11 @@
 #include "tapi.h"
 #include "debugtools.h"
 
-DEFAULT_DEBUG_CHANNEL(tapi)
+DEFAULT_DEBUG_CHANNEL(tapi);
 
+/***********************************************************************
+ *		tapiGetLocationInfo (TAPI32.@)
+ */
 DWORD WINAPI tapiGetLocationInfo(LPSTR lpszCountryCode, LPSTR lpszCityCode)
 {
     char temp[30];
@@ -23,6 +26,9 @@ DWORD WINAPI tapiGetLocationInfo(LPSTR lpszCountryCode, LPSTR lpszCityCode)
     return 0;
 }
 
+/***********************************************************************
+ *		tapiRequestMakeCall (TAPI32.@)
+ */
 DWORD WINAPI tapiRequestMakeCall(LPCSTR lpszDestAddress, LPCSTR lpszAppName,
                                  LPCSTR lpszCalledParty, LPCSTR lpszComment)
 {

dlls/tapi32/line.c

@@ -12,256 +12,381 @@
 #include "tapi.h"
 #include "debugtools.h"
 
-DEFAULT_DEBUG_CHANNEL(tapi)
+DEFAULT_DEBUG_CHANNEL(tapi);
-DECLARE_DEBUG_CHANNEL(comm)
+DECLARE_DEBUG_CHANNEL(comm);
 
+/***********************************************************************
+ *		lineAccept (TAPI32.@)
+ */
 DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
 {
     FIXME("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		lineAddProvider (TAPI32.@)
+ */
 DWORD WINAPI lineAddProvider(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
 {
     FIXME("(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineAddToConference (TAPI32.@)
+ */
 DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
 {
     FIXME("(%04x, %04x): stub.\n", hConfCall, hConsultCall);
     return 1;
 }
 
+/***********************************************************************
+ *		lineAnswer (TAPI32.@)
+ */
 DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
 {
     FIXME("(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineBlindTransfer (TAPI32.@)
+ */
 DWORD WINAPI lineBlindTransfer(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
 {
     FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineClose (TAPI32.@)
+ */
 DWORD WINAPI lineClose(HLINE hLine)
 {
     FIXME("(%04x): stub.\n", hLine);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineCompleteCall (TAPI32.@)
+ */
 DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
 {
     FIXME("(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineCompleteTransfer (TAPI32.@)
+ */
 DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
 {
     FIXME("(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
     return 1;
 }
 
+/***********************************************************************
+ *		lineConfigDialog (TAPI32.@)
+ */
 DWORD WINAPI lineConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
 {
     FIXME("(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineConfigDialogEdit (TAPI32.@)
+ */
 DWORD WINAPI lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
 {
     FIXME("stub.\n");
     return 0;
 }	
 
+/***********************************************************************
+ *		lineConfigProvider (TAPI32.@)
+ */
 DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
 {
     FIXME("(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
     return 0;
 }
 
+/***********************************************************************
+ *		lineDeallocateCall (TAPI32.@)
+ */
 DWORD WINAPI lineDeallocateCall(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 0;
 }
 
+/***********************************************************************
+ *		lineDevSpecific (TAPI32.@)
+ */
 DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
 {
     FIXME("(%04x, %08lx, %04x, %p, %ld): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineDevSpecificFeature (TAPI32.@)
+ */
 DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
 {
     FIXME("(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		lineDial (TAPI32.@)
+ */
 DWORD WINAPI lineDial(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
 {
     FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
     return 1;
 }
 
+/***********************************************************************
+ *		lineDrop (TAPI32.@)
+ */ 
 DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
 {
     FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		lineForward (TAPI32.@)
+ */
 DWORD WINAPI lineForward(HLINE hLine, DWORD bAllAddress, DWORD dwAdressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("stub.\n");
     return 1;
 }
 
+/***********************************************************************
+ *		lineGatherDigits (TAPI32.@)
+ */	
 DWORD WINAPI lineGatherDigits(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
 {
     FIXME("stub.\n");
     return 0;
 }
 
+/***********************************************************************
+ *		lineGenerateDigits (TAPI32.@)
+ */
 DWORD WINAPI lineGenerateDigits(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
 {
     FIXME("(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGenerateTone (TAPI32.@)
+ */
 DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
 {
     FIXME("(%04x, %08lx, %ld, %ld, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetAddressCaps (TAPI32.@)
+ */
 DWORD WINAPI lineGetAddressCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
 {
     FIXME("(%04x, %08lx, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetAddressID (TAPI32.@)
+ */
 DWORD WINAPI lineGetAddressID(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
 {
     FIXME("%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetAddressStatus (TAPI32.@)
+ */
 DWORD WINAPI lineGetAddressStatus(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
 {
     FIXME("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetAppPriority (TAPI32.@)
+ */
 DWORD WINAPI lineGetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
 {
     FIXME("(%s, %08lx, %p, %08lx, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetCallInfo (TAPI32.@)
+ */
 DWORD WINAPI lineGetCallInfo(HCALL hCall, LPLINECALLINFO lpCallInfo)
 {
     FIXME("(%04x, %p): stub.\n", hCall, lpCallInfo);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetCallStatus (TAPI32.@)
+ */
 DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
 {
     FIXME("(%04x, %p): stub.\n", hCall, lpCallStatus);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetConfRelatedCalls (TAPI32.@)
+ */
 DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
 {
     FIXME("(%04x, %p): stub.\n", hCall, lpCallList);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetCountry (TAPI32.@)
+ */
 DWORD WINAPI lineGetCountry(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
 {
     FIXME("(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetDevCaps (TAPI32.@)
+ */
 DWORD WINAPI lineGetDevCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
 {
     FIXME("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetDevConfig (TAPI32.@)
+ */
 DWORD WINAPI lineGetDevConfig(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
 {
     FIXME("(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetID (TAPI32.@)
+ */
 DWORD WINAPI lineGetID(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
 {
     FIXME("(%04x, %08lx, %04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetIcon (TAPI32.@)
+ */
 DWORD WINAPI lineGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
 {
     FIXME("(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetLineDevStatus (TAPI32.@)
+ */
 DWORD WINAPI lineGetLineDevStatus(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
 {
     FIXME("(%04x, %p): stub.\n", hLine, lpLineDevStatus);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetNewCalls (TAPI32.@)
+ */
 DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
 {
     FIXME("(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
     return 0;
 }
 
-
+/***********************************************************************
+ *		lineGetNumRings (TAPI32.@)
+ */
 DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
 {
     FIXME("(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
     return 0;
 }
 
+/***********************************************************************
+ *		lineGetProviderList (TAPI32.@)
+ */
 DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
 {
     FIXME("(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetRequest (TAPI32.@)
+ */
 DWORD WINAPI lineGetRequest(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
 {
     FIXME("%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetStatusMessages (TAPI32.@)
+ */
 DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
 {
     FIXME("(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineGetTranslateCaps (TAPI32.@)
+ */
 DWORD WINAPI lineGetTranslateCaps(HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
 {
     FIXME("(%04x, %08lx, %p): stub.\n", hLineApp, dwAPIVersion, lpTranslateCaps);
     return 0;
 }
 
+/***********************************************************************
+ *		lineHandoff (TAPI32.@)
+ */
 DWORD WINAPI lineHandoff(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
 {
     FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineHold (TAPI32.@)
+ */
 DWORD WINAPI lineHold(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineInitialize (TAPI32.@)
+ */
 DWORD WINAPI lineInitialize(
   LPHLINEAPP lphLineApp,
   HINSTANCE hInstance,
@@ -273,30 +398,45 @@ DWORD WINAPI lineInitialize(
     return 0;
 }
 
+/***********************************************************************
+ *		lineMakeCall (TAPI32.@)
+ */
 DWORD WINAPI lineMakeCall(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
     return 1;
 }
 
+/***********************************************************************
+ *		lineMonitorDigits (TAPI32.@)
+ */
 DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
 {
     FIXME("(%04x, %08lx): stub.\n", hCall, dwDigitModes);
     return 0;
 }
 
+/***********************************************************************
+ *		lineMonitorMedia (TAPI32.@)
+ */
 DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
 {
     FIXME("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineMonitorTones (TAPI32.@)
+ */
 DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
 {
     FIXME("(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineNegotiateAPIVersion (TAPI32.@)
+ */
 DWORD WINAPI lineNegotiateAPIVersion(
   HLINEAPP hLineApp,
   DWORD dwDeviceID,
@@ -311,39 +451,53 @@ DWORD WINAPI lineNegotiateAPIVersion(
     return 0;
 }
 
+/***********************************************************************
+ *		lineNegotiateExtVersion (TAPI32.@)
+ */
 DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
 {
     FIXME("stub.\n");
     return 0;
 }
 
+/***********************************************************************
+ *		lineOpen (TAPI32.@)
+ */
 DWORD WINAPI lineOpen(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("stub.\n");
     return 0;
 }
 
+/***********************************************************************
+ *		linePark (TAPI32.@)
+ */
 DWORD WINAPI linePark(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
 {
     FIXME("(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
     return 1;
 }	
 
+/***********************************************************************
+ *		linePickup (TAPI32.@)
+ */
 DWORD WINAPI linePickup(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
 {
     FIXME("(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
     return 1;
 }	
 
+/***********************************************************************
+ *		linePrepareAddToConference (TAPI32.@)
+ */
 DWORD WINAPI linePrepareAddToConference(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
     return 1;
 }	
 
-/*************************************************************************
+/***********************************************************************
- * lineRedirect [TAPI32.53]
+ *		lineRedirect (TAPI32.@)
- * 
  */
 DWORD WINAPI lineRedirect(
   HCALL hCall,
@@ -354,78 +508,117 @@ DWORD WINAPI lineRedirect(
   return 1;
 }
 
+/***********************************************************************
+ *		lineRegisterRequestRecipient (TAPI32.@)
+ */
 DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
 {
     FIXME("(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
     return 1;
 }
 
+/***********************************************************************
+ *		lineReleaseUserUserInfo (TAPI32.@)
+ */
 DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineRemoveFromConference (TAPI32.@)
+ */
 DWORD WINAPI lineRemoveFromConference(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 1;
 }
 
+/***********************************************************************
+ *		lineRemoveProvider (TAPI32.@)
+ */
 DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
 {
     FIXME("(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineSecureCall (TAPI32.@)
+ */
 DWORD WINAPI lineSecureCall(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 1;
 }
 
+/***********************************************************************
+ *		lineSendUserUserInfo (TAPI32.@)
+ */
 DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
 {
     FIXME("(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		lineSetAppPriority (TAPI32.@)
+ */
 DWORD WINAPI lineSetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
 {
     FIXME("(%s, %08lx, %p, %08lx, %s, %08lx): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
     return 0;
 }
 
+/***********************************************************************
+ *		lineSetAppSpecific (TAPI32.@)
+ */
 DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
 {
     FIXME("(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
     return 0;
 }
 
+/***********************************************************************
+ *		lineSetCallParams (TAPI32.@)
+ */
 DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
 {
     FIXME("(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
     return 1;
 }
 
+/***********************************************************************
+ *		lineSetCallPrivilege (TAPI32.@)
+ */
 DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
 {
     FIXME("(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
     return 0;
 }	
 		
+/***********************************************************************
+ *		lineSetCurrentLocation (TAPI32.@)
+ */
 DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
 {
     FIXME("(%04x, %08lx): stub.\n", hLineApp, dwLocation);
     return 0;
 }
 
+/***********************************************************************
+ *		lineSetDevConfig (TAPI32.@)
+ */
 DWORD WINAPI lineSetDevConfig(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
 {
     FIXME("(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
     return 0;
 }
 
+/***********************************************************************
+ *		lineSetMediaControl (TAPI32.@)
+ */
 DWORD WINAPI lineSetMediaControl(
 HLINE hLine,
 DWORD dwAddressID,
@@ -444,84 +637,126 @@ DWORD dwCallStateNumEntries)
     return 0;
 }
 
+/***********************************************************************
+ *		lineSetMediaMode (TAPI32.@)
+ */
 DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
 {
     FIXME("(%04x, %08lx): stub.\n", hCall, dwMediaModes);
     return 0;
 }	
 
+/***********************************************************************
+ *		lineSetNumRings (TAPI32.@)
+ */
 DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
 {
     FIXME("(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
     return 0;
 }	
 		
+/***********************************************************************
+ *		lineSetStatusMessages (TAPI32.@)
+ */
 DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
 {
     FIXME("(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
     return 0;
 }	
 		
+/***********************************************************************
+ *		lineSetTerminal (TAPI32.@)
+ */
 DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
 {
     FIXME("(%04x, %08lx, %04x, %08lx, %08lx, %08lx, %08lx): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineSetTollList (TAPI32.@)
+ */
 DWORD WINAPI lineSetTollList(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
 {
     FIXME("(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
     return 0;
 }	
 		
+/***********************************************************************
+ *		lineSetupConference (TAPI32.@)
+ */
 DWORD WINAPI lineSetupConference(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("(%04x, %04x, %p, %p, %08lx, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
     return 1;
 }
 
+/***********************************************************************
+ *		lineSetupTransfer (TAPI32.@)
+ */
 DWORD WINAPI lineSetupTransfer(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
 {
     FIXME("(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
     return 1;
 }	
 
+/***********************************************************************
+ *		lineShutdown (TAPI32.@)
+ */
 DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
 {
     FIXME("(%04x): stub.\n", hLineApp);
     return 0;
 }
 
+/***********************************************************************
+ *		lineSwapHold (TAPI32.@)
+ */
 DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
 {
     FIXME("(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
     return 1;
 }
 
+/***********************************************************************
+ *		lineTranslateAddress (TAPI32.@)
+ */
 DWORD WINAPI lineTranslateAddress(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
 {
     FIXME("(%04x, %08lx, %08lx, %s, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
     return 0;
 }
 
+/***********************************************************************
+ *		lineTranslateDialog (TAPI32.@)
+ */
 DWORD WINAPI lineTranslateDialog(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
 {
     FIXME("(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
     return 0;
 }
 
+/***********************************************************************
+ *		lineUncompleteCall (TAPI32.@)
+ */
 DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
 {
     FIXME("(%04x, %08lx): stub.\n", hLine, dwCompletionID);
     return 1;
 }
 
+/***********************************************************************
+ *		lineUnhold (TAPI32.@)
+ */
 DWORD WINAPI lineUnhold(HCALL hCall)
 {
     FIXME("(%04x): stub.\n", hCall);
     return 1;
 }
 
+/***********************************************************************
+ *		lineUnpark (TAPI32.@)
+ */
 DWORD WINAPI lineUnpark(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
 {
     FIXME("(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);

dlls/tapi32/phone.c

@@ -9,26 +9,38 @@
 #include "tapi.h"
 #include "debugtools.h"
 
-DEFAULT_DEBUG_CHANNEL(tapi)
+DEFAULT_DEBUG_CHANNEL(tapi);
 
+/***********************************************************************
+ *		phoneClose (TAPI32.@)
+ */
 DWORD WINAPI phoneClose(HPHONE hPhone)
 {
     FIXME("(%04x), stub.\n", hPhone);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneConfigDialog (TAPI32.@)
+ */
 DWORD WINAPI phoneConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
 {
     FIXME("(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneDevSpecific (TAPI32.@)
+ */
 DWORD WINAPI phoneDevSpecific(HPHONE hPhone, LPVOID lpParams, DWORD dwSize)
 {
     FIXME("(%04x, %p, %08ld): stub.\n", hPhone, lpParams, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneGetButtonInfo (TAPI32.@)
+ */
 DWORD WINAPI phoneGetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID,
                                 LPPHONEBUTTONINFO lpButtonInfo)
 {
@@ -36,12 +48,18 @@ DWORD WINAPI phoneGetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetData (TAPI32.@)
+ */
 DWORD WINAPI phoneGetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
 {
     FIXME("(%04x, %08ld, %p, %08ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetDevCaps (TAPI32.@)
+ */
 DWORD WINAPI phoneGetDevCaps(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
                DWORD dwAPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps)
 {
@@ -49,30 +67,45 @@ DWORD WINAPI phoneGetDevCaps(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetDisplay (TAPI32.@)
+ */
 DWORD WINAPI phoneGetDisplay(HPHONE hPhone, LPVARSTRING lpDisplay)
 {
     FIXME("(%04x, %p): stub.\n", hPhone, lpDisplay);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetGain (TAPI32.@)
+ */
 DWORD WINAPI phoneGetGain(HPHONE hPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain)
 {
     FIXME("(%04x, %08lx, %p): stub.\n", hPhone, dwHookSwitchDev, lpdwGain);
     return 0;
 }	
 		
+/***********************************************************************
+ *		phoneGetHookSwitch (TAPI32.@)
+ */
 DWORD WINAPI phoneGetHookSwitch(HPHONE hPhone, LPDWORD lpdwHookSwitchDevs)
 {
    FIXME("(%04x, %p): stub.\n", hPhone, lpdwHookSwitchDevs);
    return 0;
 }
 
+/***********************************************************************
+ *		phoneGetID (TAPI32.@)
+ */
 DWORD WINAPI phoneGetID(HPHONE hPhone, LPVARSTRING lpDeviceID,
                         LPCSTR lpszDeviceClass)
 {
     FIXME("(%04x, %p, %s): stub.\n", hPhone, lpDeviceID, lpszDeviceClass);    return 0;
 }
 
+/***********************************************************************
+ *		phoneGetIcon (TAPI32.@)
+ */
 DWORD WINAPI phoneGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass,
 		          HICON *lphIcon)
 {
@@ -80,6 +113,9 @@ DWORD WINAPI phoneGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetLamp (TAPI32.@)
+ */
 DWORD WINAPI phoneGetLamp(HPHONE hPhone, DWORD dwButtonLampID,
 		          LPDWORD lpdwLampMode)
 {
@@ -87,18 +123,27 @@ DWORD WINAPI phoneGetLamp(HPHONE hPhone, DWORD dwButtonLampID,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetRing (TAPI32.@)
+ */
 DWORD WINAPI phoneGetRing(HPHONE hPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume)
 {
     FIXME("(%04x, %p, %p): stub.\n", hPhone, lpdwRingMode, lpdwVolume);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetStatus (TAPI32.@)
+ */
 DWORD WINAPI phoneGetStatus(HPHONE hPhone, LPPHONESTATUS lpPhoneStatus)
 {
     FIXME("(%04x, %p): stub.\n", hPhone, lpPhoneStatus);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetStatusMessages (TAPI32.@)
+ */
 DWORD WINAPI phoneGetStatusMessages(HPHONE hPhone, LPDWORD lpdwPhoneStates,
 		          LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates)
 {
@@ -106,6 +151,9 @@ DWORD WINAPI phoneGetStatusMessages(HPHONE hPhone, LPDWORD lpdwPhoneStates,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneGetVolume (TAPI32.@)
+ */
 DWORD WINAPI phoneGetVolume(HPHONE hPhone, DWORD dwHookSwitchDevs,
 		            LPDWORD lpdwVolume)
 {
@@ -113,18 +161,27 @@ DWORD WINAPI phoneGetVolume(HPHONE hPhone, DWORD dwHookSwitchDevs,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneInitialize (TAPI32.@)
+ */
 DWORD WINAPI phoneInitialize(LPHPHONEAPP lphPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
 {
     FIXME("(%p, %04x, %p, %s, %p): stub.\n", lphPhoneApp, hInstance, lpfnCallback, lpszAppName, lpdwNumDevs);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneNegotiateAPIVersion (TAPI32.@)
+ */
 DWORD WINAPI phoneNegotiateAPIVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, LPDWORD lpdwAPIVersion, LPPHONEEXTENSIONID lpExtensionID)
 {
     FIXME("(): stub.\n");
     return 0;
 }
 
+/***********************************************************************
+ *		phoneNegotiateExtVersion (TAPI32.@)
+ */
 DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
 		                 DWORD dwAPIVersion, DWORD dwExtLowVersion,
 				 DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
@@ -133,66 +190,99 @@ DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
     return 0;
 }
 
+/***********************************************************************
+ *		phoneOpen (TAPI32.@)
+ */
 DWORD WINAPI phoneOpen(HPHONEAPP hPhoneApp, DWORD dwDeviceID, LPHPHONE lphPhone, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges)
 {
     FIXME("(): stub.\n");
     return 0;
 }
 
+/***********************************************************************
+ *		phoneSetButtonInfo (TAPI32.@)
+ */
 DWORD WINAPI phoneSetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo)
 {
     FIXME("(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpButtonInfo);
     return 0;
 }
 
+/***********************************************************************
+ *		phoneSetData (TAPI32.@)
+ */
 DWORD WINAPI phoneSetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
 {
     FIXME("(%04x, %08lx, %p, %ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetDisplay (TAPI32.@)
+ */
 DWORD WINAPI phoneSetDisplay(HPHONE hPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpszDisplay, DWORD dwSize)
 {
     FIXME("(%04x, '%s' at %ld/%ld, len %ld): stub.\n", hPhone, lpszDisplay, dwRow, dwColumn, dwSize);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetGain (TAPI32.@)
+ */
 DWORD WINAPI phoneSetGain(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwGain)
 {
     FIXME("(%04x, %08lx, %ld): stub.\n", hPhone, dwHookSwitchDev, dwGain);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetHookSwitch (TAPI32.@)
+ */
 DWORD WINAPI phoneSetHookSwitch(HPHONE hPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode)
 {
     FIXME("(%04x, %08lx, %08lx): stub.\n", hPhone, dwHookSwitchDevs, dwHookSwitchMode);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetLamp (TAPI32.@)
+ */
 DWORD WINAPI phoneSetLamp(HPHONE hPhone, DWORD dwButtonLampID, DWORD lpdwLampMode)
 {
     FIXME("(%04x, %08lx, %08lx): stub.\n", hPhone, dwButtonLampID, lpdwLampMode);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetRing (TAPI32.@)
+ */
 DWORD WINAPI phoneSetRing(HPHONE hPhone, DWORD dwRingMode, DWORD dwVolume)
 {
     FIXME("(%04x, %08lx, %08ld): stub.\n", hPhone, dwRingMode, dwVolume);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneSetStatusMessages (TAPI32.@)
+ */
 DWORD WINAPI phoneSetStatusMessages(HPHONE hPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates)
 {
     FIXME("(%04x, %08lx, %08lx, %08lx): stub.\n", hPhone, dwPhoneStates, dwButtonModes, dwButtonStates);
     return 0; /* FIXME ? */
 }
 
+/***********************************************************************
+ *		phoneSetVolume (TAPI32.@)
+ */
 DWORD WINAPI phoneSetVolume(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwVolume)
 {
     FIXME("(%04x, %08lx, %08ld): stub.\n", hPhone, dwHookSwitchDev, dwVolume);
     return 1;
 }
 
+/***********************************************************************
+ *		phoneShutdown (TAPI32.@)
+ */
 DWORD WINAPI phoneShutdown(HPHONEAPP hPhoneApp)
 {
     FIXME("(%04x): stub.\n", hPhoneApp);

dlls/version/install.c

@@ -158,7 +158,7 @@ static int  testFileExclusiveExistence(
 
 /*****************************************************************************
  *
- *   VerFindFile() [VER.8]
+ *   VerFindFileA() [VER.8]
  *   Determines where to install a file based on whether it locates another
  *   version of the file in the system.  The values VerFindFile returns are
  *   used in a subsequent call to the VerInstallFile function.
@@ -319,7 +319,9 @@ DWORD WINAPI VerFindFileA(
     return retval;
 }
 
-/* VerFindFile32W						[VERSION.6] */
+/*****************************************************************************
+ * VerFindFileW						[VERSION.6]
+ */
 DWORD WINAPI VerFindFileW(
 	UINT flags,LPCWSTR filename,LPCWSTR windir,LPCWSTR appdir,
 	LPWSTR curdir,UINT *pcurdirlen,LPWSTR destdir,UINT *pdestdirlen )
@@ -389,7 +391,7 @@ _error2vif(DWORD error) {
 
 
 /******************************************************************************
- * VerInstallFile32A [VERSION.7]
+ * VerInstallFileA [VERSION.7]
  */
 DWORD WINAPI VerInstallFileA(
 	UINT flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
@@ -555,7 +557,9 @@ DWORD WINAPI VerInstallFileA(
 }
 
 
-/* VerInstallFile32W				[VERSION.8] */
+/******************************************************************************
+ * VerInstallFileW				[VERSION.8]
+ */
 DWORD WINAPI VerInstallFileW(
 	UINT flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
 	LPCWSTR destdir,LPCWSTR curdir,LPWSTR tmpfile,UINT *tmpfilelen )

dlls/win32s/w32skernel.c

@@ -10,6 +10,9 @@
 #include "wine/w32skrnl.h"
 #include "winbase.h"
 
+/***********************************************************************
+ *		GetWin32sDirectory
+ */
 LPSTR WINAPI GetWin32sDirectory(void)
 {
     static char sysdir[0x80];
@@ -23,7 +26,10 @@ LPSTR WINAPI GetWin32sDirectory(void)
     return text; 
 }
 
-/* FIXME */
+/***********************************************************************
+ *		_GetThunkBuff
+ * FIXME: ???
+ */
 SEGPTR WINAPI _GetThunkBuff(void)
 {
 	return (SEGPTR)NULL;

dlls/winmm/joystick.c

@@ -96,7 +96,7 @@ static	void	CALLBACK	JOY_Timer(HWND hWnd, UINT wMsg, UINT wTimer, DWORD dwTime)
 }
 
 /**************************************************************************
- * 				JoyGetNumDevs		[WINMM.30]
+ * 				joyGetNumDevs		[WINMM.30]
  */
 UINT WINAPI joyGetNumDevs(void)
 {
@@ -112,7 +112,7 @@ UINT WINAPI joyGetNumDevs(void)
 }
 
 /**************************************************************************
- * 				JoyGetNumDevs		[MMSYSTEM.101]
+ * 				joyGetNumDevs		[MMSYSTEM.101]
  */
 UINT16 WINAPI joyGetNumDevs16(void)
 {
@@ -120,7 +120,7 @@ UINT16 WINAPI joyGetNumDevs16(void)
 }
 
 /**************************************************************************
- * 				JoyGetDevCaps		[WINMM.27]
+ * 				joyGetDevCapsA		[WINMM.27]
  */
 MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
 {
@@ -134,7 +134,7 @@ MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
 }   
 
 /**************************************************************************
- * 				JoyGetDevCaps		[WINMM.28]
+ * 				joyGetDevCapsW		[WINMM.28]
  */
 MMRESULT WINAPI joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps, UINT wSize)
 {
@@ -174,7 +174,7 @@ MMRESULT WINAPI joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps, UINT wSize)
 }
 
 /**************************************************************************
- * 				JoyGetDevCaps		[MMSYSTEM.102]
+ * 				joyGetDevCaps		[MMSYSTEM.102]
  */
 MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
 {
@@ -214,7 +214,7 @@ MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
 }
 
 /**************************************************************************
- *                              JoyGetPosEx             [WINMM.32]
+ *                              joyGetPosEx             [WINMM.32]
  */
 MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo)
 {
@@ -239,7 +239,7 @@ MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo)
 }
 
 /**************************************************************************
- *                              JoyGetPosEx16           [MMSYSTEM.]
+ *                              joyGetPosEx16           [MMSYSTEM.]
  */
 MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
 {
@@ -247,7 +247,7 @@ MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
 }
 
 /**************************************************************************
- * 				JoyGetPos	       	[WINMM.31]
+ * 				joyGetPos	       	[WINMM.31]
  */
 MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo)
 {
@@ -265,7 +265,7 @@ MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo)
 }
 
 /**************************************************************************
- * 				JoyGetPos16	       	[MMSYSTEM.103]
+ * 				joyGetPos16	       	[MMSYSTEM.103]
  */
 MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
 {
@@ -284,7 +284,7 @@ MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
 }
 
 /**************************************************************************
- * 				JoyGetThreshold		[WINMM.36]
+ * 				joyGetThreshold		[WINMM.36]
  */
 MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
 {
@@ -297,7 +297,7 @@ MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
 }
 
 /**************************************************************************
- * 				JoyGetThreshold		[MMSYSTEM.104]
+ * 				joyGetThreshold		[MMSYSTEM.104]
  */
 MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
 {
@@ -310,7 +310,7 @@ MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
 }
 
 /**************************************************************************
- * 				JoyReleaseCapture	[WINMM.34]
+ * 				joyReleaseCapture	[WINMM.34]
  */
 MMRESULT WINAPI joyReleaseCapture(UINT wID)
 {
@@ -328,7 +328,7 @@ MMRESULT WINAPI joyReleaseCapture(UINT wID)
 }
 
 /**************************************************************************
- * 				JoyReleaseCapture	[MMSYSTEM.105]
+ * 				joyReleaseCapture	[MMSYSTEM.105]
  */
 MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
 {
@@ -336,7 +336,7 @@ MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
 }
 
 /**************************************************************************
- * 				JoySetCapture		[WINMM.35]
+ * 				joySetCapture		[WINMM.35]
  */
 MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL bChanged)
 {
@@ -362,7 +362,7 @@ MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL bChanged)
 }
 
 /**************************************************************************
- * 				JoySetCapture		[MMSYSTEM.106]
+ * 				joySetCapture		[MMSYSTEM.106]
  */
 MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged)
 {
@@ -370,7 +370,7 @@ MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL1
 }
 
 /**************************************************************************
- * 				JoySetThreshold		[WINMM.36]
+ * 				joySetThreshold		[WINMM.36]
  */
 MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
 {
@@ -384,7 +384,7 @@ MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
 }
 
 /**************************************************************************
- * 				JoySetThreshold		[MMSYSTEM.107]
+ * 				joySetThreshold		[MMSYSTEM.107]
  */
 MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
 {
@@ -392,7 +392,7 @@ MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
 }
 
 /**************************************************************************
- * 				JoySetCalibration	[MMSYSTEM.109]
+ * 				joySetCalibration	[MMSYSTEM.109]
  */
 MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
 {

dlls/winmm/mmsystem.c

@@ -1384,7 +1384,7 @@ UINT16 WINAPI auxGetNumDevs16(void)
 }
 
 /**************************************************************************
- * 				auxGetDevCaps		[WINMM.20]
+ * 				auxGetDevCapsW		[WINMM.20]
  */
 UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
 {
@@ -1401,7 +1401,7 @@ UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
 }
 
 /**************************************************************************
- * 				auxGetDevCaps		[WINMM.21]
+ * 				auxGetDevCapsA		[WINMM.21]
  */
 UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
 {
@@ -2522,7 +2522,7 @@ UINT16 WINAPI midiInGetNumDevs16(void)
 }
 
 /**************************************************************************
- * 				midiInGetDevCaps	[WINMM.60]
+ * 				midiInGetDevCapsW	[WINMM.60]
  */
 UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
 {
@@ -2540,7 +2540,7 @@ UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
 }
 
 /**************************************************************************
- * 				midiInGetDevCaps	[WINMM.59]
+ * 				midiInGetDevCapsA	[WINMM.59]
  */
 UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
 {
@@ -2575,7 +2575,7 @@ UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
 }
 
 /**************************************************************************
- * 				midiInGetErrorText 		[WINMM.62]
+ * 				midiInGetErrorTextW 		[WINMM.62]
  */
 UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
 {
@@ -2588,7 +2588,7 @@ UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
 }
 
 /**************************************************************************
- * 				midiInGetErrorText 		[WINMM.61]
+ * 				midiInGetErrorTextA 		[WINMM.61]
  */
 UINT WINAPI midiInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
 {
@@ -4186,7 +4186,7 @@ UINT16 WINAPI waveInGetNumDevs16(void)
 }
 
 /**************************************************************************
- * 				waveInGetDevCapsA 		[WINMM.147]
+ * 				waveInGetDevCapsW 		[WINMM.147]
  */
 UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
 {

dlls/winmm/wineoss/audio.c

@@ -1441,7 +1441,7 @@ DWORD WINAPI OSS_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
 #else /* !HAVE_OSS */
 
 /**************************************************************************
- * 				wodMessage			[sample driver]
+ * 				OSS_wodMessage			[sample driver]
  */
 DWORD WINAPI OSS_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser, 
 			    DWORD dwParam1, DWORD dwParam2)
@@ -1451,7 +1451,7 @@ DWORD WINAPI OSS_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
 }
 
 /**************************************************************************
- * 				widMessage			[sample driver]
+ * 				OSS_widMessage			[sample driver]
  */
 DWORD WINAPI OSS_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser, 
 			    DWORD dwParam1, DWORD dwParam2)

dlls/winsock/socket.c

@@ -694,7 +694,7 @@ struct ws_protoent* _check_buffer_pe(LPWSINFO pwsi, int size)
 /***********************************************************************
  *		accept()		(WSOCK32.1)
  */
-SOCKET WINAPI WINSOCK_accept(SOCKET s, struct sockaddr *addr,
+SOCKET WINAPI WSOCK32_accept(SOCKET s, struct sockaddr *addr,
                                  INT *addrlen32)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
@@ -756,7 +756,7 @@ SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct sockaddr* addr,
                                  INT16* addrlen16 )
 {
     INT addrlen32 = addrlen16 ? *addrlen16 : 0;
-    SOCKET retSocket = WINSOCK_accept( s, addr, &addrlen32 );
+    SOCKET retSocket = WSOCK32_accept( s, addr, &addrlen32 );
     if( addrlen16 ) *addrlen16 = (INT16)addrlen32;
     return (SOCKET16)retSocket;
 }
@@ -764,7 +764,7 @@ SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct sockaddr* addr,
 /***********************************************************************
  *		bind()			(WSOCK32.2)
  */
-INT WINAPI WINSOCK_bind(SOCKET s, struct sockaddr *name, INT namelen)
+INT WINAPI WSOCK32_bind(SOCKET s, struct sockaddr *name, INT namelen)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
 #ifdef HAVE_IPX
@@ -841,13 +841,13 @@ INT WINAPI WINSOCK_bind(SOCKET s, struct sockaddr *name, INT namelen)
  */
 INT16 WINAPI WINSOCK_bind16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
 {
-  return (INT16)WINSOCK_bind( s, name, namelen );
+  return (INT16)WSOCK32_bind( s, name, namelen );
 }
 
 /***********************************************************************
  *		closesocket()		(WSOCK32.3)
  */
-INT WINAPI WINSOCK_closesocket(SOCKET s)
+INT WINAPI WSOCK32_closesocket(SOCKET s)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -866,13 +866,13 @@ INT WINAPI WINSOCK_closesocket(SOCKET s)
  */
 INT16 WINAPI WINSOCK_closesocket16(SOCKET16 s)
 {
-    return (INT16)WINSOCK_closesocket(s);
+    return (INT16)WSOCK32_closesocket(s);
 }
 
 /***********************************************************************
  *		connect()		(WSOCK32.4)
  */
-INT WINAPI WINSOCK_connect(SOCKET s, struct sockaddr *name, INT namelen)
+INT WINAPI WSOCK32_connect(SOCKET s, struct sockaddr *name, INT namelen)
 {
   LPWSINFO                 pwsi = WINSOCK_GetIData();
 #ifdef HAVE_IPX
@@ -958,13 +958,13 @@ connect_success:
  */
 INT16 WINAPI WINSOCK_connect16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
 {
-  return (INT16)WINSOCK_connect( s, name, namelen );
+  return (INT16)WSOCK32_connect( s, name, namelen );
 }
 
 /***********************************************************************
  *		getpeername()		(WSOCK32.5)
  */
-INT WINAPI WINSOCK_getpeername(SOCKET s, struct sockaddr *name,
+INT WINAPI WSOCK32_getpeername(SOCKET s, struct sockaddr *name,
                                    INT *namelen)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
@@ -1007,7 +1007,7 @@ INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct sockaddr *name,
                                    INT16 *namelen16)
 {
     INT namelen32 = *namelen16;
-    INT retVal = WINSOCK_getpeername( s, name, &namelen32 );
+    INT retVal = WSOCK32_getpeername( s, name, &namelen32 );
 
 #if DEBUG_SOCKADDR
     dump_sockaddr(name);
@@ -1020,7 +1020,7 @@ INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct sockaddr *name,
 /***********************************************************************
  *		getsockname()		(WSOCK32.6)
  */
-INT WINAPI WINSOCK_getsockname(SOCKET s, struct sockaddr *name,
+INT WINAPI WSOCK32_getsockname(SOCKET s, struct sockaddr *name,
                                    INT *namelen)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
@@ -1067,7 +1067,7 @@ INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct sockaddr *name,
     if( namelen16 )
     {
         INT namelen32 = *namelen16;
-        retVal = WINSOCK_getsockname( s, name, &namelen32 );
+        retVal = WSOCK32_getsockname( s, name, &namelen32 );
        *namelen16 = namelen32;
 
 #if DEBUG_SOCKADDR
@@ -1083,7 +1083,7 @@ INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct sockaddr *name,
 /***********************************************************************
  *		getsockopt()		(WSOCK32.7)
  */
-INT WINAPI WINSOCK_getsockopt(SOCKET s, INT level, 
+INT WINAPI WSOCK32_getsockopt(SOCKET s, INT level, 
                                   INT optname, char *optval, INT *optlen)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
@@ -1115,7 +1115,7 @@ INT16 WINAPI WINSOCK_getsockopt16(SOCKET16 s, INT16 level,
     INT *p = &optlen32;
     INT retVal;
     if( optlen ) optlen32 = *optlen; else p = NULL;
-    retVal = WINSOCK_getsockopt( s, (UINT16)level, optname, optval, p );
+    retVal = WSOCK32_getsockopt( s, (UINT16)level, optname, optval, p );
     if( optlen ) *optlen = optlen32;
     return (INT16)retVal;
 }
@@ -1133,7 +1133,7 @@ u_short WINAPI WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
  */
 u_long WINAPI WINSOCK_inet_addr(char *cp)      { return( inet_addr(cp) ); }
 /***********************************************************************
- *		htohl()			(WINSOCK.14)(WSOCK32.14)
+ *		ntohl()			(WINSOCK.14)(WSOCK32.14)
  */
 u_long WINAPI WINSOCK_ntohl(u_long netlong)    { return( ntohl(netlong) ); }
 /***********************************************************************
@@ -1144,7 +1144,7 @@ u_short WINAPI WINSOCK_ntohs(u_short netshort)  { return( ntohs(netshort) ); }
 /***********************************************************************
  *		inet_ntoa()		(WINSOCK.11)(WSOCK32.11)
  */
-char* WINAPI WINSOCK_inet_ntoa(struct in_addr in)
+char* WINAPI WSOCK32_inet_ntoa(struct in_addr in)
 {
   /* use "buffer for dummies" here because some applications have 
    * propensity to decode addresses in ws_hostent structure without 
@@ -1176,14 +1176,14 @@ char* WINAPI WINSOCK_inet_ntoa(struct in_addr in)
 
 SEGPTR WINAPI WINSOCK_inet_ntoa16(struct in_addr in)
 {
-  char* retVal = WINSOCK_inet_ntoa(in);
+  char* retVal = WSOCK32_inet_ntoa(in);
   return retVal ? SEGPTR_GET(retVal) : (SEGPTR)NULL;
 }
 
 /***********************************************************************
  *		ioctlsocket()		(WSOCK32.12)
  */
-INT WINAPI WINSOCK_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
+INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
 {
   LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -1249,14 +1249,14 @@ INT WINAPI WINSOCK_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
  */
 INT16 WINAPI WINSOCK_ioctlsocket16(SOCKET16 s, LONG cmd, ULONG *argp)
 {
-    return (INT16)WINSOCK_ioctlsocket( s, cmd, argp );
+    return (INT16)WSOCK32_ioctlsocket( s, cmd, argp );
 }
 
 
 /***********************************************************************
  *		listen()		(WSOCK32.13)
  */
-INT WINAPI WINSOCK_listen(SOCKET s, INT backlog)
+INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -1284,14 +1284,14 @@ INT WINAPI WINSOCK_listen(SOCKET s, INT backlog)
  */
 INT16 WINAPI WINSOCK_listen16(SOCKET16 s, INT16 backlog)
 {
-    return (INT16)WINSOCK_listen( s, backlog );
+    return (INT16)WSOCK32_listen( s, backlog );
 }
 
 
 /***********************************************************************
  *		recv()			(WSOCK32.16)
  */
-INT WINAPI WINSOCK_recv(SOCKET s, char *buf, INT len, INT flags)
+INT WINAPI WSOCK32_recv(SOCKET s, char *buf, INT len, INT flags)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -1330,14 +1330,14 @@ INT WINAPI WINSOCK_recv(SOCKET s, char *buf, INT len, INT flags)
  */
 INT16 WINAPI WINSOCK_recv16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
 {
-    return (INT16)WINSOCK_recv( s, buf, len, flags );
+    return (INT16)WSOCK32_recv( s, buf, len, flags );
 }
 
 
 /***********************************************************************
  *		recvfrom()		(WSOCK32.17)
  */
-INT WINAPI WINSOCK_recvfrom(SOCKET s, char *buf, INT len, INT flags, 
+INT WINAPI WSOCK32_recvfrom(SOCKET s, char *buf, INT len, INT flags, 
                                 struct sockaddr *from, INT *fromlen32)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
@@ -1417,7 +1417,7 @@ INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
     INT retVal;
 
     if( fromlen16 ) fromlen32 = *fromlen16; else p = NULL;
-    retVal = WINSOCK_recvfrom( s, buf, len, flags, from, p );
+    retVal = WSOCK32_recvfrom( s, buf, len, flags, from, p );
     if( fromlen16 ) *fromlen16 = fromlen32;
     return (INT16)retVal;
 }
@@ -1497,7 +1497,7 @@ INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
     return (INT16)__ws_select( FALSE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
 }
 
-INT WINAPI WINSOCK_select(INT nfds, ws_fd_set32 *ws_readfds,
+INT WINAPI WSOCK32_select(INT nfds, ws_fd_set32 *ws_readfds,
                               ws_fd_set32 *ws_writefds, ws_fd_set32 *ws_exceptfds,
                               struct timeval *timeout)
 {
@@ -1509,7 +1509,7 @@ INT WINAPI WINSOCK_select(INT nfds, ws_fd_set32 *ws_readfds,
 /***********************************************************************
  *		send()			(WSOCK32.19)
  */
-INT WINAPI WINSOCK_send(SOCKET s, char *buf, INT len, INT flags)
+INT WINAPI WSOCK32_send(SOCKET s, char *buf, INT len, INT flags)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -1548,13 +1548,13 @@ INT WINAPI WINSOCK_send(SOCKET s, char *buf, INT len, INT flags)
  */
 INT16 WINAPI WINSOCK_send16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
 {
-    return WINSOCK_send( s, buf, len, flags );
+    return WSOCK32_send( s, buf, len, flags );
 }
 
 /***********************************************************************
  *		sendto()		(WSOCK32.20)
  */
-INT WINAPI WINSOCK_sendto(SOCKET s, char *buf, INT len, INT flags,
+INT WINAPI WSOCK32_sendto(SOCKET s, char *buf, INT len, INT flags,
                               struct sockaddr *to, INT tolen)
 {
     LPWSINFO                 pwsi = WINSOCK_GetIData();
@@ -1623,13 +1623,13 @@ INT WINAPI WINSOCK_sendto(SOCKET s, char *buf, INT len, INT flags,
 INT16 WINAPI WINSOCK_sendto16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
                               struct sockaddr *to, INT16 tolen)
 {
-    return (INT16)WINSOCK_sendto( s, buf, len, flags, to, tolen );
+    return (INT16)WSOCK32_sendto( s, buf, len, flags, to, tolen );
 }
 
 /***********************************************************************
  *		setsockopt()		(WSOCK32.21)
  */
-INT WINAPI WINSOCK_setsockopt(SOCKET16 s, INT level, INT optname, 
+INT WINAPI WSOCK32_setsockopt(SOCKET16 s, INT level, INT optname, 
                                   char *optval, INT optlen)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
@@ -1683,14 +1683,14 @@ INT16 WINAPI WINSOCK_setsockopt16(SOCKET16 s, INT16 level, INT16 optname,
                                   char *optval, INT16 optlen)
 {
     if( !optval ) return SOCKET_ERROR;
-    return (INT16)WINSOCK_setsockopt( s, (UINT16)level, optname, optval, optlen );
+    return (INT16)WSOCK32_setsockopt( s, (UINT16)level, optname, optval, optlen );
 }
 
 
 /***********************************************************************
  *		shutdown()		(WSOCK32.22)
  */
-INT WINAPI WINSOCK_shutdown(SOCKET s, INT how)
+INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
 {
     LPWSINFO      pwsi = WINSOCK_GetIData();
 
@@ -1745,14 +1745,14 @@ INT WINAPI WINSOCK_shutdown(SOCKET s, INT how)
  */
 INT16 WINAPI WINSOCK_shutdown16(SOCKET16 s, INT16 how)
 {
-    return (INT16)WINSOCK_shutdown( s, how );
+    return (INT16)WSOCK32_shutdown( s, how );
 }
 
 
 /***********************************************************************
  *		socket()		(WSOCK32.23)
  */
-SOCKET WINAPI WINSOCK_socket(INT af, INT type, INT protocol)
+SOCKET WINAPI WSOCK32_socket(INT af, INT type, INT protocol)
 {
   LPWSINFO      pwsi = WINSOCK_GetIData();
   struct create_socket_request *req = get_req_buffer();
@@ -1830,7 +1830,7 @@ SOCKET WINAPI WINSOCK_socket(INT af, INT type, INT protocol)
  */
 SOCKET16 WINAPI WINSOCK_socket16(INT16 af, INT16 type, INT16 protocol)
 {
-    return (SOCKET16)WINSOCK_socket( af, type, protocol );
+    return (SOCKET16)WSOCK32_socket( af, type, protocol );
 }
     
 
@@ -1874,7 +1874,7 @@ SEGPTR WINAPI WINSOCK_gethostbyaddr16(const char *addr, INT16 len, INT16 type)
     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
 }
 
-struct WIN_hostent* WINAPI WINSOCK_gethostbyaddr(const char *addr, INT len,
+struct WIN_hostent* WINAPI WSOCK32_gethostbyaddr(const char *addr, INT len,
                                                 INT type)
 {
     TRACE("ptr %08x, len %d, type %d\n",
@@ -1909,7 +1909,7 @@ SEGPTR WINAPI WINSOCK_gethostbyname16(const char *name)
     return (retval)? SEGPTR_GET(retval) : ((SEGPTR)NULL) ;
 }
 
-struct WIN_hostent* WINAPI WINSOCK_gethostbyname(const char* name)
+struct WIN_hostent* WINAPI WSOCK32_gethostbyname(const char* name)
 {
     TRACE("%s\n", (name)?name:NULL_STRING);
     return __ws_gethostbyname( name, WS_DUP_LINEAR );
@@ -1943,7 +1943,7 @@ SEGPTR WINAPI WINSOCK_getprotobyname16(const char *name)
     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
 }
 
-struct WIN_protoent* WINAPI WINSOCK_getprotobyname(const char* name)
+struct WIN_protoent* WINAPI WSOCK32_getprotobyname(const char* name)
 {
     TRACE("%s\n", (name)?name:NULL_STRING);
     return __ws_getprotobyname(name, WS_DUP_LINEAR);
@@ -1977,7 +1977,7 @@ SEGPTR WINAPI WINSOCK_getprotobynumber16(INT16 number)
     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
 }
 
-struct WIN_protoent* WINAPI WINSOCK_getprotobynumber(INT number)
+struct WIN_protoent* WINAPI WSOCK32_getprotobynumber(INT number)
 {
     TRACE("%i\n", number);
     return __ws_getprotobynumber(number, WS_DUP_LINEAR);
@@ -2024,7 +2024,7 @@ SEGPTR WINAPI WINSOCK_getservbyname16(const char *name, const char *proto)
     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
 }
 
-struct WIN_servent* WINAPI WINSOCK_getservbyname(const char *name, const char *proto)
+struct WIN_servent* WINAPI WSOCK32_getservbyname(const char *name, const char *proto)
 {
     TRACE("'%s', '%s'\n",
                             (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
@@ -2069,7 +2069,7 @@ SEGPTR WINAPI WINSOCK_getservbyport16(INT16 port, const char *proto)
     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
 }
 
-struct WIN_servent* WINAPI WINSOCK_getservbyport(INT port, const char *proto)
+struct WIN_servent* WINAPI WSOCK32_getservbyport(INT port, const char *proto)
 {
     TRACE("%i, '%s'\n",
                             (int)port, (proto)?proto:NULL_STRING);
@@ -2080,7 +2080,7 @@ struct WIN_servent* WINAPI WINSOCK_getservbyport(INT port, const char *proto)
 /***********************************************************************
  *              gethostname()           (WSOCK32.57)
  */
-INT WINAPI WINSOCK_gethostname(char *name, INT namelen)
+INT WINAPI WSOCK32_gethostname(char *name, INT namelen)
 {
     LPWSINFO              pwsi = WINSOCK_GetIData();
 
@@ -2099,7 +2099,7 @@ INT WINAPI WINSOCK_gethostname(char *name, INT namelen)
  */
 INT16 WINAPI WINSOCK_gethostname16(char *name, INT16 namelen)
 {
-    return (INT16)WINSOCK_gethostname(name, namelen);
+    return (INT16)WSOCK32_gethostname(name, namelen);
 }
 
 
@@ -2246,7 +2246,7 @@ INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent)
 INT     WINAPI   WSARecvEx(SOCKET s, char *buf, INT len, INT *flags) {
   FIXME("(WSARecvEx) partial packet return value not set \n");
 
-  return WINSOCK_recv(s, buf, len, *flags);
+  return WSOCK32_recv(s, buf, len, *flags);
 }
 
 

dlls/winsock/wsock32.spec

@@ -2,36 +2,36 @@ name	wsock32
 type	win32
 init	WSOCK32_LibMain
 
-001 stdcall accept(long ptr ptr) WINSOCK_accept
+001 stdcall accept(long ptr ptr) WSOCK32_accept
-002 stdcall bind(long ptr long) WINSOCK_bind
+002 stdcall bind(long ptr long) WSOCK32_bind
-003 stdcall closesocket(long) WINSOCK_closesocket
+003 stdcall closesocket(long) WSOCK32_closesocket
-004 stdcall connect(long ptr long) WINSOCK_connect
+004 stdcall connect(long ptr long) WSOCK32_connect
-005 stdcall getpeername(long ptr ptr) WINSOCK_getpeername
+005 stdcall getpeername(long ptr ptr) WSOCK32_getpeername
-006 stdcall getsockname(long ptr ptr) WINSOCK_getsockname
+006 stdcall getsockname(long ptr ptr) WSOCK32_getsockname
-007 stdcall getsockopt(long long long ptr ptr) WINSOCK_getsockopt
+007 stdcall getsockopt(long long long ptr ptr) WSOCK32_getsockopt
 008 stdcall htonl(long) WINSOCK_htonl
 009 stdcall htons(long) WINSOCK_htons
 010 stdcall inet_addr(str) WINSOCK_inet_addr
-011 stdcall inet_ntoa(ptr) WINSOCK_inet_ntoa
+011 stdcall inet_ntoa(ptr) WSOCK32_inet_ntoa
-012 stdcall ioctlsocket(long long ptr) WINSOCK_ioctlsocket
+012 stdcall ioctlsocket(long long ptr) WSOCK32_ioctlsocket
-013 stdcall listen(long long) WINSOCK_listen
+013 stdcall listen(long long) WSOCK32_listen
 014 stdcall ntohl(long) WINSOCK_ntohl
 015 stdcall ntohs(long) WINSOCK_ntohs
-016 stdcall recv(long ptr long long) WINSOCK_recv
+016 stdcall recv(long ptr long long) WSOCK32_recv
-017 stdcall recvfrom(long ptr long long ptr ptr) WINSOCK_recvfrom
+017 stdcall recvfrom(long ptr long long ptr ptr) WSOCK32_recvfrom
-018 stdcall select(long ptr ptr ptr ptr) WINSOCK_select
+018 stdcall select(long ptr ptr ptr ptr) WSOCK32_select
-019 stdcall send(long ptr long long) WINSOCK_send
+019 stdcall send(long ptr long long) WSOCK32_send
-020 stdcall sendto(long ptr long long ptr long) WINSOCK_sendto
+020 stdcall sendto(long ptr long long ptr long) WSOCK32_sendto
-021 stdcall setsockopt(long long long ptr long) WINSOCK_setsockopt
+021 stdcall setsockopt(long long long ptr long) WSOCK32_setsockopt
-022 stdcall shutdown(long long) WINSOCK_shutdown
+022 stdcall shutdown(long long) WSOCK32_shutdown
-023 stdcall socket(long long long) WINSOCK_socket
+023 stdcall socket(long long long) WSOCK32_socket
-051 stdcall gethostbyaddr(ptr long long) WINSOCK_gethostbyaddr
+051 stdcall gethostbyaddr(ptr long long) WSOCK32_gethostbyaddr
-052 stdcall gethostbyname(str) WINSOCK_gethostbyname
+052 stdcall gethostbyname(str) WSOCK32_gethostbyname
-053 stdcall getprotobyname(str) WINSOCK_getprotobyname
+053 stdcall getprotobyname(str) WSOCK32_getprotobyname
-054 stdcall getprotobynumber(long) WINSOCK_getprotobynumber
+054 stdcall getprotobynumber(long) WSOCK32_getprotobynumber
-055 stdcall getservbyname(str str) WINSOCK_getservbyname
+055 stdcall getservbyname(str str) WSOCK32_getservbyname
-056 stdcall getservbyport(long str) WINSOCK_getservbyport
+056 stdcall getservbyport(long str) WSOCK32_getservbyport
-057 stdcall gethostname(ptr long) WINSOCK_gethostname
+057 stdcall gethostname(ptr long) WSOCK32_gethostname
 101 stdcall WSAAsyncSelect(long long long long) WSAAsyncSelect
 102 stdcall WSAAsyncGetHostByAddr(long long ptr long long ptr long) WSAAsyncGetHostByAddr
 103 stdcall WSAAsyncGetHostByName(long long str ptr long) WSAAsyncGetHostByName

misc/ddeml.c

@@ -1064,7 +1064,7 @@ DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, IN
  *  1.0      March 1999 K Matthews		stub only
  */
 
-DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax, int codepage)
+DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax, INT16 codepage)
 {
 	FIXME("(%ld, 0x%lx, %p, %ld, %d): stub \n", 
          idInst,
@@ -2051,7 +2051,7 @@ UINT WINAPI DdeGetLastError( DWORD idInst )
 /*****************************************************************
  *            DdeCmpStringHandles16 (DDEML.36)
  */
-int WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
+INT16 WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
 {
      return DdeCmpStringHandles(hsz1, hsz2);
 }
@@ -2067,7 +2067,7 @@ int WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
  * 0  The values of hsz 1 and 2 are the same or both zero.
  * 1  The value of hsz2 is zero of less than hsz1
  */
-int WINAPI DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
+INT WINAPI DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
 {
     CHAR psz1[MAX_BUFFER_LEN];
     CHAR psz2[MAX_BUFFER_LEN];