ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix some more -Wmissing-declarations warnings.

This commit is contained in:
Stefan Huehner 2005-07-05 11:05:50 +00:00 committed by Alexandre Julliard
parent c7fdb4565a
commit 17ed5537e7
11 changed files with 56 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/advapi32/crypt.c
View File

@ -174,7 +174,7 @@ static BOOL CALLBACK CRYPT_ReturnhWnd(HWND *phWnd)
if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
#define CRYPT_GetProvFuncOpt(name) \ #define CRYPT_GetProvFuncOpt(name) \
provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name) provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
PCRYPTPROV CRYPT_LoadProvider(PSTR pImage) static PCRYPTPROV CRYPT_LoadProvider(PSTR pImage)
{ {
PCRYPTPROV provider; PCRYPTPROV provider;
DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY; DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;

38
dlls/cabinet/fdi.c
View File

@ -243,7 +243,7 @@ HFDI __cdecl FDICreate(
* *
* returns the file pointer position of a file handle. * returns the file pointer position of a file handle.
*/ */
long FDI_getoffset(HFDI hfdi, INT_PTR hf) static long FDI_getoffset(HFDI hfdi, INT_PTR hf)
{ {
return PFDI_SEEK(hfdi, hf, 0L, SEEK_CUR); return PFDI_SEEK(hfdi, hf, 0L, SEEK_CUR);
} }
@ -254,7 +254,7 @@ long FDI_getoffset(HFDI hfdi, INT_PTR hf)
* we can't use _msize; the user might not be using malloc, so we require * we can't use _msize; the user might not be using malloc, so we require
* an explicit specification of the previous size. inefficient. * an explicit specification of the previous size. inefficient.
*/ */
void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize) static void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize)
{ {
void *rslt = NULL; void *rslt = NULL;
char *irslt, *imem; char *irslt, *imem;
@ -273,7 +273,7 @@ void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize)
* *
* allocate and read an arbitrarily long string from the cabinet * allocate and read an arbitrarily long string from the cabinet
*/ */
char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize) static char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize)
{ {
size_t len=256, size_t len=256,
oldlen = 0, oldlen = 0,
@ -326,7 +326,7 @@ char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize)
* process the cabinet header in the style of FDIIsCabinet, but * process the cabinet header in the style of FDIIsCabinet, but
* without the sanity checks (and bug) * without the sanity checks (and bug)
*/ */
BOOL FDI_read_entries( static BOOL FDI_read_entries(
HFDI hfdi, HFDI hfdi,
INT_PTR hf, INT_PTR hf,
PFDICABINETINFO pfdici, PFDICABINETINFO pfdici,
@ -632,7 +632,7 @@ BOOL __cdecl FDIIsCabinet(
* *
* Initialize a model which decodes symbols from [s] to [s]+[n]-1 * Initialize a model which decodes symbols from [s] to [s]+[n]-1
*/ */
void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) { static void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) {
int i; int i;
m->shiftsleft = 4; m->shiftsleft = 4;
m->entries = n; m->entries = n;
@ -649,7 +649,7 @@ void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s)
/****************************************************************** /******************************************************************
* QTMfdi_init (internal) * QTMfdi_init (internal)
*/ */
int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) { static int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) {
unsigned int wndsize = 1 << window; unsigned int wndsize = 1 << window;
int msz = window * 2, i; int msz = window * 2, i;
cab_ULONG j; cab_ULONG j;
@ -701,7 +701,7 @@ int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) {
/************************************************************ /************************************************************
* LZXfdi_init (internal) * LZXfdi_init (internal)
*/ */
int LZXfdi_init(int window, fdi_decomp_state *decomp_state) { static int LZXfdi_init(int window, fdi_decomp_state *decomp_state) {
cab_ULONG wndsize = 1 << window; cab_ULONG wndsize = 1 << window;
int i, j, posn_slots; int i, j, posn_slots;
@ -755,7 +755,7 @@ int LZXfdi_init(int window, fdi_decomp_state *decomp_state) {
/**************************************************** /****************************************************
* NONEfdi_decomp(internal) * NONEfdi_decomp(internal)
*/ */
int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
if (inlen != outlen) return DECR_ILLEGALDATA; if (inlen != outlen) return DECR_ILLEGALDATA;
memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen); memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen);
@ -765,7 +765,7 @@ int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/******************************************************** /********************************************************
* Ziphuft_free (internal) * Ziphuft_free (internal)
*/ */
void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t) static void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
{ {
register struct Ziphuft *p, *q; register struct Ziphuft *p, *q;
@ -782,7 +782,7 @@ void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
/********************************************************* /*********************************************************
* fdi_Ziphuft_build (internal) * fdi_Ziphuft_build (internal)
*/ */
cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e, static cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e,
struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state) struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state)
{ {
cab_ULONG a; /* counter for codes of length k */ cab_ULONG a; /* counter for codes of length k */
@ -1045,7 +1045,7 @@ cab_LONG fdi_Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td,
/*********************************************************** /***********************************************************
* Zipinflate_stored (internal) * Zipinflate_stored (internal)
*/ */
cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
/* "decompress" an inflated type 0 (stored) block. */ /* "decompress" an inflated type 0 (stored) block. */
{ {
cab_ULONG n; /* number of bytes in block */ cab_ULONG n; /* number of bytes in block */
@ -1089,7 +1089,7 @@ cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
/****************************************************** /******************************************************
* fdi_Zipinflate_fixed (internal) * fdi_Zipinflate_fixed (internal)
*/ */
cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
{ {
struct Ziphuft *fixed_tl; struct Ziphuft *fixed_tl;
struct Ziphuft *fixed_td; struct Ziphuft *fixed_td;
@ -1135,7 +1135,7 @@ cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
/************************************************************** /**************************************************************
* fdi_Zipinflate_dynamic (internal) * fdi_Zipinflate_dynamic (internal)
*/ */
cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
/* decompress an inflated type 2 (dynamic Huffman codes) block. */ /* decompress an inflated type 2 (dynamic Huffman codes) block. */
{ {
cab_LONG i; /* temporary variables */ cab_LONG i; /* temporary variables */
@ -1270,7 +1270,7 @@ cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
/***************************************************** /*****************************************************
* fdi_Zipinflate_block (internal) * fdi_Zipinflate_block (internal)
*/ */
cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e == last block flag */ static cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e == last block flag */
{ /* decompress an inflated block */ { /* decompress an inflated block */
cab_ULONG t; /* block type */ cab_ULONG t; /* block type */
register cab_ULONG b; /* bit buffer */ register cab_ULONG b; /* bit buffer */
@ -1308,7 +1308,7 @@ cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e
/**************************************************** /****************************************************
* ZIPfdi_decomp(internal) * ZIPfdi_decomp(internal)
*/ */
int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
cab_LONG e; /* last block flag */ cab_LONG e; /* last block flag */
@ -1336,7 +1336,7 @@ int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/******************************************************************* /*******************************************************************
* QTMfdi_decomp(internal) * QTMfdi_decomp(internal)
*/ */
int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *window = QTM(window); cab_UBYTE *window = QTM(window);
@ -1462,7 +1462,7 @@ int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/************************************************************ /************************************************************
* fdi_lzx_read_lens (internal) * fdi_lzx_read_lens (internal)
*/ */
int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb, static int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb,
fdi_decomp_state *decomp_state) { fdi_decomp_state *decomp_state) {
cab_ULONG i,j, x,y; cab_ULONG i,j, x,y;
int z; int z;
@ -1509,7 +1509,7 @@ int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct l
/******************************************************* /*******************************************************
* LZXfdi_decomp(internal) * LZXfdi_decomp(internal)
*/ */
int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) { static int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *endinp = inpos + inlen; cab_UBYTE *endinp = inpos + inlen;
cab_UBYTE *window = LZX(window); cab_UBYTE *window = LZX(window);
@ -1841,7 +1841,7 @@ int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) {
* is also where we jump to additional cabinets in the case of split * is also where we jump to additional cabinets in the case of split
* cab's, and provide (some of) the NEXT_CABINET notification semantics. * cab's, and provide (some of) the NEXT_CABINET notification semantics.
*/ */
int fdi_decomp(struct fdi_file *fi, int savemode, fdi_decomp_state *decomp_state, static int fdi_decomp(struct fdi_file *fi, int savemode, fdi_decomp_state *decomp_state,
char *pszCabPath, PFNFDINOTIFY pfnfdin, void *pvUser) char *pszCabPath, PFNFDINOTIFY pfnfdin, void *pvUser)
{ {
cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset); cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset);

8
dlls/dinput/joystick_linux.c
View File

@ -385,7 +385,7 @@ static HRESULT setup_dinput_options(JoystickImpl * device)
return DI_OK; return DI_OK;
} }
void calculate_ids(JoystickImpl* device) static void calculate_ids(JoystickImpl* device)
{ {
int i; int i;
int axis = 0; int axis = 0;
@ -830,7 +830,7 @@ static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
return DI_NOEFFECT; return DI_NOEFFECT;
} }
LONG map_axis(JoystickImpl * This, short val, short index) static LONG map_axis(JoystickImpl * This, short val, short index)
{ {
double fval = val; double fval = val;
double fmin = This->props[index].lMin; double fmin = This->props[index].lMin;
@ -848,7 +848,7 @@ LONG map_axis(JoystickImpl * This, short val, short index)
} }
/* convert wine format offset to user format object index */ /* convert wine format offset to user format object index */
int offset_to_object(JoystickImpl *This, int offset) static int offset_to_object(JoystickImpl *This, int offset)
{ {
int i; int i;
@ -1093,7 +1093,7 @@ static HRESULT WINAPI JoystickAImpl_GetDeviceData(
return hr; return hr;
} }
int find_property(JoystickImpl * This, LPCDIPROPHEADER ph) static int find_property(JoystickImpl * This, LPCDIPROPHEADER ph)
{ {
int i; int i;
if (ph->dwHow == DIPH_BYOFFSET) { if (ph->dwHow == DIPH_BYOFFSET) {

2
dlls/iphlpapi/tests/iphlpapi.c
View File

@ -146,7 +146,7 @@ static void freeIPHlpApi(void)
still-to-be-tested 98-only functions: still-to-be-tested 98-only functions:
GetUniDirectionalAdapterInfo GetUniDirectionalAdapterInfo
*/ */
void testWin98OnlyFunctions(void) static void testWin98OnlyFunctions(void)
{ {
} }

2
dlls/msvcrt/tests/headers.c
View File

@ -294,7 +294,7 @@ static void test_structs(void)
} }
/************* Checking defines ***************/ /************* Checking defines ***************/
void test_defines(void) static void test_defines(void)
{ {
CHECK_DEF("WEOF", WEOF, MSVCRT_WEOF); CHECK_DEF("WEOF", WEOF, MSVCRT_WEOF);
CHECK_DEF("EOF", EOF, MSVCRT_EOF); CHECK_DEF("EOF", EOF, MSVCRT_EOF);

39
dlls/oleaut32/typelib.c
View File

@ -1072,14 +1072,14 @@ static void dump_TypeDesc(TYPEDESC *pTD,char *szVarType) {
} }
} }
void dump_ELEMDESC(ELEMDESC *edesc) { static void dump_ELEMDESC(ELEMDESC *edesc) {
char buf[200]; char buf[200];
dump_TypeDesc(&edesc->tdesc,buf); dump_TypeDesc(&edesc->tdesc,buf);
MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf); MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
MESSAGE("\t\tu.parmadesc.flags %x\n",edesc->u.paramdesc.wParamFlags); MESSAGE("\t\tu.parmadesc.flags %x\n",edesc->u.paramdesc.wParamFlags);
MESSAGE("\t\tu.parmadesc.lpex %p\n",edesc->u.paramdesc.pparamdescex); MESSAGE("\t\tu.parmadesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
} }
void dump_FUNCDESC(FUNCDESC *funcdesc) { static void dump_FUNCDESC(FUNCDESC *funcdesc) {
int i; int i;
MESSAGE("memid is %08lx\n",funcdesc->memid); MESSAGE("memid is %08lx\n",funcdesc->memid);
for (i=0;i<funcdesc->cParams;i++) { for (i=0;i<funcdesc->cParams;i++) {
@ -1118,10 +1118,6 @@ void dump_FUNCDESC(FUNCDESC *funcdesc) {
dump_ELEMDESC(&funcdesc->elemdescFunc); dump_ELEMDESC(&funcdesc->elemdescFunc);
} }
void dump_IDLDESC(IDLDESC *idl) {
MESSAGE("\t\twIdlflags: %d\n",idl->wIDLFlags);
}
static const char * typekind_desc[] = static const char * typekind_desc[] =
{ {
"TKIND_ENUM", "TKIND_ENUM",
@ -1135,27 +1131,6 @@ static const char * typekind_desc[] =
"TKIND_MAX" "TKIND_MAX"
}; };
void dump_TYPEATTR(TYPEATTR *tattr) {
char buf[200];
MESSAGE("\tguid: %s\n",debugstr_guid(&tattr->guid));
MESSAGE("\tlcid: %ld\n",tattr->lcid);
MESSAGE("\tmemidConstructor: %ld\n",tattr->memidConstructor);
MESSAGE("\tmemidDestructor: %ld\n",tattr->memidDestructor);
MESSAGE("\tschema: %s\n",debugstr_w(tattr->lpstrSchema));
MESSAGE("\tsizeInstance: %ld\n",tattr->cbSizeInstance);
MESSAGE("\tkind:%s\n", typekind_desc[tattr->typekind]);
MESSAGE("\tcFuncs: %d\n", tattr->cFuncs);
MESSAGE("\tcVars: %d\n", tattr->cVars);
MESSAGE("\tcImplTypes: %d\n", tattr->cImplTypes);
MESSAGE("\tcbSizeVft: %d\n", tattr->cbSizeVft);
MESSAGE("\tcbAlignment: %d\n", tattr->cbAlignment);
MESSAGE("\twTypeFlags: %d\n", tattr->wTypeFlags);
MESSAGE("\tVernum: %d.%d\n", tattr->wMajorVerNum,tattr->wMinorVerNum);
dump_TypeDesc(&tattr->tdescAlias,buf);
MESSAGE("\ttypedesc: %s\n", buf);
dump_IDLDESC(&tattr->idldescType);
}
static void dump_TLBFuncDescOne(TLBFuncDesc * pfd) static void dump_TLBFuncDescOne(TLBFuncDesc * pfd)
{ {
int i; int i;
@ -1307,7 +1282,7 @@ static void dump_TypeInfo(ITypeInfoImpl * pty)
dump_TLBImplType(pty->impltypelist); dump_TLBImplType(pty->impltypelist);
} }
void dump_VARDESC(VARDESC *v) static void dump_VARDESC(VARDESC *v)
{ {
MESSAGE("memid %ld\n",v->memid); MESSAGE("memid %ld\n",v->memid);
MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema)); MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
@ -1399,7 +1374,7 @@ static void free_deep_typedesc(TYPEDESC *tdesc)
* Functions for reading MSFT typelibs (those created by CreateTypeLib2) * Functions for reading MSFT typelibs (those created by CreateTypeLib2)
*/ */
/* read function */ /* read function */
DWORD MSFT_Read(void *buffer, DWORD count, TLBContext *pcx, long where ) static DWORD MSFT_Read(void *buffer, DWORD count, TLBContext *pcx, long where )
{ {
TRACE_(typelib)("pos=0x%08x len=0x%08lx 0x%08x 0x%08x 0x%08lx\n", TRACE_(typelib)("pos=0x%08x len=0x%08lx 0x%08x 0x%08x 0x%08lx\n",
pcx->pos, count, pcx->oStart, pcx->length, where); pcx->pos, count, pcx->oStart, pcx->length, where);
@ -1456,7 +1431,7 @@ static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
TRACE_(typelib)("%s\n", debugstr_guid(pGuid)); TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
} }
BSTR MSFT_ReadName( TLBContext *pcx, int offset) static BSTR MSFT_ReadName( TLBContext *pcx, int offset)
{ {
char * name; char * name;
MSFT_NameIntro niName; MSFT_NameIntro niName;
@ -1491,7 +1466,7 @@ BSTR MSFT_ReadName( TLBContext *pcx, int offset)
return bstrName; return bstrName;
} }
BSTR MSFT_ReadString( TLBContext *pcx, int offset) static BSTR MSFT_ReadString( TLBContext *pcx, int offset)
{ {
char * string; char * string;
INT16 length; INT16 length;
@ -2043,7 +2018,7 @@ static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
/* /*
* process a typeinfo record * process a typeinfo record
*/ */
ITypeInfoImpl * MSFT_DoTypeInfo( static ITypeInfoImpl * MSFT_DoTypeInfo(
TLBContext *pcx, TLBContext *pcx,
int count, int count,
ITypeLibImpl * pLibInfo) ITypeLibImpl * pLibInfo)

22
dlls/setupapi/virtcopy.c
View File

@ -218,7 +218,7 @@ static LPVIRTNODE *pvnlist = NULL;
static DWORD vn_num = 0; static DWORD vn_num = 0;
static DWORD vn_last = 0; static DWORD vn_last = 0;
RETERR16 VCP_VirtnodeCreate(LPVCPFILESPEC vfsSrc, LPVCPFILESPEC vfsDst, WORD fl, LPARAM lParam, LPEXPANDVTBL lpExpandVtbl) static RETERR16 VCP_VirtnodeCreate(LPVCPFILESPEC vfsSrc, LPVCPFILESPEC vfsDst, WORD fl, LPARAM lParam, LPEXPANDVTBL lpExpandVtbl)
{ {
HANDLE heap; HANDLE heap;
LPVIRTNODE lpvn; LPVIRTNODE lpvn;
@ -266,7 +266,8 @@ RETERR16 VCP_VirtnodeCreate(LPVCPFILESPEC vfsSrc, LPVCPFILESPEC vfsDst, WORD fl,
return OK; return OK;
} }
BOOL VCP_VirtnodeDelete(LPVIRTNODE lpvnDel) #if 0
static BOOL VCP_VirtnodeDelete(LPVIRTNODE lpvnDel)
{ {
DWORD n; DWORD n;
RETERR16 cbres; RETERR16 cbres;
@ -283,6 +284,7 @@ BOOL VCP_VirtnodeDelete(LPVIRTNODE lpvnDel)
} }
return FALSE; return FALSE;
} }
#endif
/*********************************************************************** /***********************************************************************
* VcpOpen (SETUPX.200) * VcpOpen (SETUPX.200)
@ -452,7 +454,7 @@ LPCSTR WINAPI VcpExplain16(LPVIRTNODE lpVn, DWORD dwWhat)
return buffer; return buffer;
} }
RETERR16 VCP_CheckPaths(void) static RETERR16 VCP_CheckPaths(void)
{ {
DWORD n; DWORD n;
LPVIRTNODE lpvn; LPVIRTNODE lpvn;
@ -470,7 +472,7 @@ RETERR16 VCP_CheckPaths(void)
return OK; return OK;
} }
RETERR16 VCP_CopyFiles(void) static RETERR16 VCP_CopyFiles(void)
{ {
char fn_src[MAX_PATH], fn_dst[MAX_PATH]; char fn_src[MAX_PATH], fn_dst[MAX_PATH];
RETERR16 res = OK, cbres; RETERR16 res = OK, cbres;
@ -559,7 +561,8 @@ RETERR16 WINAPI VcpClose16(WORD fl, LPCSTR lpszBackupDest)
return OK; return OK;
} }
RETERR16 VCP_RenameFiles(void) #if 0
static RETERR16 VCP_RenameFiles(void)
{ {
char fn_src[MAX_PATH], fn_dst[MAX_PATH]; char fn_src[MAX_PATH], fn_dst[MAX_PATH];
RETERR16 res = OK, cbres; RETERR16 res = OK, cbres;
@ -582,6 +585,7 @@ RETERR16 VCP_RenameFiles(void)
cbres = VCP_Callback(&vcp_status, VCPM_VSTATRENAMEEND, 0, 0, VCP_MsgRef); cbres = VCP_Callback(&vcp_status, VCPM_VSTATRENAMEEND, 0, 0, VCP_MsgRef);
return res; return res;
} }
#endif
/*********************************************************************** /***********************************************************************
* vcpDefCallbackProc (SETUPX.202) * vcpDefCallbackProc (SETUPX.202)
@ -616,7 +620,7 @@ static INT_PTR CALLBACK VCP_UI_FileCopyDlgProc(HWND hWndDlg, UINT iMsg, WPARAM w
return retval; return retval;
} }
BOOL VCP_UI_GetDialogTemplate(LPCVOID *template32) static BOOL VCP_UI_GetDialogTemplate(LPCVOID *template32)
{ {
HRSRC hResInfo; HRSRC hResInfo;
HGLOBAL hDlgTmpl32; HGLOBAL hDlgTmpl32;
@ -646,7 +650,7 @@ VCP_UI_FileCopyWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
return 0; return 0;
} }
void VCP_UI_RegisterProgressClass(void) static void VCP_UI_RegisterProgressClass(void)
{ {
static BOOL registered = FALSE; static BOOL registered = FALSE;
WNDCLASSA wndClass; WNDCLASSA wndClass;
@ -667,7 +671,7 @@ void VCP_UI_RegisterProgressClass(void)
RegisterClassA (&wndClass); RegisterClassA (&wndClass);
} }
RETERR16 VCP_UI_NodeCompare(LPVIRTNODE vn1, LPVIRTNODE vn2) static RETERR16 VCP_UI_NodeCompare(LPVIRTNODE vn1, LPVIRTNODE vn2)
{ {
LPCSTR file1, file2; LPCSTR file1, file2;
file1 = vsmGetStringRawName16(vn1->vfsSrc.vhstrFileName); file1 = vsmGetStringRawName16(vn1->vfsSrc.vhstrFileName);
@ -675,7 +679,7 @@ RETERR16 VCP_UI_NodeCompare(LPVIRTNODE vn1, LPVIRTNODE vn2)
return (RETERR16)strcmp(file1, file2); return (RETERR16)strcmp(file1, file2);
} }
RETERR16 VCP_UI_CopyStart(void) static RETERR16 VCP_UI_CopyStart(void)
{ {
LPCVOID template32; LPCVOID template32;
char buf[256]; /* plenty */ char buf[256]; /* plenty */

2
dlls/winaspi/aspi.c
View File

@ -562,7 +562,7 @@ SCSI_MapHCtoController()
} }
#endif #endif
int SCSI_Linux_CheckDevices(void) static int SCSI_Linux_CheckDevices(void)
{ {
DIR *devdir; DIR *devdir;
struct dirent *dent = NULL; struct dirent *dent = NULL;

6
dlls/winedos/soundblaster.c
View File

@ -121,7 +121,7 @@ static DWORD CALLBACK SB_Poll( void *dummy )
return 0; return 0;
} }
BOOL SB_Init(void) static BOOL SB_Init(void)
{ {
HRESULT result; HRESULT result;
@ -191,7 +191,7 @@ BOOL SB_Init(void)
return 1; return 1;
} }
void SB_Reset(void) static void SB_Reset(void)
{ {
int i; int i;
@ -225,7 +225,7 @@ void SB_Reset(void)
} }
/* Find a standard sampling rate for DirectSound */ /* Find a standard sampling rate for DirectSound */
int SB_StdSampleRate(int SampleRate) static int SB_StdSampleRate(int SampleRate)
{ {
if (SampleRate>((44100+48000)/2)) return 48000; if (SampleRate>((44100+48000)/2)) return 48000;
if (SampleRate>((32000+44100)/2)) return 44100; if (SampleRate>((32000+44100)/2)) return 44100;

8
dlls/winedos/vga.c
View File

@ -345,14 +345,14 @@ static BOOL VGA_IsTimerRunning(void)
return VGA_timer_thread ? TRUE : FALSE; return VGA_timer_thread ? TRUE : FALSE;
} }
HANDLE VGA_AlphaConsole(void) static HANDLE VGA_AlphaConsole(void)
{ {
/* this assumes that no Win32 redirection has taken place, but then again, /* this assumes that no Win32 redirection has taken place, but then again,
* only 16-bit apps are likely to use this part of Wine... */ * only 16-bit apps are likely to use this part of Wine... */
return GetStdHandle(STD_OUTPUT_HANDLE); return GetStdHandle(STD_OUTPUT_HANDLE);
} }
char*VGA_AlphaBuffer(void) static char*VGA_AlphaBuffer(void)
{ {
return (char *)0xb8000; return (char *)0xb8000;
} }
@ -526,7 +526,7 @@ int VGA_GetMode(unsigned*Height,unsigned*Width,unsigned*Depth)
return 0; return 0;
} }
void VGA_Exit(void) static void VGA_Exit(void)
{ {
if (lpddraw) MZ_RunInThread(VGA_DoExit, 0); if (lpddraw) MZ_RunInThread(VGA_DoExit, 0);
} }
@ -687,7 +687,7 @@ void VGA_ShowMouse( BOOL show )
/* prepare the text mode video memory copy that is used to only /* prepare the text mode video memory copy that is used to only
* update the video memory line that did get updated. */ * update the video memory line that did get updated. */
void VGA_PrepareVideoMemCopy(unsigned Xres, unsigned Yres) static void VGA_PrepareVideoMemCopy(unsigned Xres, unsigned Yres)
{ {
char *p, *p2; char *p, *p2;
unsigned int i; unsigned int i;

4
dlls/winsock/socket.c
View File

@ -815,7 +815,7 @@ static const struct sockaddr* ws_sockaddr_ws2u(const struct WS_sockaddr* wsaddr,
} }
/* Allocates a Unix sockaddr structure to receive the data */ /* Allocates a Unix sockaddr structure to receive the data */
inline struct sockaddr* ws_sockaddr_alloc(const struct WS_sockaddr* wsaddr, int* wsaddrlen, int* uaddrlen) static inline struct sockaddr* ws_sockaddr_alloc(const struct WS_sockaddr* wsaddr, int* wsaddrlen, int* uaddrlen)
{ {
if (wsaddr==NULL) if (wsaddr==NULL)
{ {
@ -899,7 +899,7 @@ static int ws_sockaddr_u2ws(const struct sockaddr* uaddr, int uaddrlen, struct W
/* to be called to free the memory allocated by ws_sockaddr_ws2u or /* to be called to free the memory allocated by ws_sockaddr_ws2u or
* ws_sockaddr_alloc * ws_sockaddr_alloc
*/ */
inline void ws_sockaddr_free(const struct sockaddr* uaddr, const struct WS_sockaddr* wsaddr) static inline void ws_sockaddr_free(const struct sockaddr* uaddr, const struct WS_sockaddr* wsaddr)
{ {
if (uaddr!=(const struct sockaddr*)wsaddr) if (uaddr!=(const struct sockaddr*)wsaddr)
HeapFree(GetProcessHeap(), 0, (void *)uaddr); HeapFree(GetProcessHeap(), 0, (void *)uaddr);