perl 5.002
[perl.git] / pp_sys.c
1 /*    pp_sys.c
2  *
3  *    Copyright (c) 1991-1994, Larry Wall
4  *
5  *    You may distribute under the terms of either the GNU General Public
6  *    License or the Artistic License, as specified in the README file.
7  *
8  */
9
10 /*
11  * But only a short way ahead its floor and the walls on either side were
12  * cloven by a great fissure, out of which the red glare came, now leaping
13  * up, now dying down into darkness; and all the while far below there was
14  * a rumour and a trouble as of great engines throbbing and labouring.
15  */
16
17 #include "EXTERN.h"
18 #include "perl.h"
19
20 /* XXX Omit this -- it causes too much grief on mixed systems.
21    Next time, I should force broken systems to unset i_unistd in
22    hint files.
23 */
24 #if 0
25 # ifdef I_UNISTD
26 #  include <unistd.h>
27 # endif
28 #endif
29
30 /* Put this after #includes because fork and vfork prototypes may
31    conflict.
32 */
33 #ifndef HAS_VFORK
34 #   define vfork fork
35 #endif
36
37 #if defined(HAS_SOCKET) && !defined(VMS) /* VMS handles sockets via vmsish.h */
38 # include <sys/socket.h>
39 # include <netdb.h>
40 # ifndef ENOTSOCK
41 #  ifdef I_NET_ERRNO
42 #   include <net/errno.h>
43 #  endif
44 # endif
45 #endif
46
47 #ifdef HAS_SELECT
48 #ifdef I_SYS_SELECT
49 #ifndef I_SYS_TIME
50 #include <sys/select.h>
51 #endif
52 #endif
53 #endif
54
55 #ifdef HOST_NOT_FOUND
56 extern int h_errno;
57 #endif
58
59 #ifdef HAS_PASSWD
60 # ifdef I_PWD
61 #  include <pwd.h>
62 # else
63     struct passwd *getpwnam _((char *));
64     struct passwd *getpwuid _((Uid_t));
65 # endif
66   struct passwd *getpwent _((void));
67 #endif
68
69 #ifdef HAS_GROUP
70 # ifdef I_GRP
71 #  include <grp.h>
72 # else
73     struct group *getgrnam _((char *));
74     struct group *getgrgid _((Gid_t));
75 # endif
76     struct group *getgrent _((void));
77 #endif
78
79 #ifdef I_UTIME
80 #include <utime.h>
81 #endif
82 #ifdef I_FCNTL
83 #include <fcntl.h>
84 #endif
85 #ifdef I_SYS_FILE
86 #include <sys/file.h>
87 #endif
88
89 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
90 static int dooneliner _((char *cmd, char *filename));
91 #endif
92 /* Pushy I/O. */
93
94 PP(pp_backtick)
95 {
96     dSP; dTARGET;
97     FILE *fp;
98     char *tmps = POPp;
99     TAINT_PROPER("``");
100     fp = my_popen(tmps, "r");
101     if (fp) {
102         sv_setpv(TARG, "");     /* note that this preserves previous buffer */
103         if (GIMME == G_SCALAR) {
104             while (sv_gets(TARG, fp, SvCUR(TARG)) != Nullch)
105                 /*SUPPRESS 530*/
106                 ;
107             XPUSHs(TARG);
108         }
109         else {
110             SV *sv;
111
112             for (;;) {
113                 sv = NEWSV(56, 80);
114                 if (sv_gets(sv, fp, 0) == Nullch) {
115                     SvREFCNT_dec(sv);
116                     break;
117                 }
118                 XPUSHs(sv_2mortal(sv));
119                 if (SvLEN(sv) - SvCUR(sv) > 20) {
120                     SvLEN_set(sv, SvCUR(sv)+1);
121                     Renew(SvPVX(sv), SvLEN(sv), char);
122                 }
123             }
124         }
125         statusvalue = FIXSTATUS(my_pclose(fp));
126     }
127     else {
128         statusvalue = -1;
129         if (GIMME == G_SCALAR)
130             RETPUSHUNDEF;
131     }
132
133     RETURN;
134 }
135
136 PP(pp_glob)
137 {
138     OP *result;
139     ENTER;
140
141     SAVESPTR(last_in_gv);       /* We don't want this to be permanent. */
142     last_in_gv = (GV*)*stack_sp--;
143
144     SAVESPTR(rs);               /* This is not permanent, either. */
145     rs = sv_2mortal(newSVpv("", 1));
146 #ifndef DOSISH
147 #ifndef CSH
148     *SvPVX(rs) = '\n';
149 #endif  /* !CSH */
150 #endif  /* !MSDOS */
151
152     result = do_readline();
153     LEAVE;
154     return result;
155 }
156
157 PP(pp_indread)
158 {
159     last_in_gv = gv_fetchpv(SvPVx(GvSV((GV*)(*stack_sp--)), na), TRUE,SVt_PVIO);
160     return do_readline();
161 }
162
163 PP(pp_rcatline)
164 {
165     last_in_gv = cGVOP->op_gv;
166     return do_readline();
167 }
168
169 PP(pp_warn)
170 {
171     dSP; dMARK;
172     char *tmps;
173     if (SP - MARK != 1) {
174         dTARGET;
175         do_join(TARG, &sv_no, MARK, SP);
176         tmps = SvPV(TARG, na);
177         SP = MARK + 1;
178     }
179     else {
180         tmps = SvPV(TOPs, na);
181     }
182     if (!tmps || !*tmps) {
183         SV *error = GvSV(errgv);
184         (void)SvUPGRADE(error, SVt_PV);
185         if (SvPOK(error) && SvCUR(error))
186             sv_catpv(error, "\t...caught");
187         tmps = SvPV(error, na);
188     }
189     if (!tmps || !*tmps)
190         tmps = "Warning: something's wrong";
191     warn("%s", tmps);
192     RETSETYES;
193 }
194
195 PP(pp_die)
196 {
197     dSP; dMARK;
198     char *tmps;
199     if (SP - MARK != 1) {
200         dTARGET;
201         do_join(TARG, &sv_no, MARK, SP);
202         tmps = SvPV(TARG, na);
203         SP = MARK + 1;
204     }
205     else {
206         tmps = SvPV(TOPs, na);
207     }
208     if (!tmps || !*tmps) {
209         SV *error = GvSV(errgv);
210         (void)SvUPGRADE(error, SVt_PV);
211         if (SvPOK(error) && SvCUR(error))
212             sv_catpv(error, "\t...propagated");
213         tmps = SvPV(error, na);
214     }
215     if (!tmps || !*tmps)
216         tmps = "Died";
217     DIE("%s", tmps);
218 }
219
220 /* I/O. */
221
222 PP(pp_open)
223 {
224     dSP; dTARGET;
225     GV *gv;
226     SV *sv;
227     char *tmps;
228     STRLEN len;
229
230     if (MAXARG > 1)
231         sv = POPs;
232     else if (SvTYPE(TOPs) == SVt_PVGV)
233         sv = GvSV(TOPs);
234     else
235         DIE(no_usym, "filehandle");
236     gv = (GV*)POPs;
237     tmps = SvPV(sv, len);
238     if (do_open(gv, tmps, len, FALSE, 0, 0, Nullfp)) {
239         IoLINES(GvIOp(gv)) = 0;
240         PUSHi( (I32)forkprocess );
241     }
242     else if (forkprocess == 0)          /* we are a new child */
243         PUSHi(0);
244     else
245         RETPUSHUNDEF;
246     RETURN;
247 }
248
249 PP(pp_close)
250 {
251     dSP;
252     GV *gv;
253
254     if (MAXARG == 0)
255         gv = defoutgv;
256     else
257         gv = (GV*)POPs;
258     EXTEND(SP, 1);
259     PUSHs( do_close(gv, TRUE) ? &sv_yes : &sv_no );
260     RETURN;
261 }
262
263 PP(pp_pipe_op)
264 {
265     dSP;
266 #ifdef HAS_PIPE
267     GV *rgv;
268     GV *wgv;
269     register IO *rstio;
270     register IO *wstio;
271     int fd[2];
272
273     wgv = (GV*)POPs;
274     rgv = (GV*)POPs;
275
276     if (!rgv || !wgv)
277         goto badexit;
278
279     if (SvTYPE(rgv) != SVt_PVGV || SvTYPE(wgv) != SVt_PVGV)
280         DIE(no_usym, "filehandle");
281     rstio = GvIOn(rgv);
282     wstio = GvIOn(wgv);
283
284     if (IoIFP(rstio))
285         do_close(rgv, FALSE);
286     if (IoIFP(wstio))
287         do_close(wgv, FALSE);
288
289     if (pipe(fd) < 0)
290         goto badexit;
291
292     IoIFP(rstio) = fdopen(fd[0], "r");
293     IoOFP(wstio) = fdopen(fd[1], "w");
294     IoIFP(wstio) = IoOFP(wstio);
295     IoTYPE(rstio) = '<';
296     IoTYPE(wstio) = '>';
297
298     if (!IoIFP(rstio) || !IoOFP(wstio)) {
299         if (IoIFP(rstio)) fclose(IoIFP(rstio));
300         else close(fd[0]);
301         if (IoOFP(wstio)) fclose(IoOFP(wstio));
302         else close(fd[1]);
303         goto badexit;
304     }
305
306     RETPUSHYES;
307
308 badexit:
309     RETPUSHUNDEF;
310 #else
311     DIE(no_func, "pipe");
312 #endif
313 }
314
315 PP(pp_fileno)
316 {
317     dSP; dTARGET;
318     GV *gv;
319     IO *io;
320     FILE *fp;
321     if (MAXARG < 1)
322         RETPUSHUNDEF;
323     gv = (GV*)POPs;
324     if (!gv || !(io = GvIO(gv)) || !(fp = IoIFP(io)))
325         RETPUSHUNDEF;
326     PUSHi(fileno(fp));
327     RETURN;
328 }
329
330 PP(pp_umask)
331 {
332     dSP; dTARGET;
333     int anum;
334
335 #ifdef HAS_UMASK
336     if (MAXARG < 1) {
337         anum = umask(0);
338         (void)umask(anum);
339     }
340     else
341         anum = umask(POPi);
342     TAINT_PROPER("umask");
343     XPUSHi(anum);
344 #else
345     DIE(no_func, "Unsupported function umask");
346 #endif
347     RETURN;
348 }
349
350 PP(pp_binmode)
351 {
352     dSP;
353     GV *gv;
354     IO *io;
355     FILE *fp;
356
357     if (MAXARG < 1)
358         RETPUSHUNDEF;
359
360     gv = (GV*)POPs;
361
362     EXTEND(SP, 1);
363     if (!(io = GvIO(gv)) || !(fp = IoIFP(io)))
364         RETSETUNDEF;
365
366 #ifdef DOSISH
367 #ifdef atarist
368     if (!Fflush(fp) && (fp->_flag |= _IOBIN))
369         RETPUSHYES;
370     else
371         RETPUSHUNDEF;
372 #else
373     if (setmode(fileno(fp), OP_BINARY) != -1)
374         RETPUSHYES;
375     else
376         RETPUSHUNDEF;
377 #endif
378 #else
379     RETPUSHYES;
380 #endif
381 }
382
383 PP(pp_tie)
384 {
385     dSP;
386     SV *varsv;
387     HV* stash;
388     GV *gv;
389     BINOP myop;
390     SV *sv;
391     SV **mark = stack_base + ++*markstack_ptr;  /* reuse in entersub */
392     I32 markoff = mark - stack_base - 1;
393     char *methname;
394
395     varsv = mark[0];
396     if (SvTYPE(varsv) == SVt_PVHV)
397         methname = "TIEHASH";
398     else if (SvTYPE(varsv) == SVt_PVAV)
399         methname = "TIEARRAY";
400     else if (SvTYPE(varsv) == SVt_PVGV)
401         methname = "TIEHANDLE";
402     else
403         methname = "TIESCALAR";
404
405     stash = gv_stashsv(mark[1], FALSE);
406     if (!stash || !(gv = gv_fetchmethod(stash, methname)) || !GvCV(gv))
407         DIE("Can't locate object method \"%s\" via package \"%s\"",
408                 methname, SvPV(mark[1],na));
409
410     Zero(&myop, 1, BINOP);
411     myop.op_last = (OP *) &myop;
412     myop.op_next = Nullop;
413     myop.op_flags = OPf_KNOW|OPf_STACKED;
414
415     ENTER;
416     SAVESPTR(op);
417     op = (OP *) &myop;
418
419     XPUSHs(gv);
420     PUTBACK;
421
422     if (op = pp_entersub())
423         run();
424     SPAGAIN;
425
426     sv = TOPs;
427     if (sv_isobject(sv)) {
428         if (SvTYPE(varsv) == SVt_PVHV || SvTYPE(varsv) == SVt_PVAV) {
429             sv_unmagic(varsv, 'P');
430             sv_magic(varsv, sv, 'P', Nullch, 0);
431         }
432         else {
433             sv_unmagic(varsv, 'q');
434             sv_magic(varsv, sv, 'q', Nullch, 0);
435         }
436     }
437     LEAVE;
438     SP = stack_base + markoff;
439     PUSHs(sv);
440     RETURN;
441 }
442
443 PP(pp_untie)
444 {
445     dSP;
446     if (SvTYPE(TOPs) == SVt_PVHV || SvTYPE(TOPs) == SVt_PVAV)
447         sv_unmagic(TOPs, 'P');
448     else
449         sv_unmagic(TOPs, 'q');
450     RETSETYES;
451 }
452
453 PP(pp_tied)
454 {
455     dSP;
456     SV * sv ;
457     MAGIC * mg ;
458
459     sv = POPs;
460     if (SvMAGICAL(sv)) {
461         if (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
462             mg = mg_find(sv, 'P') ;
463         else
464             mg = mg_find(sv, 'q') ;
465
466         if (mg)  {
467             PUSHs(sv_2mortal(newSVsv(mg->mg_obj))) ; 
468             RETURN ;
469         }
470     }
471
472     RETPUSHUNDEF;
473 }
474
475 PP(pp_dbmopen)
476 {
477     dSP;
478     HV *hv;
479     dPOPPOPssrl;
480     HV* stash;
481     GV *gv;
482     BINOP myop;
483     SV *sv;
484
485     hv = (HV*)POPs;
486
487     sv = sv_mortalcopy(&sv_no);
488     sv_setpv(sv, "AnyDBM_File");
489     stash = gv_stashsv(sv, FALSE);
490     if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")) || !GvCV(gv)) {
491         PUTBACK;
492         perl_require_pv("AnyDBM_File.pm");
493         SPAGAIN;
494         if (!(gv = gv_fetchmethod(stash, "TIEHASH")) || !GvCV(gv))
495             DIE("No dbm on this machine");
496     }
497
498     Zero(&myop, 1, BINOP);
499     myop.op_last = (OP *) &myop;
500     myop.op_next = Nullop;
501     myop.op_flags = OPf_KNOW|OPf_STACKED;
502
503     ENTER;
504     SAVESPTR(op);
505     op = (OP *) &myop;
506     PUTBACK;
507     pp_pushmark();
508
509     EXTEND(sp, 5);
510     PUSHs(sv);
511     PUSHs(left);
512     if (SvIV(right))
513         PUSHs(sv_2mortal(newSViv(O_RDWR|O_CREAT)));
514     else
515         PUSHs(sv_2mortal(newSViv(O_RDWR)));
516     PUSHs(right);
517     PUSHs(gv);
518     PUTBACK;
519
520     if (op = pp_entersub())
521         run();
522     SPAGAIN;
523
524     if (!sv_isobject(TOPs)) {
525         sp--;
526         op = (OP *) &myop;
527         PUTBACK;
528         pp_pushmark();
529
530         PUSHs(sv);
531         PUSHs(left);
532         PUSHs(sv_2mortal(newSViv(O_RDONLY)));
533         PUSHs(right);
534         PUSHs(gv);
535         PUTBACK;
536
537         if (op = pp_entersub())
538             run();
539         SPAGAIN;
540     }
541
542     if (sv_isobject(TOPs))
543         sv_magic((SV*)hv, TOPs, 'P', Nullch, 0);
544     LEAVE;
545     RETURN;
546 }
547
548 PP(pp_dbmclose)
549 {
550     return pp_untie(ARGS);
551 }
552
553 PP(pp_sselect)
554 {
555     dSP; dTARGET;
556 #ifdef HAS_SELECT
557     register I32 i;
558     register I32 j;
559     register char *s;
560     register SV *sv;
561     double value;
562     I32 maxlen = 0;
563     I32 nfound;
564     struct timeval timebuf;
565     struct timeval *tbuf = &timebuf;
566     I32 growsize;
567     char *fd_sets[4];
568 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
569         I32 masksize;
570         I32 offset;
571         I32 k;
572
573 #   if BYTEORDER & 0xf0000
574 #       define ORDERBYTE (0x88888888 - BYTEORDER)
575 #   else
576 #       define ORDERBYTE (0x4444 - BYTEORDER)
577 #   endif
578
579 #endif
580
581     SP -= 4;
582     for (i = 1; i <= 3; i++) {
583         if (!SvPOK(SP[i]))
584             continue;
585         j = SvCUR(SP[i]);
586         if (maxlen < j)
587             maxlen = j;
588     }
589
590 #if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678
591 #ifdef __linux__
592     growsize = sizeof(fd_set);
593 #else
594     growsize = maxlen;          /* little endians can use vecs directly */
595 #endif
596 #else
597 #ifdef NFDBITS
598
599 #ifndef NBBY
600 #define NBBY 8
601 #endif
602
603     masksize = NFDBITS / NBBY;
604 #else
605     masksize = sizeof(long);    /* documented int, everyone seems to use long */
606 #endif
607     growsize = maxlen + (masksize - (maxlen % masksize));
608     Zero(&fd_sets[0], 4, char*);
609 #endif
610
611     sv = SP[4];
612     if (SvOK(sv)) {
613         value = SvNV(sv);
614         if (value < 0.0)
615             value = 0.0;
616         timebuf.tv_sec = (long)value;
617         value -= (double)timebuf.tv_sec;
618         timebuf.tv_usec = (long)(value * 1000000.0);
619     }
620     else
621         tbuf = Null(struct timeval*);
622
623     for (i = 1; i <= 3; i++) {
624         sv = SP[i];
625         if (!SvOK(sv)) {
626             fd_sets[i] = 0;
627             continue;
628         }
629         else if (!SvPOK(sv))
630             SvPV_force(sv,na);  /* force string conversion */
631         j = SvLEN(sv);
632         if (j < growsize) {
633             Sv_Grow(sv, growsize);
634         }
635         j = SvCUR(sv);
636         s = SvPVX(sv) + j;
637         while (++j <= growsize) {
638             *s++ = '\0';
639         }
640
641 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
642         s = SvPVX(sv);
643         New(403, fd_sets[i], growsize, char);
644         for (offset = 0; offset < growsize; offset += masksize) {
645             for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
646                 fd_sets[i][j+offset] = s[(k % masksize) + offset];
647         }
648 #else
649         fd_sets[i] = SvPVX(sv);
650 #endif
651     }
652
653     nfound = select(
654         maxlen * 8,
655         (Select_fd_set_t) fd_sets[1],
656         (Select_fd_set_t) fd_sets[2],
657         (Select_fd_set_t) fd_sets[3],
658         tbuf);
659     for (i = 1; i <= 3; i++) {
660         if (fd_sets[i]) {
661             sv = SP[i];
662 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
663             s = SvPVX(sv);
664             for (offset = 0; offset < growsize; offset += masksize) {
665                 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
666                     s[(k % masksize) + offset] = fd_sets[i][j+offset];
667             }
668             Safefree(fd_sets[i]);
669 #endif
670             SvSETMAGIC(sv);
671         }
672     }
673
674     PUSHi(nfound);
675     if (GIMME == G_ARRAY && tbuf) {
676         value = (double)(timebuf.tv_sec) +
677                 (double)(timebuf.tv_usec) / 1000000.0;
678         PUSHs(sv = sv_mortalcopy(&sv_no));
679         sv_setnv(sv, value);
680     }
681     RETURN;
682 #else
683     DIE("select not implemented");
684 #endif
685 }
686
687 void
688 setdefout(gv)
689 GV *gv;
690 {
691     if (gv)
692         (void)SvREFCNT_inc(gv);
693     if (defoutgv)
694         SvREFCNT_dec(defoutgv);
695     defoutgv = gv;
696 }
697
698 PP(pp_select)
699 {
700     dSP; dTARGET;
701     GV *newdefout, *egv;
702     HV *hv;
703
704     newdefout = (op->op_private > 0) ? ((GV *) POPs) : NULL;
705
706     egv = GvEGV(defoutgv);
707     if (!egv)
708         egv = defoutgv;
709     hv = GvSTASH(egv);
710     if (! hv)
711         XPUSHs(&sv_undef);
712     else {
713         GV **gvp = hv_fetch(hv, GvNAME(egv), GvNAMELEN(egv), FALSE);
714         if (gvp && *gvp == egv)
715             gv_efullname(TARG, defoutgv);
716         else
717             sv_setsv(TARG, sv_2mortal(newRV(egv)));
718         XPUSHTARG;
719     }
720
721     if (newdefout) {
722         if (!GvIO(newdefout))
723             gv_IOadd(newdefout);
724         setdefout(newdefout);
725     }
726
727     RETURN;
728 }
729
730 PP(pp_getc)
731 {
732     dSP; dTARGET;
733     GV *gv;
734
735     if (MAXARG <= 0)
736         gv = stdingv;
737     else
738         gv = (GV*)POPs;
739     if (!gv)
740         gv = argvgv;
741     if (!gv || do_eof(gv)) /* make sure we have fp with something */
742         RETPUSHUNDEF;
743     TAINT_IF(1);
744     sv_setpv(TARG, " ");
745     *SvPVX(TARG) = getc(IoIFP(GvIOp(gv))); /* should never be EOF */
746     PUSHTARG;
747     RETURN;
748 }
749
750 PP(pp_read)
751 {
752     return pp_sysread(ARGS);
753 }
754
755 static OP *
756 doform(cv,gv,retop)
757 CV *cv;
758 GV *gv;
759 OP *retop;
760 {
761     register CONTEXT *cx;
762     I32 gimme = GIMME;
763     AV* padlist = CvPADLIST(cv);
764     SV** svp = AvARRAY(padlist);
765
766     ENTER;
767     SAVETMPS;
768
769     push_return(retop);
770     PUSHBLOCK(cx, CXt_SUB, stack_sp);
771     PUSHFORMAT(cx);
772     SAVESPTR(curpad);
773     curpad = AvARRAY((AV*)svp[1]);
774
775     setdefout(gv);          /* locally select filehandle so $% et al work */
776     return CvSTART(cv);
777 }
778
779 PP(pp_enterwrite)
780 {
781     dSP;
782     register GV *gv;
783     register IO *io;
784     GV *fgv;
785     CV *cv;
786
787     if (MAXARG == 0)
788         gv = defoutgv;
789     else {
790         gv = (GV*)POPs;
791         if (!gv)
792             gv = defoutgv;
793     }
794     EXTEND(SP, 1);
795     io = GvIO(gv);
796     if (!io) {
797         RETPUSHNO;
798     }
799     if (IoFMT_GV(io))
800         fgv = IoFMT_GV(io);
801     else
802         fgv = gv;
803
804     cv = GvFORM(fgv);
805
806     if (!cv) {
807         if (fgv) {
808             SV *tmpsv = sv_newmortal();
809             gv_efullname(tmpsv, gv);
810             DIE("Undefined format \"%s\" called",SvPVX(tmpsv));
811         }
812         DIE("Not a format reference");
813     }
814     IoFLAGS(io) &= ~IOf_DIDTOP;
815
816     return doform(cv,gv,op->op_next);
817 }
818
819 PP(pp_leavewrite)
820 {
821     dSP;
822     GV *gv = cxstack[cxstack_ix].blk_sub.gv;
823     register IO *io = GvIOp(gv);
824     FILE *ofp = IoOFP(io);
825     FILE *fp;
826     SV **newsp;
827     I32 gimme;
828     register CONTEXT *cx;
829
830     DEBUG_f(fprintf(stderr,"left=%ld, todo=%ld\n",
831           (long)IoLINES_LEFT(io), (long)FmLINES(formtarget)));
832     if (IoLINES_LEFT(io) < FmLINES(formtarget) &&
833         formtarget != toptarget)
834     {
835         GV *fgv;
836         CV *cv;
837         if (!IoTOP_GV(io)) {
838             GV *topgv;
839             char tmpbuf[256];
840
841             if (!IoTOP_NAME(io)) {
842                 if (!IoFMT_NAME(io))
843                     IoFMT_NAME(io) = savepv(GvNAME(gv));
844                 sprintf(tmpbuf, "%s_TOP", IoFMT_NAME(io));
845                 topgv = gv_fetchpv(tmpbuf,FALSE, SVt_PVFM);
846                 if ((topgv && GvFORM(topgv)) ||
847                   !gv_fetchpv("top",FALSE,SVt_PVFM))
848                     IoTOP_NAME(io) = savepv(tmpbuf);
849                 else
850                     IoTOP_NAME(io) = savepv("top");
851             }
852             topgv = gv_fetchpv(IoTOP_NAME(io),FALSE, SVt_PVFM);
853             if (!topgv || !GvFORM(topgv)) {
854                 IoLINES_LEFT(io) = 100000000;
855                 goto forget_top;
856             }
857             IoTOP_GV(io) = topgv;
858         }
859         if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear.  It still doesn't fit. */
860             I32 lines = IoLINES_LEFT(io);
861             char *s = SvPVX(formtarget);
862             if (lines <= 0)             /* Yow, header didn't even fit!!! */
863                 goto forget_top;
864             while (lines-- > 0) {
865                 s = strchr(s, '\n');
866                 if (!s)
867                     break;
868                 s++;
869             }
870             if (s) {
871                 fwrite1(SvPVX(formtarget), s - SvPVX(formtarget), 1, ofp);
872                 sv_chop(formtarget, s);
873                 FmLINES(formtarget) -= IoLINES_LEFT(io);
874             }
875         }
876         if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
877             fwrite1(SvPVX(formfeed), SvCUR(formfeed), 1, ofp);
878         IoLINES_LEFT(io) = IoPAGE_LEN(io);
879         IoPAGE(io)++;
880         formtarget = toptarget;
881         IoFLAGS(io) |= IOf_DIDTOP;
882         fgv = IoTOP_GV(io);
883         if (!fgv)
884             DIE("bad top format reference");
885         cv = GvFORM(fgv);
886         if (!cv) {
887             SV *tmpsv = sv_newmortal();
888             gv_efullname(tmpsv, fgv);
889             DIE("Undefined top format \"%s\" called",SvPVX(tmpsv));
890         }
891         return doform(cv,gv,op);
892     }
893
894   forget_top:
895     POPBLOCK(cx,curpm);
896     POPFORMAT(cx);
897     LEAVE;
898
899     fp = IoOFP(io);
900     if (!fp) {
901         if (dowarn) {
902             if (IoIFP(io))
903                 warn("Filehandle only opened for input");
904             else
905                 warn("Write on closed filehandle");
906         }
907         PUSHs(&sv_no);
908     }
909     else {
910         if ((IoLINES_LEFT(io) -= FmLINES(formtarget)) < 0) {
911             if (dowarn)
912                 warn("page overflow");
913         }
914         if (!fwrite1(SvPVX(formtarget), 1, SvCUR(formtarget), ofp) ||
915                 ferror(fp))
916             PUSHs(&sv_no);
917         else {
918             FmLINES(formtarget) = 0;
919             SvCUR_set(formtarget, 0);
920             *SvEND(formtarget) = '\0';
921             if (IoFLAGS(io) & IOf_FLUSH)
922                 (void)Fflush(fp);
923             PUSHs(&sv_yes);
924         }
925     }
926     formtarget = bodytarget;
927     PUTBACK;
928     return pop_return();
929 }
930
931 PP(pp_prtf)
932 {
933     dSP; dMARK; dORIGMARK;
934     GV *gv;
935     IO *io;
936     FILE *fp;
937     SV *sv = NEWSV(0,0);
938
939     if (op->op_flags & OPf_STACKED)
940         gv = (GV*)*++MARK;
941     else
942         gv = defoutgv;
943     if (!(io = GvIO(gv))) {
944         if (dowarn) {
945             gv_fullname(sv,gv);
946             warn("Filehandle %s never opened", SvPV(sv,na));
947         }
948         SETERRNO(EBADF,RMS$_IFI);
949         goto just_say_no;
950     }
951     else if (!(fp = IoOFP(io))) {
952         if (dowarn)  {
953             gv_fullname(sv,gv);
954             if (IoIFP(io))
955                 warn("Filehandle %s opened only for input", SvPV(sv,na));
956             else
957                 warn("printf on closed filehandle %s", SvPV(sv,na));
958         }
959         SETERRNO(EBADF,IoIFP(io)?RMS$_FAC:RMS$_IFI);
960         goto just_say_no;
961     }
962     else {
963         do_sprintf(sv, SP - MARK, MARK + 1);
964         if (!do_print(sv, fp))
965             goto just_say_no;
966
967         if (IoFLAGS(io) & IOf_FLUSH)
968             if (Fflush(fp) == EOF)
969                 goto just_say_no;
970     }
971     SvREFCNT_dec(sv);
972     SP = ORIGMARK;
973     PUSHs(&sv_yes);
974     RETURN;
975
976   just_say_no:
977     SvREFCNT_dec(sv);
978     SP = ORIGMARK;
979     PUSHs(&sv_undef);
980     RETURN;
981 }
982
983 PP(pp_sysopen)
984 {
985     dSP;
986     GV *gv;
987     SV *sv;
988     char *tmps;
989     STRLEN len;
990     int mode, perm;
991
992     if (MAXARG > 3)
993         perm = POPi;
994     else
995         perm = 0666;
996     mode = POPi;
997     sv = POPs;
998     gv = (GV *)POPs;
999
1000     tmps = SvPV(sv, len);
1001     if (do_open(gv, tmps, len, TRUE, mode, perm, Nullfp)) {
1002         IoLINES(GvIOp(gv)) = 0;
1003         PUSHs(&sv_yes);
1004     }
1005     else {
1006         PUSHs(&sv_undef);
1007     }
1008     RETURN;
1009 }
1010
1011 PP(pp_sysread)
1012 {
1013     dSP; dMARK; dORIGMARK; dTARGET;
1014     int offset;
1015     GV *gv;
1016     IO *io;
1017     char *buffer;
1018     int length;
1019     int bufsize;
1020     SV *bufsv;
1021     STRLEN blen;
1022
1023     gv = (GV*)*++MARK;
1024     if (!gv)
1025         goto say_undef;
1026     bufsv = *++MARK;
1027     buffer = SvPV_force(bufsv, blen);
1028     length = SvIVx(*++MARK);
1029     if (length < 0)
1030         DIE("Negative length");
1031     SETERRNO(0,0);
1032     if (MARK < SP)
1033         offset = SvIVx(*++MARK);
1034     else
1035         offset = 0;
1036     io = GvIO(gv);
1037     if (!io || !IoIFP(io))
1038         goto say_undef;
1039 #ifdef HAS_SOCKET
1040     if (op->op_type == OP_RECV) {
1041         bufsize = sizeof buf;
1042         buffer = SvGROW(bufsv, length+1);
1043         length = recvfrom(fileno(IoIFP(io)), buffer, length, offset,
1044             (struct sockaddr *)buf, &bufsize);
1045         if (length < 0)
1046             RETPUSHUNDEF;
1047         SvCUR_set(bufsv, length);
1048         *SvEND(bufsv) = '\0';
1049         (void)SvPOK_only(bufsv);
1050         SvSETMAGIC(bufsv);
1051         if (tainting)
1052             sv_magic(bufsv, Nullsv, 't', Nullch, 0);
1053         SP = ORIGMARK;
1054         sv_setpvn(TARG, buf, bufsize);
1055         PUSHs(TARG);
1056         RETURN;
1057     }
1058 #else
1059     if (op->op_type == OP_RECV)
1060         DIE(no_sock_func, "recv");
1061 #endif
1062     buffer = SvGROW(bufsv, length+offset+1);
1063     if (op->op_type == OP_SYSREAD) {
1064         length = read(fileno(IoIFP(io)), buffer+offset, length);
1065     }
1066     else
1067 #ifdef HAS_SOCKET__bad_code_maybe
1068     if (IoTYPE(io) == 's') {
1069         bufsize = sizeof buf;
1070         length = recvfrom(fileno(IoIFP(io)), buffer+offset, length, 0,
1071             (struct sockaddr *)buf, &bufsize);
1072     }
1073     else
1074 #endif
1075         length = fread(buffer+offset, 1, length, IoIFP(io));
1076     if (length < 0)
1077         goto say_undef;
1078     SvCUR_set(bufsv, length+offset);
1079     *SvEND(bufsv) = '\0';
1080     (void)SvPOK_only(bufsv);
1081     SvSETMAGIC(bufsv);
1082     if (tainting)
1083         sv_magic(bufsv, Nullsv, 't', Nullch, 0);
1084     SP = ORIGMARK;
1085     PUSHi(length);
1086     RETURN;
1087
1088   say_undef:
1089     SP = ORIGMARK;
1090     RETPUSHUNDEF;
1091 }
1092
1093 PP(pp_syswrite)
1094 {
1095     return pp_send(ARGS);
1096 }
1097
1098 PP(pp_send)
1099 {
1100     dSP; dMARK; dORIGMARK; dTARGET;
1101     GV *gv;
1102     IO *io;
1103     int offset;
1104     SV *bufsv;
1105     char *buffer;
1106     int length;
1107     STRLEN blen;
1108
1109     gv = (GV*)*++MARK;
1110     if (!gv)
1111         goto say_undef;
1112     bufsv = *++MARK;
1113     buffer = SvPV(bufsv, blen);
1114     length = SvIVx(*++MARK);
1115     if (length < 0)
1116         DIE("Negative length");
1117     SETERRNO(0,0);
1118     io = GvIO(gv);
1119     if (!io || !IoIFP(io)) {
1120         length = -1;
1121         if (dowarn) {
1122             if (op->op_type == OP_SYSWRITE)
1123                 warn("Syswrite on closed filehandle");
1124             else
1125                 warn("Send on closed socket");
1126         }
1127     }
1128     else if (op->op_type == OP_SYSWRITE) {
1129         if (MARK < SP)
1130             offset = SvIVx(*++MARK);
1131         else
1132             offset = 0;
1133         if (length > blen - offset)
1134             length = blen - offset;
1135         length = write(fileno(IoIFP(io)), buffer+offset, length);
1136     }
1137 #ifdef HAS_SOCKET
1138     else if (SP > MARK) {
1139         char *sockbuf;
1140         STRLEN mlen;
1141         sockbuf = SvPVx(*++MARK, mlen);
1142         length = sendto(fileno(IoIFP(io)), buffer, blen, length,
1143                                 (struct sockaddr *)sockbuf, mlen);
1144     }
1145     else
1146         length = send(fileno(IoIFP(io)), buffer, blen, length);
1147 #else
1148     else
1149         DIE(no_sock_func, "send");
1150 #endif
1151     if (length < 0)
1152         goto say_undef;
1153     SP = ORIGMARK;
1154     PUSHi(length);
1155     RETURN;
1156
1157   say_undef:
1158     SP = ORIGMARK;
1159     RETPUSHUNDEF;
1160 }
1161
1162 PP(pp_recv)
1163 {
1164     return pp_sysread(ARGS);
1165 }
1166
1167 PP(pp_eof)
1168 {
1169     dSP;
1170     GV *gv;
1171
1172     if (MAXARG <= 0)
1173         gv = last_in_gv;
1174     else
1175         gv = last_in_gv = (GV*)POPs;
1176     PUSHs(!gv || do_eof(gv) ? &sv_yes : &sv_no);
1177     RETURN;
1178 }
1179
1180 PP(pp_tell)
1181 {
1182     dSP; dTARGET;
1183     GV *gv;
1184
1185     if (MAXARG <= 0)
1186         gv = last_in_gv;
1187     else
1188         gv = last_in_gv = (GV*)POPs;
1189     PUSHi( do_tell(gv) );
1190     RETURN;
1191 }
1192
1193 PP(pp_seek)
1194 {
1195     dSP;
1196     GV *gv;
1197     int whence = POPi;
1198     long offset = POPl;
1199
1200     gv = last_in_gv = (GV*)POPs;
1201     PUSHs( do_seek(gv, offset, whence) ? &sv_yes : &sv_no );
1202     RETURN;
1203 }
1204
1205 PP(pp_truncate)
1206 {
1207     dSP;
1208     Off_t len = (Off_t)POPn;
1209     int result = 1;
1210     GV *tmpgv;
1211
1212     SETERRNO(0,0);
1213 #if defined(HAS_TRUNCATE) || defined(HAS_CHSIZE) || defined(F_FREESP)
1214 #ifdef HAS_TRUNCATE
1215     if (op->op_flags & OPf_SPECIAL) {
1216         tmpgv = gv_fetchpv(POPp,FALSE, SVt_PVIO);
1217         if (!GvIO(tmpgv) || !IoIFP(GvIOp(tmpgv)) ||
1218           ftruncate(fileno(IoIFP(GvIOn(tmpgv))), len) < 0)
1219             result = 0;
1220     }
1221     else if (truncate(POPp, len) < 0)
1222         result = 0;
1223 #else
1224     if (op->op_flags & OPf_SPECIAL) {
1225         tmpgv = gv_fetchpv(POPp,FALSE, SVt_PVIO);
1226         if (!GvIO(tmpgv) || !IoIFP(GvIOp(tmpgv)) ||
1227           chsize(fileno(IoIFP(GvIOn(tmpgv))), len) < 0)
1228             result = 0;
1229     }
1230     else {
1231         int tmpfd;
1232
1233         if ((tmpfd = open(POPp, 0)) < 0)
1234             result = 0;
1235         else {
1236             if (chsize(tmpfd, len) < 0)
1237                 result = 0;
1238             close(tmpfd);
1239         }
1240     }
1241 #endif
1242
1243     if (result)
1244         RETPUSHYES;
1245     if (!errno)
1246         SETERRNO(EBADF,RMS$_IFI);
1247     RETPUSHUNDEF;
1248 #else
1249     DIE("truncate not implemented");
1250 #endif
1251 }
1252
1253 PP(pp_fcntl)
1254 {
1255     return pp_ioctl(ARGS);
1256 }
1257
1258 PP(pp_ioctl)
1259 {
1260     dSP; dTARGET;
1261     SV *argsv = POPs;
1262     unsigned int func = U_I(POPn);
1263     int optype = op->op_type;
1264     char *s;
1265     int retval;
1266     GV *gv = (GV*)POPs;
1267     IO *io = GvIOn(gv);
1268
1269     if (!io || !argsv || !IoIFP(io)) {
1270         SETERRNO(EBADF,RMS$_IFI);       /* well, sort of... */
1271         RETPUSHUNDEF;
1272     }
1273
1274     if (SvPOK(argsv) || !SvNIOK(argsv)) {
1275         STRLEN len;
1276         s = SvPV_force(argsv, len);
1277         retval = IOCPARM_LEN(func);
1278         if (len < retval) {
1279             s = Sv_Grow(argsv, retval+1);
1280             SvCUR_set(argsv, retval);
1281         }
1282
1283         s[SvCUR(argsv)] = 17;   /* a little sanity check here */
1284     }
1285     else {
1286         retval = SvIV(argsv);
1287 #ifdef DOSISH
1288         s = (char*)(long)retval;        /* ouch */
1289 #else
1290         s = (char*)retval;              /* ouch */
1291 #endif
1292     }
1293
1294     TAINT_PROPER(optype == OP_IOCTL ? "ioctl" : "fcntl");
1295
1296     if (optype == OP_IOCTL)
1297 #ifdef HAS_IOCTL
1298         retval = ioctl(fileno(IoIFP(io)), func, s);
1299 #else
1300         DIE("ioctl is not implemented");
1301 #endif
1302     else
1303 #if defined(DOSISH) && !defined(OS2)
1304         DIE("fcntl is not implemented");
1305 #else
1306 #   ifdef HAS_FCNTL
1307 #     if defined(OS2) && defined(__EMX__)
1308         retval = fcntl(fileno(IoIFP(io)), func, (int)s);
1309 #     else
1310         retval = fcntl(fileno(IoIFP(io)), func, s);
1311 #     endif 
1312 #   else
1313         DIE("fcntl is not implemented");
1314 #   endif
1315 #endif
1316
1317     if (SvPOK(argsv)) {
1318         if (s[SvCUR(argsv)] != 17)
1319             DIE("Possible memory corruption: %s overflowed 3rd argument",
1320                 op_name[optype]);
1321         s[SvCUR(argsv)] = 0;            /* put our null back */
1322         SvSETMAGIC(argsv);              /* Assume it has changed */
1323     }
1324
1325     if (retval == -1)
1326         RETPUSHUNDEF;
1327     if (retval != 0) {
1328         PUSHi(retval);
1329     }
1330     else {
1331         PUSHp("0 but true", 10);
1332     }
1333     RETURN;
1334 }
1335
1336 PP(pp_flock)
1337 {
1338     dSP; dTARGET;
1339     I32 value;
1340     int argtype;
1341     GV *gv;
1342     FILE *fp;
1343
1344 #if !defined(HAS_FLOCK) && defined(HAS_LOCKF)
1345 #  define flock lockf_emulate_flock
1346 #endif
1347
1348 #if defined(HAS_FLOCK) || defined(flock)
1349     argtype = POPi;
1350     if (MAXARG <= 0)
1351         gv = last_in_gv;
1352     else
1353         gv = (GV*)POPs;
1354     if (gv && GvIO(gv))
1355         fp = IoIFP(GvIOp(gv));
1356     else
1357         fp = Nullfp;
1358     if (fp) {
1359         value = (I32)(flock(fileno(fp), argtype) >= 0);
1360     }
1361     else
1362         value = 0;
1363     PUSHi(value);
1364     RETURN;
1365 #else
1366     DIE(no_func, "flock()");
1367 #endif
1368 }
1369
1370 /* Sockets. */
1371
1372 PP(pp_socket)
1373 {
1374     dSP;
1375 #ifdef HAS_SOCKET
1376     GV *gv;
1377     register IO *io;
1378     int protocol = POPi;
1379     int type = POPi;
1380     int domain = POPi;
1381     int fd;
1382
1383     gv = (GV*)POPs;
1384
1385     if (!gv) {
1386         SETERRNO(EBADF,LIB$_INVARG);
1387         RETPUSHUNDEF;
1388     }
1389
1390     io = GvIOn(gv);
1391     if (IoIFP(io))
1392         do_close(gv, FALSE);
1393
1394     TAINT_PROPER("socket");
1395     fd = socket(domain, type, protocol);
1396     if (fd < 0)
1397         RETPUSHUNDEF;
1398     IoIFP(io) = fdopen(fd, "r");        /* stdio gets confused about sockets */
1399     IoOFP(io) = fdopen(fd, "w");
1400     IoTYPE(io) = 's';
1401     if (!IoIFP(io) || !IoOFP(io)) {
1402         if (IoIFP(io)) fclose(IoIFP(io));
1403         if (IoOFP(io)) fclose(IoOFP(io));
1404         if (!IoIFP(io) && !IoOFP(io)) close(fd);
1405         RETPUSHUNDEF;
1406     }
1407
1408     RETPUSHYES;
1409 #else
1410     DIE(no_sock_func, "socket");
1411 #endif
1412 }
1413
1414 PP(pp_sockpair)
1415 {
1416     dSP;
1417 #ifdef HAS_SOCKETPAIR
1418     GV *gv1;
1419     GV *gv2;
1420     register IO *io1;
1421     register IO *io2;
1422     int protocol = POPi;
1423     int type = POPi;
1424     int domain = POPi;
1425     int fd[2];
1426
1427     gv2 = (GV*)POPs;
1428     gv1 = (GV*)POPs;
1429     if (!gv1 || !gv2)
1430         RETPUSHUNDEF;
1431
1432     io1 = GvIOn(gv1);
1433     io2 = GvIOn(gv2);
1434     if (IoIFP(io1))
1435         do_close(gv1, FALSE);
1436     if (IoIFP(io2))
1437         do_close(gv2, FALSE);
1438
1439     TAINT_PROPER("socketpair");
1440     if (socketpair(domain, type, protocol, fd) < 0)
1441         RETPUSHUNDEF;
1442     IoIFP(io1) = fdopen(fd[0], "r");
1443     IoOFP(io1) = fdopen(fd[0], "w");
1444     IoTYPE(io1) = 's';
1445     IoIFP(io2) = fdopen(fd[1], "r");
1446     IoOFP(io2) = fdopen(fd[1], "w");
1447     IoTYPE(io2) = 's';
1448     if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
1449         if (IoIFP(io1)) fclose(IoIFP(io1));
1450         if (IoOFP(io1)) fclose(IoOFP(io1));
1451         if (!IoIFP(io1) && !IoOFP(io1)) close(fd[0]);
1452         if (IoIFP(io2)) fclose(IoIFP(io2));
1453         if (IoOFP(io2)) fclose(IoOFP(io2));
1454         if (!IoIFP(io2) && !IoOFP(io2)) close(fd[1]);
1455         RETPUSHUNDEF;
1456     }
1457
1458     RETPUSHYES;
1459 #else
1460     DIE(no_sock_func, "socketpair");
1461 #endif
1462 }
1463
1464 PP(pp_bind)
1465 {
1466     dSP;
1467 #ifdef HAS_SOCKET
1468     SV *addrsv = POPs;
1469     char *addr;
1470     GV *gv = (GV*)POPs;
1471     register IO *io = GvIOn(gv);
1472     STRLEN len;
1473
1474     if (!io || !IoIFP(io))
1475         goto nuts;
1476
1477     addr = SvPV(addrsv, len);
1478     TAINT_PROPER("bind");
1479     if (bind(fileno(IoIFP(io)), (struct sockaddr *)addr, len) >= 0)
1480         RETPUSHYES;
1481     else
1482         RETPUSHUNDEF;
1483
1484 nuts:
1485     if (dowarn)
1486         warn("bind() on closed fd");
1487     SETERRNO(EBADF,SS$_IVCHAN);
1488     RETPUSHUNDEF;
1489 #else
1490     DIE(no_sock_func, "bind");
1491 #endif
1492 }
1493
1494 PP(pp_connect)
1495 {
1496     dSP;
1497 #ifdef HAS_SOCKET
1498     SV *addrsv = POPs;
1499     char *addr;
1500     GV *gv = (GV*)POPs;
1501     register IO *io = GvIOn(gv);
1502     STRLEN len;
1503
1504     if (!io || !IoIFP(io))
1505         goto nuts;
1506
1507     addr = SvPV(addrsv, len);
1508     TAINT_PROPER("connect");
1509     if (connect(fileno(IoIFP(io)), (struct sockaddr *)addr, len) >= 0)
1510         RETPUSHYES;
1511     else
1512         RETPUSHUNDEF;
1513
1514 nuts:
1515     if (dowarn)
1516         warn("connect() on closed fd");
1517     SETERRNO(EBADF,SS$_IVCHAN);
1518     RETPUSHUNDEF;
1519 #else
1520     DIE(no_sock_func, "connect");
1521 #endif
1522 }
1523
1524 PP(pp_listen)
1525 {
1526     dSP;
1527 #ifdef HAS_SOCKET
1528     int backlog = POPi;
1529     GV *gv = (GV*)POPs;
1530     register IO *io = GvIOn(gv);
1531
1532     if (!io || !IoIFP(io))
1533         goto nuts;
1534
1535     if (listen(fileno(IoIFP(io)), backlog) >= 0)
1536         RETPUSHYES;
1537     else
1538         RETPUSHUNDEF;
1539
1540 nuts:
1541     if (dowarn)
1542         warn("listen() on closed fd");
1543     SETERRNO(EBADF,SS$_IVCHAN);
1544     RETPUSHUNDEF;
1545 #else
1546     DIE(no_sock_func, "listen");
1547 #endif
1548 }
1549
1550 PP(pp_accept)
1551 {
1552     dSP; dTARGET;
1553 #ifdef HAS_SOCKET
1554     GV *ngv;
1555     GV *ggv;
1556     register IO *nstio;
1557     register IO *gstio;
1558     struct sockaddr saddr;      /* use a struct to avoid alignment problems */
1559     int len = sizeof saddr;
1560     int fd;
1561
1562     ggv = (GV*)POPs;
1563     ngv = (GV*)POPs;
1564
1565     if (!ngv)
1566         goto badexit;
1567     if (!ggv)
1568         goto nuts;
1569
1570     gstio = GvIO(ggv);
1571     if (!gstio || !IoIFP(gstio))
1572         goto nuts;
1573
1574     nstio = GvIOn(ngv);
1575     if (IoIFP(nstio))
1576         do_close(ngv, FALSE);
1577
1578     fd = accept(fileno(IoIFP(gstio)), (struct sockaddr *)&saddr, &len);
1579     if (fd < 0)
1580         goto badexit;
1581     IoIFP(nstio) = fdopen(fd, "r");
1582     IoOFP(nstio) = fdopen(fd, "w");
1583     IoTYPE(nstio) = 's';
1584     if (!IoIFP(nstio) || !IoOFP(nstio)) {
1585         if (IoIFP(nstio)) fclose(IoIFP(nstio));
1586         if (IoOFP(nstio)) fclose(IoOFP(nstio));
1587         if (!IoIFP(nstio) && !IoOFP(nstio)) close(fd);
1588         goto badexit;
1589     }
1590
1591     PUSHp((char *)&saddr, len);
1592     RETURN;
1593
1594 nuts:
1595     if (dowarn)
1596         warn("accept() on closed fd");
1597     SETERRNO(EBADF,SS$_IVCHAN);
1598
1599 badexit:
1600     RETPUSHUNDEF;
1601
1602 #else
1603     DIE(no_sock_func, "accept");
1604 #endif
1605 }
1606
1607 PP(pp_shutdown)
1608 {
1609     dSP; dTARGET;
1610 #ifdef HAS_SOCKET
1611     int how = POPi;
1612     GV *gv = (GV*)POPs;
1613     register IO *io = GvIOn(gv);
1614
1615     if (!io || !IoIFP(io))
1616         goto nuts;
1617
1618     PUSHi( shutdown(fileno(IoIFP(io)), how) >= 0 );
1619     RETURN;
1620
1621 nuts:
1622     if (dowarn)
1623         warn("shutdown() on closed fd");
1624     SETERRNO(EBADF,SS$_IVCHAN);
1625     RETPUSHUNDEF;
1626 #else
1627     DIE(no_sock_func, "shutdown");
1628 #endif
1629 }
1630
1631 PP(pp_gsockopt)
1632 {
1633 #ifdef HAS_SOCKET
1634     return pp_ssockopt(ARGS);
1635 #else
1636     DIE(no_sock_func, "getsockopt");
1637 #endif
1638 }
1639
1640 PP(pp_ssockopt)
1641 {
1642     dSP;
1643 #ifdef HAS_SOCKET
1644     int optype = op->op_type;
1645     SV *sv;
1646     int fd;
1647     unsigned int optname;
1648     unsigned int lvl;
1649     GV *gv;
1650     register IO *io;
1651     int aint;
1652
1653     if (optype == OP_GSOCKOPT)
1654         sv = sv_2mortal(NEWSV(22, 257));
1655     else
1656         sv = POPs;
1657     optname = (unsigned int) POPi;
1658     lvl = (unsigned int) POPi;
1659
1660     gv = (GV*)POPs;
1661     io = GvIOn(gv);
1662     if (!io || !IoIFP(io))
1663         goto nuts;
1664
1665     fd = fileno(IoIFP(io));
1666     switch (optype) {
1667     case OP_GSOCKOPT:
1668         SvGROW(sv, 257);
1669         (void)SvPOK_only(sv);
1670         SvCUR_set(sv,256);
1671         *SvEND(sv) ='\0';
1672         aint = SvCUR(sv);
1673         if (getsockopt(fd, lvl, optname, SvPVX(sv), &aint) < 0)
1674             goto nuts2;
1675         SvCUR_set(sv,aint);
1676         *SvEND(sv) ='\0';
1677         PUSHs(sv);
1678         break;
1679     case OP_SSOCKOPT: {
1680             STRLEN len = 0;
1681             char *buf = 0;
1682             if (SvPOKp(sv))
1683                 buf = SvPV(sv, len);
1684             else if (SvOK(sv)) {
1685                 aint = (int)SvIV(sv);
1686                 buf = (char*)&aint;
1687                 len = sizeof(int);
1688             }
1689             if (setsockopt(fd, lvl, optname, buf, (int)len) < 0)
1690                 goto nuts2;
1691             PUSHs(&sv_yes);
1692         }
1693         break;
1694     }
1695     RETURN;
1696
1697 nuts:
1698     if (dowarn)
1699         warn("[gs]etsockopt() on closed fd");
1700     SETERRNO(EBADF,SS$_IVCHAN);
1701 nuts2:
1702     RETPUSHUNDEF;
1703
1704 #else
1705     DIE(no_sock_func, "setsockopt");
1706 #endif
1707 }
1708
1709 PP(pp_getsockname)
1710 {
1711 #ifdef HAS_SOCKET
1712     return pp_getpeername(ARGS);
1713 #else
1714     DIE(no_sock_func, "getsockname");
1715 #endif
1716 }
1717
1718 PP(pp_getpeername)
1719 {
1720     dSP;
1721 #ifdef HAS_SOCKET
1722     int optype = op->op_type;
1723     SV *sv;
1724     int fd;
1725     GV *gv = (GV*)POPs;
1726     register IO *io = GvIOn(gv);
1727     int aint;
1728
1729     if (!io || !IoIFP(io))
1730         goto nuts;
1731
1732     sv = sv_2mortal(NEWSV(22, 257));
1733     (void)SvPOK_only(sv);
1734     SvCUR_set(sv,256);
1735     *SvEND(sv) ='\0';
1736     aint = SvCUR(sv);
1737     fd = fileno(IoIFP(io));
1738     switch (optype) {
1739     case OP_GETSOCKNAME:
1740         if (getsockname(fd, (struct sockaddr *)SvPVX(sv), &aint) < 0)
1741             goto nuts2;
1742         break;
1743     case OP_GETPEERNAME:
1744         if (getpeername(fd, (struct sockaddr *)SvPVX(sv), &aint) < 0)
1745             goto nuts2;
1746         break;
1747     }
1748     SvCUR_set(sv,aint);
1749     *SvEND(sv) ='\0';
1750     PUSHs(sv);
1751     RETURN;
1752
1753 nuts:
1754     if (dowarn)
1755         warn("get{sock, peer}name() on closed fd");
1756     SETERRNO(EBADF,SS$_IVCHAN);
1757 nuts2:
1758     RETPUSHUNDEF;
1759
1760 #else
1761     DIE(no_sock_func, "getpeername");
1762 #endif
1763 }
1764
1765 /* Stat calls. */
1766
1767 PP(pp_lstat)
1768 {
1769     return pp_stat(ARGS);
1770 }
1771
1772 PP(pp_stat)
1773 {
1774     dSP;
1775     GV *tmpgv;
1776     I32 max = 13;
1777
1778     if (op->op_flags & OPf_REF) {
1779         tmpgv = cGVOP->op_gv;
1780       do_fstat:
1781         if (tmpgv != defgv) {
1782             laststype = OP_STAT;
1783             statgv = tmpgv;
1784             sv_setpv(statname, "");
1785             if (!GvIO(tmpgv) || !IoIFP(GvIOp(tmpgv)) ||
1786               Fstat(fileno(IoIFP(GvIOn(tmpgv))), &statcache) < 0) {
1787                 max = 0;
1788                 laststatval = -1;
1789             }
1790         }
1791         else if (laststatval < 0)
1792             max = 0;
1793     }
1794     else {
1795         SV* sv = POPs;
1796         if (SvTYPE(sv) == SVt_PVGV) {
1797             tmpgv = (GV*)sv;
1798             goto do_fstat;
1799         }
1800         else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) {
1801             tmpgv = (GV*)SvRV(sv);
1802             goto do_fstat;
1803         }
1804         sv_setpv(statname, SvPV(sv,na));
1805         statgv = Nullgv;
1806 #ifdef HAS_LSTAT
1807         laststype = op->op_type;
1808         if (op->op_type == OP_LSTAT)
1809             laststatval = lstat(SvPV(statname, na), &statcache);
1810         else
1811 #endif
1812             laststatval = Stat(SvPV(statname, na), &statcache);
1813         if (laststatval < 0) {
1814             if (dowarn && strchr(SvPV(statname, na), '\n'))
1815                 warn(warn_nl, "stat");
1816             max = 0;
1817         }
1818     }
1819
1820     EXTEND(SP, 13);
1821     if (GIMME != G_ARRAY) {
1822         if (max)
1823             RETPUSHYES;
1824         else
1825             RETPUSHUNDEF;
1826     }
1827     if (max) {
1828         PUSHs(sv_2mortal(newSViv((I32)statcache.st_dev)));
1829         PUSHs(sv_2mortal(newSViv((I32)statcache.st_ino)));
1830         PUSHs(sv_2mortal(newSViv((I32)statcache.st_mode)));
1831         PUSHs(sv_2mortal(newSViv((I32)statcache.st_nlink)));
1832         PUSHs(sv_2mortal(newSViv((I32)statcache.st_uid)));
1833         PUSHs(sv_2mortal(newSViv((I32)statcache.st_gid)));
1834         PUSHs(sv_2mortal(newSViv((I32)statcache.st_rdev)));
1835         PUSHs(sv_2mortal(newSViv((I32)statcache.st_size)));
1836         PUSHs(sv_2mortal(newSViv((I32)statcache.st_atime)));
1837         PUSHs(sv_2mortal(newSViv((I32)statcache.st_mtime)));
1838         PUSHs(sv_2mortal(newSViv((I32)statcache.st_ctime)));
1839 #ifdef USE_STAT_BLOCKS
1840         PUSHs(sv_2mortal(newSViv((I32)statcache.st_blksize)));
1841         PUSHs(sv_2mortal(newSViv((I32)statcache.st_blocks)));
1842 #else
1843         PUSHs(sv_2mortal(newSVpv("", 0)));
1844         PUSHs(sv_2mortal(newSVpv("", 0)));
1845 #endif
1846     }
1847     RETURN;
1848 }
1849
1850 PP(pp_ftrread)
1851 {
1852     I32 result = my_stat(ARGS);
1853     dSP;
1854     if (result < 0)
1855         RETPUSHUNDEF;
1856     if (cando(S_IRUSR, 0, &statcache))
1857         RETPUSHYES;
1858     RETPUSHNO;
1859 }
1860
1861 PP(pp_ftrwrite)
1862 {
1863     I32 result = my_stat(ARGS);
1864     dSP;
1865     if (result < 0)
1866         RETPUSHUNDEF;
1867     if (cando(S_IWUSR, 0, &statcache))
1868         RETPUSHYES;
1869     RETPUSHNO;
1870 }
1871
1872 PP(pp_ftrexec)
1873 {
1874     I32 result = my_stat(ARGS);
1875     dSP;
1876     if (result < 0)
1877         RETPUSHUNDEF;
1878     if (cando(S_IXUSR, 0, &statcache))
1879         RETPUSHYES;
1880     RETPUSHNO;
1881 }
1882
1883 PP(pp_fteread)
1884 {
1885     I32 result = my_stat(ARGS);
1886     dSP;
1887     if (result < 0)
1888         RETPUSHUNDEF;
1889     if (cando(S_IRUSR, 1, &statcache))
1890         RETPUSHYES;
1891     RETPUSHNO;
1892 }
1893
1894 PP(pp_ftewrite)
1895 {
1896     I32 result = my_stat(ARGS);
1897     dSP;
1898     if (result < 0)
1899         RETPUSHUNDEF;
1900     if (cando(S_IWUSR, 1, &statcache))
1901         RETPUSHYES;
1902     RETPUSHNO;
1903 }
1904
1905 PP(pp_fteexec)
1906 {
1907     I32 result = my_stat(ARGS);
1908     dSP;
1909     if (result < 0)
1910         RETPUSHUNDEF;
1911     if (cando(S_IXUSR, 1, &statcache))
1912         RETPUSHYES;
1913     RETPUSHNO;
1914 }
1915
1916 PP(pp_ftis)
1917 {
1918     I32 result = my_stat(ARGS);
1919     dSP;
1920     if (result < 0)
1921         RETPUSHUNDEF;
1922     RETPUSHYES;
1923 }
1924
1925 PP(pp_fteowned)
1926 {
1927     return pp_ftrowned(ARGS);
1928 }
1929
1930 PP(pp_ftrowned)
1931 {
1932     I32 result = my_stat(ARGS);
1933     dSP;
1934     if (result < 0)
1935         RETPUSHUNDEF;
1936     if (statcache.st_uid == (op->op_type == OP_FTEOWNED ? euid : uid) )
1937         RETPUSHYES;
1938     RETPUSHNO;
1939 }
1940
1941 PP(pp_ftzero)
1942 {
1943     I32 result = my_stat(ARGS);
1944     dSP;
1945     if (result < 0)
1946         RETPUSHUNDEF;
1947     if (!statcache.st_size)
1948         RETPUSHYES;
1949     RETPUSHNO;
1950 }
1951
1952 PP(pp_ftsize)
1953 {
1954     I32 result = my_stat(ARGS);
1955     dSP; dTARGET;
1956     if (result < 0)
1957         RETPUSHUNDEF;
1958     PUSHi(statcache.st_size);
1959     RETURN;
1960 }
1961
1962 PP(pp_ftmtime)
1963 {
1964     I32 result = my_stat(ARGS);
1965     dSP; dTARGET;
1966     if (result < 0)
1967         RETPUSHUNDEF;
1968     PUSHn( (basetime - statcache.st_mtime) / 86400.0 );
1969     RETURN;
1970 }
1971
1972 PP(pp_ftatime)
1973 {
1974     I32 result = my_stat(ARGS);
1975     dSP; dTARGET;
1976     if (result < 0)
1977         RETPUSHUNDEF;
1978     PUSHn( (basetime - statcache.st_atime) / 86400.0 );
1979     RETURN;
1980 }
1981
1982 PP(pp_ftctime)
1983 {
1984     I32 result = my_stat(ARGS);
1985     dSP; dTARGET;
1986     if (result < 0)
1987         RETPUSHUNDEF;
1988     PUSHn( (basetime - statcache.st_ctime) / 86400.0 );
1989     RETURN;
1990 }
1991
1992 PP(pp_ftsock)
1993 {
1994     I32 result = my_stat(ARGS);
1995     dSP;
1996     if (result < 0)
1997         RETPUSHUNDEF;
1998     if (S_ISSOCK(statcache.st_mode))
1999         RETPUSHYES;
2000     RETPUSHNO;
2001 }
2002
2003 PP(pp_ftchr)
2004 {
2005     I32 result = my_stat(ARGS);
2006     dSP;
2007     if (result < 0)
2008         RETPUSHUNDEF;
2009     if (S_ISCHR(statcache.st_mode))
2010         RETPUSHYES;
2011     RETPUSHNO;
2012 }
2013
2014 PP(pp_ftblk)
2015 {
2016     I32 result = my_stat(ARGS);
2017     dSP;
2018     if (result < 0)
2019         RETPUSHUNDEF;
2020     if (S_ISBLK(statcache.st_mode))
2021         RETPUSHYES;
2022     RETPUSHNO;
2023 }
2024
2025 PP(pp_ftfile)
2026 {
2027     I32 result = my_stat(ARGS);
2028     dSP;
2029     if (result < 0)
2030         RETPUSHUNDEF;
2031     if (S_ISREG(statcache.st_mode))
2032         RETPUSHYES;
2033     RETPUSHNO;
2034 }
2035
2036 PP(pp_ftdir)
2037 {
2038     I32 result = my_stat(ARGS);
2039     dSP;
2040     if (result < 0)
2041         RETPUSHUNDEF;
2042     if (S_ISDIR(statcache.st_mode))
2043         RETPUSHYES;
2044     RETPUSHNO;
2045 }
2046
2047 PP(pp_ftpipe)
2048 {
2049     I32 result = my_stat(ARGS);
2050     dSP;
2051     if (result < 0)
2052         RETPUSHUNDEF;
2053     if (S_ISFIFO(statcache.st_mode))
2054         RETPUSHYES;
2055     RETPUSHNO;
2056 }
2057
2058 PP(pp_ftlink)
2059 {
2060     I32 result = my_lstat(ARGS);
2061     dSP;
2062     if (result < 0)
2063         RETPUSHUNDEF;
2064     if (S_ISLNK(statcache.st_mode))
2065         RETPUSHYES;
2066     RETPUSHNO;
2067 }
2068
2069 PP(pp_ftsuid)
2070 {
2071     dSP;
2072 #ifdef S_ISUID
2073     I32 result = my_stat(ARGS);
2074     SPAGAIN;
2075     if (result < 0)
2076         RETPUSHUNDEF;
2077     if (statcache.st_mode & S_ISUID)
2078         RETPUSHYES;
2079 #endif
2080     RETPUSHNO;
2081 }
2082
2083 PP(pp_ftsgid)
2084 {
2085     dSP;
2086 #ifdef S_ISGID
2087     I32 result = my_stat(ARGS);
2088     SPAGAIN;
2089     if (result < 0)
2090         RETPUSHUNDEF;
2091     if (statcache.st_mode & S_ISGID)
2092         RETPUSHYES;
2093 #endif
2094     RETPUSHNO;
2095 }
2096
2097 PP(pp_ftsvtx)
2098 {
2099     dSP;
2100 #ifdef S_ISVTX
2101     I32 result = my_stat(ARGS);
2102     SPAGAIN;
2103     if (result < 0)
2104         RETPUSHUNDEF;
2105     if (statcache.st_mode & S_ISVTX)
2106         RETPUSHYES;
2107 #endif
2108     RETPUSHNO;
2109 }
2110
2111 PP(pp_fttty)
2112 {
2113     dSP;
2114     int fd;
2115     GV *gv;
2116     char *tmps;
2117     if (op->op_flags & OPf_REF) {
2118         gv = cGVOP->op_gv;
2119         tmps = "";
2120     }
2121     else
2122         gv = gv_fetchpv(tmps = POPp, FALSE, SVt_PVIO);
2123     if (GvIO(gv) && IoIFP(GvIOp(gv)))
2124         fd = fileno(IoIFP(GvIOp(gv)));
2125     else if (isDIGIT(*tmps))
2126         fd = atoi(tmps);
2127     else
2128         RETPUSHUNDEF;
2129     if (isatty(fd))
2130         RETPUSHYES;
2131     RETPUSHNO;
2132 }
2133
2134 #if defined(atarist) /* this will work with atariST. Configure will
2135                         make guesses for other systems. */
2136 # define FILE_base(f) ((f)->_base)
2137 # define FILE_ptr(f) ((f)->_ptr)
2138 # define FILE_cnt(f) ((f)->_cnt)
2139 # define FILE_bufsiz(f) ((f)->_cnt + ((f)->_ptr - (f)->_base))
2140 #endif
2141
2142 PP(pp_fttext)
2143 {
2144     dSP;
2145     I32 i;
2146     I32 len;
2147     I32 odd = 0;
2148     STDCHAR tbuf[512];
2149     register STDCHAR *s;
2150     register IO *io;
2151     SV *sv;
2152
2153     if (op->op_flags & OPf_REF) {
2154         EXTEND(SP, 1);
2155         if (cGVOP->op_gv == defgv) {
2156             if (statgv)
2157                 io = GvIO(statgv);
2158             else {
2159                 sv = statname;
2160                 goto really_filename;
2161             }
2162         }
2163         else {
2164             statgv = cGVOP->op_gv;
2165             sv_setpv(statname, "");
2166             io = GvIO(statgv);
2167         }
2168         if (io && IoIFP(io)) {
2169 #ifdef FILE_base
2170             Fstat(fileno(IoIFP(io)), &statcache);
2171             if (S_ISDIR(statcache.st_mode))     /* handle NFS glitch */
2172                 if (op->op_type == OP_FTTEXT)
2173                     RETPUSHNO;
2174                 else
2175                     RETPUSHYES;
2176             if (FILE_cnt(IoIFP(io)) <= 0) {
2177                 i = getc(IoIFP(io));
2178                 if (i != EOF)
2179                     (void)ungetc(i, IoIFP(io));
2180             }
2181             if (FILE_cnt(IoIFP(io)) <= 0)       /* null file is anything */
2182                 RETPUSHYES;
2183             len = FILE_bufsiz(IoIFP(io));
2184             s = FILE_base(IoIFP(io));
2185 #else
2186             DIE("-T and -B not implemented on filehandles");
2187 #endif
2188         }
2189         else {
2190             if (dowarn)
2191                 warn("Test on unopened file <%s>",
2192                   GvENAME(cGVOP->op_gv));
2193             SETERRNO(EBADF,RMS$_IFI);
2194             RETPUSHUNDEF;
2195         }
2196     }
2197     else {
2198         sv = POPs;
2199         statgv = Nullgv;
2200         sv_setpv(statname, SvPV(sv, na));
2201       really_filename:
2202 #ifdef HAS_OPEN3
2203         i = open(SvPV(sv, na), O_RDONLY, 0);
2204 #else
2205         i = open(SvPV(sv, na), 0);
2206 #endif
2207         if (i < 0) {
2208             if (dowarn && strchr(SvPV(sv, na), '\n'))
2209                 warn(warn_nl, "open");
2210             RETPUSHUNDEF;
2211         }
2212         Fstat(i, &statcache);
2213         len = read(i, tbuf, 512);
2214         (void)close(i);
2215         if (len <= 0) {
2216             if (S_ISDIR(statcache.st_mode) && op->op_type == OP_FTTEXT)
2217                 RETPUSHNO;              /* special case NFS directories */
2218             RETPUSHYES;         /* null file is anything */
2219         }
2220         s = tbuf;
2221     }
2222
2223     /* now scan s to look for textiness */
2224     /*   XXX ASCII dependent code */
2225
2226     for (i = 0; i < len; i++, s++) {
2227         if (!*s) {                      /* null never allowed in text */
2228             odd += len;
2229             break;
2230         }
2231         else if (*s & 128)
2232             odd++;
2233         else if (*s < 32 &&
2234           *s != '\n' && *s != '\r' && *s != '\b' &&
2235           *s != '\t' && *s != '\f' && *s != 27)
2236             odd++;
2237     }
2238
2239     if ((odd * 3 > len) == (op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
2240         RETPUSHNO;
2241     else
2242         RETPUSHYES;
2243 }
2244
2245 PP(pp_ftbinary)
2246 {
2247     return pp_fttext(ARGS);
2248 }
2249
2250 /* File calls. */
2251
2252 PP(pp_chdir)
2253 {
2254     dSP; dTARGET;
2255     char *tmps;
2256     SV **svp;
2257
2258     if (MAXARG < 1)
2259         tmps = Nullch;
2260     else
2261         tmps = POPp;
2262     if (!tmps || !*tmps) {
2263         svp = hv_fetch(GvHVn(envgv), "HOME", 4, FALSE);
2264         if (svp)
2265             tmps = SvPV(*svp, na);
2266     }
2267     if (!tmps || !*tmps) {
2268         svp = hv_fetch(GvHVn(envgv), "LOGDIR", 6, FALSE);
2269         if (svp)
2270             tmps = SvPV(*svp, na);
2271     }
2272     TAINT_PROPER("chdir");
2273     PUSHi( chdir(tmps) >= 0 );
2274 #ifdef VMS
2275     /* Clear the DEFAULT element of ENV so we'll get the new value
2276      * in the future. */
2277     hv_delete(GvHVn(envgv),"DEFAULT",7,G_DISCARD);
2278 #endif
2279     RETURN;
2280 }
2281
2282 PP(pp_chown)
2283 {
2284     dSP; dMARK; dTARGET;
2285     I32 value;
2286 #ifdef HAS_CHOWN
2287     value = (I32)apply(op->op_type, MARK, SP);
2288     SP = MARK;
2289     PUSHi(value);
2290     RETURN;
2291 #else
2292     DIE(no_func, "Unsupported function chown");
2293 #endif
2294 }
2295
2296 PP(pp_chroot)
2297 {
2298     dSP; dTARGET;
2299     char *tmps;
2300 #ifdef HAS_CHROOT
2301     tmps = POPp;
2302     TAINT_PROPER("chroot");
2303     PUSHi( chroot(tmps) >= 0 );
2304     RETURN;
2305 #else
2306     DIE(no_func, "chroot");
2307 #endif
2308 }
2309
2310 PP(pp_unlink)
2311 {
2312     dSP; dMARK; dTARGET;
2313     I32 value;
2314     value = (I32)apply(op->op_type, MARK, SP);
2315     SP = MARK;
2316     PUSHi(value);
2317     RETURN;
2318 }
2319
2320 PP(pp_chmod)
2321 {
2322     dSP; dMARK; dTARGET;
2323     I32 value;
2324     value = (I32)apply(op->op_type, MARK, SP);
2325     SP = MARK;
2326     PUSHi(value);
2327     RETURN;
2328 }
2329
2330 PP(pp_utime)
2331 {
2332     dSP; dMARK; dTARGET;
2333     I32 value;
2334     value = (I32)apply(op->op_type, MARK, SP);
2335     SP = MARK;
2336     PUSHi(value);
2337     RETURN;
2338 }
2339
2340 PP(pp_rename)
2341 {
2342     dSP; dTARGET;
2343     int anum;
2344
2345     char *tmps2 = POPp;
2346     char *tmps = SvPV(TOPs, na);
2347     TAINT_PROPER("rename");
2348 #ifdef HAS_RENAME
2349     anum = rename(tmps, tmps2);
2350 #else
2351     if (same_dirent(tmps2, tmps))       /* can always rename to same name */
2352         anum = 1;
2353     else {
2354         if (euid || Stat(tmps2, &statbuf) < 0 || !S_ISDIR(statbuf.st_mode))
2355             (void)UNLINK(tmps2);
2356         if (!(anum = link(tmps, tmps2)))
2357             anum = UNLINK(tmps);
2358     }
2359 #endif
2360     SETi( anum >= 0 );
2361     RETURN;
2362 }
2363
2364 PP(pp_link)
2365 {
2366     dSP; dTARGET;
2367 #ifdef HAS_LINK
2368     char *tmps2 = POPp;
2369     char *tmps = SvPV(TOPs, na);
2370     TAINT_PROPER("link");
2371     SETi( link(tmps, tmps2) >= 0 );
2372 #else
2373     DIE(no_func, "Unsupported function link");
2374 #endif
2375     RETURN;
2376 }
2377
2378 PP(pp_symlink)
2379 {
2380     dSP; dTARGET;
2381 #ifdef HAS_SYMLINK
2382     char *tmps2 = POPp;
2383     char *tmps = SvPV(TOPs, na);
2384     TAINT_PROPER("symlink");
2385     SETi( symlink(tmps, tmps2) >= 0 );
2386     RETURN;
2387 #else
2388     DIE(no_func, "symlink");
2389 #endif
2390 }
2391
2392 PP(pp_readlink)
2393 {
2394     dSP; dTARGET;
2395 #ifdef HAS_SYMLINK
2396     char *tmps;
2397     int len;
2398     tmps = POPp;
2399     len = readlink(tmps, buf, sizeof buf);
2400     EXTEND(SP, 1);
2401     if (len < 0)
2402         RETPUSHUNDEF;
2403     PUSHp(buf, len);
2404     RETURN;
2405 #else
2406     EXTEND(SP, 1);
2407     RETSETUNDEF;                /* just pretend it's a normal file */
2408 #endif
2409 }
2410
2411 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
2412 static int
2413 dooneliner(cmd, filename)
2414 char *cmd;
2415 char *filename;
2416 {
2417     char mybuf[8192];
2418     char *s,
2419          *save_filename = filename;
2420     int anum = 1;
2421     FILE *myfp;
2422
2423     strcpy(mybuf, cmd);
2424     strcat(mybuf, " ");
2425     for (s = mybuf+strlen(mybuf); *filename; ) {
2426         *s++ = '\\';
2427         *s++ = *filename++;
2428     }
2429     strcpy(s, " 2>&1");
2430     myfp = my_popen(mybuf, "r");
2431     if (myfp) {
2432         *mybuf = '\0';
2433         s = fgets(mybuf, sizeof mybuf, myfp);
2434         (void)my_pclose(myfp);
2435         if (s != Nullch) {
2436             for (errno = 1; errno < sys_nerr; errno++) {
2437 #ifdef HAS_SYS_ERRLIST
2438                 if (instr(mybuf, sys_errlist[errno]))   /* you don't see this */
2439                     return 0;
2440 #else
2441                 char *errmsg;                           /* especially if it isn't there */
2442
2443                 if (instr(mybuf,
2444                           (errmsg = strerror(errno)) ? errmsg : "NoErRoR"))
2445                     return 0;
2446 #endif
2447             }
2448             SETERRNO(0,0);
2449 #ifndef EACCES
2450 #define EACCES EPERM
2451 #endif
2452             if (instr(mybuf, "cannot make"))
2453                 SETERRNO(EEXIST,RMS$_FEX);
2454             else if (instr(mybuf, "existing file"))
2455                 SETERRNO(EEXIST,RMS$_FEX);
2456             else if (instr(mybuf, "ile exists"))
2457                 SETERRNO(EEXIST,RMS$_FEX);
2458             else if (instr(mybuf, "non-exist"))
2459                 SETERRNO(ENOENT,RMS$_FNF);
2460             else if (instr(mybuf, "does not exist"))
2461                 SETERRNO(ENOENT,RMS$_FNF);
2462             else if (instr(mybuf, "not empty"))
2463                 SETERRNO(EBUSY,SS$_DEVOFFLINE);
2464             else if (instr(mybuf, "cannot access"))
2465                 SETERRNO(EACCES,RMS$_PRV);
2466             else
2467                 SETERRNO(EPERM,RMS$_PRV);
2468             return 0;
2469         }
2470         else {  /* some mkdirs return no failure indication */
2471             anum = (Stat(save_filename, &statbuf) >= 0);
2472             if (op->op_type == OP_RMDIR)
2473                 anum = !anum;
2474             if (anum)
2475                 SETERRNO(0,0);
2476             else
2477                 SETERRNO(EACCES,RMS$_PRV);      /* a guess */
2478         }
2479         return anum;
2480     }
2481     else
2482         return 0;
2483 }
2484 #endif
2485
2486 PP(pp_mkdir)
2487 {
2488     dSP; dTARGET;
2489     int mode = POPi;
2490 #ifndef HAS_MKDIR
2491     int oldumask;
2492 #endif
2493     char *tmps = SvPV(TOPs, na);
2494
2495     TAINT_PROPER("mkdir");
2496 #ifdef HAS_MKDIR
2497     SETi( mkdir(tmps, mode) >= 0 );
2498 #else
2499     SETi( dooneliner("mkdir", tmps) );
2500     oldumask = umask(0);
2501     umask(oldumask);
2502     chmod(tmps, (mode & ~oldumask) & 0777);
2503 #endif
2504     RETURN;
2505 }
2506
2507 PP(pp_rmdir)
2508 {
2509     dSP; dTARGET;
2510     char *tmps;
2511
2512     tmps = POPp;
2513     TAINT_PROPER("rmdir");
2514 #ifdef HAS_RMDIR
2515     XPUSHi( rmdir(tmps) >= 0 );
2516 #else
2517     XPUSHi( dooneliner("rmdir", tmps) );
2518 #endif
2519     RETURN;
2520 }
2521
2522 /* Directory calls. */
2523
2524 PP(pp_open_dir)
2525 {
2526     dSP;
2527 #if defined(Direntry_t) && defined(HAS_READDIR)
2528     char *dirname = POPp;
2529     GV *gv = (GV*)POPs;
2530     register IO *io = GvIOn(gv);
2531
2532     if (!io)
2533         goto nope;
2534
2535     if (IoDIRP(io))
2536         closedir(IoDIRP(io));
2537     if (!(IoDIRP(io) = opendir(dirname)))
2538         goto nope;
2539
2540     RETPUSHYES;
2541 nope:
2542     if (!errno)
2543         SETERRNO(EBADF,RMS$_DIR);
2544     RETPUSHUNDEF;
2545 #else
2546     DIE(no_dir_func, "opendir");
2547 #endif
2548 }
2549
2550 PP(pp_readdir)
2551 {
2552     dSP;
2553 #if defined(Direntry_t) && defined(HAS_READDIR)
2554 #ifndef I_DIRENT
2555     Direntry_t *readdir _((DIR *));
2556 #endif
2557     register Direntry_t *dp;
2558     GV *gv = (GV*)POPs;
2559     register IO *io = GvIOn(gv);
2560
2561     if (!io || !IoDIRP(io))
2562         goto nope;
2563
2564     if (GIMME == G_ARRAY) {
2565         /*SUPPRESS 560*/
2566         while (dp = (Direntry_t *)readdir(IoDIRP(io))) {
2567 #ifdef DIRNAMLEN
2568             XPUSHs(sv_2mortal(newSVpv(dp->d_name, dp->d_namlen)));
2569 #else
2570             XPUSHs(sv_2mortal(newSVpv(dp->d_name, 0)));
2571 #endif
2572         }
2573     }
2574     else {
2575         if (!(dp = (Direntry_t *)readdir(IoDIRP(io))))
2576             goto nope;
2577 #ifdef DIRNAMLEN
2578         XPUSHs(sv_2mortal(newSVpv(dp->d_name, dp->d_namlen)));
2579 #else
2580         XPUSHs(sv_2mortal(newSVpv(dp->d_name, 0)));
2581 #endif
2582     }
2583     RETURN;
2584
2585 nope:
2586     if (!errno)
2587         SETERRNO(EBADF,RMS$_ISI);
2588     if (GIMME == G_ARRAY)
2589         RETURN;
2590     else
2591         RETPUSHUNDEF;
2592 #else
2593     DIE(no_dir_func, "readdir");
2594 #endif
2595 }
2596
2597 PP(pp_telldir)
2598 {
2599     dSP; dTARGET;
2600 #if defined(HAS_TELLDIR) || defined(telldir)
2601 #if !defined(telldir) && !defined(HAS_TELLDIR_PROTOTYPE)
2602     long telldir _((DIR *));
2603 #endif
2604     GV *gv = (GV*)POPs;
2605     register IO *io = GvIOn(gv);
2606
2607     if (!io || !IoDIRP(io))
2608         goto nope;
2609
2610     PUSHi( telldir(IoDIRP(io)) );
2611     RETURN;
2612 nope:
2613     if (!errno)
2614         SETERRNO(EBADF,RMS$_ISI);
2615     RETPUSHUNDEF;
2616 #else
2617     DIE(no_dir_func, "telldir");
2618 #endif
2619 }
2620
2621 PP(pp_seekdir)
2622 {
2623     dSP;
2624 #if defined(HAS_SEEKDIR) || defined(seekdir)
2625     long along = POPl;
2626     GV *gv = (GV*)POPs;
2627     register IO *io = GvIOn(gv);
2628
2629     if (!io || !IoDIRP(io))
2630         goto nope;
2631
2632     (void)seekdir(IoDIRP(io), along);
2633
2634     RETPUSHYES;
2635 nope:
2636     if (!errno)
2637         SETERRNO(EBADF,RMS$_ISI);
2638     RETPUSHUNDEF;
2639 #else
2640     DIE(no_dir_func, "seekdir");
2641 #endif
2642 }
2643
2644 PP(pp_rewinddir)
2645 {
2646     dSP;
2647 #if defined(HAS_REWINDDIR) || defined(rewinddir)
2648     GV *gv = (GV*)POPs;
2649     register IO *io = GvIOn(gv);
2650
2651     if (!io || !IoDIRP(io))
2652         goto nope;
2653
2654     (void)rewinddir(IoDIRP(io));
2655     RETPUSHYES;
2656 nope:
2657     if (!errno)
2658         SETERRNO(EBADF,RMS$_ISI);
2659     RETPUSHUNDEF;
2660 #else
2661     DIE(no_dir_func, "rewinddir");
2662 #endif
2663 }
2664
2665 PP(pp_closedir)
2666 {
2667     dSP;
2668 #if defined(Direntry_t) && defined(HAS_READDIR)
2669     GV *gv = (GV*)POPs;
2670     register IO *io = GvIOn(gv);
2671
2672     if (!io || !IoDIRP(io))
2673         goto nope;
2674
2675 #ifdef VOID_CLOSEDIR
2676     closedir(IoDIRP(io));
2677 #else
2678     if (closedir(IoDIRP(io)) < 0) {
2679         IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
2680         goto nope;
2681     }
2682 #endif
2683     IoDIRP(io) = 0;
2684
2685     RETPUSHYES;
2686 nope:
2687     if (!errno)
2688         SETERRNO(EBADF,RMS$_IFI);
2689     RETPUSHUNDEF;
2690 #else
2691     DIE(no_dir_func, "closedir");
2692 #endif
2693 }
2694
2695 /* Process control. */
2696
2697 PP(pp_fork)
2698 {
2699     dSP; dTARGET;
2700     int childpid;
2701     GV *tmpgv;
2702
2703     EXTEND(SP, 1);
2704 #ifdef HAS_FORK
2705     childpid = fork();
2706     if (childpid < 0)
2707         RETSETUNDEF;
2708     if (!childpid) {
2709         /*SUPPRESS 560*/
2710         if (tmpgv = gv_fetchpv("$", TRUE, SVt_PV))
2711             sv_setiv(GvSV(tmpgv), (I32)getpid());
2712         hv_clear(pidstatus);    /* no kids, so don't wait for 'em */
2713     }
2714     PUSHi(childpid);
2715     RETURN;
2716 #else
2717     DIE(no_func, "Unsupported function fork");
2718 #endif
2719 }
2720
2721 PP(pp_wait)
2722 {
2723     dSP; dTARGET;
2724     int childpid;
2725     int argflags;
2726     I32 value;
2727
2728     EXTEND(SP, 1);
2729 #ifdef HAS_WAIT
2730     childpid = wait(&argflags);
2731     if (childpid > 0)
2732         pidgone(childpid, argflags);
2733     value = (I32)childpid;
2734     statusvalue = FIXSTATUS(argflags);
2735     PUSHi(value);
2736     RETURN;
2737 #else
2738     DIE(no_func, "Unsupported function wait");
2739 #endif
2740 }
2741
2742 PP(pp_waitpid)
2743 {
2744     dSP; dTARGET;
2745     int childpid;
2746     int optype;
2747     int argflags;
2748     I32 value;
2749
2750 #ifdef HAS_WAIT
2751     optype = POPi;
2752     childpid = TOPi;
2753     childpid = wait4pid(childpid, &argflags, optype);
2754     value = (I32)childpid;
2755     statusvalue = FIXSTATUS(argflags);
2756     SETi(value);
2757     RETURN;
2758 #else
2759     DIE(no_func, "Unsupported function wait");
2760 #endif
2761 }
2762
2763 PP(pp_system)
2764 {
2765     dSP; dMARK; dORIGMARK; dTARGET;
2766     I32 value;
2767     int childpid;
2768     int result;
2769     int status;
2770     Signal_t (*ihand)();     /* place to save signal during system() */
2771     Signal_t (*qhand)();     /* place to save signal during system() */
2772
2773 #if defined(HAS_FORK) && !defined(VMS) && !defined(OS2)
2774     if (SP - MARK == 1) {
2775         if (tainting) {
2776             char *junk = SvPV(TOPs, na);
2777             TAINT_ENV();
2778             TAINT_PROPER("system");
2779         }
2780     }
2781     while ((childpid = vfork()) == -1) {
2782         if (errno != EAGAIN) {
2783             value = -1;
2784             SP = ORIGMARK;
2785             PUSHi(value);
2786             RETURN;
2787         }
2788         sleep(5);
2789     }
2790     if (childpid > 0) {
2791         ihand = signal(SIGINT, SIG_IGN);
2792         qhand = signal(SIGQUIT, SIG_IGN);
2793         do {
2794             result = wait4pid(childpid, &status, 0);
2795         } while (result == -1 && errno == EINTR);
2796         (void)signal(SIGINT, ihand);
2797         (void)signal(SIGQUIT, qhand);
2798         statusvalue = FIXSTATUS(status);
2799         if (result < 0)
2800             value = -1;
2801         else {
2802             value = (I32)((unsigned int)status & 0xffff);
2803         }
2804         do_execfree();  /* free any memory child malloced on vfork */
2805         SP = ORIGMARK;
2806         PUSHi(value);
2807         RETURN;
2808     }
2809     if (op->op_flags & OPf_STACKED) {
2810         SV *really = *++MARK;
2811         value = (I32)do_aexec(really, MARK, SP);
2812     }
2813     else if (SP - MARK != 1)
2814         value = (I32)do_aexec(Nullsv, MARK, SP);
2815     else {
2816         value = (I32)do_exec(SvPVx(sv_mortalcopy(*SP), na));
2817     }
2818     _exit(-1);
2819 #else /* ! FORK or VMS or OS/2 */
2820     if (op->op_flags & OPf_STACKED) {
2821         SV *really = *++MARK;
2822         value = (I32)do_aspawn(really, MARK, SP);
2823     }
2824     else if (SP - MARK != 1)
2825         value = (I32)do_aspawn(Nullsv, MARK, SP);
2826     else {
2827         value = (I32)do_spawn(SvPVx(sv_mortalcopy(*SP), na));
2828     }
2829     statusvalue = FIXSTATUS(value);
2830     do_execfree();
2831     SP = ORIGMARK;
2832     PUSHi(value);
2833 #endif /* !FORK or VMS */
2834     RETURN;
2835 }
2836
2837 PP(pp_exec)
2838 {
2839     dSP; dMARK; dORIGMARK; dTARGET;
2840     I32 value;
2841
2842     if (op->op_flags & OPf_STACKED) {
2843         SV *really = *++MARK;
2844         value = (I32)do_aexec(really, MARK, SP);
2845     }
2846     else if (SP - MARK != 1)
2847 #ifdef VMS
2848         value = (I32)vms_do_aexec(Nullsv, MARK, SP);
2849 #else
2850         value = (I32)do_aexec(Nullsv, MARK, SP);
2851 #endif
2852     else {
2853         if (tainting) {
2854             char *junk = SvPV(*SP, na);
2855             TAINT_ENV();
2856             TAINT_PROPER("exec");
2857         }
2858 #ifdef VMS
2859         value = (I32)vms_do_exec(SvPVx(sv_mortalcopy(*SP), na));
2860 #else
2861         value = (I32)do_exec(SvPVx(sv_mortalcopy(*SP), na));
2862 #endif
2863     }
2864     SP = ORIGMARK;
2865     PUSHi(value);
2866     RETURN;
2867 }
2868
2869 PP(pp_kill)
2870 {
2871     dSP; dMARK; dTARGET;
2872     I32 value;
2873 #ifdef HAS_KILL
2874     value = (I32)apply(op->op_type, MARK, SP);
2875     SP = MARK;
2876     PUSHi(value);
2877     RETURN;
2878 #else
2879     DIE(no_func, "Unsupported function kill");
2880 #endif
2881 }
2882
2883 PP(pp_getppid)
2884 {
2885 #ifdef HAS_GETPPID
2886     dSP; dTARGET;
2887     XPUSHi( getppid() );
2888     RETURN;
2889 #else
2890     DIE(no_func, "getppid");
2891 #endif
2892 }
2893
2894 PP(pp_getpgrp)
2895 {
2896 #ifdef HAS_GETPGRP
2897     dSP; dTARGET;
2898     int pid;
2899     I32 value;
2900
2901     if (MAXARG < 1)
2902         pid = 0;
2903     else
2904         pid = SvIVx(POPs);
2905 #ifdef BSD_GETPGRP
2906     value = (I32)BSD_GETPGRP(pid);
2907 #else
2908     if (pid != 0)
2909         DIE("POSIX getpgrp can't take an argument");
2910     value = (I32)getpgrp();
2911 #endif
2912     XPUSHi(value);
2913     RETURN;
2914 #else
2915     DIE(no_func, "getpgrp()");
2916 #endif
2917 }
2918
2919 PP(pp_setpgrp)
2920 {
2921 #ifdef HAS_SETPGRP
2922     dSP; dTARGET;
2923     int pgrp;
2924     int pid;
2925     if (MAXARG < 2) {
2926         pgrp = 0;
2927         pid = 0;
2928     }
2929     else {
2930         pgrp = POPi;
2931         pid = TOPi;
2932     }
2933
2934     TAINT_PROPER("setpgrp");
2935 #ifdef BSD_SETPGRP
2936     SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
2937 #else
2938     if ((pgrp != 0) || (pid != 0)) {
2939         DIE("POSIX setpgrp can't take an argument");
2940     }
2941     SETi( setpgrp() >= 0 );
2942 #endif /* USE_BSDPGRP */
2943     RETURN;
2944 #else
2945     DIE(no_func, "setpgrp()");
2946 #endif
2947 }
2948
2949 PP(pp_getpriority)
2950 {
2951     dSP; dTARGET;
2952     int which;
2953     int who;
2954 #ifdef HAS_GETPRIORITY
2955     who = POPi;
2956     which = TOPi;
2957     SETi( getpriority(which, who) );
2958     RETURN;
2959 #else
2960     DIE(no_func, "getpriority()");
2961 #endif
2962 }
2963
2964 PP(pp_setpriority)
2965 {
2966     dSP; dTARGET;
2967     int which;
2968     int who;
2969     int niceval;
2970 #ifdef HAS_SETPRIORITY
2971     niceval = POPi;
2972     who = POPi;
2973     which = TOPi;
2974     TAINT_PROPER("setpriority");
2975     SETi( setpriority(which, who, niceval) >= 0 );
2976     RETURN;
2977 #else
2978     DIE(no_func, "setpriority()");
2979 #endif
2980 }
2981
2982 /* Time calls. */
2983
2984 PP(pp_time)
2985 {
2986     dSP; dTARGET;
2987     XPUSHi( time(Null(Time_t*)) );
2988     RETURN;
2989 }
2990
2991 #ifndef HZ
2992 #define HZ 60
2993 #endif
2994
2995 PP(pp_tms)
2996 {
2997     dSP;
2998
2999 #if defined(MSDOS) || !defined(HAS_TIMES)
3000     DIE("times not implemented");
3001 #else
3002     EXTEND(SP, 4);
3003
3004 #ifndef VMS
3005     (void)times(&timesbuf);
3006 #else
3007     (void)times((tbuffer_t *)&timesbuf);  /* time.h uses different name for */
3008                                           /* struct tms, though same data   */
3009                                           /* is returned.                   */
3010 #undef HZ
3011 #define HZ CLK_TCK
3012 #endif
3013
3014     PUSHs(sv_2mortal(newSVnv(((double)timesbuf.tms_utime)/HZ)));
3015     if (GIMME == G_ARRAY) {
3016         PUSHs(sv_2mortal(newSVnv(((double)timesbuf.tms_stime)/HZ)));
3017         PUSHs(sv_2mortal(newSVnv(((double)timesbuf.tms_cutime)/HZ)));
3018         PUSHs(sv_2mortal(newSVnv(((double)timesbuf.tms_cstime)/HZ)));
3019     }
3020     RETURN;
3021 #endif /* MSDOS */
3022 }
3023
3024 PP(pp_localtime)
3025 {
3026     return pp_gmtime(ARGS);
3027 }
3028
3029 PP(pp_gmtime)
3030 {
3031     dSP;
3032     Time_t when;
3033     struct tm *tmbuf;
3034     static char *dayname[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
3035     static char *monname[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3036                               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
3037
3038     if (MAXARG < 1)
3039         (void)time(&when);
3040     else
3041         when = (Time_t)SvIVx(POPs);
3042
3043     if (op->op_type == OP_LOCALTIME)
3044         tmbuf = localtime(&when);
3045     else
3046         tmbuf = gmtime(&when);
3047
3048     EXTEND(SP, 9);
3049     if (GIMME != G_ARRAY) {
3050         dTARGET;
3051         char mybuf[30];
3052         if (!tmbuf)
3053             RETPUSHUNDEF;
3054         sprintf(mybuf, "%s %s %2d %02d:%02d:%02d %d",
3055             dayname[tmbuf->tm_wday],
3056             monname[tmbuf->tm_mon],
3057             tmbuf->tm_mday,
3058             tmbuf->tm_hour,
3059             tmbuf->tm_min,
3060             tmbuf->tm_sec,
3061             tmbuf->tm_year + 1900);
3062         PUSHp(mybuf, strlen(mybuf));
3063     }
3064     else if (tmbuf) {
3065         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_sec)));
3066         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_min)));
3067         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_hour)));
3068         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_mday)));
3069         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_mon)));
3070         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_year)));
3071         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_wday)));
3072         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_yday)));
3073         PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_isdst)));
3074     }
3075     RETURN;
3076 }
3077
3078 PP(pp_alarm)
3079 {
3080     dSP; dTARGET;
3081     int anum;
3082 #ifdef HAS_ALARM
3083     anum = POPi;
3084     anum = alarm((unsigned int)anum);
3085     EXTEND(SP, 1);
3086     if (anum < 0)
3087         RETPUSHUNDEF;
3088     PUSHi((I32)anum);
3089     RETURN;
3090 #else
3091     DIE(no_func, "Unsupported function alarm");
3092 #endif
3093 }
3094
3095 PP(pp_sleep)
3096 {
3097     dSP; dTARGET;
3098     I32 duration;
3099     Time_t lasttime;
3100     Time_t when;
3101
3102     (void)time(&lasttime);
3103     if (MAXARG < 1)
3104         pause();
3105     else {
3106         duration = POPi;
3107         sleep((unsigned int)duration);
3108     }
3109     (void)time(&when);
3110     XPUSHi(when - lasttime);
3111     RETURN;
3112 }
3113
3114 /* Shared memory. */
3115
3116 PP(pp_shmget)
3117 {
3118     return pp_semget(ARGS);
3119 }
3120
3121 PP(pp_shmctl)
3122 {
3123     return pp_semctl(ARGS);
3124 }
3125
3126 PP(pp_shmread)
3127 {
3128     return pp_shmwrite(ARGS);
3129 }
3130
3131 PP(pp_shmwrite)
3132 {
3133 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3134     dSP; dMARK; dTARGET;
3135     I32 value = (I32)(do_shmio(op->op_type, MARK, SP) >= 0);
3136     SP = MARK;
3137     PUSHi(value);
3138     RETURN;
3139 #else
3140     return pp_semget(ARGS);
3141 #endif
3142 }
3143
3144 /* Message passing. */
3145
3146 PP(pp_msgget)
3147 {
3148     return pp_semget(ARGS);
3149 }
3150
3151 PP(pp_msgctl)
3152 {
3153     return pp_semctl(ARGS);
3154 }
3155
3156 PP(pp_msgsnd)
3157 {
3158 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3159     dSP; dMARK; dTARGET;
3160     I32 value = (I32)(do_msgsnd(MARK, SP) >= 0);
3161     SP = MARK;
3162     PUSHi(value);
3163     RETURN;
3164 #else
3165     return pp_semget(ARGS);
3166 #endif
3167 }
3168
3169 PP(pp_msgrcv)
3170 {
3171 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3172     dSP; dMARK; dTARGET;
3173     I32 value = (I32)(do_msgrcv(MARK, SP) >= 0);
3174     SP = MARK;
3175     PUSHi(value);
3176     RETURN;
3177 #else
3178     return pp_semget(ARGS);
3179 #endif
3180 }
3181
3182 /* Semaphores. */
3183
3184 PP(pp_semget)
3185 {
3186 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3187     dSP; dMARK; dTARGET;
3188     int anum = do_ipcget(op->op_type, MARK, SP);
3189     SP = MARK;
3190     if (anum == -1)
3191         RETPUSHUNDEF;
3192     PUSHi(anum);
3193     RETURN;
3194 #else
3195     DIE("System V IPC is not implemented on this machine");
3196 #endif
3197 }
3198
3199 PP(pp_semctl)
3200 {
3201 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3202     dSP; dMARK; dTARGET;
3203     int anum = do_ipcctl(op->op_type, MARK, SP);
3204     SP = MARK;
3205     if (anum == -1)
3206         RETSETUNDEF;
3207     if (anum != 0) {
3208         PUSHi(anum);
3209     }
3210     else {
3211         PUSHp("0 but true",10);
3212     }
3213     RETURN;
3214 #else
3215     return pp_semget(ARGS);
3216 #endif
3217 }
3218
3219 PP(pp_semop)
3220 {
3221 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
3222     dSP; dMARK; dTARGET;
3223     I32 value = (I32)(do_semop(MARK, SP) >= 0);
3224     SP = MARK;
3225     PUSHi(value);
3226     RETURN;
3227 #else
3228     return pp_semget(ARGS);
3229 #endif
3230 }
3231
3232 /* Get system info. */
3233
3234 PP(pp_ghbyname)
3235 {
3236 #ifdef HAS_SOCKET
3237     return pp_ghostent(ARGS);
3238 #else
3239     DIE(no_sock_func, "gethostbyname");
3240 #endif
3241 }
3242
3243 PP(pp_ghbyaddr)
3244 {
3245 #ifdef HAS_SOCKET
3246     return pp_ghostent(ARGS);
3247 #else
3248     DIE(no_sock_func, "gethostbyaddr");
3249 #endif
3250 }
3251
3252 PP(pp_ghostent)
3253 {
3254     dSP;
3255 #ifdef HAS_SOCKET
3256     I32 which = op->op_type;
3257     register char **elem;
3258     register SV *sv;
3259     struct hostent *gethostbyname();
3260     struct hostent *gethostbyaddr();
3261 #ifdef HAS_GETHOSTENT
3262     struct hostent *gethostent();
3263 #endif
3264     struct hostent *hent;
3265     unsigned long len;
3266
3267     EXTEND(SP, 10);
3268     if (which == OP_GHBYNAME) {
3269         hent = gethostbyname(POPp);
3270     }
3271     else if (which == OP_GHBYADDR) {
3272         int addrtype = POPi;
3273         SV *addrsv = POPs;
3274         STRLEN addrlen;
3275         char *addr = SvPV(addrsv, addrlen);
3276
3277         hent = gethostbyaddr(addr, addrlen, addrtype);
3278     }
3279     else
3280 #ifdef HAS_GETHOSTENT
3281         hent = gethostent();
3282 #else
3283         DIE("gethostent not implemented");
3284 #endif
3285
3286 #ifdef HOST_NOT_FOUND
3287     if (!hent)
3288         statusvalue = FIXSTATUS(h_errno);
3289 #endif
3290
3291     if (GIMME != G_ARRAY) {
3292         PUSHs(sv = sv_newmortal());
3293         if (hent) {
3294             if (which == OP_GHBYNAME) {
3295                 if (hent->h_addr)
3296                     sv_setpvn(sv, hent->h_addr, hent->h_length);
3297             }
3298             else
3299                 sv_setpv(sv, (char*)hent->h_name);
3300         }
3301         RETURN;
3302     }
3303
3304     if (hent) {
3305         PUSHs(sv = sv_mortalcopy(&sv_no));
3306         sv_setpv(sv, (char*)hent->h_name);
3307         PUSHs(sv = sv_mortalcopy(&sv_no));
3308         for (elem = hent->h_aliases; elem && *elem; elem++) {
3309             sv_catpv(sv, *elem);
3310             if (elem[1])
3311                 sv_catpvn(sv, " ", 1);
3312         }
3313         PUSHs(sv = sv_mortalcopy(&sv_no));
3314         sv_setiv(sv, (I32)hent->h_addrtype);
3315         PUSHs(sv = sv_mortalcopy(&sv_no));
3316         len = hent->h_length;
3317         sv_setiv(sv, (I32)len);
3318 #ifdef h_addr
3319         for (elem = hent->h_addr_list; elem && *elem; elem++) {
3320             XPUSHs(sv = sv_mortalcopy(&sv_no));
3321             sv_setpvn(sv, *elem, len);
3322         }
3323 #else
3324         PUSHs(sv = sv_mortalcopy(&sv_no));
3325         if (hent->h_addr)
3326             sv_setpvn(sv, hent->h_addr, len);
3327 #endif /* h_addr */
3328     }
3329     RETURN;
3330 #else
3331     DIE(no_sock_func, "gethostent");
3332 #endif
3333 }
3334
3335 PP(pp_gnbyname)
3336 {
3337 #ifdef HAS_SOCKET
3338     return pp_gnetent(ARGS);
3339 #else
3340     DIE(no_sock_func, "getnetbyname");
3341 #endif
3342 }
3343
3344 PP(pp_gnbyaddr)
3345 {
3346 #ifdef HAS_SOCKET
3347     return pp_gnetent(ARGS);
3348 #else
3349     DIE(no_sock_func, "getnetbyaddr");
3350 #endif
3351 }
3352
3353 PP(pp_gnetent)
3354 {
3355     dSP;
3356 #ifdef HAS_SOCKET
3357     I32 which = op->op_type;
3358     register char **elem;
3359     register SV *sv;
3360     struct netent *getnetbyname();
3361     struct netent *getnetbyaddr();
3362     struct netent *getnetent();
3363     struct netent *nent;
3364
3365     if (which == OP_GNBYNAME)
3366         nent = getnetbyname(POPp);
3367     else if (which == OP_GNBYADDR) {
3368         int addrtype = POPi;
3369         unsigned long addr = U_L(POPn);
3370         nent = getnetbyaddr((long)addr, addrtype);
3371     }
3372     else
3373         nent = getnetent();
3374
3375     EXTEND(SP, 4);
3376     if (GIMME != G_ARRAY) {
3377         PUSHs(sv = sv_newmortal());
3378         if (nent) {
3379             if (which == OP_GNBYNAME)
3380                 sv_setiv(sv, (I32)nent->n_net);
3381             else
3382                 sv_setpv(sv, nent->n_name);
3383         }
3384         RETURN;
3385     }
3386
3387     if (nent) {
3388         PUSHs(sv = sv_mortalcopy(&sv_no));
3389         sv_setpv(sv, nent->n_name);
3390         PUSHs(sv = sv_mortalcopy(&sv_no));
3391         for (elem = nent->n_aliases; *elem; elem++) {
3392             sv_catpv(sv, *elem);
3393             if (elem[1])
3394                 sv_catpvn(sv, " ", 1);
3395         }
3396         PUSHs(sv = sv_mortalcopy(&sv_no));
3397         sv_setiv(sv, (I32)nent->n_addrtype);
3398         PUSHs(sv = sv_mortalcopy(&sv_no));
3399         sv_setiv(sv, (I32)nent->n_net);
3400     }
3401
3402     RETURN;
3403 #else
3404     DIE(no_sock_func, "getnetent");
3405 #endif
3406 }
3407
3408 PP(pp_gpbyname)
3409 {
3410 #ifdef HAS_SOCKET
3411     return pp_gprotoent(ARGS);
3412 #else
3413     DIE(no_sock_func, "getprotobyname");
3414 #endif
3415 }
3416
3417 PP(pp_gpbynumber)
3418 {
3419 #ifdef HAS_SOCKET
3420     return pp_gprotoent(ARGS);
3421 #else
3422     DIE(no_sock_func, "getprotobynumber");
3423 #endif
3424 }
3425
3426 PP(pp_gprotoent)
3427 {
3428     dSP;
3429 #ifdef HAS_SOCKET
3430     I32 which = op->op_type;
3431     register char **elem;
3432     register SV *sv;
3433     struct protoent *getprotobyname();
3434     struct protoent *getprotobynumber();
3435     struct protoent *getprotoent();
3436     struct protoent *pent;
3437
3438     if (which == OP_GPBYNAME)
3439         pent = getprotobyname(POPp);
3440     else if (which == OP_GPBYNUMBER)
3441         pent = getprotobynumber(POPi);
3442     else
3443         pent = getprotoent();
3444
3445     EXTEND(SP, 3);
3446     if (GIMME != G_ARRAY) {
3447         PUSHs(sv = sv_newmortal());
3448         if (pent) {
3449             if (which == OP_GPBYNAME)
3450                 sv_setiv(sv, (I32)pent->p_proto);
3451             else
3452                 sv_setpv(sv, pent->p_name);
3453         }
3454         RETURN;
3455     }
3456
3457     if (pent) {
3458         PUSHs(sv = sv_mortalcopy(&sv_no));
3459         sv_setpv(sv, pent->p_name);
3460         PUSHs(sv = sv_mortalcopy(&sv_no));
3461         for (elem = pent->p_aliases; *elem; elem++) {
3462             sv_catpv(sv, *elem);
3463             if (elem[1])
3464                 sv_catpvn(sv, " ", 1);
3465         }
3466         PUSHs(sv = sv_mortalcopy(&sv_no));
3467         sv_setiv(sv, (I32)pent->p_proto);
3468     }
3469
3470     RETURN;
3471 #else
3472     DIE(no_sock_func, "getprotoent");
3473 #endif
3474 }
3475
3476 PP(pp_gsbyname)
3477 {
3478 #ifdef HAS_SOCKET
3479     return pp_gservent(ARGS);
3480 #else
3481     DIE(no_sock_func, "getservbyname");
3482 #endif
3483 }
3484
3485 PP(pp_gsbyport)
3486 {
3487 #ifdef HAS_SOCKET
3488     return pp_gservent(ARGS);
3489 #else
3490     DIE(no_sock_func, "getservbyport");
3491 #endif
3492 }
3493
3494 PP(pp_gservent)
3495 {
3496     dSP;
3497 #ifdef HAS_SOCKET
3498     I32 which = op->op_type;
3499     register char **elem;
3500     register SV *sv;
3501     struct servent *getservbyname();
3502     struct servent *getservbynumber();
3503     struct servent *getservent();
3504     struct servent *sent;
3505
3506     if (which == OP_GSBYNAME) {
3507         char *proto = POPp;
3508         char *name = POPp;
3509
3510         if (proto && !*proto)
3511             proto = Nullch;
3512
3513         sent = getservbyname(name, proto);
3514     }
3515     else if (which == OP_GSBYPORT) {
3516         char *proto = POPp;
3517         int port = POPi;
3518
3519         sent = getservbyport(port, proto);
3520     }
3521     else
3522         sent = getservent();
3523
3524     EXTEND(SP, 4);
3525     if (GIMME != G_ARRAY) {
3526         PUSHs(sv = sv_newmortal());
3527         if (sent) {
3528             if (which == OP_GSBYNAME) {
3529 #ifdef HAS_NTOHS
3530                 sv_setiv(sv, (I32)ntohs(sent->s_port));
3531 #else
3532                 sv_setiv(sv, (I32)(sent->s_port));
3533 #endif
3534             }
3535             else
3536                 sv_setpv(sv, sent->s_name);
3537         }
3538         RETURN;
3539     }
3540
3541     if (sent) {
3542         PUSHs(sv = sv_mortalcopy(&sv_no));
3543         sv_setpv(sv, sent->s_name);
3544         PUSHs(sv = sv_mortalcopy(&sv_no));
3545         for (elem = sent->s_aliases; *elem; elem++) {
3546             sv_catpv(sv, *elem);
3547             if (elem[1])
3548                 sv_catpvn(sv, " ", 1);
3549         }
3550         PUSHs(sv = sv_mortalcopy(&sv_no));
3551 #ifdef HAS_NTOHS
3552         sv_setiv(sv, (I32)ntohs(sent->s_port));
3553 #else
3554         sv_setiv(sv, (I32)(sent->s_port));
3555 #endif
3556         PUSHs(sv = sv_mortalcopy(&sv_no));
3557         sv_setpv(sv, sent->s_proto);
3558     }
3559
3560     RETURN;
3561 #else
3562     DIE(no_sock_func, "getservent");
3563 #endif
3564 }
3565
3566 PP(pp_shostent)
3567 {
3568     dSP;
3569 #ifdef HAS_SOCKET
3570     sethostent(TOPi);
3571     RETSETYES;
3572 #else
3573     DIE(no_sock_func, "sethostent");
3574 #endif
3575 }
3576
3577 PP(pp_snetent)
3578 {
3579     dSP;
3580 #ifdef HAS_SOCKET
3581     setnetent(TOPi);
3582     RETSETYES;
3583 #else
3584     DIE(no_sock_func, "setnetent");
3585 #endif
3586 }
3587
3588 PP(pp_sprotoent)
3589 {
3590     dSP;
3591 #ifdef HAS_SOCKET
3592     setprotoent(TOPi);
3593     RETSETYES;
3594 #else
3595     DIE(no_sock_func, "setprotoent");
3596 #endif
3597 }
3598
3599 PP(pp_sservent)
3600 {
3601     dSP;
3602 #ifdef HAS_SOCKET
3603     setservent(TOPi);
3604     RETSETYES;
3605 #else
3606     DIE(no_sock_func, "setservent");
3607 #endif
3608 }
3609
3610 PP(pp_ehostent)
3611 {
3612     dSP;
3613 #ifdef HAS_SOCKET
3614     endhostent();
3615     EXTEND(sp,1);
3616     RETPUSHYES;
3617 #else
3618     DIE(no_sock_func, "endhostent");
3619 #endif
3620 }
3621
3622 PP(pp_enetent)
3623 {
3624     dSP;
3625 #ifdef HAS_SOCKET
3626     endnetent();
3627     EXTEND(sp,1);
3628     RETPUSHYES;
3629 #else
3630     DIE(no_sock_func, "endnetent");
3631 #endif
3632 }
3633
3634 PP(pp_eprotoent)
3635 {
3636     dSP;
3637 #ifdef HAS_SOCKET
3638     endprotoent();
3639     EXTEND(sp,1);
3640     RETPUSHYES;
3641 #else
3642     DIE(no_sock_func, "endprotoent");
3643 #endif
3644 }
3645
3646 PP(pp_eservent)
3647 {
3648     dSP;
3649 #ifdef HAS_SOCKET
3650     endservent();
3651     EXTEND(sp,1);
3652     RETPUSHYES;
3653 #else
3654     DIE(no_sock_func, "endservent");
3655 #endif
3656 }
3657
3658 PP(pp_gpwnam)
3659 {
3660 #ifdef HAS_PASSWD
3661     return pp_gpwent(ARGS);
3662 #else
3663     DIE(no_func, "getpwnam");
3664 #endif
3665 }
3666
3667 PP(pp_gpwuid)
3668 {
3669 #ifdef HAS_PASSWD
3670     return pp_gpwent(ARGS);
3671 #else
3672     DIE(no_func, "getpwuid");
3673 #endif
3674 }
3675
3676 PP(pp_gpwent)
3677 {
3678     dSP;
3679 #ifdef HAS_PASSWD
3680     I32 which = op->op_type;
3681     register SV *sv;
3682     struct passwd *pwent;
3683
3684     if (which == OP_GPWNAM)
3685         pwent = getpwnam(POPp);
3686     else if (which == OP_GPWUID)
3687         pwent = getpwuid(POPi);
3688     else
3689         pwent = (struct passwd *)getpwent();
3690
3691     EXTEND(SP, 10);
3692     if (GIMME != G_ARRAY) {
3693         PUSHs(sv = sv_newmortal());
3694         if (pwent) {
3695             if (which == OP_GPWNAM)
3696                 sv_setiv(sv, (I32)pwent->pw_uid);
3697             else
3698                 sv_setpv(sv, pwent->pw_name);
3699         }
3700         RETURN;
3701     }
3702
3703     if (pwent) {
3704         PUSHs(sv = sv_mortalcopy(&sv_no));
3705         sv_setpv(sv, pwent->pw_name);
3706         PUSHs(sv = sv_mortalcopy(&sv_no));
3707         sv_setpv(sv, pwent->pw_passwd);
3708         PUSHs(sv = sv_mortalcopy(&sv_no));
3709         sv_setiv(sv, (I32)pwent->pw_uid);
3710         PUSHs(sv = sv_mortalcopy(&sv_no));
3711         sv_setiv(sv, (I32)pwent->pw_gid);
3712         PUSHs(sv = sv_mortalcopy(&sv_no));
3713 #ifdef PWCHANGE
3714         sv_setiv(sv, (I32)pwent->pw_change);
3715 #else
3716 #ifdef PWQUOTA
3717         sv_setiv(sv, (I32)pwent->pw_quota);
3718 #else
3719 #ifdef PWAGE
3720         sv_setpv(sv, pwent->pw_age);
3721 #endif
3722 #endif
3723 #endif
3724         PUSHs(sv = sv_mortalcopy(&sv_no));
3725 #ifdef PWCLASS
3726         sv_setpv(sv, pwent->pw_class);
3727 #else
3728 #ifdef PWCOMMENT
3729         sv_setpv(sv, pwent->pw_comment);
3730 #endif
3731 #endif
3732         PUSHs(sv = sv_mortalcopy(&sv_no));
3733         sv_setpv(sv, pwent->pw_gecos);
3734         PUSHs(sv = sv_mortalcopy(&sv_no));
3735         sv_setpv(sv, pwent->pw_dir);
3736         PUSHs(sv = sv_mortalcopy(&sv_no));
3737         sv_setpv(sv, pwent->pw_shell);
3738 #ifdef PWEXPIRE
3739         PUSHs(sv = sv_mortalcopy(&sv_no));
3740         sv_setiv(sv, (I32)pwent->pw_expire);
3741 #endif
3742     }
3743     RETURN;
3744 #else
3745     DIE(no_func, "getpwent");
3746 #endif
3747 }
3748
3749 PP(pp_spwent)
3750 {
3751     dSP;
3752 #ifdef HAS_PASSWD
3753     setpwent();
3754     RETPUSHYES;
3755 #else
3756     DIE(no_func, "setpwent");
3757 #endif
3758 }
3759
3760 PP(pp_epwent)
3761 {
3762     dSP;
3763 #ifdef HAS_PASSWD
3764     endpwent();
3765     RETPUSHYES;
3766 #else
3767     DIE(no_func, "endpwent");
3768 #endif
3769 }
3770
3771 PP(pp_ggrnam)
3772 {
3773 #ifdef HAS_GROUP
3774     return pp_ggrent(ARGS);
3775 #else
3776     DIE(no_func, "getgrnam");
3777 #endif
3778 }
3779
3780 PP(pp_ggrgid)
3781 {
3782 #ifdef HAS_GROUP
3783     return pp_ggrent(ARGS);
3784 #else
3785     DIE(no_func, "getgrgid");
3786 #endif
3787 }
3788
3789 PP(pp_ggrent)
3790 {
3791     dSP;
3792 #ifdef HAS_GROUP
3793     I32 which = op->op_type;
3794     register char **elem;
3795     register SV *sv;
3796     struct group *grent;
3797
3798     if (which == OP_GGRNAM)
3799         grent = (struct group *)getgrnam(POPp);
3800     else if (which == OP_GGRGID)
3801         grent = (struct group *)getgrgid(POPi);
3802     else
3803         grent = (struct group *)getgrent();
3804
3805     EXTEND(SP, 4);
3806     if (GIMME != G_ARRAY) {
3807         PUSHs(sv = sv_newmortal());
3808         if (grent) {
3809             if (which == OP_GGRNAM)
3810                 sv_setiv(sv, (I32)grent->gr_gid);
3811             else
3812                 sv_setpv(sv, grent->gr_name);
3813         }
3814         RETURN;
3815     }
3816
3817     if (grent) {
3818         PUSHs(sv = sv_mortalcopy(&sv_no));
3819         sv_setpv(sv, grent->gr_name);
3820         PUSHs(sv = sv_mortalcopy(&sv_no));
3821         sv_setpv(sv, grent->gr_passwd);
3822         PUSHs(sv = sv_mortalcopy(&sv_no));
3823         sv_setiv(sv, (I32)grent->gr_gid);
3824         PUSHs(sv = sv_mortalcopy(&sv_no));
3825         for (elem = grent->gr_mem; *elem; elem++) {
3826             sv_catpv(sv, *elem);
3827             if (elem[1])
3828                 sv_catpvn(sv, " ", 1);
3829         }
3830     }
3831
3832     RETURN;
3833 #else
3834     DIE(no_func, "getgrent");
3835 #endif
3836 }
3837
3838 PP(pp_sgrent)
3839 {
3840     dSP;
3841 #ifdef HAS_GROUP
3842     setgrent();
3843     RETPUSHYES;
3844 #else
3845     DIE(no_func, "setgrent");
3846 #endif
3847 }
3848
3849 PP(pp_egrent)
3850 {
3851     dSP;
3852 #ifdef HAS_GROUP
3853     endgrent();
3854     RETPUSHYES;
3855 #else
3856     DIE(no_func, "endgrent");
3857 #endif
3858 }
3859
3860 PP(pp_getlogin)
3861 {
3862     dSP; dTARGET;
3863 #ifdef HAS_GETLOGIN
3864     char *tmps;
3865     EXTEND(SP, 1);
3866     if (!(tmps = getlogin()))
3867         RETPUSHUNDEF;
3868     PUSHp(tmps, strlen(tmps));
3869     RETURN;
3870 #else
3871     DIE(no_func, "getlogin");
3872 #endif
3873 }
3874
3875 /* Miscellaneous. */
3876
3877 PP(pp_syscall)
3878 {
3879 #ifdef HAS_SYSCALL
3880     dSP; dMARK; dORIGMARK; dTARGET;
3881     register I32 items = SP - MARK;
3882     unsigned long a[20];
3883     register I32 i = 0;
3884     I32 retval = -1;
3885     MAGIC *mg;
3886
3887     if (tainting) {
3888         while (++MARK <= SP) {
3889             if (SvGMAGICAL(*MARK) && SvSMAGICAL(*MARK) &&
3890               (mg = mg_find(*MARK, 't')) && mg->mg_len & 1)
3891                 tainted = TRUE;
3892         }
3893         MARK = ORIGMARK;
3894         TAINT_PROPER("syscall");
3895     }
3896
3897     /* This probably won't work on machines where sizeof(long) != sizeof(int)
3898      * or where sizeof(long) != sizeof(char*).  But such machines will
3899      * not likely have syscall implemented either, so who cares?
3900      */
3901     while (++MARK <= SP) {
3902         if (SvNIOK(*MARK) || !i)
3903             a[i++] = SvIV(*MARK);
3904         else if (*MARK == &sv_undef)
3905             a[i++] = 0;
3906         else 
3907             a[i++] = (unsigned long)SvPV_force(*MARK, na);
3908         if (i > 15)
3909             break;
3910     }
3911     switch (items) {
3912     default:
3913         DIE("Too many args to syscall");
3914     case 0:
3915         DIE("Too few args to syscall");
3916     case 1:
3917         retval = syscall(a[0]);
3918         break;
3919     case 2:
3920         retval = syscall(a[0],a[1]);
3921         break;
3922     case 3:
3923         retval = syscall(a[0],a[1],a[2]);
3924         break;
3925     case 4:
3926         retval = syscall(a[0],a[1],a[2],a[3]);
3927         break;
3928     case 5:
3929         retval = syscall(a[0],a[1],a[2],a[3],a[4]);
3930         break;
3931     case 6:
3932         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
3933         break;
3934     case 7:
3935         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
3936         break;
3937     case 8:
3938         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
3939         break;
3940 #ifdef atarist
3941     case 9:
3942         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);
3943         break;
3944     case 10:
3945         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);
3946         break;
3947     case 11:
3948         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
3949           a[10]);
3950         break;
3951     case 12:
3952         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
3953           a[10],a[11]);
3954         break;
3955     case 13:
3956         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
3957           a[10],a[11],a[12]);
3958         break;
3959     case 14:
3960         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
3961           a[10],a[11],a[12],a[13]);
3962         break;
3963 #endif /* atarist */
3964     }
3965     SP = ORIGMARK;
3966     PUSHi(retval);
3967     RETURN;
3968 #else
3969     DIE(no_func, "syscall");
3970 #endif
3971 }
3972
3973 #if !defined(HAS_FLOCK) && defined(HAS_LOCKF)
3974
3975 /*  XXX Emulate flock() with lockf().  This is just to increase
3976     portability of scripts.  The calls are not completely
3977     interchangeable.  What's really needed is a good file
3978     locking module.
3979 */
3980
3981 /*  We might need <unistd.h> because it sometimes defines the lockf()
3982     constants.  Unfortunately, <unistd.h> causes troubles on some mixed
3983     (BSD/POSIX) systems, such as SunOS 4.1.3.  We could just try including
3984     <unistd.h> here in this part of the file, but that might
3985     conflict with various other #defines and includes above, such as
3986         #define vfork fork above.
3987
3988    Further, the lockf() constants aren't POSIX, so they might not be
3989    visible if we're compiling with _POSIX_SOURCE defined.  Thus, we'll
3990    just stick in the SVID values and be done with it.  Sigh.
3991 */
3992
3993 # ifndef F_ULOCK
3994 #  define F_ULOCK       0       /* Unlock a previously locked region */
3995 # endif
3996 # ifndef F_LOCK
3997 #  define F_LOCK        1       /* Lock a region for exclusive use */
3998 # endif
3999 # ifndef F_TLOCK
4000 #  define F_TLOCK       2       /* Test and lock a region for exclusive use */
4001 # endif
4002 # ifndef F_TEST
4003 #  define F_TEST        3       /* Test a region for other processes locks */
4004 # endif
4005
4006 /* These are the flock() constants.  Since this sytems doesn't have
4007    flock(), the values of the constants are probably not available.
4008 */
4009 # ifndef LOCK_SH
4010 #  define LOCK_SH 1
4011 # endif
4012 # ifndef LOCK_EX
4013 #  define LOCK_EX 2
4014 # endif
4015 # ifndef LOCK_NB
4016 #  define LOCK_NB 4
4017 # endif
4018 # ifndef LOCK_UN
4019 #  define LOCK_UN 8
4020 # endif
4021
4022 int
4023 lockf_emulate_flock (fd, operation)
4024 int fd;
4025 int operation;
4026 {
4027     int i;
4028     switch (operation) {
4029
4030         /* LOCK_SH - get a shared lock */
4031         case LOCK_SH:
4032         /* LOCK_EX - get an exclusive lock */
4033         case LOCK_EX:
4034             i = lockf (fd, F_LOCK, 0);
4035             break;
4036
4037         /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
4038         case LOCK_SH|LOCK_NB:
4039         /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
4040         case LOCK_EX|LOCK_NB:
4041             i = lockf (fd, F_TLOCK, 0);
4042             if (i == -1)
4043                 if ((errno == EAGAIN) || (errno == EACCES))
4044                     errno = EWOULDBLOCK;
4045             break;
4046
4047         /* LOCK_UN - unlock */
4048         case LOCK_UN:
4049             i = lockf (fd, F_ULOCK, 0);
4050             break;
4051
4052         /* Default - can't decipher operation */
4053         default:
4054             i = -1;
4055             errno = EINVAL;
4056             break;
4057     }
4058     return (i);
4059 }
4060 #endif