Updated #includes to reflect util library split
[dyninst.git] / common / h / irixHeaders.h
1 /*
2  * Copyright (c) 1998 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #if !defined(_irix_headers_h)
43 #define _irix_headers_h
44
45 #include <assert.h>
46 #include <stdio.h>
47 #include <string.h>
48 #include <stdlib.h>
49 #include <errno.h>
50 #include <assert.h>
51 #include <fcntl.h>
52 #include <netinet/in.h>
53 #include <netdb.h>
54 #include <sys/types.h>
55 #include <sys/mman.h>
56 #include <sys/time.h>
57 #include <unistd.h>
58 #include <sys/file.h>
59 #include <sys/socket.h>
60 #include <sys/errno.h>
61 #include <sys/wait.h>
62 #include <signal.h>
63 #include <sys/time.h>
64 #include <sys/resource.h>
65 #include <stdarg.h>
66 #include <time.h>
67 #include <sys/utsname.h>
68 #include <sys/stat.h>
69 #include <sys/un.h>
70
71 #include <rpc/types.h>
72 #include <rpc/xdr.h>
73
74 #include <strstream.h>
75
76 /* unprototyped system calls */
77 #if defined(__cplusplus)
78 extern "C" {
79 #endif
80 extern int rexec(char **ahost, int inport, char *user, 
81                  char *passwd, char *cmd, int *fd2p);
82 extern pid_t vfork();
83 #if defined(__cplusplus)
84 };
85 #endif
86
87
88 typedef int (*P_xdrproc_t)(XDR*, ...);
89 extern char *sys_errlist[];
90
91 /* POSIX */
92 inline void P_abort (void) { abort();}
93 inline int P_close (int FILEDES) { return (close(FILEDES));}
94 inline int P_dup2 (int OLD, int NEW) { return (dup2(OLD, NEW));}
95 inline int P_execvp (const char *FILENAME, char *const ARGV[]) {
96   return (execvp(FILENAME, ARGV));}
97 inline void P__exit (int STATUS) { _exit(STATUS);}
98 inline int P_fcntl (int FILEDES, int COMMAND, int ARG2) {
99   return (fcntl(FILEDES, COMMAND, ARG2));}
100 inline FILE * P_fdopen (int FILEDES, const char *OPENTYPE) {
101   return (fdopen(FILEDES, OPENTYPE));}
102 inline FILE * P_fopen (const char *FILENAME, const char *OPENTYPE) {
103   return (fopen(FILENAME, OPENTYPE));}
104 inline int P_fstat (int FILEDES, struct stat *BUF) { return (fstat(FILEDES, BUF));}
105 inline pid_t P_getpid () { return (getpid());}
106 inline int P_kill(pid_t PID, int SIGNUM) { return (kill(PID, SIGNUM));}
107 inline off_t P_lseek (int FILEDES, off_t OFFSET, int WHENCE) {
108   return (lseek(FILEDES, OFFSET, WHENCE));}
109 inline int P_open(const char *FILENAME, int FLAGS, mode_t MODE) {
110   return (open(FILENAME, FLAGS, MODE));}
111 inline int P_pclose (FILE *STREAM) { return (pclose(STREAM));}
112 inline FILE *P_popen (const char *COMMAND, const char *MODE) {
113   return (popen(COMMAND, MODE));}
114 inline size_t P_read (int FILEDES, void *BUFFER, size_t SIZE) {
115   return (read(FILEDES, BUFFER, SIZE));}
116 inline int P_uname(struct utsname *un) { return (uname(un));}
117 inline pid_t P_wait(int *status_ptr) { return (wait(status_ptr));}
118 inline int P_waitpid(pid_t pid, int *statusp, int options) {
119   return (waitpid(pid, statusp, options));}
120 inline size_t P_write (int FILEDES, const void *BUFFER, size_t SIZE) {
121   return (write(FILEDES, BUFFER, SIZE));}
122 inline int P_chdir(const char *path) { return (chdir(path)); }
123 inline int P_putenv(char *str) { return putenv(str); }
124
125 /* SYSTEM-V shared memory */
126 #include <sys/ipc.h>
127 #include <sys/shm.h> /* shmid_ds */
128 inline int P_shmget(key_t theKey, int size, int flags) {
129    return shmget(theKey, size, flags);
130 }
131 inline void *P_shmat(int shmid, void *addr, int flags) {
132    return shmat(shmid, (char *)addr, flags);
133 }
134 inline int P_shmdt(void *addr) {return shmdt((char*)addr);}
135 inline int P_shmctl(int shmid, int cmd, struct shmid_ds *buf) {
136    return shmctl(shmid, cmd, buf);
137 }
138
139 /* ANSI */
140 inline void P_exit (int STATUS) { exit(STATUS);}
141 inline int P_fflush(FILE *stream) { return (fflush(stream));}
142 inline char * P_fgets (char *S, int COUNT, FILE *STREAM) {
143   return (fgets(S, COUNT, STREAM));}
144 inline void * P_malloc (size_t SIZE) { return (malloc(SIZE));}
145 inline void * P_memcpy (void *A1, const void *A2, size_t SIZE) {
146   return memcpy(A1, A2, SIZE);}
147 inline void * P_memset (void *BLOCK, int C, size_t SIZE) {
148   return (memset(BLOCK, C, SIZE));}
149 inline void P_perror (const char *MESSAGE) { perror(MESSAGE);}
150 typedef void (*P_sig_handler)(int);
151 inline P_sig_handler P_signal (int SIGNUM, P_sig_handler ACTION) {
152   return (signal(SIGNUM, ACTION));}
153 inline char * P_strcat (char *TO, const char *FROM) {
154   return (strcat(TO, FROM));}
155
156 inline const char * P_strchr (const char *STRING, int C) {return (strchr(STRING, C));}
157 inline char * P_strchr (char *STRING, int C) {return (strchr(STRING, C));}
158
159 inline int P_strcmp (const char *S1, const char *S2) {
160   return (strcmp(S1, S2));}
161 inline char * P_strcpy (char *TO, const char *FROM) {
162   return (strcpy(TO, FROM));}
163 inline char *P_strdup(const char *S) { return (strdup(S));}
164 inline size_t P_strlen (const char *S) { return (strlen(S));}
165 inline char * P_strncat (char *TO, const char *FROM, size_t SIZE) {
166   return (strncat(TO, FROM, SIZE)); }
167 inline int P_strncmp (const char *S1, const char *S2, size_t SIZE) {
168   return (strncmp(S1, S2, SIZE));}
169 inline char * P_strncpy (char *TO, const char *FROM, size_t SIZE) {
170   return (strncpy(TO, FROM, SIZE));}
171
172 inline const char * P_strrchr (const char *STRING, int C) {return (strrchr(STRING, C));}
173 inline char * P_strrchr (char *STRING, int C) {return (strrchr(STRING, C));}
174
175 inline const char * P_strstr (const char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
176 inline char * P_strstr (char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
177
178 inline double P_strtod (const char *STRING, char **TAILPTR) {
179   return (strtod(STRING, TAILPTR));}
180 inline char * P_strtok (char *NEWSTRING, const char *DELIMITERS) {
181   return (strtok(NEWSTRING, DELIMITERS));}
182 inline long int P_strtol (const char *STRING, char **TAILPTR, int BASE) {
183   return (strtol(STRING, TAILPTR, BASE));}
184 inline unsigned long int P_strtoul(const char *STRING, char **TAILPTR, int BASE) { 
185   return (strtoul(STRING, TAILPTR, BASE));}
186
187 /* BSD */
188 inline int P_accept (int SOCK, struct sockaddr *ADDR, size_t *LENGTH_PTR)
189 {
190   int len_tmp = *LENGTH_PTR;
191   int ret = accept(SOCK, ADDR, &len_tmp);
192   *LENGTH_PTR = len_tmp;
193   return ret;
194 }
195 inline int P_bind(int socket, struct sockaddr *addr, size_t len) {
196   return (bind(socket, addr, len));}
197 inline int P_connect(int socket, struct sockaddr *addr, size_t len) {
198   return (connect(socket, addr, len));}
199 inline struct hostent * P_gethostbyname (const char *NAME) {
200   return (gethostbyname(NAME));}
201 inline int P_getrusage(int i, struct rusage *ru) { 
202    return (getrusage(i, ru));}
203 inline struct servent * P_getservbyname (const char *NAME, const char *PROTO) {
204   return (getservbyname(NAME, PROTO));}
205 inline int P_getsockname (int SOCKET, struct sockaddr *ADDR, size_t *LENGTH_PTR)
206 {
207   int len_tmp = *LENGTH_PTR;
208   int ret = getsockname(SOCKET, ADDR, &len_tmp);
209   *LENGTH_PTR = len_tmp;
210   return ret;
211 }
212 inline int P_getsockopt(int s, int level, int optname, void *optval, int *optlen) {
213    return getsockopt(s, level, optname, (char*)optval, optlen);}
214 inline int P_setsockopt(int s, int level, int optname, void *optval, int optlen) {
215    return setsockopt(s, level, optname, (const char*)optval, optlen);}
216
217 inline int P_gettimeofday (struct timeval *TP, struct timezone *TZP) {
218   return (gettimeofday(TP, TZP));} 
219 inline int P_listen (int socket, unsigned int n) { return (listen(socket, n));}
220 inline caddr_t P_mmap(caddr_t addr, size_t len, int prot, int flags,
221                       int fd, off_t off) {
222   return (caddr_t)(mmap(addr, len, prot, flags, fd, off));}
223 inline int P_munmap(caddr_t addr, int i) { return (munmap(addr, i));}
224 inline int P_socket (int NAMESPACE, int STYLE, int PROTOCOL) {
225   return (socket(NAMESPACE, STYLE, PROTOCOL));}
226 inline int P_socketpair(int namesp, int style, int protocol, int filedes[2]) {
227   return (socketpair(namesp, style, protocol, filedes));}
228 inline int P_pipe(int fds[2]) { return (pipe(fds)); }
229 inline int P_strcasecmp(const char *s1, const char *s2) {
230   return (strcasecmp(s1, s2));}
231 inline int P_strncasecmp (const char *S1, const char *S2, size_t N) {
232   return (strncasecmp(S1, S2,N));}
233 inline int P_endservent(void) { endservent(); return 0; }
234
235 /* Ugly */
236
237 inline int P_ptrace(int req, pid_t pid, int addr, int data) {
238   return (ptrace(req, pid, addr, data));}
239
240 inline int P_select(int wid, fd_set *rd, fd_set *wr, fd_set *ex,
241                     struct timeval *tm) {
242   return (select(wid, rd, wr, ex, tm));}
243
244 inline int P_rexec(char **ahost, u_short inport, char *user,
245                    char *passwd, char *cmd, int *fd2p) {
246   return (rexec(ahost, (int)inport, user, passwd, cmd, fd2p));}
247
248 // for matherr()
249 struct exception { // CSS
250         int type;
251         char *name;
252         double arg1;
253         double arg2;
254         double retval;
255 };
256
257
258 inline void   P_xdr_destroy(XDR *x) { xdr_destroy(x);}
259 inline bool_t P_xdr_u_char(XDR *x, u_char *uc) { return (xdr_u_char(x, uc));}
260 inline bool_t P_xdr_int(XDR *x, int *i) { return (xdr_int(x, i));}
261 inline bool_t P_xdr_double(XDR *x, double *d) {
262   return (xdr_double(x, d));}
263 inline bool_t P_xdr_u_int(XDR *x, u_int *u){
264   return (xdr_u_int(x, u));}
265 inline bool_t P_xdr_float(XDR *x, float *f) {
266   return (xdr_float(x, f));}
267 inline bool_t P_xdr_char(XDR *x, char *c) {
268   return (xdr_char(x, c));}
269 inline bool_t P_xdr_string(XDR *x, char **h, const u_int maxsize) {
270   return (xdr_string(x, h, maxsize));}
271
272 inline void P_xdrrec_create(XDR *x, const u_int send_sz, const u_int rec_sz,
273                             const caddr_t handle, 
274                             xdr_rd_func read_r, xdr_wr_func write_f) {
275   xdrrec_create(x, send_sz, rec_sz, handle, 
276                 (int (*)(void *, void *, u_int))read_r, 
277                 (int (*)(void *, void *, u_int))write_f);
278 }
279 inline bool_t P_xdrrec_endofrecord(XDR *x, int now) { 
280   return (xdrrec_endofrecord(x, now));}
281 inline bool_t P_xdrrec_skiprecord(XDR *x) { return (xdrrec_skiprecord(x));}
282 inline bool_t P_xdrrec_eof(XDR *x) { return (xdrrec_eof(x)); }
283
284 #endif