These are the windows fixes that I previously alluded to, combined with
[dyninst.git] / common / h / solarisHeaders.h
1 /*
2  * Copyright (c) 1996-2007 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  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
30  */
31
32
33 #if !defined(_solaris_headers_h)
34 #define _solaris_headers_h
35
36 #include <assert.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <errno.h>
41 #include <assert.h>
42 #include <fcntl.h>
43 #include <netinet/in.h>
44 #include <netdb.h>
45 #include <sys/types.h>
46 #include <sys/mman.h>
47 #include <sys/time.h>
48 #include <unistd.h>
49 #include <sys/file.h>
50 #include <sys/socket.h>
51 #include <sys/errno.h>
52 #include <sys/wait.h>
53 #include <signal.h>
54 #include <sys/resource.h>
55 #include <stdarg.h>
56 #include <time.h>
57 #include <sys/utsname.h>
58 #include <sys/stat.h>
59 #include <sys/un.h>
60
61 #include <rpc/types.h>
62 #include <rpc/xdr.h>
63
64 #define PDSOCKET_ERROR (-1)
65 typedef int PDSOCKET;
66 typedef int (*P_xdrproc_t)(XDR*, ...);
67 extern const char *sys_errlist[];
68
69 extern int (*P_native_demangle)(const char *, char *, size_t);
70
71 extern "C" int rexec(char **, unsigned short, const char *,
72                      const char *, const char *, int *);
73
74 /* POSIX */
75 inline int P_getopt(int argc, char *argv[], const char *optstring) { return getopt(argc, argv, optstring);}
76 inline void P_abort (void) { abort();}
77 inline int P_close (int FILEDES) { return (close(FILEDES));}
78 inline int P_dup2 (int OLD, int NEW) { return (dup2(OLD, NEW));}
79 inline int P_execvp (const char *FILENAME, char *const ARGV[]) {
80   return (execvp(FILENAME, ARGV));}
81 inline int P_execve (const char* FILENAME,
82                      char* const ARGV[], char* const ENVP[]) {
83     return (execve(FILENAME, ARGV, ENVP));
84 }
85 inline void P__exit (int STATUS) { _exit(STATUS);}
86 inline int P_fcntl (int FILEDES, int COMMAND, int ARG2) {
87   return (fcntl(FILEDES, COMMAND, ARG2));}
88 inline FILE * P_fdopen (int FILEDES, const char *OPENTYPE) {
89   return (fdopen(FILEDES, OPENTYPE));}
90 inline FILE * P_fopen (const char *FILENAME, const char *OPENTYPE) {
91   return (fopen(FILENAME, OPENTYPE));}
92 inline int P_fstat (int FILEDES, struct stat *BUF) { return (fstat(FILEDES, BUF));}
93 inline pid_t P_getpid () { return (getpid());}
94 inline int P_kill(pid_t PID, int SIGNUM) { return (kill(PID, SIGNUM));}
95 inline off_t P_lseek (int FILEDES, off_t OFFSET, int WHENCE) {
96   return (lseek(FILEDES, OFFSET, WHENCE));}
97 inline int P_open(const char *FILENAME, int FLAGS, mode_t MODE) {
98   return (open(FILENAME, FLAGS, MODE));}
99 inline int P_pclose (FILE *STREAM) { return (pclose(STREAM));}
100 inline FILE *P_popen (const char *COMMAND, const char *MODE) {
101   return (popen(COMMAND, MODE));}
102 inline size_t P_read (int FILEDES, void *BUFFER, size_t SIZE) {
103   return (read(FILEDES, BUFFER, SIZE));}
104 inline int P_uname(struct utsname *un) { return (uname(un));}
105 inline pid_t P_wait(int *status_ptr) { return (wait(status_ptr));}
106 inline int P_waitpid(pid_t pid, int *statusp, int options) {
107   return (waitpid(pid, statusp, options));}
108 inline size_t P_write (int FILEDES, const void *BUFFER, size_t SIZE) {
109   return (write(FILEDES, BUFFER, SIZE));}
110 inline int P_chdir(const char *path) { return (chdir(path)); }
111 inline int P_putenv(char *str) { return putenv(str); }
112
113 /* SYSTEM-V shared memory */
114 #include <sys/ipc.h>
115 #include <sys/shm.h> /* shmid_ds */
116 inline int P_shmget(key_t theKey, int size, int flags) {
117    return shmget(theKey, size, flags);
118 }
119 inline void *P_shmat(int shmid, void *addr, int flags) {
120    return shmat(shmid, (char *)addr, flags);
121 }
122 inline int P_shmdt(void *addr) {return shmdt((char*)addr);}
123 inline int P_shmctl(int shmid, int cmd, struct shmid_ds *buf) {
124    return shmctl(shmid, cmd, buf);
125 }
126
127 /* ANSI */
128 inline void P_exit (int STATUS) { exit(STATUS);}
129 inline int P_fflush(FILE *stream) { return (fflush(stream));}
130 inline char * P_fgets (char *S, int COUNT, FILE *STREAM) {
131   return (fgets(S, COUNT, STREAM));}
132 inline void * P_malloc (size_t SIZE) { return (malloc(SIZE));}
133 extern void * P_memcpy (void *A1, const void *A2, size_t SIZE);
134 inline void * P_memset (void *BLOCK, int C, size_t SIZE) {
135   return (memset(BLOCK, C, SIZE));}
136 inline void P_perror (const char *MESSAGE) { perror(MESSAGE);}
137 extern "C" {
138 typedef void (*P_sig_handler)(int);
139 }
140 inline P_sig_handler P_signal (int SIGNUM, P_sig_handler ACTION) {
141   return (signal(SIGNUM, ACTION));}
142 inline char * P_strcat (char *TO, const char *FROM) {
143   return (strcat(TO, FROM));}
144
145 inline const char * P_strchr (const char *P_STRING, int C) {return (strchr(P_STRING, C));}
146 inline char * P_strchr (char *P_STRING, int C) {return (strchr(P_STRING, C));}
147
148 inline int P_strcmp (const char *S1, const char *S2) {
149   return (strcmp(S1, S2));}
150 inline char * P_strcpy (char *TO, const char *FROM) {
151   return (strcpy(TO, FROM));}
152 inline char *P_strdup(const char *S) { return (strdup(S));}
153 inline size_t P_strlen (const char *S) { return (strlen(S));}
154 inline char * P_strncat (char *TO, const char *FROM, size_t SIZE) {
155   return (strncat(TO, FROM, SIZE)); }
156 inline int P_strncmp (const char *S1, const char *S2, size_t SIZE) {
157   return (strncmp(S1, S2, SIZE));}
158 inline char * P_strncpy (char *TO, const char *FROM, size_t SIZE) {
159   return (strncpy(TO, FROM, SIZE));}
160
161 inline const char * P_strrchr (const char *P_STRING, int C) {return (strrchr(P_STRING, C));}
162 inline char * P_strrchr (char *P_STRING, int C) {return (strrchr(P_STRING, C));}
163
164 inline const char * P_strstr (const char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
165 inline char * P_strstr (char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
166
167 inline double P_strtod (const char *P_STRING, char **TAILPTR) {
168   return (strtod(P_STRING, TAILPTR));}
169 inline char * P_strtok (char *NEWP_STRING, const char *DELIMITERS) {
170   return (strtok(NEWP_STRING, DELIMITERS));}
171 inline long int P_strtol (const char *P_STRING, char **TAILPTR, int BASE) {
172   return (strtol(P_STRING, TAILPTR, BASE));}
173 inline unsigned long int P_strtoul(const char *P_STRING, char **TAILPTR, int BASE) { 
174   return (strtoul(P_STRING, TAILPTR, BASE));}
175
176 /* BSD */
177 inline int P_accept (int SOCK, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
178   return (accept(SOCK, ADDR, LENGTH_PTR));}
179 inline int P_bind(int socket, struct sockaddr *addr, size_t len) {
180   return (bind(socket, addr, len));}
181 inline int P_connect(int socket, struct sockaddr *addr, size_t len) {
182   return (connect(socket, addr, len));}
183 inline struct hostent * P_gethostbyname (const char *NAME) {
184   return (gethostbyname(NAME));}
185 /* inline int P_gethostname(char *name, size_t size) {
186    return (gethostname(name, size));} */
187 /* inline int P_getrusage(int i, struct rusage *ru) { 
188    return (getrusage(i, ru));} */
189 inline struct servent * P_getservbyname (const char *NAME, const char *PROTO) {
190   return (getservbyname(NAME, PROTO));}
191 inline int P_getsockname (int SOCKET, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
192   return (getsockname(SOCKET, ADDR, LENGTH_PTR));}
193 inline int P_getsockopt(int s, int level, int optname, void *optval, 
194                         unsigned int *optlen) {
195    return getsockopt(s, level, optname, optval, 
196                      static_cast<socklen_t*>(optlen));
197 }
198 inline int P_setsockopt(int s, int level, int optname, void *optval, int optlen) {
199    return setsockopt(s, level, optname, (const char*)optval, optlen);
200 }
201
202 /* inline int P_gettimeofday (struct timeval *TP, struct timezone *TZP) {
203   return (gettimeofday(TP, TZP));} */
204 inline int P_listen (int socket, unsigned int n) { return (listen(socket, n));}
205 inline caddr_t P_mmap(caddr_t addr, size_t len, int prot, int flags,
206                       int fd, off_t off) {
207   return (static_cast<caddr_t>(mmap(addr, len, prot, flags, fd, off)));}
208 inline int P_munmap(caddr_t addr, int i) { return (munmap(addr, i));}
209 inline int P_socket (int NAMESPACE, int STYLE, int PROTOCOL) {
210   return (socket(NAMESPACE, STYLE, PROTOCOL));}
211 inline int P_socketpair(int namesp, int style, int protocol, int filedes[2]) {
212   return (socketpair(namesp, style, protocol, filedes));}
213 inline int P_pipe(int fds[2]) { return (pipe(fds)); }
214 inline int P_strcasecmp(const char *s1, const char *s2) {
215   return (strcasecmp(s1, s2));}
216 inline int P_strncasecmp (const char *S1, const char *S2, size_t N) {
217   return (strncasecmp(S1, S2,N));}
218 inline void P_endservent(void) { endservent(); }
219 inline int P_getpagesize() { return getpagesize(); }
220 inline int P_recv(int s, void *buf, size_t len, int flags) {
221    return (recv(s, buf, len, flags));
222 }
223
224 /* Ugly */
225
226 inline int P_ptrace(int req, pid_t pid, int addr, int data, int /*word_len*/) {
227   return (ptrace(req, pid, addr, data));}
228
229 inline int P_select(int wid, fd_set *rd, fd_set *wr, fd_set *ex,
230                     struct timeval *tm) {
231   return (select(wid, rd, wr, ex, tm));}
232
233 inline int P_rexec(char **ahost, u_short inport, char *user,
234                    char *passwd, char *cmd, int *fd2p) {
235   return (rexec(ahost, inport, user, passwd, cmd, fd2p));}
236
237 #if defined(__GNUC__)
238 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
239 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
240
241 extern "C" char *cplus_demangle(char *, int);
242
243 /* Hack to allow nativeDemanglerBrokenness() to compile under gcc. */
244 #define DEMANGLE_ESPACE -1
245 #define DEMANGLE_ENAME  1
246
247 #else
248
249 #include <demangle.h>
250
251 #endif
252
253 inline char * nativeDemanglerBrokenness( int (*P_native_demangle)(const char *, char *, size_t),
254                                         char * symbol ) {
255         int length = 1024;
256         char * demangled = NULL;
257
258         while( true ) {
259                 demangled = (char *)malloc( length * sizeof( char ) );
260                 if( demangled == NULL ) { return NULL; }
261                 
262                 int result = (* P_native_demangle)( symbol, demangled, length );
263
264                 switch( result ) {
265                         case 0:
266                                 if (!strcmp(demangled,symbol)) {
267                                    free(demangled);
268                                    demangled = NULL;
269                                 }
270                                 return demangled;
271                         case DEMANGLE_ENAME:
272                                 return NULL;
273                         case DEMANGLE_ESPACE:
274                                 break;
275                         default:
276                                 assert( 0 );
277                         } /* end result switch */
278
279                 length += 1024;
280                 free( demangled );
281                 } /* end sizing loop */
282         } /* end nativeCompilerBrokenness() */
283
284 extern void dedemangle( const char * demangled, char * dedemangled );
285 inline char * P_cplus_demangle( const char *symbol, bool nativeCompiler,
286                                         bool includeTypes = false ) {
287         char * demangled = NULL;
288
289 #if defined( __GNUC__ )
290   /* If the native demangler exists, try to demangled with it.
291      Otherwise, use the GNU demangler. */
292   if( ! nativeCompiler || P_native_demangle == NULL ) {
293     /* If we've been compiled with GNU and we're
294        demangling a GNU name, use cplus_demangle(). */
295     demangled = cplus_demangle( const_cast<char *>( symbol ), 
296                                     includeTypes ? DMGL_PARAMS|DMGL_ANSI  : 0 );
297     if( demangled == NULL ) { return NULL; }
298     } /* end if there's no native demangler */
299   else {
300     /* Use the native demangler. */
301     demangled = nativeDemanglerBrokenness( P_native_demangle, const_cast< char * >( symbol ) );
302
303     if( demangled == NULL ) { return NULL; }
304     } /* end if we're using the native demangler. */
305
306 #else 
307
308   /* We were compiled with the native compiler, so use its demangler. */
309   demangled = nativeDemanglerBrokenness( cplus_demangle, (char *)symbol );
310
311   if( demangled == NULL ) { return NULL; }  
312
313 #endif
314
315   if( ! includeTypes ) {
316         /* de-demangling never increases the length */
317         char * dedemangled = strdup( demangled );
318         assert( dedemangled != NULL );
319         dedemangle( demangled, dedemangled );
320         assert( dedemangled != NULL );
321
322         free( demangled );
323         return dedemangled;  
324         }
325
326   return demangled;
327   } /* end P_cplus_demangle() */
328
329 inline void   P_xdr_destroy(XDR *x) { xdr_destroy(x);}
330 inline bool_t P_xdr_u_char(XDR *x, u_char *uc) { return (xdr_u_char(x, uc));}
331 inline bool_t P_xdr_int(XDR *x, int *i) { return (xdr_int(x, i));}
332 inline bool_t P_xdr_double(XDR *x, double *d) {
333   return (xdr_double(x, d));}
334 inline bool_t P_xdr_u_int(XDR *x, u_int *u){
335   return (xdr_u_int(x, u));}
336 inline bool_t P_xdr_float(XDR *x, float *f) {
337   return (xdr_float(x, f));}
338 inline bool_t P_xdr_char(XDR *x, char *c) {
339   return (xdr_char(x, c));}
340 inline bool_t P_xdr_string(XDR *x, char **h, const u_int maxsize) {
341   return (xdr_string(x, h, maxsize));}
342
343 inline void P_xdrrec_create(XDR *x, const u_int send_sz, const u_int rec_sz,
344                             const caddr_t handle, 
345                             xdr_rd_func read_r, xdr_wr_func write_f) {
346 #if !defined(__GNUC__)
347   xdrrec_create(x, send_sz, rec_sz, handle,
348         read_r, write_f);
349 #else
350   xdrrec_create(x, send_sz, rec_sz, handle, read_r, write_f);
351 #endif
352 }
353 inline bool_t P_xdrrec_endofrecord(XDR *x, int now) { 
354   return (xdrrec_endofrecord(x, now));}
355 inline bool_t P_xdrrec_skiprecord(XDR *x) { return (xdrrec_skiprecord(x));}
356 inline bool_t P_xdrrec_eof(XDR *x) { return (xdrrec_eof(x)); }
357
358 #endif