+Mon Feb 21 00:19:40 2000 Christopher Faylor <cgf@cygnus.com>
+
+ Respond to a multitude of new g++ warnings.
+
Sun Feb 20 22:10:21 2000 Christopher Faylor <cgf@cygnus.com>
* environ.cc (getwinenv): Make __stdcall.
HANDLE NO_COPY hMainProc = NULL;
HANDLE NO_COPY hMainThread = NULL;
-static per_process dummy_user_data = {0};
-per_process NO_COPY *user_data = &dummy_user_data;
+static NO_COPY char dummy_user_data[sizeof (per_process)] = {0};
+per_process NO_COPY *user_data = (per_process *) &dummy_user_data;
per_thread_waitq NO_COPY waitq_storage;
per_thread_vfork NO_COPY vfork_storage;
while (--pfunc > in_pfunc)
(*pfunc) ();
- if (user_data != &dummy_user_data)
+ if (user_data != (per_process *) &dummy_user_data)
atexit (do_global_dtors);
}
/* Step over a run of characters delimited by quotes */
static __inline char *
-quoted (char *word, char *cmd, int winshell)
+quoted (char *cmd, int winshell)
{
char *p;
char quote = *cmd;
/* Skip over characters until the closing quote */
{
sawquote = cmd;
- cmd = quoted (word, cmd, winshell);
+ cmd = quoted (cmd, winshell);
}
if (issep (*cmd)) // End of argument if space
break;
#define EBP 6
#define ESP 7
-extern void __inline__
+extern __inline__ void
alloc_stack_hard_way (child_info_fork *ci, volatile char *b)
{
void *new_stack_pointer;
/* extend the stack prior to fork longjmp */
-extern void __inline__
+extern __inline__ void
alloc_stack (child_info_fork *ci)
{
/* FIXME: adding 16384 seems to avoid a stack copy problem during
return_MAX_PATH, return_MAX_PATH},
{"LD_LIBRARY_PATH=", 16, NULL, NULL, cygwin_conv_to_full_posix_path,
cygwin_conv_to_full_win32_path, return_MAX_PATH, return_MAX_PATH},
- {NULL}
+ {NULL, 0, NULL, NULL, NULL, NULL, 0, 0}
};
void
/* Turn environment variable part of a=b string into uppercase. */
-static void __inline
+static __inline__ void
ucenv (char *p, char *eq)
{
/* Amazingly, NT has a case sensitive environment name list,
/* Main exception handler. */
static int
-handle_exceptions (EXCEPTION_RECORD *e, void *arg, CONTEXT *in, void *x)
+handle_exceptions (EXCEPTION_RECORD *e, void *, CONTEXT *in, void *)
{
int sig;
n = ralen;
if (n > 0 && ralen)
{
- if ((ralen -= n) < 0)
+ if ((int) (ralen -= n) < 0)
ralen = 0;
if (raixget >= ralen)
/* Base terminal handlers. These just return errors. */
int
-fhandler_base::tcflush (int queue)
+fhandler_base::tcflush (int)
{
set_errno (ENOTTY);
return -1;
}
int
-fhandler_base::tcsendbreak (int duration)
+fhandler_base::tcsendbreak (int)
{
set_errno (ENOTTY);
return -1;
}
int
-fhandler_base::tcflow (int action)
+fhandler_base::tcflow (int)
{
set_errno (ENOTTY);
return -1;
}
int
-fhandler_base::tcsetattr (int a, const struct termios *t)
+fhandler_base::tcsetattr (int, const struct termios *)
{
set_errno (ENOTTY);
return -1;
}
int
-fhandler_base::tcgetattr (struct termios *t)
+fhandler_base::tcgetattr (struct termios *)
{
set_errno (ENOTTY);
return -1;
}
int
-fhandler_base::tcsetpgrp (const pid_t pid)
+fhandler_base::tcsetpgrp (const pid_t)
{
set_errno (ENOTTY);
return -1;
startpos = 0;
break;
case SEEK_CUR:
- if ((startpos = lseek (0, SEEK_CUR)) < 0)
+ if ((off_t) (startpos = lseek (0, SEEK_CUR)) == (off_t)-1)
return -1;
break;
case SEEK_END:
}
void __stdcall
-set_inheritance (HANDLE &h, int not_inheriting, const char *name)
+set_inheritance (HANDLE &h, int not_inheriting, const char *)
{
HANDLE newh;
{
return windows_device_names[FHDEVN (status)];
}
- virtual int bg_check (int, int x = 0) {return 1;}
+ virtual int bg_check (int) {return 1;}
};
class fhandler_socket: public fhandler_base
int write (const void *ptr, size_t len);
int read (void *ptr, size_t len);
int ioctl (unsigned int cmd, void *);
- off_t lseek (off_t offset, int whence) { return 0; }
+ off_t lseek (off_t, int) { return 0; }
int close ();
select_record *select_read (select_record *s);
int tcflow (int);
int tcsetattr (int a, const struct termios *t);
int tcgetattr (struct termios *t);
- off_t lseek (off_t offset, int whence) { return 0; }
+ off_t lseek (off_t, int) { return 0; }
int tcflush (int);
void dump ();
int is_tty () { return 1; }
{
protected:
HANDLE output_handle;
- virtual void doecho (const void *str, DWORD len) {};
+ virtual void doecho (const void *, DWORD) {};
virtual int accept_input () {return 1;};
public:
tty_min *tc;
int tcgetpgrp ();
int tcsetpgrp (int pid);
void set_ctty (int ttynum, int flags);
- int bg_check (int sig, int blocksigs = 1);
+ int bg_check (int sig);
};
/* This is a input and output console handle */
int tcflush (int);
int ioctl (unsigned int cmd, void *);
- off_t lseek (off_t offset, int whence) { return 0; }
+ off_t lseek (off_t, int) { return 0; }
};
class fhandler_pty_master: public fhandler_tty_common
int tcflush (int);
int ioctl (unsigned int cmd, void *);
- off_t lseek (off_t offset, int whence) { return 0; }
+ off_t lseek (off_t, int) { return 0; }
char *ptsname ();
void set_close_on_exec (int val);
int write (const void *ptr, size_t len);
int read (void *ptr, size_t len);
int ioctl (unsigned int cmd, void *);
- off_t lseek (off_t offset, int whence) { return 0; }
+ off_t lseek (off_t, int) { return 0; }
int close (void) { return 0; }
void set_close_on_exec (int val);
}
return 0;
case TIOCSWINSZ:
- (void) bg_check (SIGTTOU, 0);
+ (void) bg_check (SIGTTOU);
return 0;
}
}
void
-fhandler_console::fixup_after_fork (HANDLE parent)
+fhandler_console::fixup_after_fork (HANDLE)
{
HANDLE h = get_handle ();
HANDLE oh = get_output_handle ();
}
int
-fhandler_dev_floppy::is_eof (int win_error)
+fhandler_dev_floppy::is_eof (int)
{
int ret = 0;
if (ret)
}
int
-fhandler_termios::bg_check (int sig, int blocksigs)
+fhandler_termios::bg_check (int sig)
{
if (!myself->pgid || tc->getpgid () == myself->pgid ||
myself->ctty != tc->ntty ||
}
static DWORD WINAPI
-process_input (void *arg)
+process_input (void *)
{
char rawbuf[INP_BUFFER_SIZE];
}
static DWORD WINAPI
-process_output (void *arg)
+process_output (void *)
{
char buf[OUT_BUFFER_SIZE*2];
int n;
/* Process tty ioctl requests */
static DWORD WINAPI
-process_ioctl (void *arg)
+process_ioctl (void *)
{
while (1)
{
}
void
-fhandler_tty_slave::init (HANDLE f, DWORD a, mode_t)
+fhandler_tty_slave::init (HANDLE, DWORD a, mode_t)
{
int mode = 0;
}
int
-fhandler_tty_slave::tcsetattr (int a, const struct termios *t)
+fhandler_tty_slave::tcsetattr (int, const struct termios *t)
{
acquire_output_mutex (INFINITE);
get_ttyp ()->ti = *t;
}
int
-fhandler_tty_slave::tcflush (int a)
+fhandler_tty_slave::tcflush (int)
{
return 0;
}
DWORD n;
char *cptr = (char *) ptr;
- if (! PeekNamedPipe (get_handle (), NULL, 0, NULL, &n, NULL))
+ if (!PeekNamedPipe (get_handle (), NULL, 0, NULL, &n, NULL))
{
if (GetLastError () == ERROR_BROKEN_PIPE)
{
*cptr++ = TIOCPKT_DATA;
len--;
}
- n = process_slave_output (cptr, len);
- if (n < 0)
+
+ int x;
+ x = process_slave_output (cptr, len);
+ if (x < 0)
return -1;
if (output_done_event != NULL)
SetEvent (output_done_event);
- if (pktmode && n > 0)
- n++;
- return n;
+ if (pktmode && x > 0)
+ x++;
+ return x;
}
int
}
int
-fhandler_pty_master::tcsetattr (int a, const struct termios *t)
+fhandler_pty_master::tcsetattr (int, const struct termios *t)
{
cygwin_shared->tty[ttynum]->ti = *t;
return 0;
}
int
-fhandler_pty_master::tcflush (int a)
+fhandler_pty_master::tcflush (int)
{
return 0;
}
}
int
-fhandler_dev_zero::open (const char *path, int flags, mode_t mode = 0)
+fhandler_dev_zero::open (const char *, int flags, mode_t)
{
set_flags (flags);
return 1;
}
int
-fhandler_dev_zero::write (const void *ptr, size_t len)
+fhandler_dev_zero::write (const void *, size_t len)
{
return len;
}
}
off_t
-fhandler_dev_zero::lseek (off_t offset, int whence)
+fhandler_dev_zero::lseek (off_t, int)
{
return 0;
}
}
static int
-resume_child (PROCESS_INFORMATION &pi, HANDLE subproc_ready,
- HANDLE forker_finished)
+resume_child (PROCESS_INFORMATION &pi, HANDLE forker_finished)
{
int rc;
DllList::the().numberOfOpenedDlls();
/* Start thread, and wait for it to reload dlls. */
- if (!resume_child (pi, subproc_ready, forker_finished) ||
+ if (!resume_child (pi, forker_finished) ||
!sync_with_child (pi, subproc_ready, load_dll, "child loading dlls"))
goto cleanup;
}
DLL_DONE;
/* Start the child up again. */
- (void) resume_child (pi, subproc_ready, forker_finished);
+ (void) resume_child (pi, forker_finished);
}
ForceCloseHandle (subproc_ready);
extern "C"
int
-initgroups (const char *user, gid_t grp)
+initgroups (const char *, gid_t)
{
return 0;
}
static unsigned page_const = 0;
-static int __inline
+static __inline__ int
getpagesize(void)
{
SYSTEM_INFO si;
int NO_COPY dynamically_loaded;
int
-WINAPI dll_entry (HANDLE hdll, DWORD reason, void *static_load)
+WINAPI dll_entry (HANDLE, DWORD reason, void *static_load)
{
switch (reason)
{
/*ARGSUSED*/
static void
-localsub(timep, offset, tmp)
-const time_t * const timep;
-const long offset;
-struct tm * const tmp;
+localsub (const time_t * const timep, const long offset,
+ struct tm * const tmp)
{
register struct state * sp;
register const struct ttinfo * ttisp;
extern "C"
void
-__malloc_lock (struct _reent *ptr)
+__malloc_lock (struct _reent *)
{
SetResourceLock(LOCK_MEMORY_LIST,WRITE_LOCK|READ_LOCK," __malloc_lock");
}
extern "C"
void
-__malloc_unlock (struct _reent *ptr)
+__malloc_unlock (struct _reent *)
{
ReleaseResourceLock(LOCK_MEMORY_LIST,WRITE_LOCK|READ_LOCK," __malloc_unlock");
}
/* exported as herror: standards? */
extern "C"
void
-cygwin_herror (const char *p)
+cygwin_herror (const char *)
{
debug_printf ("********%d*************", __LINE__);
}
return default_pw;
}
-extern "C"
-struct passwd *
+extern "C" struct passwd *
getpwuid (uid_t uid)
{
if (!passwd_in_memory_p)
return search_for (uid, 0);
}
-extern "C"
-struct passwd *
+extern "C" struct passwd *
getpwnam (const char *name)
{
if (!passwd_in_memory_p)
return search_for (0, name);
}
-extern "C"
-struct passwd *
+extern "C" struct passwd *
getpwent (void)
{
if (!passwd_in_memory_p)
return NULL;
}
-extern "C"
-struct passwd *
-getpwduid (uid_t uid)
+extern "C" struct passwd *
+getpwduid (uid_t)
{
if (!passwd_in_memory_p)
read_etc_passwd();
return NULL;
}
-extern "C"
-void
+extern "C" void
setpwent (void)
{
if (!passwd_in_memory_p)
pw_pos = 0;
}
-extern "C"
-void
+extern "C" void
endpwent (void)
{
if (!passwd_in_memory_p)
pw_pos = 0;
}
-extern "C"
-int
+extern "C" int
setpassent ()
{
if (!passwd_in_memory_p)
return 0;
}
-extern "C"
-char *
+extern "C" char *
getpass (const char * prompt)
{
#ifdef _MT_SAFE
return NULL;
}
-static int __inline
+static __inline__ int
next_suffix (char *ext_here, const suffix_info *&suffixes)
{
if (!suffixes)
enum
{
+ PATH_NOTHING = 0,
PATH_SYMLINK = 1,
PATH_BINARY = MOUNT_BINARY,
PATH_EXEC = MOUNT_EXEC,
void set_binary () {path_flags |= PATH_BINARY;}
void set_symlink () {path_flags |= PATH_SYMLINK;}
- void set_exec (int x = 1) {path_flags |= x ? PATH_EXEC : 0;}
- void set_has_acls (int x = 1) {path_flags |= x ? PATH_HASACLS : 0;}
+ void set_exec (int x = 1) {path_flags |= x ? PATH_EXEC : PATH_NOTHING;}
+ void set_has_acls (int x = 1) {path_flags |= x ? PATH_HASACLS : PATH_NOTHING;}
char *known_suffix;
int use_full_path = 0, const suffix_info *suffixes = NULL);
inline char *get_win32 () { return path; }
BOOL is_device () {return devn != FH_BAD;}
- DWORD get_devn () {return devn == FH_BAD ? FH_DISK : devn;}
+ DWORD get_devn () {return devn == FH_BAD ? (DWORD) FH_DISK : devn;}
short get_unitn () {return devn == FH_BAD ? 0 : unit;}
DWORD file_attributes () {return fileattr;}
};
longest = NULL;
len = 0;
for (; scan != NULL; scan = regnext(scan))
- if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
+ if (OP(scan) == EXACTLY && (int) strlen(OPERAND(scan)) >= len) {
longest = OPERAND(scan);
len = strlen(OPERAND(scan));
}
extern "C"
int
-aclsort (int nentries, int calclass, aclent_t *aclbufp)
+aclsort (int nentries, int, aclent_t *aclbufp)
{
if (aclcheck (aclbufp, nentries, NULL))
return -1;
extern "C"
aclent_t *
-aclfromtext (char *acltextp, int *aclcnt)
+aclfromtext (char *acltextp, int *)
{
if (!acltextp)
{
}
static int
-verify_true (select_record *me, fd_set *readfds, fd_set *writefds,
- fd_set *exceptfds)
+verify_true (select_record *, fd_set *, fd_set *, fd_set *)
{
return 1;
}
}
static int
-no_startup (select_record *me, select_stuff *stuff)
+no_startup (select_record *, select_stuff *)
{
return 1;
}
}
static void
-pipe_cleanup (select_record *me, select_stuff *stuff)
+pipe_cleanup (select_record *, select_stuff *stuff)
{
pipeinf *pi = (pipeinf *)stuff->device_specific[FHDEVN(FH_PIPE)];
if (pi && pi->thread)
}
static void
-serial_cleanup (select_record *me, select_stuff *stuff)
+serial_cleanup (select_record *, select_stuff *stuff)
{
serialinf *si = (serialinf *)stuff->device_specific[FHDEVN(FH_SERIAL)];
if (si && si->thread)
}
void
-socket_cleanup (select_record *me, select_stuff *stuff)
+socket_cleanup (select_record *, select_stuff *stuff)
{
socketinf *si = (socketinf *)stuff->device_specific[FHDEVN(FH_SOCKET)];
select_printf ("si %p si->thread %p", si, si ? si->thread : NULL);
void __stdcall shared_init (void);
void __stdcall shared_terminate (void);
-/* This is for programs that want to access the shared data. */
-extern "C" class shared_info *cygwin_getshared (void);
-
char *__stdcall shared_name (const char *, int);
void *__stdcall open_shared (const char *name, HANDLE &shared_h, DWORD size, void *addr);
+extern "C" {
+/* This is for programs that want to access the shared data. */
+class shared_info *cygwin_getshared (void);
+
struct cygwin_version_info
{
unsigned short api_major;
unsigned short shared_data;
unsigned short mount_registry;
const char *dll_build_date;
- const char shared_id[sizeof (CYGWIN_VERSION_DLL_IDENTIFIER) + 64];
+ char shared_id[sizeof (CYGWIN_VERSION_DLL_IDENTIFIER) + 64];
};
+}
extern cygwin_version_info cygwin_version;
extern const char *cygwin_version_strings;
/* Functions
*/
static int __stdcall checkstate (waitq *);
-static BOOL __inline get_proc_lock (DWORD, DWORD);
+static __inline__ BOOL get_proc_lock (DWORD, DWORD);
static HANDLE __stdcall getsem (pinfo *, const char *, int, int);
static void __stdcall remove_child (int);
static void __stdcall remove_zombie (int);
* Attempt to handle case where process is exiting as we try to grab
* the mutex.
*/
-static BOOL __inline
+static __inline__ BOOL
get_proc_lock (DWORD what, DWORD val)
{
Static int lastwhat = -1;
* has been handled, as per POSIX.
*/
static DWORD WINAPI
-wait_sig (VOID *arg)
+wait_sig (VOID *)
{
/* Initialization */
(void) SetThreadPriority (hwait_sig, WAIT_SIG_PRIORITY);
/* Wait for subprocesses to terminate. Executes in a separate thread. */
static DWORD WINAPI
-wait_subproc (VOID *arg)
+wait_subproc (VOID *)
{
sip_printf ("starting");
int errloop = 0;
}
void __stdcall
-mark (const char *fn, int i)
+mark (const char *, int)
{
}
DWORD tid; /* Thread Id of lock owner. */
public:
void *operator new (size_t, void *p) {return p;}
- void *operator new (size_t n) {return ::new muto; }
- void operator delete (void *p) {;} /* can't handle allocated mutos
+ void *operator new (size_t) {return ::new muto; }
+ void operator delete (void *) {;} /* can't handle allocated mutos
currently */
/* This simple constructor is used for cases where no bruteforce
}
static int
-read_handler (int fd, void *ptr, size_t len, int blocksigs)
+read_handler (int fd, void *ptr, size_t len)
{
int res;
fhandler_base *fh = dtable[fd];
/* Check to see if this is a background read from a "tty",
sending a SIGTTIN, if appropriate */
- res = fh->bg_check (SIGTTIN, blocksigs);
+ res = fh->bg_check (SIGTTIN);
if (res > 0)
{
myself->process_state |= PID_TTYIN;
fh->get_r_no_interrupt ())
{
debug_printf ("non-interruptible read\n");
- return read_handler (fd, ptr, len, 0);
+ return read_handler (fd, ptr, len);
}
if (fh->ready_for_read (fd, INFINITE, 0))
- return read_handler (fd, ptr, len, 1);
+ return read_handler (fd, ptr, len);
set_sig_errno (EINTR);
syscall_printf ("%d = read (%d<%s>, %p, %d), errno %d", -1, fd, fh->get_name (),
fhandler_base *fh;
fh = dtable[fd];
- res = fh->bg_check (SIGTTOU, 0);
+ res = fh->bg_check (SIGTTOU);
if (res > 0)
{
myself->process_state |= PID_TTYOU;
static HANDLE window_started;
static DWORD WINAPI
-Winmain (VOID *arg)
+Winmain (VOID *)
{
MSG msg;
WNDCLASS wc;
OSDN Git Service
