Fix for "perlio bug in koi8-r encoding". The problem
[p5sagit/p5-mst-13.2.git] / ext / POSIX / POSIX.xs
1 #ifdef WIN32
2 #define _POSIX_
3 #endif
4
5 #ifdef NETWARE
6         #define _POSIX_
7         /*
8          * Ideally this should be somewhere down in the includes
9          * but putting it in other places is giving compiler errors.
10          * Also here I am unable to check for HAS_UNAME since it wouldn't have
11          * yet come into the file at this stage - sgp 18th Oct 2000
12          */
13         #include <sys/utsname.h>
14 #endif  /* NETWARE */
15
16 #define PERL_NO_GET_CONTEXT
17
18 #include "EXTERN.h"
19 #define PERLIO_NOT_STDIO 1
20 #include "perl.h"
21 #include "XSUB.h"
22 #if defined(PERL_IMPLICIT_SYS)
23 #  undef signal
24 #  undef open
25 #  undef setmode
26 #  define open PerlLIO_open3
27 #endif
28 #include <ctype.h>
29 #ifdef I_DIRENT    /* XXX maybe better to just rely on perl.h? */
30 #include <dirent.h>
31 #endif
32 #include <errno.h>
33 #ifdef I_FLOAT
34 #include <float.h>
35 #endif
36 #ifdef I_LIMITS
37 #include <limits.h>
38 #endif
39 #include <locale.h>
40 #include <math.h>
41 #ifdef I_PWD
42 #include <pwd.h>
43 #endif
44 #include <setjmp.h>
45 #include <signal.h>
46 #include <stdarg.h>
47
48 #ifdef I_STDDEF
49 #include <stddef.h>
50 #endif
51
52 #ifdef I_UNISTD
53 #include <unistd.h>
54 #endif
55
56 /* XXX This comment is just to make I_TERMIO and I_SGTTY visible to 
57    metaconfig for future extension writers.  We don't use them in POSIX.
58    (This is really sneaky :-)  --AD
59 */
60 #if defined(I_TERMIOS)
61 #include <termios.h>
62 #endif
63 #ifdef I_STDLIB
64 #include <stdlib.h>
65 #endif
66 #include <string.h>
67 #include <sys/stat.h>
68 #include <sys/types.h>
69 #include <time.h>
70 #ifdef I_UNISTD
71 #include <unistd.h>
72 #endif
73 #ifdef MACOS_TRADITIONAL
74 #undef fdopen
75 #endif
76 #include <fcntl.h>
77
78 #ifdef HAS_TZNAME
79 #  if !defined(WIN32) && !defined(__CYGWIN__) && !defined(NETWARE)
80 extern char *tzname[];
81 #  endif
82 #else
83 #if !defined(WIN32) || (defined(__MINGW32__) && !defined(tzname))
84 char *tzname[] = { "" , "" };
85 #endif
86 #endif
87
88 #if defined(__VMS) && !defined(__POSIX_SOURCE)
89 #  include <libdef.h>       /* LIB$_INVARG constant */
90 #  include <lib$routines.h> /* prototype for lib$ediv() */
91 #  include <starlet.h>      /* prototype for sys$gettim() */
92 #  if DECC_VERSION < 50000000
93 #    define pid_t int       /* old versions of DECC miss this in types.h */
94 #  endif
95
96 #  undef mkfifo
97 #  define mkfifo(a,b) (not_here("mkfifo"),-1)
98 #  define tzset() not_here("tzset")
99
100 #if ((__VMS_VER >= 70000000) && (__DECC_VER >= 50200000)) || (__CRTL_VER >= 70000000)
101 #    define HAS_TZNAME  /* shows up in VMS 7.0 or Dec C 5.6 */
102 #    include <utsname.h>
103 #  endif /* __VMS_VER >= 70000000 or Dec C 5.6 */
104
105    /* The POSIX notion of ttyname() is better served by getname() under VMS */
106    static char ttnambuf[64];
107 #  define ttyname(fd) (isatty(fd) > 0 ? getname(fd,ttnambuf,0) : NULL)
108
109    /* The non-POSIX CRTL times() has void return type, so we just get the
110       current time directly */
111    clock_t vms_times(struct tms *bufptr) {
112         dTHX;
113         clock_t retval;
114         /* Get wall time and convert to 10 ms intervals to
115          * produce the return value that the POSIX standard expects */
116 #  if defined(__DECC) && defined (__ALPHA)
117 #    include <ints.h>
118         uint64 vmstime;
119         _ckvmssts(sys$gettim(&vmstime));
120         vmstime /= 100000;
121         retval = vmstime & 0x7fffffff;
122 #  else
123         /* (Older hw or ccs don't have an atomic 64-bit type, so we
124          * juggle 32-bit ints (and a float) to produce a time_t result
125          * with minimal loss of information.) */
126         long int vmstime[2],remainder,divisor = 100000;
127         _ckvmssts(sys$gettim((unsigned long int *)vmstime));
128         vmstime[1] &= 0x7fff;  /* prevent overflow in EDIV */
129         _ckvmssts(lib$ediv(&divisor,vmstime,(long int *)&retval,&remainder));
130 #  endif
131         /* Fill in the struct tms using the CRTL routine . . .*/
132         times((tbuffer_t *)bufptr);
133         return (clock_t) retval;
134    }
135 #  define times(t) vms_times(t)
136 #else
137 #if defined (__CYGWIN__)
138 #    define tzname _tzname
139 #endif
140 #if defined (WIN32) || defined (NETWARE)
141 #  undef mkfifo
142 #  define mkfifo(a,b) not_here("mkfifo")
143 #  define ttyname(a) (char*)not_here("ttyname")
144 #  define sigset_t long
145 #  define pid_t long
146 #  ifdef __BORLANDC__
147 #    define tzname _tzname
148 #  endif
149 #  ifdef _MSC_VER
150 #    define mode_t short
151 #  endif
152 #  ifdef __MINGW32__
153 #    define mode_t short
154 #    ifndef tzset
155 #      define tzset()           not_here("tzset")
156 #    endif
157 #    ifndef _POSIX_OPEN_MAX
158 #      define _POSIX_OPEN_MAX   FOPEN_MAX       /* XXX bogus ? */
159 #    endif
160 #  endif
161 #  define sigaction(a,b,c)      not_here("sigaction")
162 #  define sigpending(a)         not_here("sigpending")
163 #  define sigprocmask(a,b,c)    not_here("sigprocmask")
164 #  define sigsuspend(a)         not_here("sigsuspend")
165 #  define sigemptyset(a)        not_here("sigemptyset")
166 #  define sigaddset(a,b)        not_here("sigaddset")
167 #  define sigdelset(a,b)        not_here("sigdelset")
168 #  define sigfillset(a)         not_here("sigfillset")
169 #  define sigismember(a,b)      not_here("sigismember")
170 #ifndef NETWARE
171 #  define setuid(a)             not_here("setuid")
172 #  define setgid(a)             not_here("setgid")
173 #endif  /* NETWARE */
174 #else
175
176 #  ifndef HAS_MKFIFO
177 #    if defined(OS2) || defined(MACOS_TRADITIONAL)
178 #      define mkfifo(a,b) not_here("mkfifo")
179 #    else       /* !( defined OS2 ) */ 
180 #      ifndef mkfifo
181 #        define mkfifo(path, mode) (mknod((path), (mode) | S_IFIFO, 0))
182 #      endif
183 #    endif
184 #  endif /* !HAS_MKFIFO */
185
186 #  ifdef MACOS_TRADITIONAL
187 #    define ttyname(a) (char*)not_here("ttyname")
188 #    define tzset() not_here("tzset")
189 #  else
190 #    include <grp.h>
191 #    include <sys/times.h>
192 #    ifdef HAS_UNAME
193 #      include <sys/utsname.h>
194 #    endif
195 #    include <sys/wait.h>
196 #  endif
197 #  ifdef I_UTIME
198 #    include <utime.h>
199 #  endif
200 #endif /* WIN32 || NETWARE */
201 #endif /* __VMS */
202
203 typedef int SysRet;
204 typedef long SysRetLong;
205 typedef sigset_t* POSIX__SigSet;
206 typedef HV* POSIX__SigAction;
207 #ifdef I_TERMIOS
208 typedef struct termios* POSIX__Termios;
209 #else /* Define termios types to int, and call not_here for the functions.*/
210 #define POSIX__Termios int
211 #define speed_t int
212 #define tcflag_t int
213 #define cc_t int
214 #define cfgetispeed(x) not_here("cfgetispeed")
215 #define cfgetospeed(x) not_here("cfgetospeed")
216 #define tcdrain(x) not_here("tcdrain")
217 #define tcflush(x,y) not_here("tcflush")
218 #define tcsendbreak(x,y) not_here("tcsendbreak")
219 #define cfsetispeed(x,y) not_here("cfsetispeed")
220 #define cfsetospeed(x,y) not_here("cfsetospeed")
221 #define ctermid(x) (char *) not_here("ctermid")
222 #define tcflow(x,y) not_here("tcflow")
223 #define tcgetattr(x,y) not_here("tcgetattr")
224 #define tcsetattr(x,y,z) not_here("tcsetattr")
225 #endif
226
227 /* Possibly needed prototypes */
228 char *cuserid (char *);
229 double strtod (const char *, char **);
230 long strtol (const char *, char **, int);
231 unsigned long strtoul (const char *, char **, int);
232
233 #ifndef HAS_CUSERID
234 #define cuserid(a) (char *) not_here("cuserid")
235 #endif
236 #ifndef HAS_DIFFTIME
237 #ifndef difftime
238 #define difftime(a,b) not_here("difftime")
239 #endif
240 #endif
241 #ifndef HAS_FPATHCONF
242 #define fpathconf(f,n)  (SysRetLong) not_here("fpathconf")
243 #endif
244 #ifndef HAS_MKTIME
245 #define mktime(a) not_here("mktime")
246 #endif
247 #ifndef HAS_NICE
248 #define nice(a) not_here("nice")
249 #endif
250 #ifndef HAS_PATHCONF
251 #define pathconf(f,n)   (SysRetLong) not_here("pathconf")
252 #endif
253 #ifndef HAS_SYSCONF
254 #define sysconf(n)      (SysRetLong) not_here("sysconf")
255 #endif
256 #ifndef HAS_READLINK
257 #define readlink(a,b,c) not_here("readlink")
258 #endif
259 #ifndef HAS_SETPGID
260 #define setpgid(a,b) not_here("setpgid")
261 #endif
262 #ifndef HAS_SETSID
263 #define setsid() not_here("setsid")
264 #endif
265 #ifndef HAS_STRCOLL
266 #define strcoll(s1,s2) not_here("strcoll")
267 #endif
268 #ifndef HAS_STRTOD
269 #define strtod(s1,s2) not_here("strtod")
270 #endif
271 #ifndef HAS_STRTOL
272 #define strtol(s1,s2,b) not_here("strtol")
273 #endif
274 #ifndef HAS_STRTOUL
275 #define strtoul(s1,s2,b) not_here("strtoul")
276 #endif
277 #ifndef HAS_STRXFRM
278 #define strxfrm(s1,s2,n) not_here("strxfrm")
279 #endif
280 #ifndef HAS_TCGETPGRP
281 #define tcgetpgrp(a) not_here("tcgetpgrp")
282 #endif
283 #ifndef HAS_TCSETPGRP
284 #define tcsetpgrp(a,b) not_here("tcsetpgrp")
285 #endif
286 #ifndef HAS_TIMES
287 #ifndef NETWARE
288 #define times(a) not_here("times")
289 #endif  /* NETWARE */
290 #endif
291 #ifndef HAS_UNAME
292 #define uname(a) not_here("uname")
293 #endif
294 #ifndef HAS_WAITPID
295 #define waitpid(a,b,c) not_here("waitpid")
296 #endif
297
298 #ifndef HAS_MBLEN
299 #ifndef mblen
300 #define mblen(a,b) not_here("mblen")
301 #endif
302 #endif
303 #ifndef HAS_MBSTOWCS
304 #define mbstowcs(s, pwcs, n) not_here("mbstowcs")
305 #endif
306 #ifndef HAS_MBTOWC
307 #define mbtowc(pwc, s, n) not_here("mbtowc")
308 #endif
309 #ifndef HAS_WCSTOMBS
310 #define wcstombs(s, pwcs, n) not_here("wcstombs")
311 #endif
312 #ifndef HAS_WCTOMB
313 #define wctomb(s, wchar) not_here("wcstombs")
314 #endif
315 #if !defined(HAS_MBLEN) && !defined(HAS_MBSTOWCS) && !defined(HAS_MBTOWC) && !defined(HAS_WCSTOMBS) && !defined(HAS_WCTOMB)
316 /* If we don't have these functions, then we wouldn't have gotten a typedef
317    for wchar_t, the wide character type.  Defining wchar_t allows the
318    functions referencing it to compile.  Its actual type is then meaningless,
319    since without the above functions, all sections using it end up calling
320    not_here() and croak.  --Kaveh Ghazi (ghazi@noc.rutgers.edu) 9/18/94. */
321 #ifndef wchar_t
322 #define wchar_t char
323 #endif
324 #endif
325
326 #ifndef HAS_LOCALECONV
327 #define localeconv() not_here("localeconv")
328 #endif
329
330 #ifdef HAS_LONG_DOUBLE
331 #  if LONG_DOUBLESIZE > NVSIZE
332 #    undef HAS_LONG_DOUBLE  /* XXX until we figure out how to use them */
333 #  endif
334 #endif
335
336 #ifndef HAS_LONG_DOUBLE
337 #ifdef LDBL_MAX
338 #undef LDBL_MAX
339 #endif
340 #ifdef LDBL_MIN
341 #undef LDBL_MIN
342 #endif
343 #ifdef LDBL_EPSILON
344 #undef LDBL_EPSILON
345 #endif
346 #endif
347
348 static int
349 not_here(char *s)
350 {
351     croak("POSIX::%s not implemented on this architecture", s);
352     return -1;
353 }
354
355 #include "constants.c"
356
357 /* These were implemented in the old "constant" subroutine. They are actually
358    macros that take an integer argument and return an integer result.  */
359 static int
360 int_macro_int (const char *name, STRLEN len, IV *arg_result) {
361   /* Initially switch on the length of the name.  */
362   /* This code has been edited from a "constant" function generated by:
363
364 use ExtUtils::Constant qw (constant_types C_constant XS_constant);
365
366 my $types = {map {($_, 1)} qw(IV)};
367 my @names = (qw(S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG WEXITSTATUS WIFEXITED
368                WIFSIGNALED WIFSTOPPED WSTOPSIG WTERMSIG));
369
370 print constant_types(); # macro defs
371 foreach (C_constant ("POSIX", 'int_macro_int', 'IV', $types, undef, 5, @names) ) {
372     print $_, "\n"; # C constant subs
373 }
374 print "#### XS Section:\n";
375 print XS_constant ("POSIX", $types);
376 __END__
377    */
378
379   switch (len) {
380   case 7:
381     /* Names all of length 7.  */
382     /* S_ISBLK S_ISCHR S_ISDIR S_ISREG */
383     /* Offset 5 gives the best switch position.  */
384     switch (name[5]) {
385     case 'E':
386       if (memEQ(name, "S_ISREG", 7)) {
387       /*                    ^       */
388 #ifdef S_ISREG
389         *arg_result = S_ISREG(*arg_result);
390         return PERL_constant_ISIV;
391 #else
392         return PERL_constant_NOTDEF;
393 #endif
394       }
395       break;
396     case 'H':
397       if (memEQ(name, "S_ISCHR", 7)) {
398       /*                    ^       */
399 #ifdef S_ISCHR
400         *arg_result = S_ISCHR(*arg_result);
401         return PERL_constant_ISIV;
402 #else
403         return PERL_constant_NOTDEF;
404 #endif
405       }
406       break;
407     case 'I':
408       if (memEQ(name, "S_ISDIR", 7)) {
409       /*                    ^       */
410 #ifdef S_ISDIR
411         *arg_result = S_ISDIR(*arg_result);
412         return PERL_constant_ISIV;
413 #else
414         return PERL_constant_NOTDEF;
415 #endif
416       }
417       break;
418     case 'L':
419       if (memEQ(name, "S_ISBLK", 7)) {
420       /*                    ^       */
421 #ifdef S_ISBLK
422         *arg_result = S_ISBLK(*arg_result);
423         return PERL_constant_ISIV;
424 #else
425         return PERL_constant_NOTDEF;
426 #endif
427       }
428       break;
429     }
430     break;
431   case 8:
432     /* Names all of length 8.  */
433     /* S_ISFIFO WSTOPSIG WTERMSIG */
434     /* Offset 3 gives the best switch position.  */
435     switch (name[3]) {
436     case 'O':
437       if (memEQ(name, "WSTOPSIG", 8)) {
438       /*                  ^          */
439 #ifdef WSTOPSIG
440         *arg_result = WSTOPSIG(*arg_result);
441         return PERL_constant_ISIV;
442 #else
443         return PERL_constant_NOTDEF;
444 #endif
445       }
446       break;
447     case 'R':
448       if (memEQ(name, "WTERMSIG", 8)) {
449       /*                  ^          */
450 #ifdef WTERMSIG
451         *arg_result = WTERMSIG(*arg_result);
452         return PERL_constant_ISIV;
453 #else
454         return PERL_constant_NOTDEF;
455 #endif
456       }
457       break;
458     case 'S':
459       if (memEQ(name, "S_ISFIFO", 8)) {
460       /*                  ^          */
461 #ifdef S_ISFIFO
462         *arg_result = S_ISFIFO(*arg_result);
463         return PERL_constant_ISIV;
464 #else
465         return PERL_constant_NOTDEF;
466 #endif
467       }
468       break;
469     }
470     break;
471   case 9:
472     if (memEQ(name, "WIFEXITED", 9)) {
473 #ifdef WIFEXITED
474       *arg_result = WIFEXITED(*arg_result);
475       return PERL_constant_ISIV;
476 #else
477       return PERL_constant_NOTDEF;
478 #endif
479     }
480     break;
481   case 10:
482     if (memEQ(name, "WIFSTOPPED", 10)) {
483 #ifdef WIFSTOPPED
484       *arg_result = WIFSTOPPED(*arg_result);
485       return PERL_constant_ISIV;
486 #else
487       return PERL_constant_NOTDEF;
488 #endif
489     }
490     break;
491   case 11:
492     /* Names all of length 11.  */
493     /* WEXITSTATUS WIFSIGNALED */
494     /* Offset 1 gives the best switch position.  */
495     switch (name[1]) {
496     case 'E':
497       if (memEQ(name, "WEXITSTATUS", 11)) {
498       /*                ^                */
499 #ifdef WEXITSTATUS
500         *arg_result = WEXITSTATUS(*arg_result);
501         return PERL_constant_ISIV;
502 #else
503         return PERL_constant_NOTDEF;
504 #endif
505       }
506       break;
507     case 'I':
508       if (memEQ(name, "WIFSIGNALED", 11)) {
509       /*                ^                */
510 #ifdef WIFSIGNALED
511         *arg_result = WIFSIGNALED(*arg_result);
512         return PERL_constant_ISIV;
513 #else
514         return PERL_constant_NOTDEF;
515 #endif
516       }
517       break;
518     }
519     break;
520   }
521   return PERL_constant_NOTFOUND;
522 }
523
524 static void
525 restore_sigmask(pTHX_ SV *osset_sv)
526 {
527      /* Fortunately, restoring the signal mask can't fail, because
528       * there's nothing we can do about it if it does -- we're not
529       * supposed to return -1 from sigaction unless the disposition
530       * was unaffected.
531       */
532      sigset_t *ossetp = (sigset_t *) SvPV_nolen( osset_sv );
533      (void)sigprocmask(SIG_SETMASK, ossetp, (sigset_t *)0);
534 }
535
536 MODULE = SigSet         PACKAGE = POSIX::SigSet         PREFIX = sig
537
538 POSIX::SigSet
539 new(packname = "POSIX::SigSet", ...)
540     char *              packname
541     CODE:
542         {
543             int i;
544             New(0, RETVAL, 1, sigset_t);
545             sigemptyset(RETVAL);
546             for (i = 1; i < items; i++)
547                 sigaddset(RETVAL, SvIV(ST(i)));
548         }
549     OUTPUT:
550         RETVAL
551
552 void
553 DESTROY(sigset)
554         POSIX::SigSet   sigset
555     CODE:
556         Safefree(sigset);
557
558 SysRet
559 sigaddset(sigset, sig)
560         POSIX::SigSet   sigset
561         int             sig
562
563 SysRet
564 sigdelset(sigset, sig)
565         POSIX::SigSet   sigset
566         int             sig
567
568 SysRet
569 sigemptyset(sigset)
570         POSIX::SigSet   sigset
571
572 SysRet
573 sigfillset(sigset)
574         POSIX::SigSet   sigset
575
576 int
577 sigismember(sigset, sig)
578         POSIX::SigSet   sigset
579         int             sig
580
581
582 MODULE = Termios        PACKAGE = POSIX::Termios        PREFIX = cf
583
584 POSIX::Termios
585 new(packname = "POSIX::Termios", ...)
586     char *              packname
587     CODE:
588         {
589 #ifdef I_TERMIOS
590             New(0, RETVAL, 1, struct termios);
591 #else
592             not_here("termios");
593         RETVAL = 0;
594 #endif
595         }
596     OUTPUT:
597         RETVAL
598
599 void
600 DESTROY(termios_ref)
601         POSIX::Termios  termios_ref
602     CODE:
603 #ifdef I_TERMIOS
604         Safefree(termios_ref);
605 #else
606             not_here("termios");
607 #endif
608
609 SysRet
610 getattr(termios_ref, fd = 0)
611         POSIX::Termios  termios_ref
612         int             fd
613     CODE:
614         RETVAL = tcgetattr(fd, termios_ref);
615     OUTPUT:
616         RETVAL
617
618 SysRet
619 setattr(termios_ref, fd = 0, optional_actions = 0)
620         POSIX::Termios  termios_ref
621         int             fd
622         int             optional_actions
623     CODE:
624         RETVAL = tcsetattr(fd, optional_actions, termios_ref);
625     OUTPUT:
626         RETVAL
627
628 speed_t
629 cfgetispeed(termios_ref)
630         POSIX::Termios  termios_ref
631
632 speed_t
633 cfgetospeed(termios_ref)
634         POSIX::Termios  termios_ref
635
636 tcflag_t
637 getiflag(termios_ref)
638         POSIX::Termios  termios_ref
639     CODE:
640 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
641         RETVAL = termios_ref->c_iflag;
642 #else
643      not_here("getiflag");
644      RETVAL = 0;
645 #endif
646     OUTPUT:
647         RETVAL
648
649 tcflag_t
650 getoflag(termios_ref)
651         POSIX::Termios  termios_ref
652     CODE:
653 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
654         RETVAL = termios_ref->c_oflag;
655 #else
656      not_here("getoflag");
657      RETVAL = 0;
658 #endif
659     OUTPUT:
660         RETVAL
661
662 tcflag_t
663 getcflag(termios_ref)
664         POSIX::Termios  termios_ref
665     CODE:
666 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
667         RETVAL = termios_ref->c_cflag;
668 #else
669      not_here("getcflag");
670      RETVAL = 0;
671 #endif
672     OUTPUT:
673         RETVAL
674
675 tcflag_t
676 getlflag(termios_ref)
677         POSIX::Termios  termios_ref
678     CODE:
679 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
680         RETVAL = termios_ref->c_lflag;
681 #else
682      not_here("getlflag");
683      RETVAL = 0;
684 #endif
685     OUTPUT:
686         RETVAL
687
688 cc_t
689 getcc(termios_ref, ccix)
690         POSIX::Termios  termios_ref
691         int             ccix
692     CODE:
693 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
694         if (ccix >= NCCS)
695             croak("Bad getcc subscript");
696         RETVAL = termios_ref->c_cc[ccix];
697 #else
698      not_here("getcc");
699      RETVAL = 0;
700 #endif
701     OUTPUT:
702         RETVAL
703
704 SysRet
705 cfsetispeed(termios_ref, speed)
706         POSIX::Termios  termios_ref
707         speed_t         speed
708
709 SysRet
710 cfsetospeed(termios_ref, speed)
711         POSIX::Termios  termios_ref
712         speed_t         speed
713
714 void
715 setiflag(termios_ref, iflag)
716         POSIX::Termios  termios_ref
717         tcflag_t        iflag
718     CODE:
719 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
720         termios_ref->c_iflag = iflag;
721 #else
722             not_here("setiflag");
723 #endif
724
725 void
726 setoflag(termios_ref, oflag)
727         POSIX::Termios  termios_ref
728         tcflag_t        oflag
729     CODE:
730 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
731         termios_ref->c_oflag = oflag;
732 #else
733             not_here("setoflag");
734 #endif
735
736 void
737 setcflag(termios_ref, cflag)
738         POSIX::Termios  termios_ref
739         tcflag_t        cflag
740     CODE:
741 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
742         termios_ref->c_cflag = cflag;
743 #else
744             not_here("setcflag");
745 #endif
746
747 void
748 setlflag(termios_ref, lflag)
749         POSIX::Termios  termios_ref
750         tcflag_t        lflag
751     CODE:
752 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
753         termios_ref->c_lflag = lflag;
754 #else
755             not_here("setlflag");
756 #endif
757
758 void
759 setcc(termios_ref, ccix, cc)
760         POSIX::Termios  termios_ref
761         int             ccix
762         cc_t            cc
763     CODE:
764 #ifdef I_TERMIOS /* References a termios structure member so ifdef it out. */
765         if (ccix >= NCCS)
766             croak("Bad setcc subscript");
767         termios_ref->c_cc[ccix] = cc;
768 #else
769             not_here("setcc");
770 #endif
771
772
773 MODULE = POSIX          PACKAGE = POSIX
774
775 INCLUDE: constants.xs
776
777 void
778 int_macro_int(sv, iv)
779     PREINIT:
780         dXSTARG;
781         STRLEN          len;
782         int             type;
783     INPUT:
784         SV *            sv;
785         const char *    s = SvPV(sv, len);
786         IV              iv;
787     PPCODE:
788         /* Change this to int_macro_int(s, len, &iv, &nv);
789            if you need to return both NVs and IVs */
790         type = int_macro_int(s, len, &iv);
791       /* Return 1 or 2 items. First is error message, or undef if no error.
792            Second, if present, is found value */
793         switch (type) {
794         case PERL_constant_NOTFOUND:
795           sv = sv_2mortal(newSVpvf("%s is not a valid POSIX macro", s));
796           EXTEND(SP, 1);
797           PUSHs(&PL_sv_undef);
798           PUSHs(sv);
799           break;
800         case PERL_constant_NOTDEF:
801           sv = sv_2mortal(newSVpvf(
802             "Your vendor has not defined POSIX macro %s, used", s));
803           EXTEND(SP, 1);
804           PUSHs(&PL_sv_undef);
805           PUSHs(sv);
806           break;
807         case PERL_constant_ISIV:
808           PUSHi(iv);
809           break;
810         default:
811           sv = sv_2mortal(newSVpvf(
812             "Unexpected return type %d while processing POSIX macro %s, used",
813                type, s));
814           EXTEND(SP, 1);
815           PUSHs(&PL_sv_undef);
816           PUSHs(sv);
817         }
818
819 int
820 isalnum(charstring)
821         unsigned char * charstring
822     CODE:
823         unsigned char *s = charstring;
824         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
825         for (RETVAL = 1; RETVAL && s < e; s++)
826             if (!isalnum(*s))
827                 RETVAL = 0;
828     OUTPUT:
829         RETVAL
830
831 int
832 isalpha(charstring)
833         unsigned char * charstring
834     CODE:
835         unsigned char *s = charstring;
836         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
837         for (RETVAL = 1; RETVAL && s < e; s++)
838             if (!isalpha(*s))
839                 RETVAL = 0;
840     OUTPUT:
841         RETVAL
842
843 int
844 iscntrl(charstring)
845         unsigned char * charstring
846     CODE:
847         unsigned char *s = charstring;
848         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
849         for (RETVAL = 1; RETVAL && s < e; s++)
850             if (!iscntrl(*s))
851                 RETVAL = 0;
852     OUTPUT:
853         RETVAL
854
855 int
856 isdigit(charstring)
857         unsigned char * charstring
858     CODE:
859         unsigned char *s = charstring;
860         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
861         for (RETVAL = 1; RETVAL && s < e; s++)
862             if (!isdigit(*s))
863                 RETVAL = 0;
864     OUTPUT:
865         RETVAL
866
867 int
868 isgraph(charstring)
869         unsigned char * charstring
870     CODE:
871         unsigned char *s = charstring;
872         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
873         for (RETVAL = 1; RETVAL && s < e; s++)
874             if (!isgraph(*s))
875                 RETVAL = 0;
876     OUTPUT:
877         RETVAL
878
879 int
880 islower(charstring)
881         unsigned char * charstring
882     CODE:
883         unsigned char *s = charstring;
884         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
885         for (RETVAL = 1; RETVAL && s < e; s++)
886             if (!islower(*s))
887                 RETVAL = 0;
888     OUTPUT:
889         RETVAL
890
891 int
892 isprint(charstring)
893         unsigned char * charstring
894     CODE:
895         unsigned char *s = charstring;
896         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
897         for (RETVAL = 1; RETVAL && s < e; s++)
898             if (!isprint(*s))
899                 RETVAL = 0;
900     OUTPUT:
901         RETVAL
902
903 int
904 ispunct(charstring)
905         unsigned char * charstring
906     CODE:
907         unsigned char *s = charstring;
908         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
909         for (RETVAL = 1; RETVAL && s < e; s++)
910             if (!ispunct(*s))
911                 RETVAL = 0;
912     OUTPUT:
913         RETVAL
914
915 int
916 isspace(charstring)
917         unsigned char * charstring
918     CODE:
919         unsigned char *s = charstring;
920         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
921         for (RETVAL = 1; RETVAL && s < e; s++)
922             if (!isspace(*s))
923                 RETVAL = 0;
924     OUTPUT:
925         RETVAL
926
927 int
928 isupper(charstring)
929         unsigned char * charstring
930     CODE:
931         unsigned char *s = charstring;
932         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
933         for (RETVAL = 1; RETVAL && s < e; s++)
934             if (!isupper(*s))
935                 RETVAL = 0;
936     OUTPUT:
937         RETVAL
938
939 int
940 isxdigit(charstring)
941         unsigned char * charstring
942     CODE:
943         unsigned char *s = charstring;
944         unsigned char *e = s + PL_na;   /* "PL_na" set by typemap side effect */
945         for (RETVAL = 1; RETVAL && s < e; s++)
946             if (!isxdigit(*s))
947                 RETVAL = 0;
948     OUTPUT:
949         RETVAL
950
951 SysRet
952 open(filename, flags = O_RDONLY, mode = 0666)
953         char *          filename
954         int             flags
955         Mode_t          mode
956     CODE:
957         if (flags & (O_APPEND|O_CREAT|O_TRUNC|O_RDWR|O_WRONLY|O_EXCL))
958             TAINT_PROPER("open");
959         RETVAL = open(filename, flags, mode);
960     OUTPUT:
961         RETVAL
962
963
964 HV *
965 localeconv()
966     CODE:
967 #ifdef HAS_LOCALECONV
968         struct lconv *lcbuf;
969         RETVAL = newHV();
970         if ((lcbuf = localeconv())) {
971             /* the strings */
972             if (lcbuf->decimal_point && *lcbuf->decimal_point)
973                 hv_store(RETVAL, "decimal_point", 13,
974                     newSVpv(lcbuf->decimal_point, 0), 0);
975             if (lcbuf->thousands_sep && *lcbuf->thousands_sep)
976                 hv_store(RETVAL, "thousands_sep", 13,
977                     newSVpv(lcbuf->thousands_sep, 0), 0);
978 #ifndef NO_LOCALECONV_GROUPING
979             if (lcbuf->grouping && *lcbuf->grouping)
980                 hv_store(RETVAL, "grouping", 8,
981                     newSVpv(lcbuf->grouping, 0), 0);
982 #endif
983             if (lcbuf->int_curr_symbol && *lcbuf->int_curr_symbol)
984                 hv_store(RETVAL, "int_curr_symbol", 15,
985                     newSVpv(lcbuf->int_curr_symbol, 0), 0);
986             if (lcbuf->currency_symbol && *lcbuf->currency_symbol)
987                 hv_store(RETVAL, "currency_symbol", 15,
988                     newSVpv(lcbuf->currency_symbol, 0), 0);
989             if (lcbuf->mon_decimal_point && *lcbuf->mon_decimal_point)
990                 hv_store(RETVAL, "mon_decimal_point", 17,
991                     newSVpv(lcbuf->mon_decimal_point, 0), 0);
992 #ifndef NO_LOCALECONV_MON_THOUSANDS_SEP
993             if (lcbuf->mon_thousands_sep && *lcbuf->mon_thousands_sep)
994                 hv_store(RETVAL, "mon_thousands_sep", 17,
995                     newSVpv(lcbuf->mon_thousands_sep, 0), 0);
996 #endif                    
997 #ifndef NO_LOCALECONV_MON_GROUPING
998             if (lcbuf->mon_grouping && *lcbuf->mon_grouping)
999                 hv_store(RETVAL, "mon_grouping", 12,
1000                     newSVpv(lcbuf->mon_grouping, 0), 0);
1001 #endif
1002             if (lcbuf->positive_sign && *lcbuf->positive_sign)
1003                 hv_store(RETVAL, "positive_sign", 13,
1004                     newSVpv(lcbuf->positive_sign, 0), 0);
1005             if (lcbuf->negative_sign && *lcbuf->negative_sign)
1006                 hv_store(RETVAL, "negative_sign", 13,
1007                     newSVpv(lcbuf->negative_sign, 0), 0);
1008             /* the integers */
1009             if (lcbuf->int_frac_digits != CHAR_MAX)
1010                 hv_store(RETVAL, "int_frac_digits", 15,
1011                     newSViv(lcbuf->int_frac_digits), 0);
1012             if (lcbuf->frac_digits != CHAR_MAX)
1013                 hv_store(RETVAL, "frac_digits", 11,
1014                     newSViv(lcbuf->frac_digits), 0);
1015             if (lcbuf->p_cs_precedes != CHAR_MAX)
1016                 hv_store(RETVAL, "p_cs_precedes", 13,
1017                     newSViv(lcbuf->p_cs_precedes), 0);
1018             if (lcbuf->p_sep_by_space != CHAR_MAX)
1019                 hv_store(RETVAL, "p_sep_by_space", 14,
1020                     newSViv(lcbuf->p_sep_by_space), 0);
1021             if (lcbuf->n_cs_precedes != CHAR_MAX)
1022                 hv_store(RETVAL, "n_cs_precedes", 13,
1023                     newSViv(lcbuf->n_cs_precedes), 0);
1024             if (lcbuf->n_sep_by_space != CHAR_MAX)
1025                 hv_store(RETVAL, "n_sep_by_space", 14,
1026                     newSViv(lcbuf->n_sep_by_space), 0);
1027             if (lcbuf->p_sign_posn != CHAR_MAX)
1028                 hv_store(RETVAL, "p_sign_posn", 11,
1029                     newSViv(lcbuf->p_sign_posn), 0);
1030             if (lcbuf->n_sign_posn != CHAR_MAX)
1031                 hv_store(RETVAL, "n_sign_posn", 11,
1032                     newSViv(lcbuf->n_sign_posn), 0);
1033         }
1034 #else
1035         localeconv(); /* A stub to call not_here(). */
1036 #endif
1037     OUTPUT:
1038         RETVAL
1039
1040 char *
1041 setlocale(category, locale = 0)
1042         int             category
1043         char *          locale
1044     CODE:
1045         RETVAL = setlocale(category, locale);
1046         if (RETVAL) {
1047 #ifdef USE_LOCALE_CTYPE
1048             if (category == LC_CTYPE
1049 #ifdef LC_ALL
1050                 || category == LC_ALL
1051 #endif
1052                 )
1053             {
1054                 char *newctype;
1055 #ifdef LC_ALL
1056                 if (category == LC_ALL)
1057                     newctype = setlocale(LC_CTYPE, NULL);
1058                 else
1059 #endif
1060                     newctype = RETVAL;
1061                 new_ctype(newctype);
1062             }
1063 #endif /* USE_LOCALE_CTYPE */
1064 #ifdef USE_LOCALE_COLLATE
1065             if (category == LC_COLLATE
1066 #ifdef LC_ALL
1067                 || category == LC_ALL
1068 #endif
1069                 )
1070             {
1071                 char *newcoll;
1072 #ifdef LC_ALL
1073                 if (category == LC_ALL)
1074                     newcoll = setlocale(LC_COLLATE, NULL);
1075                 else
1076 #endif
1077                     newcoll = RETVAL;
1078                 new_collate(newcoll);
1079             }
1080 #endif /* USE_LOCALE_COLLATE */
1081 #ifdef USE_LOCALE_NUMERIC
1082             if (category == LC_NUMERIC
1083 #ifdef LC_ALL
1084                 || category == LC_ALL
1085 #endif
1086                 )
1087             {
1088                 char *newnum;
1089 #ifdef LC_ALL
1090                 if (category == LC_ALL)
1091                     newnum = setlocale(LC_NUMERIC, NULL);
1092                 else
1093 #endif
1094                     newnum = RETVAL;
1095                 new_numeric(newnum);
1096             }
1097 #endif /* USE_LOCALE_NUMERIC */
1098         }
1099     OUTPUT:
1100         RETVAL
1101
1102
1103 NV
1104 acos(x)
1105         NV              x
1106
1107 NV
1108 asin(x)
1109         NV              x
1110
1111 NV
1112 atan(x)
1113         NV              x
1114
1115 NV
1116 ceil(x)
1117         NV              x
1118
1119 NV
1120 cosh(x)
1121         NV              x
1122
1123 NV
1124 floor(x)
1125         NV              x
1126
1127 NV
1128 fmod(x,y)
1129         NV              x
1130         NV              y
1131
1132 void
1133 frexp(x)
1134         NV              x
1135     PPCODE:
1136         int expvar;
1137         /* (We already know stack is long enough.) */
1138         PUSHs(sv_2mortal(newSVnv(frexp(x,&expvar))));
1139         PUSHs(sv_2mortal(newSViv(expvar)));
1140
1141 NV
1142 ldexp(x,exp)
1143         NV              x
1144         int             exp
1145
1146 NV
1147 log10(x)
1148         NV              x
1149
1150 void
1151 modf(x)
1152         NV              x
1153     PPCODE:
1154         NV intvar;
1155         /* (We already know stack is long enough.) */
1156         PUSHs(sv_2mortal(newSVnv(Perl_modf(x,&intvar))));
1157         PUSHs(sv_2mortal(newSVnv(intvar)));
1158
1159 NV
1160 sinh(x)
1161         NV              x
1162
1163 NV
1164 tan(x)
1165         NV              x
1166
1167 NV
1168 tanh(x)
1169         NV              x
1170
1171 SysRet
1172 sigaction(sig, optaction, oldaction = 0)
1173         int                     sig
1174         SV *                    optaction
1175         POSIX::SigAction        oldaction
1176     CODE:
1177 #if defined(WIN32) || defined(NETWARE)
1178         RETVAL = not_here("sigaction");
1179 #else
1180 # This code is really grody because we're trying to make the signal
1181 # interface look beautiful, which is hard.
1182
1183         {
1184             POSIX__SigAction action;
1185             GV *siggv = gv_fetchpv("SIG", TRUE, SVt_PVHV);
1186             struct sigaction act;
1187             struct sigaction oact;
1188             sigset_t sset;
1189             SV *osset_sv;
1190             sigset_t osset;
1191             POSIX__SigSet sigset;
1192             SV** svp;
1193             SV** sigsvp = hv_fetch(GvHVn(siggv),
1194                                  PL_sig_name[sig],
1195                                  strlen(PL_sig_name[sig]),
1196                                  TRUE);
1197
1198             /* Check optaction and set action */
1199             if(SvTRUE(optaction)) {
1200                 if(sv_isa(optaction, "POSIX::SigAction"))
1201                         action = (HV*)SvRV(optaction);
1202                 else
1203                         croak("action is not of type POSIX::SigAction");
1204             }
1205             else {
1206                 action=0;
1207             }
1208
1209             /* sigaction() is supposed to look atomic. In particular, any
1210              * signal handler invoked during a sigaction() call should
1211              * see either the old or the new disposition, and not something
1212              * in between. We use sigprocmask() to make it so.
1213              */
1214             sigfillset(&sset);
1215             RETVAL=sigprocmask(SIG_BLOCK, &sset, &osset);
1216             if(RETVAL == -1)
1217                XSRETURN_UNDEF;
1218             ENTER;
1219             /* Restore signal mask no matter how we exit this block. */
1220             osset_sv = newSVpv((char *)(&osset), sizeof(sigset_t));
1221             SAVEFREESV( osset_sv );
1222             SAVEDESTRUCTOR_X(restore_sigmask, osset_sv);
1223
1224             RETVAL=-1; /* In case both oldaction and action are 0. */
1225
1226             /* Remember old disposition if desired. */
1227             if (oldaction) {
1228                 svp = hv_fetch(oldaction, "HANDLER", 7, TRUE);
1229                 if(!svp)
1230                     croak("Can't supply an oldaction without a HANDLER");
1231                 if(SvTRUE(*sigsvp)) { /* TBD: what if "0"? */
1232                         sv_setsv(*svp, *sigsvp);
1233                 }
1234                 else {
1235                         sv_setpv(*svp, "DEFAULT");
1236                 }
1237                 RETVAL = sigaction(sig, (struct sigaction *)0, & oact);
1238                 if(RETVAL == -1)
1239                    XSRETURN_UNDEF;
1240                 /* Get back the mask. */
1241                 svp = hv_fetch(oldaction, "MASK", 4, TRUE);
1242                 if (sv_isa(*svp, "POSIX::SigSet")) {
1243                     IV tmp = SvIV((SV*)SvRV(*svp));
1244                     sigset = INT2PTR(sigset_t*, tmp);
1245                 }
1246                 else {
1247                     New(0, sigset, 1, sigset_t);
1248                     sv_setptrobj(*svp, sigset, "POSIX::SigSet");
1249                 }
1250                 *sigset = oact.sa_mask;
1251
1252                 /* Get back the flags. */
1253                 svp = hv_fetch(oldaction, "FLAGS", 5, TRUE);
1254                 sv_setiv(*svp, oact.sa_flags);
1255             }
1256
1257             if (action) {
1258                 /* Vector new handler through %SIG.  (We always use sighandler
1259                    for the C signal handler, which reads %SIG to dispatch.) */
1260                 svp = hv_fetch(action, "HANDLER", 7, FALSE);
1261                 if (!svp)
1262                     croak("Can't supply an action without a HANDLER");
1263                 sv_setsv(*sigsvp, *svp);
1264                 mg_set(*sigsvp);        /* handles DEFAULT and IGNORE */
1265                 if(SvPOK(*svp)) {
1266                         char *s=SvPVX(*svp);
1267                         if(strEQ(s,"IGNORE")) {
1268                                 act.sa_handler = SIG_IGN;
1269                         }
1270                         else if(strEQ(s,"DEFAULT")) {
1271                                 act.sa_handler = SIG_DFL;
1272                         }
1273                         else {
1274                                 act.sa_handler = PL_sighandlerp;
1275                         }
1276                 }
1277                 else {
1278                         act.sa_handler = PL_sighandlerp;
1279                 }
1280
1281                 /* Set up any desired mask. */
1282                 svp = hv_fetch(action, "MASK", 4, FALSE);
1283                 if (svp && sv_isa(*svp, "POSIX::SigSet")) {
1284                     IV tmp = SvIV((SV*)SvRV(*svp));
1285                     sigset = INT2PTR(sigset_t*, tmp);
1286                     act.sa_mask = *sigset;
1287                 }
1288                 else
1289                     sigemptyset(& act.sa_mask);
1290
1291                 /* Set up any desired flags. */
1292                 svp = hv_fetch(action, "FLAGS", 5, FALSE);
1293                 act.sa_flags = svp ? SvIV(*svp) : 0;
1294
1295                 /* Don't worry about cleaning up *sigsvp if this fails,
1296                  * because that means we tried to disposition a
1297                  * nonblockable signal, in which case *sigsvp is
1298                  * essentially meaningless anyway.
1299                  */
1300                 RETVAL = sigaction(sig, & act, (struct sigaction *)0);
1301                if(RETVAL == -1)
1302                    XSRETURN_UNDEF;
1303             }
1304
1305             LEAVE;
1306         }
1307 #endif
1308     OUTPUT:
1309         RETVAL
1310
1311 SysRet
1312 sigpending(sigset)
1313         POSIX::SigSet           sigset
1314
1315 SysRet
1316 sigprocmask(how, sigset, oldsigset = 0)
1317         int                     how
1318         POSIX::SigSet           sigset
1319         POSIX::SigSet           oldsigset = NO_INIT
1320 INIT:
1321         if ( items < 3 ) {
1322             oldsigset = 0;
1323         }
1324         else if (sv_derived_from(ST(2), "POSIX::SigSet")) {
1325             IV tmp = SvIV((SV*)SvRV(ST(2)));
1326             oldsigset = INT2PTR(POSIX__SigSet,tmp);
1327         }
1328         else {
1329             New(0, oldsigset, 1, sigset_t);
1330             sigemptyset(oldsigset);
1331             sv_setref_pv(ST(2), "POSIX::SigSet", (void*)oldsigset);
1332         }
1333
1334 SysRet
1335 sigsuspend(signal_mask)
1336         POSIX::SigSet           signal_mask
1337
1338 void
1339 _exit(status)
1340         int             status
1341
1342 SysRet
1343 close(fd)
1344         int             fd
1345
1346 SysRet
1347 dup(fd)
1348         int             fd
1349
1350 SysRet
1351 dup2(fd1, fd2)
1352         int             fd1
1353         int             fd2
1354
1355 SysRetLong
1356 lseek(fd, offset, whence)
1357         int             fd
1358         Off_t           offset
1359         int             whence
1360
1361 SysRet
1362 nice(incr)
1363         int             incr
1364
1365 void
1366 pipe()
1367     PPCODE:
1368         int fds[2];
1369         if (pipe(fds) != -1) {
1370             EXTEND(SP,2);
1371             PUSHs(sv_2mortal(newSViv(fds[0])));
1372             PUSHs(sv_2mortal(newSViv(fds[1])));
1373         }
1374
1375 SysRet
1376 read(fd, buffer, nbytes)
1377     PREINIT:
1378         SV *sv_buffer = SvROK(ST(1)) ? SvRV(ST(1)) : ST(1);
1379     INPUT:
1380         int             fd
1381         size_t          nbytes
1382         char *          buffer = sv_grow( sv_buffer, nbytes+1 );
1383     CLEANUP:
1384         if (RETVAL >= 0) {
1385             SvCUR(sv_buffer) = RETVAL;
1386             SvPOK_only(sv_buffer);
1387             *SvEND(sv_buffer) = '\0';
1388             SvTAINTED_on(sv_buffer);
1389         }
1390
1391 SysRet
1392 setpgid(pid, pgid)
1393         pid_t           pid
1394         pid_t           pgid
1395
1396 pid_t
1397 setsid()
1398
1399 pid_t
1400 tcgetpgrp(fd)
1401         int             fd
1402
1403 SysRet
1404 tcsetpgrp(fd, pgrp_id)
1405         int             fd
1406         pid_t           pgrp_id
1407
1408 void
1409 uname()
1410     PPCODE:
1411 #ifdef HAS_UNAME
1412         struct utsname buf;
1413         if (uname(&buf) >= 0) {
1414             EXTEND(SP, 5);
1415             PUSHs(sv_2mortal(newSVpv(buf.sysname, 0)));
1416             PUSHs(sv_2mortal(newSVpv(buf.nodename, 0)));
1417             PUSHs(sv_2mortal(newSVpv(buf.release, 0)));
1418             PUSHs(sv_2mortal(newSVpv(buf.version, 0)));
1419             PUSHs(sv_2mortal(newSVpv(buf.machine, 0)));
1420         }
1421 #else
1422         uname((char *) 0); /* A stub to call not_here(). */
1423 #endif
1424
1425 SysRet
1426 write(fd, buffer, nbytes)
1427         int             fd
1428         char *          buffer
1429         size_t          nbytes
1430
1431 SV *
1432 tmpnam()
1433     PREINIT:
1434         STRLEN i;
1435         int len;
1436     CODE:
1437         RETVAL = newSVpvn("", 0);
1438         SvGROW(RETVAL, L_tmpnam);
1439         len = strlen(tmpnam(SvPV(RETVAL, i)));
1440         SvCUR_set(RETVAL, len);
1441     OUTPUT:
1442         RETVAL
1443
1444 void
1445 abort()
1446
1447 int
1448 mblen(s, n)
1449         char *          s
1450         size_t          n
1451
1452 size_t
1453 mbstowcs(s, pwcs, n)
1454         wchar_t *       s
1455         char *          pwcs
1456         size_t          n
1457
1458 int
1459 mbtowc(pwc, s, n)
1460         wchar_t *       pwc
1461         char *          s
1462         size_t          n
1463
1464 int
1465 wcstombs(s, pwcs, n)
1466         char *          s
1467         wchar_t *       pwcs
1468         size_t          n
1469
1470 int
1471 wctomb(s, wchar)
1472         char *          s
1473         wchar_t         wchar
1474
1475 int
1476 strcoll(s1, s2)
1477         char *          s1
1478         char *          s2
1479
1480 void
1481 strtod(str)
1482         char *          str
1483     PREINIT:
1484         double num;
1485         char *unparsed;
1486     PPCODE:
1487         SET_NUMERIC_LOCAL();
1488         num = strtod(str, &unparsed);
1489         PUSHs(sv_2mortal(newSVnv(num)));
1490         if (GIMME == G_ARRAY) {
1491             EXTEND(SP, 1);
1492             if (unparsed)
1493                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1494             else
1495                 PUSHs(&PL_sv_undef);
1496         }
1497
1498 void
1499 strtol(str, base = 0)
1500         char *          str
1501         int             base
1502     PREINIT:
1503         long num;
1504         char *unparsed;
1505     PPCODE:
1506         num = strtol(str, &unparsed, base);
1507 #if IVSIZE <= LONGSIZE
1508         if (num < IV_MIN || num > IV_MAX)
1509             PUSHs(sv_2mortal(newSVnv((double)num)));
1510         else
1511 #endif
1512             PUSHs(sv_2mortal(newSViv((IV)num)));
1513         if (GIMME == G_ARRAY) {
1514             EXTEND(SP, 1);
1515             if (unparsed)
1516                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1517             else
1518                 PUSHs(&PL_sv_undef);
1519         }
1520
1521 void
1522 strtoul(str, base = 0)
1523         char *          str
1524         int             base
1525     PREINIT:
1526         unsigned long num;
1527         char *unparsed;
1528     PPCODE:
1529         num = strtoul(str, &unparsed, base);
1530         if (num <= IV_MAX)
1531             PUSHs(sv_2mortal(newSViv((IV)num)));
1532         else
1533             PUSHs(sv_2mortal(newSVnv((double)num)));
1534         if (GIMME == G_ARRAY) {
1535             EXTEND(SP, 1);
1536             if (unparsed)
1537                 PUSHs(sv_2mortal(newSViv(strlen(unparsed))));
1538             else
1539                 PUSHs(&PL_sv_undef);
1540         }
1541
1542 void
1543 strxfrm(src)
1544         SV *            src
1545     CODE:
1546         {
1547           STRLEN srclen;
1548           STRLEN dstlen;
1549           char *p = SvPV(src,srclen);
1550           srclen++;
1551           ST(0) = sv_2mortal(NEWSV(800,srclen));
1552           dstlen = strxfrm(SvPVX(ST(0)), p, (size_t)srclen);
1553           if (dstlen > srclen) {
1554               dstlen++;
1555               SvGROW(ST(0), dstlen);
1556               strxfrm(SvPVX(ST(0)), p, (size_t)dstlen);
1557               dstlen--;
1558           }
1559           SvCUR(ST(0)) = dstlen;
1560             SvPOK_only(ST(0));
1561         }
1562
1563 SysRet
1564 mkfifo(filename, mode)
1565         char *          filename
1566         Mode_t          mode
1567     CODE:
1568         TAINT_PROPER("mkfifo");
1569         RETVAL = mkfifo(filename, mode);
1570     OUTPUT:
1571         RETVAL
1572
1573 SysRet
1574 tcdrain(fd)
1575         int             fd
1576
1577
1578 SysRet
1579 tcflow(fd, action)
1580         int             fd
1581         int             action
1582
1583
1584 SysRet
1585 tcflush(fd, queue_selector)
1586         int             fd
1587         int             queue_selector
1588
1589 SysRet
1590 tcsendbreak(fd, duration)
1591         int             fd
1592         int             duration
1593
1594 char *
1595 asctime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
1596         int             sec
1597         int             min
1598         int             hour
1599         int             mday
1600         int             mon
1601         int             year
1602         int             wday
1603         int             yday
1604         int             isdst
1605     CODE:
1606         {
1607             struct tm mytm;
1608             init_tm(&mytm);     /* XXX workaround - see init_tm() above */
1609             mytm.tm_sec = sec;
1610             mytm.tm_min = min;
1611             mytm.tm_hour = hour;
1612             mytm.tm_mday = mday;
1613             mytm.tm_mon = mon;
1614             mytm.tm_year = year;
1615             mytm.tm_wday = wday;
1616             mytm.tm_yday = yday;
1617             mytm.tm_isdst = isdst;
1618             RETVAL = asctime(&mytm);
1619         }
1620     OUTPUT:
1621         RETVAL
1622
1623 long
1624 clock()
1625
1626 char *
1627 ctime(time)
1628         Time_t          &time
1629
1630 void
1631 times()
1632         PPCODE:
1633         struct tms tms;
1634         clock_t realtime;
1635         realtime = times( &tms );
1636         EXTEND(SP,5);
1637         PUSHs( sv_2mortal( newSViv( (IV) realtime ) ) );
1638         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_utime ) ) );
1639         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_stime ) ) );
1640         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cutime ) ) );
1641         PUSHs( sv_2mortal( newSViv( (IV) tms.tms_cstime ) ) );
1642
1643 double
1644 difftime(time1, time2)
1645         Time_t          time1
1646         Time_t          time2
1647
1648 SysRetLong
1649 mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
1650         int             sec
1651         int             min
1652         int             hour
1653         int             mday
1654         int             mon
1655         int             year
1656         int             wday
1657         int             yday
1658         int             isdst
1659     CODE:
1660         {
1661             struct tm mytm;
1662             init_tm(&mytm);     /* XXX workaround - see init_tm() above */
1663             mytm.tm_sec = sec;
1664             mytm.tm_min = min;
1665             mytm.tm_hour = hour;
1666             mytm.tm_mday = mday;
1667             mytm.tm_mon = mon;
1668             mytm.tm_year = year;
1669             mytm.tm_wday = wday;
1670             mytm.tm_yday = yday;
1671             mytm.tm_isdst = isdst;
1672             RETVAL = mktime(&mytm);
1673         }
1674     OUTPUT:
1675         RETVAL
1676
1677 #XXX: if $xsubpp::WantOptimize is always the default
1678 #     sv_setpv(TARG, ...) could be used rather than
1679 #     ST(0) = sv_2mortal(newSVpv(...))
1680 void
1681 strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
1682         char *          fmt
1683         int             sec
1684         int             min
1685         int             hour
1686         int             mday
1687         int             mon
1688         int             year
1689         int             wday
1690         int             yday
1691         int             isdst
1692     CODE:
1693         {
1694             char *buf = my_strftime(fmt, sec, min, hour, mday, mon, year, wday, yday, isdst);
1695             if (buf) {
1696                 ST(0) = sv_2mortal(newSVpv(buf, 0));
1697                 Safefree(buf);
1698             }
1699         }
1700
1701 void
1702 tzset()
1703
1704 void
1705 tzname()
1706     PPCODE:
1707         EXTEND(SP,2);
1708         PUSHs(sv_2mortal(newSVpvn(tzname[0],strlen(tzname[0]))));
1709         PUSHs(sv_2mortal(newSVpvn(tzname[1],strlen(tzname[1]))));
1710
1711 SysRet
1712 access(filename, mode)
1713         char *          filename
1714         Mode_t          mode
1715
1716 char *
1717 ctermid(s = 0)
1718         char *          s = 0;
1719
1720 char *
1721 cuserid(s = 0)
1722         char *          s = 0;
1723
1724 SysRetLong
1725 fpathconf(fd, name)
1726         int             fd
1727         int             name
1728
1729 SysRetLong
1730 pathconf(filename, name)
1731         char *          filename
1732         int             name
1733
1734 SysRet
1735 pause()
1736
1737 SysRet
1738 setgid(gid)
1739         Gid_t           gid
1740
1741 SysRet
1742 setuid(uid)
1743         Uid_t           uid
1744
1745 SysRetLong
1746 sysconf(name)
1747         int             name
1748
1749 char *
1750 ttyname(fd)
1751         int             fd
1752
1753 void
1754 getcwd()
1755     PPCODE:
1756       {
1757         dXSTARG;
1758         getcwd_sv(TARG);
1759         XSprePUSH; PUSHTARG;
1760       }
1761