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 }