[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/se3-unattended/var/se3/unattended/install/linuxaux/opt/perl/lib/5.10.0/i586-linux-thread-multi/CORE/ -> iperlsys.h (source)

   1  /*
   2   * iperlsys.h - Perl's interface to the system
   3   *
   4   * This file defines the system level functionality that perl needs.
   5   *
   6   * When using C, this definition is in the form of a set of macros
   7   * that can be #defined to the system-level function (or a wrapper
   8   * provided elsewhere).
   9   *
  10   * GSAR 21-JUN-98
  11   */
  12  
  13  #ifndef __Inc__IPerl___
  14  #define __Inc__IPerl___
  15  
  16  /*
  17   *    PerlXXX_YYY explained - DickH and DougL @ ActiveState.com
  18   *
  19   * XXX := functional group
  20   * YYY := stdlib/OS function name
  21   *
  22   * Continuing with the theme of PerlIO, all OS functionality was
  23   * encapsulated into one of several interfaces.
  24   *
  25   * PerlIO - stdio
  26   * PerlLIO - low level I/O
  27   * PerlMem - malloc, realloc, free
  28   * PerlDir - directory related
  29   * PerlEnv - process environment handling
  30   * PerlProc - process control
  31   * PerlSock - socket functions
  32   *
  33   *
  34   * The features of this are:
  35   * 1. All OS dependant code is in the Perl Host and not the Perl Core.
  36   *    (At least this is the holy grail goal of this work)
  37   * 2. The Perl Host (see perl.h for description) can provide a new and
  38   *    improved interface to OS functionality if required.
  39   * 3. Developers can easily hook into the OS calls for instrumentation
  40   *    or diagnostic purposes.
  41   *
  42   * What was changed to do this:
  43   * 1. All calls to OS functions were replaced with PerlXXX_YYY
  44   *
  45   */
  46  
  47  /*
  48      Interface for perl stdio functions, or whatever we are Configure-d
  49      to use.
  50  */
  51  #include "perlio.h"
  52  
  53  #ifndef Sighandler_t
  54  #  if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
  55  typedef Signal_t (*Sighandler_t) (int, siginfo_t*, void*);
  56  #  else
  57  typedef Signal_t (*Sighandler_t) (int);
  58  #  endif
  59  #endif
  60  
  61  #if defined(PERL_IMPLICIT_SYS)
  62  
  63  /* IPerlStdIO        */
  64  struct IPerlStdIO;
  65  struct IPerlStdIOInfo;
  66  typedef FILE*        (*LPStdin)(struct IPerlStdIO*);
  67  typedef FILE*        (*LPStdout)(struct IPerlStdIO*);
  68  typedef FILE*        (*LPStderr)(struct IPerlStdIO*);
  69  typedef FILE*        (*LPOpen)(struct IPerlStdIO*, const char*,
  70                  const char*);
  71  typedef int        (*LPClose)(struct IPerlStdIO*, FILE*);
  72  typedef int        (*LPEof)(struct IPerlStdIO*, FILE*);
  73  typedef int        (*LPError)(struct IPerlStdIO*, FILE*);
  74  typedef void        (*LPClearerr)(struct IPerlStdIO*, FILE*);
  75  typedef int        (*LPGetc)(struct IPerlStdIO*, FILE*);
  76  typedef char*        (*LPGetBase)(struct IPerlStdIO*, FILE*);
  77  typedef int        (*LPGetBufsiz)(struct IPerlStdIO*, FILE*);
  78  typedef int        (*LPGetCnt)(struct IPerlStdIO*, FILE*);
  79  typedef char*        (*LPGetPtr)(struct IPerlStdIO*, FILE*);
  80  typedef char*        (*LPGets)(struct IPerlStdIO*, FILE*, char*, int);
  81  typedef int        (*LPPutc)(struct IPerlStdIO*, FILE*, int);
  82  typedef int        (*LPPuts)(struct IPerlStdIO*, FILE*, const char*);
  83  typedef int        (*LPFlush)(struct IPerlStdIO*, FILE*);
  84  typedef int        (*LPUngetc)(struct IPerlStdIO*, int,FILE*);
  85  typedef int        (*LPFileno)(struct IPerlStdIO*, FILE*);
  86  typedef FILE*        (*LPFdopen)(struct IPerlStdIO*, int, const char*);
  87  typedef FILE*        (*LPReopen)(struct IPerlStdIO*, const char*,
  88                  const char*, FILE*);
  89  typedef SSize_t        (*LPRead)(struct IPerlStdIO*, void*, Size_t, Size_t, FILE *);
  90  typedef SSize_t        (*LPWrite)(struct IPerlStdIO*, const void*, Size_t, Size_t, FILE *);
  91  typedef void        (*LPSetBuf)(struct IPerlStdIO*, FILE*, char*);
  92  typedef int        (*LPSetVBuf)(struct IPerlStdIO*, FILE*, char*, int,
  93                  Size_t);
  94  typedef void        (*LPSetCnt)(struct IPerlStdIO*, FILE*, int);
  95  
  96  #ifndef NETWARE
  97  typedef void        (*LPSetPtr)(struct IPerlStdIO*, FILE*, char*);
  98  #elif defined(NETWARE)
  99  typedef void        (*LPSetPtr)(struct IPerlStdIO*, FILE*, char*, int);
 100  #endif
 101  
 102  typedef void        (*LPSetlinebuf)(struct IPerlStdIO*, FILE*);
 103  typedef int        (*LPPrintf)(struct IPerlStdIO*, FILE*, const char*,
 104                  ...);
 105  typedef int        (*LPVprintf)(struct IPerlStdIO*, FILE*, const char*,
 106                  va_list);
 107  typedef Off_t        (*LPTell)(struct IPerlStdIO*, FILE*);
 108  typedef int        (*LPSeek)(struct IPerlStdIO*, FILE*, Off_t, int);
 109  typedef void        (*LPRewind)(struct IPerlStdIO*, FILE*);
 110  typedef FILE*        (*LPTmpfile)(struct IPerlStdIO*);
 111  typedef int        (*LPGetpos)(struct IPerlStdIO*, FILE*, Fpos_t*);
 112  typedef int        (*LPSetpos)(struct IPerlStdIO*, FILE*,
 113                  const Fpos_t*);
 114  typedef void        (*LPInit)(struct IPerlStdIO*);
 115  typedef void        (*LPInitOSExtras)(struct IPerlStdIO*);
 116  typedef FILE*        (*LPFdupopen)(struct IPerlStdIO*, FILE*);
 117  
 118  struct IPerlStdIO
 119  {
 120      LPStdin        pStdin;
 121      LPStdout        pStdout;
 122      LPStderr        pStderr;
 123      LPOpen        pOpen;
 124      LPClose        pClose;
 125      LPEof        pEof;
 126      LPError        pError;
 127      LPClearerr        pClearerr;
 128      LPGetc        pGetc;
 129      LPGetBase        pGetBase;
 130      LPGetBufsiz        pGetBufsiz;
 131      LPGetCnt        pGetCnt;
 132      LPGetPtr        pGetPtr;
 133      LPGets        pGets;
 134      LPPutc        pPutc;
 135      LPPuts        pPuts;
 136      LPFlush        pFlush;
 137      LPUngetc        pUngetc;
 138      LPFileno        pFileno;
 139      LPFdopen        pFdopen;
 140      LPReopen        pReopen;
 141      LPRead        pRead;
 142      LPWrite        pWrite;
 143      LPSetBuf        pSetBuf;
 144      LPSetVBuf        pSetVBuf;
 145      LPSetCnt        pSetCnt;
 146      LPSetPtr        pSetPtr;
 147      LPSetlinebuf    pSetlinebuf;
 148      LPPrintf        pPrintf;
 149      LPVprintf        pVprintf;
 150      LPTell        pTell;
 151      LPSeek        pSeek;
 152      LPRewind        pRewind;
 153      LPTmpfile        pTmpfile;
 154      LPGetpos        pGetpos;
 155      LPSetpos        pSetpos;
 156      LPInit        pInit;
 157      LPInitOSExtras    pInitOSExtras;
 158      LPFdupopen        pFdupopen;
 159  };
 160  
 161  struct IPerlStdIOInfo
 162  {
 163      unsigned long    nCount;        /* number of entries expected */
 164      struct IPerlStdIO    perlStdIOList;
 165  };
 166  
 167  /* These do not belong here ... NI-S, 14 Nov 2000 */
 168  
 169  #ifdef USE_STDIO_PTR
 170  #  define PerlSIO_has_cntptr(f)        1
 171  #  ifdef STDIO_PTR_LVALUE
 172  #    ifdef  STDIO_CNT_LVALUE
 173  #      define PerlSIO_canset_cnt(f)    1
 174  #      ifdef STDIO_PTR_LVAL_NOCHANGE_CNT
 175  #        define PerlSIO_fast_gets(f)    1
 176  #      endif
 177  #    else /* STDIO_CNT_LVALUE */
 178  #      define PerlSIO_canset_cnt(f)    0
 179  #    endif
 180  #  else /* STDIO_PTR_LVALUE */
 181  #    ifdef STDIO_PTR_LVAL_SETS_CNT
 182  #      define PerlSIO_fast_gets(f)    1
 183  #    endif
 184  #  endif
 185  #else  /* USE_STDIO_PTR */
 186  #  define PerlSIO_has_cntptr(f)        0
 187  #  define PerlSIO_canset_cnt(f)        0
 188  #endif /* USE_STDIO_PTR */
 189  
 190  #ifndef PerlSIO_fast_gets
 191  #define PerlSIO_fast_gets(f)        0
 192  #endif
 193  
 194  #ifdef FILE_base
 195  #define PerlSIO_has_base(f)        1
 196  #else
 197  #define PerlSIO_has_base(f)        0
 198  #endif
 199  
 200  /* Now take FILE * via function table */
 201  
 202  #define PerlSIO_stdin                            \
 203      (*PL_StdIO->pStdin)(PL_StdIO)
 204  #define PerlSIO_stdout                            \
 205      (*PL_StdIO->pStdout)(PL_StdIO)
 206  #define PerlSIO_stderr                            \
 207      (*PL_StdIO->pStderr)(PL_StdIO)
 208  #define PerlSIO_fopen(x,y)                        \
 209      (*PL_StdIO->pOpen)(PL_StdIO, (x),(y))
 210  #define PerlSIO_fclose(f)                        \
 211      (*PL_StdIO->pClose)(PL_StdIO, (f))
 212  #define PerlSIO_feof(f)                            \
 213      (*PL_StdIO->pEof)(PL_StdIO, (f))
 214  #define PerlSIO_ferror(f)                        \
 215      (*PL_StdIO->pError)(PL_StdIO, (f))
 216  #define PerlSIO_clearerr(f)                        \
 217      (*PL_StdIO->pClearerr)(PL_StdIO, (f))
 218  #define PerlSIO_fgetc(f)                        \
 219      (*PL_StdIO->pGetc)(PL_StdIO, (f))
 220  #define PerlSIO_get_base(f)                        \
 221      (*PL_StdIO->pGetBase)(PL_StdIO, (f))
 222  #define PerlSIO_get_bufsiz(f)                        \
 223      (*PL_StdIO->pGetBufsiz)(PL_StdIO, (f))
 224  #define PerlSIO_get_cnt(f)                        \
 225      (*PL_StdIO->pGetCnt)(PL_StdIO, (f))
 226  #define PerlSIO_get_ptr(f)                        \
 227      (*PL_StdIO->pGetPtr)(PL_StdIO, (f))
 228  #define PerlSIO_fputc(f,c)                        \
 229      (*PL_StdIO->pPutc)(PL_StdIO, (f),(c))
 230  #define PerlSIO_fputs(f,s)                        \
 231      (*PL_StdIO->pPuts)(PL_StdIO, (f),(s))
 232  #define PerlSIO_fflush(f)                        \
 233      (*PL_StdIO->pFlush)(PL_StdIO, (f))
 234  #define PerlSIO_fgets(s, n, fp)                        \
 235      (*PL_StdIO->pGets)(PL_StdIO, (fp), s, n)
 236  #define PerlSIO_ungetc(c,f)                        \
 237      (*PL_StdIO->pUngetc)(PL_StdIO, (c),(f))
 238  #define PerlSIO_fileno(f)                        \
 239      (*PL_StdIO->pFileno)(PL_StdIO, (f))
 240  #define PerlSIO_fdopen(f, s)                        \
 241      (*PL_StdIO->pFdopen)(PL_StdIO, (f),(s))
 242  #define PerlSIO_freopen(p, m, f)                    \
 243      (*PL_StdIO->pReopen)(PL_StdIO, (p), (m), (f))
 244  #define PerlSIO_fread(buf,sz,count,f)                    \
 245      (*PL_StdIO->pRead)(PL_StdIO, (buf), (sz), (count), (f))
 246  #define PerlSIO_fwrite(buf,sz,count,f)                    \
 247      (*PL_StdIO->pWrite)(PL_StdIO, (buf), (sz), (count), (f))
 248  #define PerlSIO_setbuf(f,b)                        \
 249      (*PL_StdIO->pSetBuf)(PL_StdIO, (f), (b))
 250  #define PerlSIO_setvbuf(f,b,t,s)                    \
 251      (*PL_StdIO->pSetVBuf)(PL_StdIO, (f),(b),(t),(s))
 252  #define PerlSIO_set_cnt(f,c)                        \
 253      (*PL_StdIO->pSetCnt)(PL_StdIO, (f), (c))
 254  #define PerlSIO_set_ptr(f,p)                        \
 255      (*PL_StdIO->pSetPtr)(PL_StdIO, (f), (p))
 256  #define PerlSIO_setlinebuf(f)                        \
 257      (*PL_StdIO->pSetlinebuf)(PL_StdIO, (f))
 258  #define PerlSIO_printf        Perl_fprintf_nocontext
 259  #define PerlSIO_stdoutf        Perl_printf_nocontext
 260  #define PerlSIO_vprintf(f,fmt,a)                        \
 261      (*PL_StdIO->pVprintf)(PL_StdIO, (f),(fmt),a)
 262  #define PerlSIO_ftell(f)                            \
 263      (*PL_StdIO->pTell)(PL_StdIO, (f))
 264  #define PerlSIO_fseek(f,o,w)                        \
 265      (*PL_StdIO->pSeek)(PL_StdIO, (f),(o),(w))
 266  #define PerlSIO_fgetpos(f,p)                        \
 267      (*PL_StdIO->pGetpos)(PL_StdIO, (f),(p))
 268  #define PerlSIO_fsetpos(f,p)                        \
 269      (*PL_StdIO->pSetpos)(PL_StdIO, (f),(p))
 270  #define PerlSIO_rewind(f)                        \
 271      (*PL_StdIO->pRewind)(PL_StdIO, (f))
 272  #define PerlSIO_tmpfile()                        \
 273      (*PL_StdIO->pTmpfile)(PL_StdIO)
 274  #define PerlSIO_init()                            \
 275      (*PL_StdIO->pInit)(PL_StdIO)
 276  #undef     init_os_extras
 277  #define init_os_extras()                        \
 278      (*PL_StdIO->pInitOSExtras)(PL_StdIO)
 279  #define PerlSIO_fdupopen(f)                        \
 280      (*PL_StdIO->pFdupopen)(PL_StdIO, (f))
 281  
 282  #else    /* PERL_IMPLICIT_SYS */
 283  
 284  #define PerlSIO_stdin            stdin
 285  #define PerlSIO_stdout            stdout
 286  #define PerlSIO_stderr            stderr
 287  #define PerlSIO_fopen(x,y)        fopen(x,y)
 288  #ifdef __VOS__
 289  /* Work around VOS bug posix-979, wrongly setting errno when at end of file. */
 290  #define PerlSIO_fclose(f)        (((errno==1025)?errno=0:0),fclose(f))
 291  #define PerlSIO_feof(f)            (((errno==1025)?errno=0:0),feof(f))
 292  #define PerlSIO_ferror(f)        (((errno==1025)?errno=0:0),ferror(f))
 293  #else
 294  #define PerlSIO_fclose(f)        fclose(f)
 295  #define PerlSIO_feof(f)            feof(f)
 296  #define PerlSIO_ferror(f)        ferror(f)
 297  #endif
 298  #define PerlSIO_clearerr(f)        clearerr(f)
 299  #define PerlSIO_fgetc(f)            fgetc(f)
 300  #ifdef FILE_base
 301  #define PerlSIO_get_base(f)        FILE_base(f)
 302  #define PerlSIO_get_bufsiz(f)        FILE_bufsiz(f)
 303  #else
 304  #define PerlSIO_get_base(f)        NULL
 305  #define PerlSIO_get_bufsiz(f)        0
 306  #endif
 307  #ifdef USE_STDIO_PTR
 308  #define PerlSIO_get_cnt(f)        FILE_cnt(f)
 309  #define PerlSIO_get_ptr(f)        FILE_ptr(f)
 310  #else
 311  #define PerlSIO_get_cnt(f)        0
 312  #define PerlSIO_get_ptr(f)        NULL
 313  #endif
 314  #define PerlSIO_fputc(f,c)        fputc(c,f)
 315  #define PerlSIO_fputs(f,s)        fputs(s,f)
 316  #define PerlSIO_fflush(f)        Fflush(f)
 317  #define PerlSIO_fgets(s, n, fp)        fgets(s,n,fp)
 318  #if defined(VMS) && defined(__DECC)
 319       /* Unusual definition of ungetc() here to accomodate fast_sv_gets()'
 320        * belief that it can mix getc/ungetc with reads from stdio buffer */
 321       int decc$ungetc(int __c, FILE *__stream);
 322  #    define PerlSIO_ungetc(c,f) ((c) == EOF ? EOF : \
 323              ((*(f) && !((*(f))->_flag & _IONBF) && \
 324              ((*(f))->_ptr > (*(f))->_base)) ? \
 325              ((*(f))->_cnt++, *(--(*(f))->_ptr) = (c)) : decc$ungetc(c,f)))
 326  #else
 327  #  define PerlSIO_ungetc(c,f)          ungetc(c,f)
 328  #endif
 329  #define PerlSIO_fileno(f)        fileno(f)
 330  #define PerlSIO_fdopen(f, s)        fdopen(f,s)
 331  #define PerlSIO_freopen(p, m, f)    freopen(p,m,f)
 332  #define PerlSIO_fread(buf,sz,count,f)    fread(buf,sz,count,f)
 333  #define PerlSIO_fwrite(buf,sz,count,f)    fwrite(buf,sz,count,f)
 334  #define PerlSIO_setbuf(f,b)        setbuf(f,b)
 335  #define PerlSIO_setvbuf(f,b,t,s)    setvbuf(f,b,t,s)
 336  #if defined(USE_STDIO_PTR) && defined(STDIO_CNT_LVALUE)
 337  #define PerlSIO_set_cnt(f,c)        FILE_cnt(f) = (c)
 338  #else
 339  #define PerlSIO_set_cnt(f,c)        PerlIOProc_abort()
 340  #endif
 341  #if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE)
 342  #define PerlSIO_set_ptr(f,p)        (FILE_ptr(f) = (p))
 343  #else
 344  #define PerlSIO_set_ptr(f,p)        PerlIOProc_abort()
 345  #endif
 346  #define PerlSIO_setlinebuf(f)        setlinebuf(f)
 347  #define PerlSIO_printf            fprintf
 348  #define PerlSIO_stdoutf            printf
 349  #define PerlSIO_vprintf(f,fmt,a)    vfprintf(f,fmt,a)
 350  #define PerlSIO_ftell(f)        ftell(f)
 351  #define PerlSIO_fseek(f,o,w)        fseek(f,o,w)
 352  #define PerlSIO_fgetpos(f,p)        fgetpos(f,p)
 353  #define PerlSIO_fsetpos(f,p)        fsetpos(f,p)
 354  #define PerlSIO_rewind(f)        rewind(f)
 355  #define PerlSIO_tmpfile()        tmpfile()
 356  #define PerlSIO_fdupopen(f)        (f)
 357  
 358  #endif    /* PERL_IMPLICIT_SYS */
 359  
 360  /*
 361   *   Interface for directory functions
 362   */
 363  
 364  #if defined(PERL_IMPLICIT_SYS)
 365  
 366  /* IPerlDir        */
 367  struct IPerlDir;
 368  struct IPerlDirInfo;
 369  typedef int        (*LPMakedir)(struct IPerlDir*, const char*, int);
 370  typedef int        (*LPChdir)(struct IPerlDir*, const char*);
 371  typedef int        (*LPRmdir)(struct IPerlDir*, const char*);
 372  typedef int        (*LPDirClose)(struct IPerlDir*, DIR*);
 373  typedef DIR*        (*LPDirOpen)(struct IPerlDir*, const char*);
 374  typedef struct direct*    (*LPDirRead)(struct IPerlDir*, DIR*);
 375  typedef void        (*LPDirRewind)(struct IPerlDir*, DIR*);
 376  typedef void        (*LPDirSeek)(struct IPerlDir*, DIR*, long);
 377  typedef long        (*LPDirTell)(struct IPerlDir*, DIR*);
 378  #ifdef WIN32
 379  typedef char*        (*LPDirMapPathA)(struct IPerlDir*, const char*);
 380  typedef WCHAR*        (*LPDirMapPathW)(struct IPerlDir*, const WCHAR*);
 381  #endif
 382  
 383  struct IPerlDir
 384  {
 385      LPMakedir        pMakedir;
 386      LPChdir        pChdir;
 387      LPRmdir        pRmdir;
 388      LPDirClose        pClose;
 389      LPDirOpen        pOpen;
 390      LPDirRead        pRead;
 391      LPDirRewind        pRewind;
 392      LPDirSeek        pSeek;
 393      LPDirTell        pTell;
 394  #ifdef WIN32
 395      LPDirMapPathA    pMapPathA;
 396      LPDirMapPathW    pMapPathW;
 397  #endif
 398  };
 399  
 400  struct IPerlDirInfo
 401  {
 402      unsigned long    nCount;        /* number of entries expected */
 403      struct IPerlDir    perlDirList;
 404  };
 405  
 406  #define PerlDir_mkdir(name, mode)                \
 407      (*PL_Dir->pMakedir)(PL_Dir, (name), (mode))
 408  #define PerlDir_chdir(name)                    \
 409      (*PL_Dir->pChdir)(PL_Dir, (name))
 410  #define PerlDir_rmdir(name)                    \
 411      (*PL_Dir->pRmdir)(PL_Dir, (name))
 412  #define PerlDir_close(dir)                    \
 413      (*PL_Dir->pClose)(PL_Dir, (dir))
 414  #define PerlDir_open(name)                    \
 415      (*PL_Dir->pOpen)(PL_Dir, (name))
 416  #define PerlDir_read(dir)                    \
 417      (*PL_Dir->pRead)(PL_Dir, (dir))
 418  #define PerlDir_rewind(dir)                    \
 419      (*PL_Dir->pRewind)(PL_Dir, (dir))
 420  #define PerlDir_seek(dir, loc)                    \
 421      (*PL_Dir->pSeek)(PL_Dir, (dir), (loc))
 422  #define PerlDir_tell(dir)                    \
 423      (*PL_Dir->pTell)(PL_Dir, (dir))
 424  #ifdef WIN32
 425  #define PerlDir_mapA(dir)                    \
 426      (*PL_Dir->pMapPathA)(PL_Dir, (dir))
 427  #define PerlDir_mapW(dir)                    \
 428      (*PL_Dir->pMapPathW)(PL_Dir, (dir))
 429  #endif
 430  
 431  #else    /* PERL_IMPLICIT_SYS */
 432  
 433  #define PerlDir_mkdir(name, mode)    Mkdir((name), (mode))
 434  #ifdef VMS
 435  #  define PerlDir_chdir(n)        Chdir((n))
 436  #else
 437  #  define PerlDir_chdir(name)        chdir((name))
 438  #endif
 439  #define PerlDir_rmdir(name)        rmdir((name))
 440  #define PerlDir_close(dir)        closedir((dir))
 441  #define PerlDir_open(name)        opendir((name))
 442  #define PerlDir_read(dir)        readdir((dir))
 443  #define PerlDir_rewind(dir)        rewinddir((dir))
 444  #define PerlDir_seek(dir, loc)        seekdir((dir), (loc))
 445  #define PerlDir_tell(dir)        telldir((dir))
 446  #ifdef WIN32
 447  #define PerlDir_mapA(dir)        dir
 448  #define PerlDir_mapW(dir)        dir
 449  #endif
 450  
 451  #endif    /* PERL_IMPLICIT_SYS */
 452  
 453  /*
 454      Interface for perl environment functions
 455  */
 456  
 457  #if defined(PERL_IMPLICIT_SYS)
 458  
 459  /* IPerlEnv        */
 460  struct IPerlEnv;
 461  struct IPerlEnvInfo;
 462  typedef char*        (*LPEnvGetenv)(struct IPerlEnv*, const char*);
 463  typedef int        (*LPEnvPutenv)(struct IPerlEnv*, const char*);
 464  typedef char*        (*LPEnvGetenv_len)(struct IPerlEnv*,
 465                      const char *varname, unsigned long *len);
 466  typedef int        (*LPEnvUname)(struct IPerlEnv*, struct utsname *name);
 467  typedef void        (*LPEnvClearenv)(struct IPerlEnv*);
 468  typedef void*        (*LPEnvGetChildenv)(struct IPerlEnv*);
 469  typedef void        (*LPEnvFreeChildenv)(struct IPerlEnv*, void* env);
 470  typedef char*        (*LPEnvGetChilddir)(struct IPerlEnv*);
 471  typedef void        (*LPEnvFreeChilddir)(struct IPerlEnv*, char* dir);
 472  #ifdef HAS_ENVGETENV
 473  typedef char*        (*LPENVGetenv)(struct IPerlEnv*, const char *varname);
 474  typedef char*        (*LPENVGetenv_len)(struct IPerlEnv*,
 475                      const char *varname, unsigned long *len);
 476  #endif
 477  #ifdef WIN32
 478  typedef unsigned long    (*LPEnvOsID)(struct IPerlEnv*);
 479  typedef char*        (*LPEnvLibPath)(struct IPerlEnv*, const char*);
 480  typedef char*        (*LPEnvSiteLibPath)(struct IPerlEnv*, const char*);
 481  typedef char*        (*LPEnvVendorLibPath)(struct IPerlEnv*, const char*);
 482  typedef void        (*LPEnvGetChildIO)(struct IPerlEnv*, child_IO_table*);
 483  #endif
 484  
 485  struct IPerlEnv
 486  {
 487      LPEnvGetenv        pGetenv;
 488      LPEnvPutenv        pPutenv;
 489      LPEnvGetenv_len    pGetenv_len;
 490      LPEnvUname        pEnvUname;
 491      LPEnvClearenv    pClearenv;
 492      LPEnvGetChildenv    pGetChildenv;
 493      LPEnvFreeChildenv    pFreeChildenv;
 494      LPEnvGetChilddir    pGetChilddir;
 495      LPEnvFreeChilddir    pFreeChilddir;
 496  #ifdef HAS_ENVGETENV
 497      LPENVGetenv        pENVGetenv;
 498      LPENVGetenv_len    pENVGetenv_len;
 499  #endif
 500  #ifdef WIN32
 501      LPEnvOsID        pEnvOsID;
 502      LPEnvLibPath    pLibPath;
 503      LPEnvSiteLibPath    pSiteLibPath;
 504      LPEnvVendorLibPath    pVendorLibPath;
 505      LPEnvGetChildIO    pGetChildIO;
 506  #endif
 507  };
 508  
 509  struct IPerlEnvInfo
 510  {
 511      unsigned long    nCount;        /* number of entries expected */
 512      struct IPerlEnv    perlEnvList;
 513  };
 514  
 515  #define PerlEnv_putenv(str)                    \
 516      (*PL_Env->pPutenv)(PL_Env,(str))
 517  #define PerlEnv_getenv(str)                    \
 518      (*PL_Env->pGetenv)(PL_Env,(str))
 519  #define PerlEnv_getenv_len(str,l)                \
 520      (*PL_Env->pGetenv_len)(PL_Env,(str), (l))
 521  #define PerlEnv_clearenv()                    \
 522      (*PL_Env->pClearenv)(PL_Env)
 523  #define PerlEnv_get_childenv()                    \
 524      (*PL_Env->pGetChildenv)(PL_Env)
 525  #define PerlEnv_free_childenv(e)                \
 526      (*PL_Env->pFreeChildenv)(PL_Env, (e))
 527  #define PerlEnv_get_childdir()                    \
 528      (*PL_Env->pGetChilddir)(PL_Env)
 529  #define PerlEnv_free_childdir(d)                \
 530      (*PL_Env->pFreeChilddir)(PL_Env, (d))
 531  #ifdef HAS_ENVGETENV
 532  #  define PerlEnv_ENVgetenv(str)                \
 533      (*PL_Env->pENVGetenv)(PL_Env,(str))
 534  #  define PerlEnv_ENVgetenv_len(str,l)                \
 535      (*PL_Env->pENVGetenv_len)(PL_Env,(str), (l))
 536  #else
 537  #  define PerlEnv_ENVgetenv(str)                \
 538      PerlEnv_getenv((str))
 539  #  define PerlEnv_ENVgetenv_len(str,l)                \
 540      PerlEnv_getenv_len((str),(l))
 541  #endif
 542  #define PerlEnv_uname(name)                    \
 543      (*PL_Env->pEnvUname)(PL_Env,(name))
 544  #ifdef WIN32
 545  #define PerlEnv_os_id()                        \
 546      (*PL_Env->pEnvOsID)(PL_Env)
 547  #define PerlEnv_lib_path(str)                    \
 548      (*PL_Env->pLibPath)(PL_Env,(str))
 549  #define PerlEnv_sitelib_path(str)                \
 550      (*PL_Env->pSiteLibPath)(PL_Env,(str))
 551  #define PerlEnv_vendorlib_path(str)                \
 552      (*PL_Env->pVendorLibPath)(PL_Env,(str))
 553  #define PerlEnv_get_child_IO(ptr)                \
 554      (*PL_Env->pGetChildIO)(PL_Env, ptr)
 555  #endif
 556  
 557  #else    /* PERL_IMPLICIT_SYS */
 558  
 559  #define PerlEnv_putenv(str)        putenv((str))
 560  #define PerlEnv_getenv(str)        getenv((str))
 561  #define PerlEnv_getenv_len(str,l)    getenv_len((str), (l))
 562  #ifdef HAS_ENVGETENV
 563  #  define PerlEnv_ENVgetenv(str)    ENVgetenv((str))
 564  #  define PerlEnv_ENVgetenv_len(str,l)    ENVgetenv_len((str), (l))
 565  #else
 566  #  define PerlEnv_ENVgetenv(str)    PerlEnv_getenv((str))
 567  #  define PerlEnv_ENVgetenv_len(str,l)    PerlEnv_getenv_len((str), (l))
 568  #endif
 569  #define PerlEnv_uname(name)        uname((name))
 570  
 571  #ifdef WIN32
 572  #define PerlEnv_os_id()            win32_os_id()
 573  #define PerlEnv_lib_path(str)        win32_get_privlib(str)
 574  #define PerlEnv_sitelib_path(str)    win32_get_sitelib(str)
 575  #define PerlEnv_vendorlib_path(str)    win32_get_vendorlib(str)
 576  #define PerlEnv_get_child_IO(ptr)    win32_get_child_IO(ptr)
 577  #define PerlEnv_clearenv()        win32_clearenv()
 578  #define PerlEnv_get_childenv()        win32_get_childenv()
 579  #define PerlEnv_free_childenv(e)    win32_free_childenv((e))
 580  #define PerlEnv_get_childdir()        win32_get_childdir()
 581  #define PerlEnv_free_childdir(d)    win32_free_childdir((d))
 582  #else
 583  #define PerlEnv_clearenv()        clearenv()
 584  #define PerlEnv_get_childenv()        get_childenv()
 585  #define PerlEnv_free_childenv(e)    free_childenv((e))
 586  #define PerlEnv_get_childdir()        get_childdir()
 587  #define PerlEnv_free_childdir(d)    free_childdir((d))
 588  #endif
 589  
 590  #endif    /* PERL_IMPLICIT_SYS */
 591  
 592  /*
 593      Interface for perl low-level IO functions
 594  */
 595  
 596  #if defined(PERL_IMPLICIT_SYS)
 597  
 598  /* IPerlLIO        */
 599  struct IPerlLIO;
 600  struct IPerlLIOInfo;
 601  typedef int        (*LPLIOAccess)(struct IPerlLIO*, const char*, int);
 602  typedef int        (*LPLIOChmod)(struct IPerlLIO*, const char*, int);
 603  typedef int        (*LPLIOChown)(struct IPerlLIO*, const char*, uid_t,
 604                  gid_t);
 605  typedef int        (*LPLIOChsize)(struct IPerlLIO*, int, Off_t);
 606  typedef int        (*LPLIOClose)(struct IPerlLIO*, int);
 607  typedef int        (*LPLIODup)(struct IPerlLIO*, int);
 608  typedef int        (*LPLIODup2)(struct IPerlLIO*, int, int);
 609  typedef int        (*LPLIOFlock)(struct IPerlLIO*, int, int);
 610  typedef int        (*LPLIOFileStat)(struct IPerlLIO*, int, Stat_t*);
 611  typedef int        (*LPLIOIOCtl)(struct IPerlLIO*, int, unsigned int,
 612                  char*);
 613  typedef int        (*LPLIOIsatty)(struct IPerlLIO*, int);
 614  typedef int        (*LPLIOLink)(struct IPerlLIO*, const char*,
 615                       const char *);
 616  typedef Off_t        (*LPLIOLseek)(struct IPerlLIO*, int, Off_t, int);
 617  typedef int        (*LPLIOLstat)(struct IPerlLIO*, const char*,
 618                  Stat_t*);
 619  typedef char*        (*LPLIOMktemp)(struct IPerlLIO*, char*);
 620  typedef int        (*LPLIOOpen)(struct IPerlLIO*, const char*, int);    
 621  typedef int        (*LPLIOOpen3)(struct IPerlLIO*, const char*, int, int);    
 622  typedef int        (*LPLIORead)(struct IPerlLIO*, int, void*, unsigned int);
 623  typedef int        (*LPLIORename)(struct IPerlLIO*, const char*,
 624                  const char*);
 625  #ifdef NETWARE
 626  typedef int        (*LPLIOSetmode)(struct IPerlLIO*, FILE*, int);
 627  #else
 628  typedef int        (*LPLIOSetmode)(struct IPerlLIO*, int, int);
 629  #endif    /* NETWARE */
 630  typedef int        (*LPLIONameStat)(struct IPerlLIO*, const char*,
 631                  Stat_t*);
 632  typedef char*        (*LPLIOTmpnam)(struct IPerlLIO*, char*);
 633  typedef int        (*LPLIOUmask)(struct IPerlLIO*, int);
 634  typedef int        (*LPLIOUnlink)(struct IPerlLIO*, const char*);
 635  typedef int        (*LPLIOUtime)(struct IPerlLIO*, const char*, struct utimbuf*);
 636  typedef int        (*LPLIOWrite)(struct IPerlLIO*, int, const void*,
 637                  unsigned int);
 638  
 639  struct IPerlLIO
 640  {
 641      LPLIOAccess        pAccess;
 642      LPLIOChmod        pChmod;
 643      LPLIOChown        pChown;
 644      LPLIOChsize        pChsize;
 645      LPLIOClose        pClose;
 646      LPLIODup        pDup;
 647      LPLIODup2        pDup2;
 648      LPLIOFlock        pFlock;
 649      LPLIOFileStat    pFileStat;
 650      LPLIOIOCtl        pIOCtl;
 651      LPLIOIsatty        pIsatty;
 652      LPLIOLink        pLink;
 653      LPLIOLseek        pLseek;
 654      LPLIOLstat        pLstat;
 655      LPLIOMktemp        pMktemp;
 656      LPLIOOpen        pOpen;
 657      LPLIOOpen3        pOpen3;
 658      LPLIORead        pRead;
 659      LPLIORename        pRename;
 660      LPLIOSetmode    pSetmode;
 661      LPLIONameStat    pNameStat;
 662      LPLIOTmpnam        pTmpnam;
 663      LPLIOUmask        pUmask;
 664      LPLIOUnlink        pUnlink;
 665      LPLIOUtime        pUtime;
 666      LPLIOWrite        pWrite;
 667  };
 668  
 669  struct IPerlLIOInfo
 670  {
 671      unsigned long    nCount;        /* number of entries expected */
 672      struct IPerlLIO    perlLIOList;
 673  };
 674  
 675  #define PerlLIO_access(file, mode)                    \
 676      (*PL_LIO->pAccess)(PL_LIO, (file), (mode))
 677  #define PerlLIO_chmod(file, mode)                    \
 678      (*PL_LIO->pChmod)(PL_LIO, (file), (mode))
 679  #define PerlLIO_chown(file, owner, group)                \
 680      (*PL_LIO->pChown)(PL_LIO, (file), (owner), (group))
 681  #define PerlLIO_chsize(fd, size)                    \
 682      (*PL_LIO->pChsize)(PL_LIO, (fd), (size))
 683  #define PerlLIO_close(fd)                        \
 684      (*PL_LIO->pClose)(PL_LIO, (fd))
 685  #define PerlLIO_dup(fd)                            \
 686      (*PL_LIO->pDup)(PL_LIO, (fd))
 687  #define PerlLIO_dup2(fd1, fd2)                        \
 688      (*PL_LIO->pDup2)(PL_LIO, (fd1), (fd2))
 689  #define PerlLIO_flock(fd, op)                        \
 690      (*PL_LIO->pFlock)(PL_LIO, (fd), (op))
 691  #define PerlLIO_fstat(fd, buf)                        \
 692      (*PL_LIO->pFileStat)(PL_LIO, (fd), (buf))
 693  #define PerlLIO_ioctl(fd, u, buf)                    \
 694      (*PL_LIO->pIOCtl)(PL_LIO, (fd), (u), (buf))
 695  #define PerlLIO_isatty(fd)                        \
 696      (*PL_LIO->pIsatty)(PL_LIO, (fd))
 697  #define PerlLIO_link(oldname, newname)                    \
 698      (*PL_LIO->pLink)(PL_LIO, (oldname), (newname))
 699  #define PerlLIO_lseek(fd, offset, mode)                    \
 700      (*PL_LIO->pLseek)(PL_LIO, (fd), (offset), (mode))
 701  #define PerlLIO_lstat(name, buf)                    \
 702      (*PL_LIO->pLstat)(PL_LIO, (name), (buf))
 703  #define PerlLIO_mktemp(file)                        \
 704      (*PL_LIO->pMktemp)(PL_LIO, (file))
 705  #define PerlLIO_open(file, flag)                    \
 706      (*PL_LIO->pOpen)(PL_LIO, (file), (flag))
 707  #define PerlLIO_open3(file, flag, perm)                    \
 708      (*PL_LIO->pOpen3)(PL_LIO, (file), (flag), (perm))
 709  #define PerlLIO_read(fd, buf, count)                    \
 710      (*PL_LIO->pRead)(PL_LIO, (fd), (buf), (count))
 711  #define PerlLIO_rename(oname, newname)                    \
 712      (*PL_LIO->pRename)(PL_LIO, (oname), (newname))
 713  #define PerlLIO_setmode(fd, mode)                    \
 714      (*PL_LIO->pSetmode)(PL_LIO, (fd), (mode))
 715  #define PerlLIO_stat(name, buf)                        \
 716      (*PL_LIO->pNameStat)(PL_LIO, (name), (buf))
 717  #define PerlLIO_tmpnam(str)                        \
 718      (*PL_LIO->pTmpnam)(PL_LIO, (str))
 719  #define PerlLIO_umask(mode)                        \
 720      (*PL_LIO->pUmask)(PL_LIO, (mode))
 721  #define PerlLIO_unlink(file)                        \
 722      (*PL_LIO->pUnlink)(PL_LIO, (file))
 723  #define PerlLIO_utime(file, time)                    \
 724      (*PL_LIO->pUtime)(PL_LIO, (file), (time))
 725  #define PerlLIO_write(fd, buf, count)                    \
 726      (*PL_LIO->pWrite)(PL_LIO, (fd), (buf), (count))
 727  
 728  #else    /* PERL_IMPLICIT_SYS */
 729  
 730  #define PerlLIO_access(file, mode)    access((file), (mode))
 731  #define PerlLIO_chmod(file, mode)    chmod((file), (mode))
 732  #define PerlLIO_chown(file, owner, grp)    chown((file), (owner), (grp))
 733  #if defined(HAS_TRUNCATE)
 734  #  define PerlLIO_chsize(fd, size)    ftruncate((fd), (size))
 735  #elif defined(HAS_CHSIZE)
 736  #  define PerlLIO_chsize(fd, size)    chsize((fd), (size))
 737  #else
 738  #  define PerlLIO_chsize(fd, size)    my_chsize((fd), (size))
 739  #endif
 740  #define PerlLIO_close(fd)        close((fd))
 741  #define PerlLIO_dup(fd)            dup((fd))
 742  #define PerlLIO_dup2(fd1, fd2)        dup2((fd1), (fd2))
 743  #define PerlLIO_flock(fd, op)        FLOCK((fd), (op))
 744  #define PerlLIO_fstat(fd, buf)        Fstat((fd), (buf))
 745  #define PerlLIO_ioctl(fd, u, buf)    ioctl((fd), (u), (buf))
 746  #define PerlLIO_isatty(fd)        isatty((fd))
 747  #define PerlLIO_link(oldname, newname)    link((oldname), (newname))
 748  #define PerlLIO_lseek(fd, offset, mode)    lseek((fd), (offset), (mode))
 749  #define PerlLIO_stat(name, buf)        Stat((name), (buf))
 750  #ifdef HAS_LSTAT
 751  #  define PerlLIO_lstat(name, buf)    lstat((name), (buf))
 752  #else
 753  #  define PerlLIO_lstat(name, buf)    PerlLIO_stat((name), (buf))
 754  #endif
 755  #define PerlLIO_mktemp(file)        mktemp((file))
 756  #define PerlLIO_mkstemp(file)        mkstemp((file))
 757  #define PerlLIO_open(file, flag)    open((file), (flag))
 758  #define PerlLIO_open3(file, flag, perm)    open((file), (flag), (perm))
 759  #define PerlLIO_read(fd, buf, count)    read((fd), (buf), (count))
 760  #define PerlLIO_rename(old, new)    rename((old), (new))
 761  #define PerlLIO_setmode(fd, mode)    setmode((fd), (mode))
 762  #define PerlLIO_tmpnam(str)        tmpnam((str))
 763  #define PerlLIO_umask(mode)        umask((mode))
 764  #define PerlLIO_unlink(file)        unlink((file))
 765  #define PerlLIO_utime(file, time)    utime((file), (time))
 766  #define PerlLIO_write(fd, buf, count)    write((fd), (buf), (count))
 767  
 768  #endif    /* PERL_IMPLICIT_SYS */
 769  
 770  /*
 771      Interface for perl memory allocation
 772  */
 773  
 774  #if defined(PERL_IMPLICIT_SYS)
 775  
 776  /* IPerlMem        */
 777  struct IPerlMem;
 778  struct IPerlMemInfo;
 779  typedef void*        (*LPMemMalloc)(struct IPerlMem*, size_t);
 780  typedef void*        (*LPMemRealloc)(struct IPerlMem*, void*, size_t);
 781  typedef void        (*LPMemFree)(struct IPerlMem*, void*);
 782  typedef void*        (*LPMemCalloc)(struct IPerlMem*, size_t, size_t);
 783  typedef void        (*LPMemGetLock)(struct IPerlMem*);
 784  typedef void        (*LPMemFreeLock)(struct IPerlMem*);
 785  typedef int        (*LPMemIsLocked)(struct IPerlMem*);
 786  
 787  struct IPerlMem
 788  {
 789      LPMemMalloc        pMalloc;
 790      LPMemRealloc    pRealloc;
 791      LPMemFree        pFree;
 792      LPMemCalloc        pCalloc;
 793      LPMemGetLock    pGetLock;
 794      LPMemFreeLock    pFreeLock;
 795      LPMemIsLocked    pIsLocked;
 796  };
 797  
 798  struct IPerlMemInfo
 799  {
 800      unsigned long    nCount;        /* number of entries expected */
 801      struct IPerlMem    perlMemList;
 802  };
 803  
 804  /* Interpreter specific memory macros */
 805  #define PerlMem_malloc(size)                    \
 806      (*PL_Mem->pMalloc)(PL_Mem, (size))
 807  #define PerlMem_realloc(buf, size)                \
 808      (*PL_Mem->pRealloc)(PL_Mem, (buf), (size))
 809  #define PerlMem_free(buf)                    \
 810      (*PL_Mem->pFree)(PL_Mem, (buf))
 811  #define PerlMem_calloc(num, size)                \
 812      (*PL_Mem->pCalloc)(PL_Mem, (num), (size))
 813  #define PerlMem_get_lock()                    \
 814      (*PL_Mem->pGetLock)(PL_Mem)
 815  #define PerlMem_free_lock()                    \
 816      (*PL_Mem->pFreeLock)(PL_Mem)
 817  #define PerlMem_is_locked()                    \
 818      (*PL_Mem->pIsLocked)(PL_Mem)
 819  
 820  /* Shared memory macros */
 821  #ifdef NETWARE
 822  
 823  #define PerlMemShared_malloc(size)                \
 824      (*PL_Mem->pMalloc)(PL_Mem, (size))
 825  #define PerlMemShared_realloc(buf, size)            \
 826      (*PL_Mem->pRealloc)(PL_Mem, (buf), (size))
 827  #define PerlMemShared_free(buf)                    \
 828      (*PL_Mem->pFree)(PL_Mem, (buf))
 829  #define PerlMemShared_calloc(num, size)                \
 830      (*PL_Mem->pCalloc)(PL_Mem, (num), (size))
 831  #define PerlMemShared_get_lock()                \
 832      (*PL_Mem->pGetLock)(PL_Mem)
 833  #define PerlMemShared_free_lock()                \
 834      (*PL_Mem->pFreeLock)(PL_Mem)
 835  #define PerlMemShared_is_locked()                \
 836      (*PL_Mem->pIsLocked)(PL_Mem)
 837  
 838  #else
 839  
 840  #define PerlMemShared_malloc(size)                \
 841      (*PL_MemShared->pMalloc)(PL_MemShared, (size))
 842  #define PerlMemShared_realloc(buf, size)            \
 843      (*PL_MemShared->pRealloc)(PL_MemShared, (buf), (size))
 844  #define PerlMemShared_free(buf)                    \
 845      (*PL_MemShared->pFree)(PL_MemShared, (buf))
 846  #define PerlMemShared_calloc(num, size)                \
 847      (*PL_MemShared->pCalloc)(PL_MemShared, (num), (size))
 848  #define PerlMemShared_get_lock()                \
 849      (*PL_MemShared->pGetLock)(PL_MemShared)
 850  #define PerlMemShared_free_lock()                \
 851      (*PL_MemShared->pFreeLock)(PL_MemShared)
 852  #define PerlMemShared_is_locked()                \
 853      (*PL_MemShared->pIsLocked)(PL_MemShared)
 854  
 855  #endif
 856  
 857  /* Parse tree memory macros */
 858  #define PerlMemParse_malloc(size)                \
 859      (*PL_MemParse->pMalloc)(PL_MemParse, (size))
 860  #define PerlMemParse_realloc(buf, size)                \
 861      (*PL_MemParse->pRealloc)(PL_MemParse, (buf), (size))
 862  #define PerlMemParse_free(buf)                    \
 863      (*PL_MemParse->pFree)(PL_MemParse, (buf))
 864  #define PerlMemParse_calloc(num, size)                \
 865      (*PL_MemParse->pCalloc)(PL_MemParse, (num), (size))
 866  #define PerlMemParse_get_lock()                    \
 867      (*PL_MemParse->pGetLock)(PL_MemParse)
 868  #define PerlMemParse_free_lock()                \
 869      (*PL_MemParse->pFreeLock)(PL_MemParse)
 870  #define PerlMemParse_is_locked()                \
 871      (*PL_MemParse->pIsLocked)(PL_MemParse)
 872  
 873  
 874  #else    /* PERL_IMPLICIT_SYS */
 875  
 876  /* Interpreter specific memory macros */
 877  #define PerlMem_malloc(size)        malloc((size))
 878  #define PerlMem_realloc(buf, size)    realloc((buf), (size))
 879  #define PerlMem_free(buf)        free((buf))
 880  #define PerlMem_calloc(num, size)    calloc((num), (size))
 881  #define PerlMem_get_lock()        
 882  #define PerlMem_free_lock()
 883  #define PerlMem_is_locked()        0
 884  
 885  /* Shared memory macros */
 886  #define PerlMemShared_malloc(size)        malloc((size))
 887  #define PerlMemShared_realloc(buf, size)    realloc((buf), (size))
 888  #define PerlMemShared_free(buf)            free((buf))
 889  #define PerlMemShared_calloc(num, size)        calloc((num), (size))
 890  #define PerlMemShared_get_lock()        
 891  #define PerlMemShared_free_lock()
 892  #define PerlMemShared_is_locked()        0
 893  
 894  /* Parse tree memory macros */
 895  #define PerlMemParse_malloc(size)    malloc((size))
 896  #define PerlMemParse_realloc(buf, size)    realloc((buf), (size))
 897  #define PerlMemParse_free(buf)        free((buf))
 898  #define PerlMemParse_calloc(num, size)    calloc((num), (size))
 899  #define PerlMemParse_get_lock()        
 900  #define PerlMemParse_free_lock()
 901  #define PerlMemParse_is_locked()    0
 902  
 903  #endif    /* PERL_IMPLICIT_SYS */
 904  
 905  /*
 906      Interface for perl process functions
 907  */
 908  
 909  
 910  #if defined(PERL_IMPLICIT_SYS)
 911  
 912  #ifndef jmp_buf
 913  #include <setjmp.h>
 914  #endif
 915  
 916  /* IPerlProc        */
 917  struct IPerlProc;
 918  struct IPerlProcInfo;
 919  typedef void        (*LPProcAbort)(struct IPerlProc*);
 920  typedef char*        (*LPProcCrypt)(struct IPerlProc*, const char*,
 921                  const char*);
 922  typedef void        (*LPProcExit)(struct IPerlProc*, int)
 923                  __attribute__noreturn__;
 924  typedef void        (*LPProc_Exit)(struct IPerlProc*, int)
 925                  __attribute__noreturn__;
 926  typedef int        (*LPProcExecl)(struct IPerlProc*, const char*,
 927                  const char*, const char*, const char*,
 928                  const char*);
 929  typedef int        (*LPProcExecv)(struct IPerlProc*, const char*,
 930                  const char*const*);
 931  typedef int        (*LPProcExecvp)(struct IPerlProc*, const char*,
 932                  const char*const*);
 933  typedef uid_t        (*LPProcGetuid)(struct IPerlProc*);
 934  typedef uid_t        (*LPProcGeteuid)(struct IPerlProc*);
 935  typedef gid_t        (*LPProcGetgid)(struct IPerlProc*);
 936  typedef gid_t        (*LPProcGetegid)(struct IPerlProc*);
 937  typedef char*        (*LPProcGetlogin)(struct IPerlProc*);
 938  typedef int        (*LPProcKill)(struct IPerlProc*, int, int);
 939  typedef int        (*LPProcKillpg)(struct IPerlProc*, int, int);
 940  typedef int        (*LPProcPauseProc)(struct IPerlProc*);
 941  typedef PerlIO*        (*LPProcPopen)(struct IPerlProc*, const char*,
 942                  const char*);
 943  typedef PerlIO*        (*LPProcPopenList)(struct IPerlProc*, const char*,
 944                  IV narg, SV **args);
 945  typedef int        (*LPProcPclose)(struct IPerlProc*, PerlIO*);
 946  typedef int        (*LPProcPipe)(struct IPerlProc*, int*);
 947  typedef int        (*LPProcSetuid)(struct IPerlProc*, uid_t);
 948  typedef int        (*LPProcSetgid)(struct IPerlProc*, gid_t);
 949  typedef int        (*LPProcSleep)(struct IPerlProc*, unsigned int);
 950  typedef int        (*LPProcTimes)(struct IPerlProc*, struct tms*);
 951  typedef int        (*LPProcWait)(struct IPerlProc*, int*);
 952  typedef int        (*LPProcWaitpid)(struct IPerlProc*, int, int*, int);
 953  typedef Sighandler_t    (*LPProcSignal)(struct IPerlProc*, int, Sighandler_t);
 954  typedef int        (*LPProcFork)(struct IPerlProc*);
 955  typedef int        (*LPProcGetpid)(struct IPerlProc*);
 956  #ifdef WIN32
 957  typedef void*        (*LPProcDynaLoader)(struct IPerlProc*, const char*);
 958  typedef void        (*LPProcGetOSError)(struct IPerlProc*,
 959                  SV* sv, DWORD dwErr);
 960  typedef int        (*LPProcSpawnvp)(struct IPerlProc*, int, const char*,
 961                  const char*const*);
 962  #endif
 963  typedef int        (*LPProcLastHost)(struct IPerlProc*);
 964  typedef int        (*LPProcGetTimeOfDay)(struct IPerlProc*,
 965                            struct timeval*, void*);
 966  
 967  struct IPerlProc
 968  {
 969      LPProcAbort        pAbort;
 970      LPProcCrypt        pCrypt;
 971      LPProcExit        pExit;
 972      LPProc_Exit        p_Exit;
 973      LPProcExecl        pExecl;
 974      LPProcExecv        pExecv;
 975      LPProcExecvp    pExecvp;
 976      LPProcGetuid    pGetuid;
 977      LPProcGeteuid    pGeteuid;
 978      LPProcGetgid    pGetgid;
 979      LPProcGetegid    pGetegid;
 980      LPProcGetlogin    pGetlogin;
 981      LPProcKill        pKill;
 982      LPProcKillpg    pKillpg;
 983      LPProcPauseProc    pPauseProc;
 984      LPProcPopen        pPopen;
 985      LPProcPclose    pPclose;
 986      LPProcPipe        pPipe;
 987      LPProcSetuid    pSetuid;
 988      LPProcSetgid    pSetgid;
 989      LPProcSleep        pSleep;
 990      LPProcTimes        pTimes;
 991      LPProcWait        pWait;
 992      LPProcWaitpid    pWaitpid;
 993      LPProcSignal    pSignal;
 994      LPProcFork        pFork;
 995      LPProcGetpid    pGetpid;
 996  #ifdef WIN32
 997      LPProcDynaLoader    pDynaLoader;
 998      LPProcGetOSError    pGetOSError;
 999      LPProcSpawnvp    pSpawnvp;
1000  #endif
1001      LPProcLastHost      pLastHost;
1002      LPProcPopenList    pPopenList;
1003      LPProcGetTimeOfDay    pGetTimeOfDay;
1004  };
1005  
1006  struct IPerlProcInfo
1007  {
1008      unsigned long    nCount;        /* number of entries expected */
1009      struct IPerlProc    perlProcList;
1010  };
1011  
1012  #define PerlProc_abort()                        \
1013      (*PL_Proc->pAbort)(PL_Proc)
1014  #define PerlProc_crypt(c,s)                        \
1015      (*PL_Proc->pCrypt)(PL_Proc, (c), (s))
1016  #define PerlProc_exit(s)                        \
1017      (*PL_Proc->pExit)(PL_Proc, (s))
1018  #define PerlProc__exit(s)                        \
1019      (*PL_Proc->p_Exit)(PL_Proc, (s))
1020  #define PerlProc_execl(c, w, x, y, z)                    \
1021      (*PL_Proc->pExecl)(PL_Proc, (c), (w), (x), (y), (z))
1022  #define PerlProc_execv(c, a)                        \
1023      (*PL_Proc->pExecv)(PL_Proc, (c), (a))
1024  #define PerlProc_execvp(c, a)                        \
1025      (*PL_Proc->pExecvp)(PL_Proc, (c), (a))
1026  #define PerlProc_getuid()                        \
1027      (*PL_Proc->pGetuid)(PL_Proc)
1028  #define PerlProc_geteuid()                        \
1029      (*PL_Proc->pGeteuid)(PL_Proc)
1030  #define PerlProc_getgid()                        \
1031      (*PL_Proc->pGetgid)(PL_Proc)
1032  #define PerlProc_getegid()                        \
1033      (*PL_Proc->pGetegid)(PL_Proc)
1034  #define PerlProc_getlogin()                        \
1035      (*PL_Proc->pGetlogin)(PL_Proc)
1036  #define PerlProc_kill(i, a)                        \
1037      (*PL_Proc->pKill)(PL_Proc, (i), (a))
1038  #define PerlProc_killpg(i, a)                        \
1039      (*PL_Proc->pKillpg)(PL_Proc, (i), (a))
1040  #define PerlProc_pause()                        \
1041      (*PL_Proc->pPauseProc)(PL_Proc)
1042  #define PerlProc_popen(c, m)                        \
1043      (*PL_Proc->pPopen)(PL_Proc, (c), (m))
1044  #define PerlProc_popen_list(m, n, a)                    \
1045      (*PL_Proc->pPopenList)(PL_Proc, (m), (n), (a))
1046  #define PerlProc_pclose(f)                        \
1047      (*PL_Proc->pPclose)(PL_Proc, (f))
1048  #define PerlProc_pipe(fd)                        \
1049      (*PL_Proc->pPipe)(PL_Proc, (fd))
1050  #define PerlProc_setuid(u)                        \
1051      (*PL_Proc->pSetuid)(PL_Proc, (u))
1052  #define PerlProc_setgid(g)                        \
1053      (*PL_Proc->pSetgid)(PL_Proc, (g))
1054  #define PerlProc_sleep(t)                        \
1055      (*PL_Proc->pSleep)(PL_Proc, (t))
1056  #define PerlProc_times(t)                        \
1057      (*PL_Proc->pTimes)(PL_Proc, (t))
1058  #define PerlProc_wait(t)                        \
1059      (*PL_Proc->pWait)(PL_Proc, (t))
1060  #define PerlProc_waitpid(p,s,f)                        \
1061      (*PL_Proc->pWaitpid)(PL_Proc, (p), (s), (f))
1062  #define PerlProc_signal(n, h)                        \
1063      (*PL_Proc->pSignal)(PL_Proc, (n), (h))
1064  #define PerlProc_fork()                            \
1065      (*PL_Proc->pFork)(PL_Proc)
1066  #define PerlProc_getpid()                        \
1067      (*PL_Proc->pGetpid)(PL_Proc)
1068  #define PerlProc_setjmp(b, n) Sigsetjmp((b), (n))
1069  #define PerlProc_longjmp(b, n) Siglongjmp((b), (n))
1070  
1071  #ifdef WIN32
1072  #define PerlProc_DynaLoad(f)                        \
1073      (*PL_Proc->pDynaLoader)(PL_Proc, (f))
1074  #define PerlProc_GetOSError(s,e)                    \
1075      (*PL_Proc->pGetOSError)(PL_Proc, (s), (e))
1076  #define PerlProc_spawnvp(m, c, a)                    \
1077      (*PL_Proc->pSpawnvp)(PL_Proc, (m), (c), (a))
1078  #endif
1079  #define PerlProc_lasthost()                        \
1080      (*PL_Proc->pLastHost)(PL_Proc)
1081  #define PerlProc_gettimeofday(t,z)                    \
1082      (*PL_Proc->pGetTimeOfDay)(PL_Proc,(t),(z))
1083  
1084  #else    /* PERL_IMPLICIT_SYS */
1085  
1086  #define PerlProc_abort()    abort()
1087  #define PerlProc_crypt(c,s)    crypt((c), (s))
1088  #define PerlProc_exit(s)    exit((s))
1089  #define PerlProc__exit(s)    _exit((s))
1090  #define PerlProc_execl(c,w,x,y,z)                    \
1091      execl((c), (w), (x), (y), (z))
1092  #define PerlProc_execv(c, a)    execv((c), (a))
1093  #define PerlProc_execvp(c, a)    execvp((c), (a))
1094  #define PerlProc_getuid()    getuid()
1095  #define PerlProc_geteuid()    geteuid()
1096  #define PerlProc_getgid()    getgid()
1097  #define PerlProc_getegid()    getegid()
1098  #define PerlProc_getlogin()    getlogin()
1099  #define PerlProc_kill(i, a)    kill((i), (a))
1100  #define PerlProc_killpg(i, a)    killpg((i), (a))
1101  #define PerlProc_pause()    Pause()
1102  #define PerlProc_popen(c, m)    my_popen((c), (m))
1103  #define PerlProc_popen_list(m,n,a)    my_popen_list((m),(n),(a))
1104  #define PerlProc_pclose(f)    my_pclose((f))
1105  #define PerlProc_pipe(fd)    pipe((fd))
1106  #define PerlProc_setuid(u)    setuid((u))
1107  #define PerlProc_setgid(g)    setgid((g))
1108  #define PerlProc_sleep(t)    sleep((t))
1109  #define PerlProc_times(t)    times((t))
1110  #define PerlProc_wait(t)    wait((t))
1111  #define PerlProc_waitpid(p,s,f)    waitpid((p), (s), (f))
1112  #define PerlProc_setjmp(b, n)    Sigsetjmp((b), (n))
1113  #define PerlProc_longjmp(b, n)    Siglongjmp((b), (n))
1114  #define PerlProc_signal(n, h)    signal((n), (h))
1115  #define PerlProc_fork()        my_fork()
1116  #define PerlProc_getpid()    getpid()
1117  #define PerlProc_gettimeofday(t,z)    gettimeofday((t),(z))
1118  
1119  #ifdef WIN32
1120  #define PerlProc_DynaLoad(f)                        \
1121      win32_dynaload((f))
1122  #define PerlProc_GetOSError(s,e)                    \
1123      win32_str_os_error((s), (e))
1124  #define PerlProc_spawnvp(m, c, a)                    \
1125      win32_spawnvp((m), (c), (a))
1126  #undef PerlProc_signal
1127  #define PerlProc_signal(n, h) win32_signal((n), (h))
1128  #endif
1129  #endif    /* PERL_IMPLICIT_SYS */
1130  
1131  /*
1132      Interface for perl socket functions
1133  */
1134  
1135  #if defined(PERL_IMPLICIT_SYS)
1136  
1137  /* PerlSock        */
1138  struct IPerlSock;
1139  struct IPerlSockInfo;
1140  typedef u_long        (*LPHtonl)(struct IPerlSock*, u_long);
1141  typedef u_short        (*LPHtons)(struct IPerlSock*, u_short);
1142  typedef u_long        (*LPNtohl)(struct IPerlSock*, u_long);
1143  typedef u_short        (*LPNtohs)(struct IPerlSock*, u_short);
1144  typedef SOCKET        (*LPAccept)(struct IPerlSock*, SOCKET,
1145                  struct sockaddr*, int*);
1146  typedef int        (*LPBind)(struct IPerlSock*, SOCKET,
1147                  const struct sockaddr*, int);
1148  typedef int        (*LPConnect)(struct IPerlSock*, SOCKET,
1149                  const struct sockaddr*, int);
1150  typedef void        (*LPEndhostent)(struct IPerlSock*);
1151  typedef void        (*LPEndnetent)(struct IPerlSock*);
1152  typedef void        (*LPEndprotoent)(struct IPerlSock*);
1153  typedef void        (*LPEndservent)(struct IPerlSock*);
1154  typedef int        (*LPGethostname)(struct IPerlSock*, char*, int);
1155  typedef int        (*LPGetpeername)(struct IPerlSock*, SOCKET,
1156                  struct sockaddr*, int*);
1157  typedef struct hostent*    (*LPGethostbyaddr)(struct IPerlSock*, const char*,
1158                  int, int);
1159  typedef struct hostent*    (*LPGethostbyname)(struct IPerlSock*, const char*);
1160  typedef struct hostent*    (*LPGethostent)(struct IPerlSock*);
1161  typedef struct netent*    (*LPGetnetbyaddr)(struct IPerlSock*, long, int);
1162  typedef struct netent*    (*LPGetnetbyname)(struct IPerlSock*, const char*);
1163  typedef struct netent*    (*LPGetnetent)(struct IPerlSock*);
1164  typedef struct protoent*(*LPGetprotobyname)(struct IPerlSock*, const char*);
1165  typedef struct protoent*(*LPGetprotobynumber)(struct IPerlSock*, int);
1166  typedef struct protoent*(*LPGetprotoent)(struct IPerlSock*);
1167  typedef struct servent*    (*LPGetservbyname)(struct IPerlSock*, const char*,
1168                  const char*);
1169  typedef struct servent*    (*LPGetservbyport)(struct IPerlSock*, int,
1170                  const char*);
1171  typedef struct servent*    (*LPGetservent)(struct IPerlSock*);
1172  typedef int        (*LPGetsockname)(struct IPerlSock*, SOCKET,
1173                  struct sockaddr*, int*);
1174  typedef int        (*LPGetsockopt)(struct IPerlSock*, SOCKET, int, int,
1175                  char*, int*);
1176  typedef unsigned long    (*LPInetAddr)(struct IPerlSock*, const char*);
1177  typedef char*        (*LPInetNtoa)(struct IPerlSock*, struct in_addr);
1178  typedef int        (*LPListen)(struct IPerlSock*, SOCKET, int);
1179  typedef int        (*LPRecv)(struct IPerlSock*, SOCKET, char*, int, int);
1180  typedef int        (*LPRecvfrom)(struct IPerlSock*, SOCKET, char*, int,
1181                  int, struct sockaddr*, int*);
1182  typedef int        (*LPSelect)(struct IPerlSock*, int, char*, char*,
1183                  char*, const struct timeval*);
1184  typedef int        (*LPSend)(struct IPerlSock*, SOCKET, const char*, int,
1185                  int);
1186  typedef int        (*LPSendto)(struct IPerlSock*, SOCKET, const char*,
1187                  int, int, const struct sockaddr*, int);
1188  typedef void        (*LPSethostent)(struct IPerlSock*, int);
1189  typedef void        (*LPSetnetent)(struct IPerlSock*, int);
1190  typedef void        (*LPSetprotoent)(struct IPerlSock*, int);
1191  typedef void        (*LPSetservent)(struct IPerlSock*, int);
1192  typedef int        (*LPSetsockopt)(struct IPerlSock*, SOCKET, int, int,
1193                  const char*, int);
1194  typedef int        (*LPShutdown)(struct IPerlSock*, SOCKET, int);
1195  typedef SOCKET        (*LPSocket)(struct IPerlSock*, int, int, int);
1196  typedef int        (*LPSocketpair)(struct IPerlSock*, int, int, int,
1197                  int*);
1198  #ifdef WIN32
1199  typedef int        (*LPClosesocket)(struct IPerlSock*, SOCKET s);
1200  #endif
1201  
1202  struct IPerlSock
1203  {
1204      LPHtonl        pHtonl;
1205      LPHtons        pHtons;
1206      LPNtohl        pNtohl;
1207      LPNtohs        pNtohs;
1208      LPAccept        pAccept;
1209      LPBind        pBind;
1210      LPConnect        pConnect;
1211      LPEndhostent    pEndhostent;
1212      LPEndnetent        pEndnetent;
1213      LPEndprotoent    pEndprotoent;
1214      LPEndservent    pEndservent;
1215      LPGethostname    pGethostname;
1216      LPGetpeername    pGetpeername;
1217      LPGethostbyaddr    pGethostbyaddr;
1218      LPGethostbyname    pGethostbyname;
1219      LPGethostent    pGethostent;
1220      LPGetnetbyaddr    pGetnetbyaddr;
1221      LPGetnetbyname    pGetnetbyname;
1222      LPGetnetent        pGetnetent;
1223      LPGetprotobyname    pGetprotobyname;
1224      LPGetprotobynumber    pGetprotobynumber;
1225      LPGetprotoent    pGetprotoent;
1226      LPGetservbyname    pGetservbyname;
1227      LPGetservbyport    pGetservbyport;
1228      LPGetservent    pGetservent;
1229      LPGetsockname    pGetsockname;
1230      LPGetsockopt    pGetsockopt;
1231      LPInetAddr        pInetAddr;
1232      LPInetNtoa        pInetNtoa;
1233      LPListen        pListen;
1234      LPRecv        pRecv;
1235      LPRecvfrom        pRecvfrom;
1236      LPSelect        pSelect;
1237      LPSend        pSend;
1238      LPSendto        pSendto;
1239      LPSethostent    pSethostent;
1240      LPSetnetent        pSetnetent;
1241      LPSetprotoent    pSetprotoent;
1242      LPSetservent    pSetservent;
1243      LPSetsockopt    pSetsockopt;
1244      LPShutdown        pShutdown;
1245      LPSocket        pSocket;
1246      LPSocketpair    pSocketpair;
1247  #ifdef WIN32
1248      LPClosesocket    pClosesocket;
1249  #endif
1250  };
1251  
1252  struct IPerlSockInfo
1253  {
1254      unsigned long    nCount;        /* number of entries expected */
1255      struct IPerlSock    perlSockList;
1256  };
1257  
1258  #define PerlSock_htonl(x)                        \
1259      (*PL_Sock->pHtonl)(PL_Sock, x)
1260  #define PerlSock_htons(x)                        \
1261      (*PL_Sock->pHtons)(PL_Sock, x)
1262  #define PerlSock_ntohl(x)                        \
1263      (*PL_Sock->pNtohl)(PL_Sock, x)
1264  #define PerlSock_ntohs(x)                        \
1265      (*PL_Sock->pNtohs)(PL_Sock, x)
1266  #define PerlSock_accept(s, a, l)                    \
1267      (*PL_Sock->pAccept)(PL_Sock, s, a, l)
1268  #define PerlSock_bind(s, n, l)                        \
1269      (*PL_Sock->pBind)(PL_Sock, s, n, l)
1270  #define PerlSock_connect(s, n, l)                    \
1271      (*PL_Sock->pConnect)(PL_Sock, s, n, l)
1272  #define PerlSock_endhostent()                        \
1273      (*PL_Sock->pEndhostent)(PL_Sock)
1274  #define PerlSock_endnetent()                        \
1275      (*PL_Sock->pEndnetent)(PL_Sock)
1276  #define PerlSock_endprotoent()                        \
1277      (*PL_Sock->pEndprotoent)(PL_Sock)
1278  #define PerlSock_endservent()                        \
1279      (*PL_Sock->pEndservent)(PL_Sock)
1280  #define PerlSock_gethostbyaddr(a, l, t)                    \
1281      (*PL_Sock->pGethostbyaddr)(PL_Sock, a, l, t)
1282  #define PerlSock_gethostbyname(n)                    \
1283      (*PL_Sock->pGethostbyname)(PL_Sock, n)
1284  #define PerlSock_gethostent()                        \
1285      (*PL_Sock->pGethostent)(PL_Sock)
1286  #define PerlSock_gethostname(n, l)                    \
1287      (*PL_Sock->pGethostname)(PL_Sock, n, l)
1288  #define PerlSock_getnetbyaddr(n, t)                    \
1289      (*PL_Sock->pGetnetbyaddr)(PL_Sock, n, t)
1290  #define PerlSock_getnetbyname(c)                    \
1291      (*PL_Sock->pGetnetbyname)(PL_Sock, c)
1292  #define PerlSock_getnetent()                        \
1293      (*PL_Sock->pGetnetent)(PL_Sock)
1294  #define PerlSock_getpeername(s, n, l)                    \
1295      (*PL_Sock->pGetpeername)(PL_Sock, s, n, l)
1296  #define PerlSock_getprotobyname(n)                    \
1297      (*PL_Sock->pGetprotobyname)(PL_Sock, n)
1298  #define PerlSock_getprotobynumber(n)                    \
1299      (*PL_Sock->pGetprotobynumber)(PL_Sock, n)
1300  #define PerlSock_getprotoent()                        \
1301      (*PL_Sock->pGetprotoent)(PL_Sock)
1302  #define PerlSock_getservbyname(n, p)                    \
1303      (*PL_Sock->pGetservbyname)(PL_Sock, n, p)
1304  #define PerlSock_getservbyport(port, p)                    \
1305      (*PL_Sock->pGetservbyport)(PL_Sock, port, p)
1306  #define PerlSock_getservent()                        \
1307      (*PL_Sock->pGetservent)(PL_Sock)
1308  #define PerlSock_getsockname(s, n, l)                    \
1309      (*PL_Sock->pGetsockname)(PL_Sock, s, n, l)
1310  #define PerlSock_getsockopt(s,l,n,v,i)                    \
1311      (*PL_Sock->pGetsockopt)(PL_Sock, s, l, n, v, i)
1312  #define PerlSock_inet_addr(c)                        \
1313      (*PL_Sock->pInetAddr)(PL_Sock, c)
1314  #define PerlSock_inet_ntoa(i)                        \
1315      (*PL_Sock->pInetNtoa)(PL_Sock, i)
1316  #define PerlSock_listen(s, b)                        \
1317      (*PL_Sock->pListen)(PL_Sock, s, b)
1318  #define PerlSock_recv(s, b, l, f)                    \
1319      (*PL_Sock->pRecv)(PL_Sock, s, b, l, f)
1320  #define PerlSock_recvfrom(s,b,l,f,from,fromlen)                \
1321      (*PL_Sock->pRecvfrom)(PL_Sock, s, b, l, f, from, fromlen)
1322  #define PerlSock_select(n, r, w, e, t)                    \
1323      (*PL_Sock->pSelect)(PL_Sock, n, (char*)r, (char*)w, (char*)e, t)
1324  #define PerlSock_send(s, b, l, f)                    \
1325      (*PL_Sock->pSend)(PL_Sock, s, b, l, f)
1326  #define PerlSock_sendto(s, b, l, f, t, tlen)                \
1327      (*PL_Sock->pSendto)(PL_Sock, s, b, l, f, t, tlen)
1328  #define PerlSock_sethostent(f)                        \
1329      (*PL_Sock->pSethostent)(PL_Sock, f)
1330  #define PerlSock_setnetent(f)                        \
1331      (*PL_Sock->pSetnetent)(PL_Sock, f)
1332  #define PerlSock_setprotoent(f)                        \
1333      (*PL_Sock->pSetprotoent)(PL_Sock, f)
1334  #define PerlSock_setservent(f)                        \
1335      (*PL_Sock->pSetservent)(PL_Sock, f)
1336  #define PerlSock_setsockopt(s, l, n, v, len)                \
1337      (*PL_Sock->pSetsockopt)(PL_Sock, s, l, n, v, len)
1338  #define PerlSock_shutdown(s, h)                        \
1339      (*PL_Sock->pShutdown)(PL_Sock, s, h)
1340  #define PerlSock_socket(a, t, p)                    \
1341      (*PL_Sock->pSocket)(PL_Sock, a, t, p)
1342  #define PerlSock_socketpair(a, t, p, f)                    \
1343      (*PL_Sock->pSocketpair)(PL_Sock, a, t, p, f)
1344  
1345  #ifdef WIN32
1346  #define    PerlSock_closesocket(s)                        \
1347      (*PL_Sock->pClosesocket)(PL_Sock, s)
1348  #endif
1349  
1350  #else    /* PERL_IMPLICIT_SYS */
1351  
1352  #define PerlSock_htonl(x)        htonl(x)
1353  #define PerlSock_htons(x)        htons(x)
1354  #define PerlSock_ntohl(x)        ntohl(x)
1355  #define PerlSock_ntohs(x)        ntohs(x)
1356  #define PerlSock_accept(s, a, l)    accept(s, a, l)
1357  #define PerlSock_bind(s, n, l)        bind(s, n, l)
1358  #define PerlSock_connect(s, n, l)    connect(s, n, l)
1359  
1360  #define PerlSock_gethostbyaddr(a, l, t)    gethostbyaddr(a, l, t)
1361  #define PerlSock_gethostbyname(n)    gethostbyname(n)
1362  #define PerlSock_gethostent        gethostent
1363  #define PerlSock_endhostent        endhostent
1364  #define PerlSock_gethostname(n, l)    gethostname(n, l)
1365  
1366  #define PerlSock_getnetbyaddr(n, t)    getnetbyaddr(n, t)
1367  #define PerlSock_getnetbyname(n)    getnetbyname(n)
1368  #define PerlSock_getnetent        getnetent
1369  #define PerlSock_endnetent        endnetent
1370  #define PerlSock_getpeername(s, n, l)    getpeername(s, n, l)
1371  
1372  #define PerlSock_getprotobyname(n)    getprotobyname(n)
1373  #define PerlSock_getprotobynumber(n)    getprotobynumber(n)
1374  #define PerlSock_getprotoent        getprotoent
1375  #define PerlSock_endprotoent        endprotoent
1376  
1377  #define PerlSock_getservbyname(n, p)    getservbyname(n, p)
1378  #define PerlSock_getservbyport(port, p)    getservbyport(port, p)
1379  #define PerlSock_getservent        getservent
1380  #define PerlSock_endservent        endservent
1381  
1382  #define PerlSock_getsockname(s, n, l)    getsockname(s, n, l)
1383  #define PerlSock_getsockopt(s,l,n,v,i)    getsockopt(s, l, n, v, i)
1384  #define PerlSock_inet_addr(c)        inet_addr(c)
1385  #define PerlSock_inet_ntoa(i)        inet_ntoa(i)
1386  #define PerlSock_listen(s, b)        listen(s, b)
1387  #define PerlSock_recv(s, b, l, f)    recv(s, b, l, f)
1388  #define PerlSock_recvfrom(s, b, l, f, from, fromlen)            \
1389      recvfrom(s, b, l, f, from, fromlen)
1390  #define PerlSock_select(n, r, w, e, t)    select(n, r, w, e, t)
1391  #define PerlSock_send(s, b, l, f)    send(s, b, l, f)
1392  #define PerlSock_sendto(s, b, l, f, t, tlen)                \
1393      sendto(s, b, l, f, t, tlen)
1394  #define PerlSock_sethostent(f)        sethostent(f)
1395  #define PerlSock_setnetent(f)        setnetent(f)
1396  #define PerlSock_setprotoent(f)        setprotoent(f)
1397  #define PerlSock_setservent(f)        setservent(f)
1398  #define PerlSock_setsockopt(s, l, n, v, len)                \
1399      setsockopt(s, l, n, v, len)
1400  #define PerlSock_shutdown(s, h)        shutdown(s, h)
1401  #define PerlSock_socket(a, t, p)    socket(a, t, p)
1402  #define PerlSock_socketpair(a, t, p, f)    socketpair(a, t, p, f)
1403  
1404  #ifdef WIN32
1405  #define PerlSock_closesocket(s)        closesocket(s)
1406  #endif
1407  
1408  #endif    /* PERL_IMPLICIT_SYS */
1409  
1410  #endif    /* __Inc__IPerl___ */
1411  


Generated: Tue Mar 17 22:47:18 2015 Cross-referenced by PHPXref 0.7.1