perl 5.0 alpha 6
[perl.git] / POSIX.c
1 #include "EXTERN.h"
2 #include "perl.h"
3 #include "XSUB.h"
4 #include <sys/utsname.h>
5
6 #define HAS_UNAME
7
8 #ifndef HAS_GETPGRP
9 #define getpgrp(a,b) not_here("getpgrp")
10 #endif
11 #ifndef HAS_NICE
12 #define nice(a) not_here("nice")
13 #endif
14 #ifndef HAS_READLINK
15 #define readlink(a,b,c) not_here("readlink")
16 #endif
17 #ifndef HAS_SETPGID
18 #define setpgid(a,b) not_here("setpgid")
19 #endif
20 #ifndef HAS_SETPGRP
21 #define setpgrp(a,b) not_here("setpgrp")
22 #endif
23 #ifndef HAS_SETSID
24 #define setsid() not_here("setsid")
25 #endif
26 #ifndef HAS_SYMLINK
27 #define symlink(a,b) not_here("symlink")
28 #endif
29 #ifndef HAS_TCGETPGRP
30 #define tcgetpgrp(a) not_here("tcgetpgrp")
31 #endif
32 #ifndef HAS_TCSETPGRP
33 #define tcsetpgrp(a,b) not_here("tcsetpgrp")
34 #endif
35 #ifndef HAS_TIMES
36 #define times(a) not_here("times")
37 #endif
38 #ifndef HAS_UNAME
39 #define uname(a) not_here("uname")
40 #endif
41 #ifndef HAS_WAITPID
42 #define waitpid(a,b,c) not_here("waitpid")
43 #endif
44
45 static int
46 not_here(s)
47 char *s;
48 {
49     croak("POSIX::%s not implemented on this architecture", s);
50     return -1;
51 }
52
53 static int
54 XS_POSIX__exit(ix, ax, items)
55 register int ix;
56 register int ax;
57 register int items;
58 {
59     if (items != 1) {
60         croak("Usage: POSIX::_exit(status)");
61     }
62     {
63         int     status = (int)SvIV(ST(1));
64
65         _exit(status);
66     }
67     return ax;
68 }
69
70 static int
71 XS_POSIX_chdir(ix, ax, items)
72 register int ix;
73 register int ax;
74 register int items;
75 {
76     if (items != 1) {
77         croak("Usage: POSIX::chdir(path)");
78     }
79     {
80         char *  path = SvPV(ST(1),na);
81         int     RETVAL;
82
83         RETVAL = chdir(path);
84         ST(0) = sv_newmortal();
85         sv_setiv(ST(0), (I32)RETVAL);
86     }
87     return ax;
88 }
89
90 static int
91 XS_POSIX_chmod(ix, ax, items)
92 register int ix;
93 register int ax;
94 register int items;
95 {
96     if (items != 2) {
97         croak("Usage: POSIX::chmod(path, mode)");
98     }
99     {
100         char *  path = SvPV(ST(1),na);
101         mode_t  mode = (int)SvIV(ST(2));
102         int     RETVAL;
103
104         RETVAL = chmod(path, mode);
105         ST(0) = sv_newmortal();
106         sv_setiv(ST(0), (I32)RETVAL);
107     }
108     return ax;
109 }
110
111 static int
112 XS_POSIX_close(ix, ax, items)
113 register int ix;
114 register int ax;
115 register int items;
116 {
117     if (items != 1) {
118         croak("Usage: POSIX::close(fd)");
119     }
120     {
121         int     fd = (int)SvIV(ST(1));
122         int     RETVAL;
123
124         RETVAL = close(fd);
125         ST(0) = sv_newmortal();
126         sv_setiv(ST(0), (I32)RETVAL);
127     }
128     return ax;
129 }
130
131 static int
132 XS_POSIX_dup(ix, ax, items)
133 register int ix;
134 register int ax;
135 register int items;
136 {
137     if (items != 1) {
138         croak("Usage: POSIX::dup(fd)");
139     }
140     {
141         int     fd = (int)SvIV(ST(1));
142         int     RETVAL;
143
144         RETVAL = dup(fd);
145         ST(0) = sv_newmortal();
146         sv_setiv(ST(0), (I32)RETVAL);
147     }
148     return ax;
149 }
150
151 static int
152 XS_POSIX_dup2(ix, ax, items)
153 register int ix;
154 register int ax;
155 register int items;
156 {
157     if (items != 2) {
158         croak("Usage: POSIX::dup2(fd1, fd2)");
159     }
160     {
161         int     fd1 = (int)SvIV(ST(1));
162         int     fd2 = (int)SvIV(ST(2));
163         int     RETVAL;
164
165         RETVAL = dup2(fd1, fd2);
166         ST(0) = sv_newmortal();
167         sv_setiv(ST(0), (I32)RETVAL);
168     }
169     return ax;
170 }
171
172 static int
173 XS_POSIX_fdopen(ix, ax, items)
174 register int ix;
175 register int ax;
176 register int items;
177 {
178     if (items != 2) {
179         croak("Usage: POSIX::fdopen(fd, type)");
180     }
181     {
182         int     fd = (int)SvIV(ST(1));
183         char *  type = SvPV(ST(2),na);
184         FILE *  RETVAL;
185
186         RETVAL = fdopen(fd, type);
187         ST(0) = sv_newmortal();
188         sv_setnv(ST(0), (double)(unsigned long)RETVAL);
189     }
190     return ax;
191 }
192
193 static int
194 XS_POSIX_fstat(ix, ax, items)
195 register int ix;
196 register int ax;
197 register int items;
198 {
199     if (items != 2) {
200         croak("Usage: POSIX::fstat(fd, buf)");
201     }
202     {
203         int     fd = (int)SvIV(ST(1));
204         struct stat * buf = (struct stat*)sv_grow(ST(2),sizeof(struct stat));
205         int     RETVAL;
206
207         RETVAL = fstat(fd, buf);
208         ST(0) = sv_newmortal();
209         sv_setiv(ST(0), (I32)RETVAL);
210         SvCUR(ST(2)) = sizeof(struct stat);
211     }
212     return ax;
213 }
214
215 static int
216 XS_POSIX_getpgrp(ix, ax, items)
217 register int ix;
218 register int ax;
219 register int items;
220 {
221     if (items != 1) {
222         croak("Usage: POSIX::getpgrp(pid)");
223     }
224     {
225         int     pid = (int)SvIV(ST(1));
226         int     RETVAL;
227
228         RETVAL = getpgrp(pid);
229         ST(0) = sv_newmortal();
230         sv_setiv(ST(0), (I32)RETVAL);
231     }
232     return ax;
233 }
234
235 static int
236 XS_POSIX_link(ix, ax, items)
237 register int ix;
238 register int ax;
239 register int items;
240 {
241     if (items != 0) {
242         croak("Usage: POSIX::link()");
243     }
244     {
245         int     RETVAL;
246
247         RETVAL = link();
248         ST(0) = sv_newmortal();
249         sv_setiv(ST(0), (I32)RETVAL);
250     }
251     return ax;
252 }
253
254 static int
255 XS_POSIX_lseek(ix, ax, items)
256 register int ix;
257 register int ax;
258 register int items;
259 {
260     if (items != 0) {
261         croak("Usage: POSIX::lseek()");
262     }
263     {
264         int     RETVAL;
265
266         RETVAL = lseek();
267         ST(0) = sv_newmortal();
268         sv_setiv(ST(0), (I32)RETVAL);
269     }
270     return ax;
271 }
272
273 static int
274 XS_POSIX_lstat(ix, ax, items)
275 register int ix;
276 register int ax;
277 register int items;
278 {
279     if (items != 0) {
280         croak("Usage: POSIX::lstat()");
281     }
282     {
283         int     RETVAL;
284
285         RETVAL = lstat();
286         ST(0) = sv_newmortal();
287         sv_setiv(ST(0), (I32)RETVAL);
288     }
289     return ax;
290 }
291
292 static int
293 XS_POSIX_mkdir(ix, ax, items)
294 register int ix;
295 register int ax;
296 register int items;
297 {
298     if (items != 0) {
299         croak("Usage: POSIX::mkdir()");
300     }
301     {
302         int     RETVAL;
303
304         RETVAL = mkdir();
305         ST(0) = sv_newmortal();
306         sv_setiv(ST(0), (I32)RETVAL);
307     }
308     return ax;
309 }
310
311 static int
312 XS_POSIX_nice(ix, ax, items)
313 register int ix;
314 register int ax;
315 register int items;
316 {
317     if (items != 1) {
318         croak("Usage: POSIX::nice(incr)");
319     }
320     {
321         int     incr = (int)SvIV(ST(1));
322         int     RETVAL;
323
324         RETVAL = nice(incr);
325         ST(0) = sv_newmortal();
326         sv_setiv(ST(0), (I32)RETVAL);
327     }
328     return ax;
329 }
330
331 static int
332 XS_POSIX_open(ix, ax, items)
333 register int ix;
334 register int ax;
335 register int items;
336 {
337     if (items != 0) {
338         croak("Usage: POSIX::open()");
339     }
340     {
341         int     RETVAL;
342
343         RETVAL = open();
344         ST(0) = sv_newmortal();
345         sv_setiv(ST(0), (I32)RETVAL);
346     }
347     return ax;
348 }
349
350 static int
351 XS_POSIX_pipe(ix, ax, items)
352 register int ix;
353 register int ax;
354 register int items;
355 {
356     if (items != 0) {
357         croak("Usage: POSIX::pipe()");
358     }
359     {
360         int     RETVAL;
361
362         RETVAL = pipe();
363         ST(0) = sv_newmortal();
364         sv_setiv(ST(0), (I32)RETVAL);
365     }
366     return ax;
367 }
368
369 static int
370 XS_POSIX_read(ix, ax, items)
371 register int ix;
372 register int ax;
373 register int items;
374 {
375     if (items != 0) {
376         croak("Usage: POSIX::read()");
377     }
378     {
379         int     RETVAL;
380
381         RETVAL = read();
382         ST(0) = sv_newmortal();
383         sv_setiv(ST(0), (I32)RETVAL);
384     }
385     return ax;
386 }
387
388 static int
389 XS_POSIX_readlink(ix, ax, items)
390 register int ix;
391 register int ax;
392 register int items;
393 {
394     if (items != 3) {
395         croak("Usage: POSIX::readlink(path, buf, bufsiz)");
396     }
397     {
398         char *  path = SvPV(ST(1),na);
399         char * buf = sv_grow(ST(2), SvIV(ST(3)));
400         int     bufsiz = (int)SvIV(ST(3));
401         int     RETVAL;
402
403         RETVAL = readlink(path, buf, bufsiz);
404         ST(0) = sv_newmortal();
405         sv_setiv(ST(0), (I32)RETVAL);
406     }
407     return ax;
408 }
409
410 static int
411 XS_POSIX_rename(ix, ax, items)
412 register int ix;
413 register int ax;
414 register int items;
415 {
416     if (items != 0) {
417         croak("Usage: POSIX::rename()");
418     }
419     {
420         int     RETVAL;
421
422         RETVAL = rename();
423         ST(0) = sv_newmortal();
424         sv_setiv(ST(0), (I32)RETVAL);
425     }
426     return ax;
427 }
428
429 static int
430 XS_POSIX_rmdir(ix, ax, items)
431 register int ix;
432 register int ax;
433 register int items;
434 {
435     if (items != 0) {
436         croak("Usage: POSIX::rmdir()");
437     }
438     {
439         int     RETVAL;
440
441         RETVAL = rmdir();
442         ST(0) = sv_newmortal();
443         sv_setiv(ST(0), (I32)RETVAL);
444     }
445     return ax;
446 }
447
448 static int
449 XS_POSIX_setgid(ix, ax, items)
450 register int ix;
451 register int ax;
452 register int items;
453 {
454     if (items != 0) {
455         croak("Usage: POSIX::setgid()");
456     }
457     {
458         int     RETVAL;
459
460         RETVAL = setgid();
461         ST(0) = sv_newmortal();
462         sv_setiv(ST(0), (I32)RETVAL);
463     }
464     return ax;
465 }
466
467 static int
468 XS_POSIX_setpgid(ix, ax, items)
469 register int ix;
470 register int ax;
471 register int items;
472 {
473     if (items != 2) {
474         croak("Usage: POSIX::setpgid(pid, pgid)");
475     }
476     {
477         pid_t   pid = (int)SvIV(ST(1));
478         pid_t   pgid = (int)SvIV(ST(2));
479         int     RETVAL;
480
481         RETVAL = setpgid(pid, pgid);
482         ST(0) = sv_newmortal();
483         sv_setiv(ST(0), (I32)RETVAL);
484     }
485     return ax;
486 }
487
488 static int
489 XS_POSIX_setpgrp(ix, ax, items)
490 register int ix;
491 register int ax;
492 register int items;
493 {
494     if (items != 2) {
495         croak("Usage: POSIX::setpgrp(pid, pgrp)");
496     }
497     {
498         int     pid = (int)SvIV(ST(1));
499         int     pgrp = (int)SvIV(ST(2));
500         int     RETVAL;
501
502         RETVAL = setpgrp(pid, pgrp);
503         ST(0) = sv_newmortal();
504         sv_setiv(ST(0), (I32)RETVAL);
505     }
506     return ax;
507 }
508
509 static int
510 XS_POSIX_setsid(ix, ax, items)
511 register int ix;
512 register int ax;
513 register int items;
514 {
515     if (items != 0) {
516         croak("Usage: POSIX::setsid()");
517     }
518     {
519         pid_t   RETVAL;
520
521         RETVAL = setsid();
522         ST(0) = sv_newmortal();
523         sv_setiv(ST(0), (I32)RETVAL);
524     }
525     return ax;
526 }
527
528 static int
529 XS_POSIX_setuid(ix, ax, items)
530 register int ix;
531 register int ax;
532 register int items;
533 {
534     if (items != 0) {
535         croak("Usage: POSIX::setuid()");
536     }
537     {
538         int     RETVAL;
539
540         RETVAL = setuid();
541         ST(0) = sv_newmortal();
542         sv_setiv(ST(0), (I32)RETVAL);
543     }
544     return ax;
545 }
546
547 static int
548 XS_POSIX_stat(ix, ax, items)
549 register int ix;
550 register int ax;
551 register int items;
552 {
553     if (items != 0) {
554         croak("Usage: POSIX::stat()");
555     }
556     {
557         int     RETVAL;
558
559         RETVAL = stat();
560         ST(0) = sv_newmortal();
561         sv_setiv(ST(0), (I32)RETVAL);
562     }
563     return ax;
564 }
565
566 static int
567 XS_POSIX_symlink(ix, ax, items)
568 register int ix;
569 register int ax;
570 register int items;
571 {
572     if (items != 0) {
573         croak("Usage: POSIX::symlink()");
574     }
575     {
576         int     RETVAL;
577
578         RETVAL = symlink();
579         ST(0) = sv_newmortal();
580         sv_setiv(ST(0), (I32)RETVAL);
581     }
582     return ax;
583 }
584
585 static int
586 XS_POSIX_system(ix, ax, items)
587 register int ix;
588 register int ax;
589 register int items;
590 {
591     if (items != 0) {
592         croak("Usage: POSIX::system()");
593     }
594     {
595         int     RETVAL;
596
597         RETVAL = system();
598         ST(0) = sv_newmortal();
599         sv_setiv(ST(0), (I32)RETVAL);
600     }
601     return ax;
602 }
603
604 static int
605 XS_POSIX_tcgetpgrp(ix, ax, items)
606 register int ix;
607 register int ax;
608 register int items;
609 {
610     if (items != 1) {
611         croak("Usage: POSIX::tcgetpgrp(fd)");
612     }
613     {
614         int     fd = (int)SvIV(ST(1));
615         pid_t   RETVAL;
616
617         RETVAL = tcgetpgrp(fd);
618         ST(0) = sv_newmortal();
619         sv_setiv(ST(0), (I32)RETVAL);
620     }
621     return ax;
622 }
623
624 static int
625 XS_POSIX_tcsetpgrp(ix, ax, items)
626 register int ix;
627 register int ax;
628 register int items;
629 {
630     if (items != 2) {
631         croak("Usage: POSIX::tcsetpgrp(fd, pgrp_id)");
632     }
633     {
634         int     fd = (int)SvIV(ST(1));
635         pid_t   pgrp_id = (int)SvIV(ST(2));
636         int     RETVAL;
637
638         RETVAL = tcsetpgrp(fd, pgrp_id);
639         ST(0) = sv_newmortal();
640         sv_setiv(ST(0), (I32)RETVAL);
641     }
642     return ax;
643 }
644
645 static int
646 XS_POSIX_times(ix, ax, items)
647 register int ix;
648 register int ax;
649 register int items;
650 {
651     if (items != 1) {
652         croak("Usage: POSIX::times(tms)");
653     }
654     {
655         struct tms * tms = (struct tms*)sv_grow(ST(1), sizeof(struct tms));
656         int     RETVAL;
657
658         RETVAL = times(tms);
659         ST(0) = sv_newmortal();
660         sv_setiv(ST(0), (I32)RETVAL);
661         SvCUR(ST(1)) = sizeof(struct tms);
662     }
663     return ax;
664 }
665
666 static int
667 XS_POSIX_umask(ix, ax, items)
668 register int ix;
669 register int ax;
670 register int items;
671 {
672     if (items != 0) {
673         croak("Usage: POSIX::umask()");
674     }
675     {
676         int     RETVAL;
677
678         RETVAL = umask();
679         ST(0) = sv_newmortal();
680         sv_setiv(ST(0), (I32)RETVAL);
681     }
682     return ax;
683 }
684
685 static int
686 XS_POSIX_uname(ix, ax, items)
687 register int ix;
688 register int ax;
689 register int items;
690 {
691     if (items != 0) {
692         croak("Usage: POSIX::uname()");
693     }
694     {
695         int     RETVAL;
696         dSP;
697         struct utsname utsname;
698         sp--;
699         if (uname(&utsname) >= 0) {
700             EXTEND(sp, 5);
701             PUSHs(sv_2mortal(newSVpv(utsname.sysname, 0)));
702             PUSHs(sv_2mortal(newSVpv(utsname.nodename, 0)));
703             PUSHs(sv_2mortal(newSVpv(utsname.release, 0)));
704             PUSHs(sv_2mortal(newSVpv(utsname.version, 0)));
705             PUSHs(sv_2mortal(newSVpv(utsname.machine, 0)));
706         }
707         return sp - stack_base;
708     }
709     return ax;
710 }
711
712 static int
713 XS_POSIX_unlink(ix, ax, items)
714 register int ix;
715 register int ax;
716 register int items;
717 {
718     if (items != 0) {
719         croak("Usage: POSIX::unlink()");
720     }
721     {
722         int     RETVAL;
723
724         RETVAL = unlink();
725         ST(0) = sv_newmortal();
726         sv_setiv(ST(0), (I32)RETVAL);
727     }
728     return ax;
729 }
730
731 static int
732 XS_POSIX_utime(ix, ax, items)
733 register int ix;
734 register int ax;
735 register int items;
736 {
737     if (items != 0) {
738         croak("Usage: POSIX::utime()");
739     }
740     {
741         int     RETVAL;
742
743         RETVAL = utime();
744         ST(0) = sv_newmortal();
745         sv_setiv(ST(0), (I32)RETVAL);
746     }
747     return ax;
748 }
749
750 static int
751 XS_POSIX_wait(ix, ax, items)
752 register int ix;
753 register int ax;
754 register int items;
755 {
756     if (items != 0) {
757         croak("Usage: POSIX::wait()");
758     }
759     {
760         int     RETVAL;
761
762         RETVAL = wait();
763         ST(0) = sv_newmortal();
764         sv_setiv(ST(0), (I32)RETVAL);
765     }
766     return ax;
767 }
768
769 static int
770 XS_POSIX_waitpid(ix, ax, items)
771 register int ix;
772 register int ax;
773 register int items;
774 {
775     if (items != 3) {
776         croak("Usage: POSIX::waitpid(pid, statusp, options)");
777     }
778     {
779         int     pid = (int)SvIV(ST(1));
780         int     statusp = (int)SvIV(ST(2));
781         int     options = (int)SvIV(ST(3));
782         int     RETVAL;
783
784         RETVAL = waitpid(pid, &statusp, options);
785         ST(0) = sv_newmortal();
786         sv_setiv(ST(0), (I32)RETVAL);
787         sv_setiv(ST(2), (I32)statusp);
788     }
789     return ax;
790 }
791
792 static int
793 XS_POSIX_write(ix, ax, items)
794 register int ix;
795 register int ax;
796 register int items;
797 {
798     if (items != 0) {
799         croak("Usage: POSIX::write()");
800     }
801     {
802         int     RETVAL;
803
804         RETVAL = write();
805         ST(0) = sv_newmortal();
806         sv_setiv(ST(0), (I32)RETVAL);
807     }
808     return ax;
809 }
810
811 int boot_POSIX(ix,ax,items)
812 int ix;
813 int ax;
814 int items;
815 {
816     char* file = __FILE__;
817
818     newXSUB("POSIX::_exit", 0, XS_POSIX__exit, file);
819     newXSUB("POSIX::chdir", 0, XS_POSIX_chdir, file);
820     newXSUB("POSIX::chmod", 0, XS_POSIX_chmod, file);
821     newXSUB("POSIX::close", 0, XS_POSIX_close, file);
822     newXSUB("POSIX::dup", 0, XS_POSIX_dup, file);
823     newXSUB("POSIX::dup2", 0, XS_POSIX_dup2, file);
824     newXSUB("POSIX::fdopen", 0, XS_POSIX_fdopen, file);
825     newXSUB("POSIX::fstat", 0, XS_POSIX_fstat, file);
826     newXSUB("POSIX::getpgrp", 0, XS_POSIX_getpgrp, file);
827     newXSUB("POSIX::link", 0, XS_POSIX_link, file);
828     newXSUB("POSIX::lseek", 0, XS_POSIX_lseek, file);
829     newXSUB("POSIX::lstat", 0, XS_POSIX_lstat, file);
830     newXSUB("POSIX::mkdir", 0, XS_POSIX_mkdir, file);
831     newXSUB("POSIX::nice", 0, XS_POSIX_nice, file);
832     newXSUB("POSIX::open", 0, XS_POSIX_open, file);
833     newXSUB("POSIX::pipe", 0, XS_POSIX_pipe, file);
834     newXSUB("POSIX::read", 0, XS_POSIX_read, file);
835     newXSUB("POSIX::readlink", 0, XS_POSIX_readlink, file);
836     newXSUB("POSIX::rename", 0, XS_POSIX_rename, file);
837     newXSUB("POSIX::rmdir", 0, XS_POSIX_rmdir, file);
838     newXSUB("POSIX::setgid", 0, XS_POSIX_setgid, file);
839     newXSUB("POSIX::setpgid", 0, XS_POSIX_setpgid, file);
840     newXSUB("POSIX::setpgrp", 0, XS_POSIX_setpgrp, file);
841     newXSUB("POSIX::setsid", 0, XS_POSIX_setsid, file);
842     newXSUB("POSIX::setuid", 0, XS_POSIX_setuid, file);
843     newXSUB("POSIX::stat", 0, XS_POSIX_stat, file);
844     newXSUB("POSIX::symlink", 0, XS_POSIX_symlink, file);
845     newXSUB("POSIX::system", 0, XS_POSIX_system, file);
846     newXSUB("POSIX::tcgetpgrp", 0, XS_POSIX_tcgetpgrp, file);
847     newXSUB("POSIX::tcsetpgrp", 0, XS_POSIX_tcsetpgrp, file);
848     newXSUB("POSIX::times", 0, XS_POSIX_times, file);
849     newXSUB("POSIX::umask", 0, XS_POSIX_umask, file);
850     newXSUB("POSIX::uname", 0, XS_POSIX_uname, file);
851     newXSUB("POSIX::unlink", 0, XS_POSIX_unlink, file);
852     newXSUB("POSIX::utime", 0, XS_POSIX_utime, file);
853     newXSUB("POSIX::wait", 0, XS_POSIX_wait, file);
854     newXSUB("POSIX::waitpid", 0, XS_POSIX_waitpid, file);
855     newXSUB("POSIX::write", 0, XS_POSIX_write, file);
856 }