home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Database Designers / Rational Rose 2000 / Rational Setup.EXE / common / lib / MSWin32-x86 / CORE / opcode.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-26  |  51.4 KB  |  2,526 lines
  1. #define pp_i_preinc pp_preinc
  2. #define pp_i_predec pp_predec
  3. #define pp_i_postinc pp_postinc
  4. #define pp_i_postdec pp_postdec
  5.  
  6. typedef enum {
  7.     OP_NULL,    /* 0 */
  8.     OP_STUB,    /* 1 */
  9.     OP_SCALAR,    /* 2 */
  10.     OP_PUSHMARK,    /* 3 */
  11.     OP_WANTARRAY,    /* 4 */
  12.     OP_CONST,    /* 5 */
  13.     OP_GVSV,    /* 6 */
  14.     OP_GV,        /* 7 */
  15.     OP_GELEM,    /* 8 */
  16.     OP_PADSV,    /* 9 */
  17.     OP_PADAV,    /* 10 */
  18.     OP_PADHV,    /* 11 */
  19.     OP_PADANY,    /* 12 */
  20.     OP_PUSHRE,    /* 13 */
  21.     OP_RV2GV,    /* 14 */
  22.     OP_RV2SV,    /* 15 */
  23.     OP_AV2ARYLEN,    /* 16 */
  24.     OP_RV2CV,    /* 17 */
  25.     OP_ANONCODE,    /* 18 */
  26.     OP_PROTOTYPE,    /* 19 */
  27.     OP_REFGEN,    /* 20 */
  28.     OP_SREFGEN,    /* 21 */
  29.     OP_REF,        /* 22 */
  30.     OP_BLESS,    /* 23 */
  31.     OP_BACKTICK,    /* 24 */
  32.     OP_GLOB,    /* 25 */
  33.     OP_READLINE,    /* 26 */
  34.     OP_RCATLINE,    /* 27 */
  35.     OP_REGCMAYBE,    /* 28 */
  36.     OP_REGCRESET,    /* 29 */
  37.     OP_REGCOMP,    /* 30 */
  38.     OP_MATCH,    /* 31 */
  39.     OP_QR,        /* 32 */
  40.     OP_SUBST,    /* 33 */
  41.     OP_SUBSTCONT,    /* 34 */
  42.     OP_TRANS,    /* 35 */
  43.     OP_SASSIGN,    /* 36 */
  44.     OP_AASSIGN,    /* 37 */
  45.     OP_CHOP,    /* 38 */
  46.     OP_SCHOP,    /* 39 */
  47.     OP_CHOMP,    /* 40 */
  48.     OP_SCHOMP,    /* 41 */
  49.     OP_DEFINED,    /* 42 */
  50.     OP_UNDEF,    /* 43 */
  51.     OP_STUDY,    /* 44 */
  52.     OP_POS,        /* 45 */
  53.     OP_PREINC,    /* 46 */
  54.     OP_I_PREINC,    /* 47 */
  55.     OP_PREDEC,    /* 48 */
  56.     OP_I_PREDEC,    /* 49 */
  57.     OP_POSTINC,    /* 50 */
  58.     OP_I_POSTINC,    /* 51 */
  59.     OP_POSTDEC,    /* 52 */
  60.     OP_I_POSTDEC,    /* 53 */
  61.     OP_POW,        /* 54 */
  62.     OP_MULTIPLY,    /* 55 */
  63.     OP_I_MULTIPLY,    /* 56 */
  64.     OP_DIVIDE,    /* 57 */
  65.     OP_I_DIVIDE,    /* 58 */
  66.     OP_MODULO,    /* 59 */
  67.     OP_I_MODULO,    /* 60 */
  68.     OP_REPEAT,    /* 61 */
  69.     OP_ADD,        /* 62 */
  70.     OP_I_ADD,    /* 63 */
  71.     OP_SUBTRACT,    /* 64 */
  72.     OP_I_SUBTRACT,    /* 65 */
  73.     OP_CONCAT,    /* 66 */
  74.     OP_STRINGIFY,    /* 67 */
  75.     OP_LEFT_SHIFT,    /* 68 */
  76.     OP_RIGHT_SHIFT,    /* 69 */
  77.     OP_LT,        /* 70 */
  78.     OP_I_LT,    /* 71 */
  79.     OP_GT,        /* 72 */
  80.     OP_I_GT,    /* 73 */
  81.     OP_LE,        /* 74 */
  82.     OP_I_LE,    /* 75 */
  83.     OP_GE,        /* 76 */
  84.     OP_I_GE,    /* 77 */
  85.     OP_EQ,        /* 78 */
  86.     OP_I_EQ,    /* 79 */
  87.     OP_NE,        /* 80 */
  88.     OP_I_NE,    /* 81 */
  89.     OP_NCMP,    /* 82 */
  90.     OP_I_NCMP,    /* 83 */
  91.     OP_SLT,        /* 84 */
  92.     OP_SGT,        /* 85 */
  93.     OP_SLE,        /* 86 */
  94.     OP_SGE,        /* 87 */
  95.     OP_SEQ,        /* 88 */
  96.     OP_SNE,        /* 89 */
  97.     OP_SCMP,    /* 90 */
  98.     OP_BIT_AND,    /* 91 */
  99.     OP_BIT_XOR,    /* 92 */
  100.     OP_BIT_OR,    /* 93 */
  101.     OP_NEGATE,    /* 94 */
  102.     OP_I_NEGATE,    /* 95 */
  103.     OP_NOT,        /* 96 */
  104.     OP_COMPLEMENT,    /* 97 */
  105.     OP_ATAN2,    /* 98 */
  106.     OP_SIN,        /* 99 */
  107.     OP_COS,        /* 100 */
  108.     OP_RAND,    /* 101 */
  109.     OP_SRAND,    /* 102 */
  110.     OP_EXP,        /* 103 */
  111.     OP_LOG,        /* 104 */
  112.     OP_SQRT,    /* 105 */
  113.     OP_INT,        /* 106 */
  114.     OP_HEX,        /* 107 */
  115.     OP_OCT,        /* 108 */
  116.     OP_ABS,        /* 109 */
  117.     OP_LENGTH,    /* 110 */
  118.     OP_SUBSTR,    /* 111 */
  119.     OP_VEC,        /* 112 */
  120.     OP_INDEX,    /* 113 */
  121.     OP_RINDEX,    /* 114 */
  122.     OP_SPRINTF,    /* 115 */
  123.     OP_FORMLINE,    /* 116 */
  124.     OP_ORD,        /* 117 */
  125.     OP_CHR,        /* 118 */
  126.     OP_CRYPT,    /* 119 */
  127.     OP_UCFIRST,    /* 120 */
  128.     OP_LCFIRST,    /* 121 */
  129.     OP_UC,        /* 122 */
  130.     OP_LC,        /* 123 */
  131.     OP_QUOTEMETA,    /* 124 */
  132.     OP_RV2AV,    /* 125 */
  133.     OP_AELEMFAST,    /* 126 */
  134.     OP_AELEM,    /* 127 */
  135.     OP_ASLICE,    /* 128 */
  136.     OP_EACH,    /* 129 */
  137.     OP_VALUES,    /* 130 */
  138.     OP_KEYS,    /* 131 */
  139.     OP_DELETE,    /* 132 */
  140.     OP_EXISTS,    /* 133 */
  141.     OP_RV2HV,    /* 134 */
  142.     OP_HELEM,    /* 135 */
  143.     OP_HSLICE,    /* 136 */
  144.     OP_UNPACK,    /* 137 */
  145.     OP_PACK,    /* 138 */
  146.     OP_SPLIT,    /* 139 */
  147.     OP_JOIN,    /* 140 */
  148.     OP_LIST,    /* 141 */
  149.     OP_LSLICE,    /* 142 */
  150.     OP_ANONLIST,    /* 143 */
  151.     OP_ANONHASH,    /* 144 */
  152.     OP_SPLICE,    /* 145 */
  153.     OP_PUSH,    /* 146 */
  154.     OP_POP,        /* 147 */
  155.     OP_SHIFT,    /* 148 */
  156.     OP_UNSHIFT,    /* 149 */
  157.     OP_SORT,    /* 150 */
  158.     OP_REVERSE,    /* 151 */
  159.     OP_GREPSTART,    /* 152 */
  160.     OP_GREPWHILE,    /* 153 */
  161.     OP_MAPSTART,    /* 154 */
  162.     OP_MAPWHILE,    /* 155 */
  163.     OP_RANGE,    /* 156 */
  164.     OP_FLIP,    /* 157 */
  165.     OP_FLOP,    /* 158 */
  166.     OP_AND,        /* 159 */
  167.     OP_OR,        /* 160 */
  168.     OP_XOR,        /* 161 */
  169.     OP_COND_EXPR,    /* 162 */
  170.     OP_ANDASSIGN,    /* 163 */
  171.     OP_ORASSIGN,    /* 164 */
  172.     OP_METHOD,    /* 165 */
  173.     OP_ENTERSUB,    /* 166 */
  174.     OP_LEAVESUB,    /* 167 */
  175.     OP_CALLER,    /* 168 */
  176.     OP_WARN,    /* 169 */
  177.     OP_DIE,        /* 170 */
  178.     OP_RESET,    /* 171 */
  179.     OP_LINESEQ,    /* 172 */
  180.     OP_NEXTSTATE,    /* 173 */
  181.     OP_DBSTATE,    /* 174 */
  182.     OP_UNSTACK,    /* 175 */
  183.     OP_ENTER,    /* 176 */
  184.     OP_LEAVE,    /* 177 */
  185.     OP_SCOPE,    /* 178 */
  186.     OP_ENTERITER,    /* 179 */
  187.     OP_ITER,    /* 180 */
  188.     OP_ENTERLOOP,    /* 181 */
  189.     OP_LEAVELOOP,    /* 182 */
  190.     OP_RETURN,    /* 183 */
  191.     OP_LAST,    /* 184 */
  192.     OP_NEXT,    /* 185 */
  193.     OP_REDO,    /* 186 */
  194.     OP_DUMP,    /* 187 */
  195.     OP_GOTO,    /* 188 */
  196.     OP_EXIT,    /* 189 */
  197.     OP_OPEN,    /* 190 */
  198.     OP_CLOSE,    /* 191 */
  199.     OP_PIPE_OP,    /* 192 */
  200.     OP_FILENO,    /* 193 */
  201.     OP_UMASK,    /* 194 */
  202.     OP_BINMODE,    /* 195 */
  203.     OP_TIE,        /* 196 */
  204.     OP_UNTIE,    /* 197 */
  205.     OP_TIED,    /* 198 */
  206.     OP_DBMOPEN,    /* 199 */
  207.     OP_DBMCLOSE,    /* 200 */
  208.     OP_SSELECT,    /* 201 */
  209.     OP_SELECT,    /* 202 */
  210.     OP_GETC,    /* 203 */
  211.     OP_READ,    /* 204 */
  212.     OP_ENTERWRITE,    /* 205 */
  213.     OP_LEAVEWRITE,    /* 206 */
  214.     OP_PRTF,    /* 207 */
  215.     OP_PRINT,    /* 208 */
  216.     OP_SYSOPEN,    /* 209 */
  217.     OP_SYSSEEK,    /* 210 */
  218.     OP_SYSREAD,    /* 211 */
  219.     OP_SYSWRITE,    /* 212 */
  220.     OP_SEND,    /* 213 */
  221.     OP_RECV,    /* 214 */
  222.     OP_EOF,        /* 215 */
  223.     OP_TELL,    /* 216 */
  224.     OP_SEEK,    /* 217 */
  225.     OP_TRUNCATE,    /* 218 */
  226.     OP_FCNTL,    /* 219 */
  227.     OP_IOCTL,    /* 220 */
  228.     OP_FLOCK,    /* 221 */
  229.     OP_SOCKET,    /* 222 */
  230.     OP_SOCKPAIR,    /* 223 */
  231.     OP_BIND,    /* 224 */
  232.     OP_CONNECT,    /* 225 */
  233.     OP_LISTEN,    /* 226 */
  234.     OP_ACCEPT,    /* 227 */
  235.     OP_SHUTDOWN,    /* 228 */
  236.     OP_GSOCKOPT,    /* 229 */
  237.     OP_SSOCKOPT,    /* 230 */
  238.     OP_GETSOCKNAME,    /* 231 */
  239.     OP_GETPEERNAME,    /* 232 */
  240.     OP_LSTAT,    /* 233 */
  241.     OP_STAT,    /* 234 */
  242.     OP_FTRREAD,    /* 235 */
  243.     OP_FTRWRITE,    /* 236 */
  244.     OP_FTREXEC,    /* 237 */
  245.     OP_FTEREAD,    /* 238 */
  246.     OP_FTEWRITE,    /* 239 */
  247.     OP_FTEEXEC,    /* 240 */
  248.     OP_FTIS,    /* 241 */
  249.     OP_FTEOWNED,    /* 242 */
  250.     OP_FTROWNED,    /* 243 */
  251.     OP_FTZERO,    /* 244 */
  252.     OP_FTSIZE,    /* 245 */
  253.     OP_FTMTIME,    /* 246 */
  254.     OP_FTATIME,    /* 247 */
  255.     OP_FTCTIME,    /* 248 */
  256.     OP_FTSOCK,    /* 249 */
  257.     OP_FTCHR,    /* 250 */
  258.     OP_FTBLK,    /* 251 */
  259.     OP_FTFILE,    /* 252 */
  260.     OP_FTDIR,    /* 253 */
  261.     OP_FTPIPE,    /* 254 */
  262.     OP_FTLINK,    /* 255 */
  263.     OP_FTSUID,    /* 256 */
  264.     OP_FTSGID,    /* 257 */
  265.     OP_FTSVTX,    /* 258 */
  266.     OP_FTTTY,    /* 259 */
  267.     OP_FTTEXT,    /* 260 */
  268.     OP_FTBINARY,    /* 261 */
  269.     OP_CHDIR,    /* 262 */
  270.     OP_CHOWN,    /* 263 */
  271.     OP_CHROOT,    /* 264 */
  272.     OP_UNLINK,    /* 265 */
  273.     OP_CHMOD,    /* 266 */
  274.     OP_UTIME,    /* 267 */
  275.     OP_RENAME,    /* 268 */
  276.     OP_LINK,    /* 269 */
  277.     OP_SYMLINK,    /* 270 */
  278.     OP_READLINK,    /* 271 */
  279.     OP_MKDIR,    /* 272 */
  280.     OP_RMDIR,    /* 273 */
  281.     OP_OPEN_DIR,    /* 274 */
  282.     OP_READDIR,    /* 275 */
  283.     OP_TELLDIR,    /* 276 */
  284.     OP_SEEKDIR,    /* 277 */
  285.     OP_REWINDDIR,    /* 278 */
  286.     OP_CLOSEDIR,    /* 279 */
  287.     OP_FORK,    /* 280 */
  288.     OP_WAIT,    /* 281 */
  289.     OP_WAITPID,    /* 282 */
  290.     OP_SYSTEM,    /* 283 */
  291.     OP_EXEC,    /* 284 */
  292.     OP_KILL,    /* 285 */
  293.     OP_GETPPID,    /* 286 */
  294.     OP_GETPGRP,    /* 287 */
  295.     OP_SETPGRP,    /* 288 */
  296.     OP_GETPRIORITY,    /* 289 */
  297.     OP_SETPRIORITY,    /* 290 */
  298.     OP_TIME,    /* 291 */
  299.     OP_TMS,        /* 292 */
  300.     OP_LOCALTIME,    /* 293 */
  301.     OP_GMTIME,    /* 294 */
  302.     OP_ALARM,    /* 295 */
  303.     OP_SLEEP,    /* 296 */
  304.     OP_SHMGET,    /* 297 */
  305.     OP_SHMCTL,    /* 298 */
  306.     OP_SHMREAD,    /* 299 */
  307.     OP_SHMWRITE,    /* 300 */
  308.     OP_MSGGET,    /* 301 */
  309.     OP_MSGCTL,    /* 302 */
  310.     OP_MSGSND,    /* 303 */
  311.     OP_MSGRCV,    /* 304 */
  312.     OP_SEMGET,    /* 305 */
  313.     OP_SEMCTL,    /* 306 */
  314.     OP_SEMOP,    /* 307 */
  315.     OP_REQUIRE,    /* 308 */
  316.     OP_DOFILE,    /* 309 */
  317.     OP_ENTEREVAL,    /* 310 */
  318.     OP_LEAVEEVAL,    /* 311 */
  319.     OP_ENTERTRY,    /* 312 */
  320.     OP_LEAVETRY,    /* 313 */
  321.     OP_GHBYNAME,    /* 314 */
  322.     OP_GHBYADDR,    /* 315 */
  323.     OP_GHOSTENT,    /* 316 */
  324.     OP_GNBYNAME,    /* 317 */
  325.     OP_GNBYADDR,    /* 318 */
  326.     OP_GNETENT,    /* 319 */
  327.     OP_GPBYNAME,    /* 320 */
  328.     OP_GPBYNUMBER,    /* 321 */
  329.     OP_GPROTOENT,    /* 322 */
  330.     OP_GSBYNAME,    /* 323 */
  331.     OP_GSBYPORT,    /* 324 */
  332.     OP_GSERVENT,    /* 325 */
  333.     OP_SHOSTENT,    /* 326 */
  334.     OP_SNETENT,    /* 327 */
  335.     OP_SPROTOENT,    /* 328 */
  336.     OP_SSERVENT,    /* 329 */
  337.     OP_EHOSTENT,    /* 330 */
  338.     OP_ENETENT,    /* 331 */
  339.     OP_EPROTOENT,    /* 332 */
  340.     OP_ESERVENT,    /* 333 */
  341.     OP_GPWNAM,    /* 334 */
  342.     OP_GPWUID,    /* 335 */
  343.     OP_GPWENT,    /* 336 */
  344.     OP_SPWENT,    /* 337 */
  345.     OP_EPWENT,    /* 338 */
  346.     OP_GGRNAM,    /* 339 */
  347.     OP_GGRGID,    /* 340 */
  348.     OP_GGRENT,    /* 341 */
  349.     OP_SGRENT,    /* 342 */
  350.     OP_EGRENT,    /* 343 */
  351.     OP_GETLOGIN,    /* 344 */
  352.     OP_SYSCALL,    /* 345 */
  353.     OP_LOCK,    /* 346 */
  354.     OP_THREADSV,    /* 347 */
  355.     OP_max        
  356. } opcode;
  357.  
  358. #define MAXO 348
  359.  
  360. #ifndef DOINIT
  361. EXT char *op_name[];
  362. #else
  363. EXT char *op_name[] = {
  364.     "null",
  365.     "stub",
  366.     "scalar",
  367.     "pushmark",
  368.     "wantarray",
  369.     "const",
  370.     "gvsv",
  371.     "gv",
  372.     "gelem",
  373.     "padsv",
  374.     "padav",
  375.     "padhv",
  376.     "padany",
  377.     "pushre",
  378.     "rv2gv",
  379.     "rv2sv",
  380.     "av2arylen",
  381.     "rv2cv",
  382.     "anoncode",
  383.     "prototype",
  384.     "refgen",
  385.     "srefgen",
  386.     "ref",
  387.     "bless",
  388.     "backtick",
  389.     "glob",
  390.     "readline",
  391.     "rcatline",
  392.     "regcmaybe",
  393.     "regcreset",
  394.     "regcomp",
  395.     "match",
  396.     "qr",
  397.     "subst",
  398.     "substcont",
  399.     "trans",
  400.     "sassign",
  401.     "aassign",
  402.     "chop",
  403.     "schop",
  404.     "chomp",
  405.     "schomp",
  406.     "defined",
  407.     "undef",
  408.     "study",
  409.     "pos",
  410.     "preinc",
  411.     "i_preinc",
  412.     "predec",
  413.     "i_predec",
  414.     "postinc",
  415.     "i_postinc",
  416.     "postdec",
  417.     "i_postdec",
  418.     "pow",
  419.     "multiply",
  420.     "i_multiply",
  421.     "divide",
  422.     "i_divide",
  423.     "modulo",
  424.     "i_modulo",
  425.     "repeat",
  426.     "add",
  427.     "i_add",
  428.     "subtract",
  429.     "i_subtract",
  430.     "concat",
  431.     "stringify",
  432.     "left_shift",
  433.     "right_shift",
  434.     "lt",
  435.     "i_lt",
  436.     "gt",
  437.     "i_gt",
  438.     "le",
  439.     "i_le",
  440.     "ge",
  441.     "i_ge",
  442.     "eq",
  443.     "i_eq",
  444.     "ne",
  445.     "i_ne",
  446.     "ncmp",
  447.     "i_ncmp",
  448.     "slt",
  449.     "sgt",
  450.     "sle",
  451.     "sge",
  452.     "seq",
  453.     "sne",
  454.     "scmp",
  455.     "bit_and",
  456.     "bit_xor",
  457.     "bit_or",
  458.     "negate",
  459.     "i_negate",
  460.     "not",
  461.     "complement",
  462.     "atan2",
  463.     "sin",
  464.     "cos",
  465.     "rand",
  466.     "srand",
  467.     "exp",
  468.     "log",
  469.     "sqrt",
  470.     "int",
  471.     "hex",
  472.     "oct",
  473.     "abs",
  474.     "length",
  475.     "substr",
  476.     "vec",
  477.     "index",
  478.     "rindex",
  479.     "sprintf",
  480.     "formline",
  481.     "ord",
  482.     "chr",
  483.     "crypt",
  484.     "ucfirst",
  485.     "lcfirst",
  486.     "uc",
  487.     "lc",
  488.     "quotemeta",
  489.     "rv2av",
  490.     "aelemfast",
  491.     "aelem",
  492.     "aslice",
  493.     "each",
  494.     "values",
  495.     "keys",
  496.     "delete",
  497.     "exists",
  498.     "rv2hv",
  499.     "helem",
  500.     "hslice",
  501.     "unpack",
  502.     "pack",
  503.     "split",
  504.     "join",
  505.     "list",
  506.     "lslice",
  507.     "anonlist",
  508.     "anonhash",
  509.     "splice",
  510.     "push",
  511.     "pop",
  512.     "shift",
  513.     "unshift",
  514.     "sort",
  515.     "reverse",
  516.     "grepstart",
  517.     "grepwhile",
  518.     "mapstart",
  519.     "mapwhile",
  520.     "range",
  521.     "flip",
  522.     "flop",
  523.     "and",
  524.     "or",
  525.     "xor",
  526.     "cond_expr",
  527.     "andassign",
  528.     "orassign",
  529.     "method",
  530.     "entersub",
  531.     "leavesub",
  532.     "caller",
  533.     "warn",
  534.     "die",
  535.     "reset",
  536.     "lineseq",
  537.     "nextstate",
  538.     "dbstate",
  539.     "unstack",
  540.     "enter",
  541.     "leave",
  542.     "scope",
  543.     "enteriter",
  544.     "iter",
  545.     "enterloop",
  546.     "leaveloop",
  547.     "return",
  548.     "last",
  549.     "next",
  550.     "redo",
  551.     "dump",
  552.     "goto",
  553.     "exit",
  554.     "open",
  555.     "close",
  556.     "pipe_op",
  557.     "fileno",
  558.     "umask",
  559.     "binmode",
  560.     "tie",
  561.     "untie",
  562.     "tied",
  563.     "dbmopen",
  564.     "dbmclose",
  565.     "sselect",
  566.     "select",
  567.     "getc",
  568.     "read",
  569.     "enterwrite",
  570.     "leavewrite",
  571.     "prtf",
  572.     "print",
  573.     "sysopen",
  574.     "sysseek",
  575.     "sysread",
  576.     "syswrite",
  577.     "send",
  578.     "recv",
  579.     "eof",
  580.     "tell",
  581.     "seek",
  582.     "truncate",
  583.     "fcntl",
  584.     "ioctl",
  585.     "flock",
  586.     "socket",
  587.     "sockpair",
  588.     "bind",
  589.     "connect",
  590.     "listen",
  591.     "accept",
  592.     "shutdown",
  593.     "gsockopt",
  594.     "ssockopt",
  595.     "getsockname",
  596.     "getpeername",
  597.     "lstat",
  598.     "stat",
  599.     "ftrread",
  600.     "ftrwrite",
  601.     "ftrexec",
  602.     "fteread",
  603.     "ftewrite",
  604.     "fteexec",
  605.     "ftis",
  606.     "fteowned",
  607.     "ftrowned",
  608.     "ftzero",
  609.     "ftsize",
  610.     "ftmtime",
  611.     "ftatime",
  612.     "ftctime",
  613.     "ftsock",
  614.     "ftchr",
  615.     "ftblk",
  616.     "ftfile",
  617.     "ftdir",
  618.     "ftpipe",
  619.     "ftlink",
  620.     "ftsuid",
  621.     "ftsgid",
  622.     "ftsvtx",
  623.     "fttty",
  624.     "fttext",
  625.     "ftbinary",
  626.     "chdir",
  627.     "chown",
  628.     "chroot",
  629.     "unlink",
  630.     "chmod",
  631.     "utime",
  632.     "rename",
  633.     "link",
  634.     "symlink",
  635.     "readlink",
  636.     "mkdir",
  637.     "rmdir",
  638.     "open_dir",
  639.     "readdir",
  640.     "telldir",
  641.     "seekdir",
  642.     "rewinddir",
  643.     "closedir",
  644.     "fork",
  645.     "wait",
  646.     "waitpid",
  647.     "system",
  648.     "exec",
  649.     "kill",
  650.     "getppid",
  651.     "getpgrp",
  652.     "setpgrp",
  653.     "getpriority",
  654.     "setpriority",
  655.     "time",
  656.     "tms",
  657.     "localtime",
  658.     "gmtime",
  659.     "alarm",
  660.     "sleep",
  661.     "shmget",
  662.     "shmctl",
  663.     "shmread",
  664.     "shmwrite",
  665.     "msgget",
  666.     "msgctl",
  667.     "msgsnd",
  668.     "msgrcv",
  669.     "semget",
  670.     "semctl",
  671.     "semop",
  672.     "require",
  673.     "dofile",
  674.     "entereval",
  675.     "leaveeval",
  676.     "entertry",
  677.     "leavetry",
  678.     "ghbyname",
  679.     "ghbyaddr",
  680.     "ghostent",
  681.     "gnbyname",
  682.     "gnbyaddr",
  683.     "gnetent",
  684.     "gpbyname",
  685.     "gpbynumber",
  686.     "gprotoent",
  687.     "gsbyname",
  688.     "gsbyport",
  689.     "gservent",
  690.     "shostent",
  691.     "snetent",
  692.     "sprotoent",
  693.     "sservent",
  694.     "ehostent",
  695.     "enetent",
  696.     "eprotoent",
  697.     "eservent",
  698.     "gpwnam",
  699.     "gpwuid",
  700.     "gpwent",
  701.     "spwent",
  702.     "epwent",
  703.     "ggrnam",
  704.     "ggrgid",
  705.     "ggrent",
  706.     "sgrent",
  707.     "egrent",
  708.     "getlogin",
  709.     "syscall",
  710.     "lock",
  711.     "threadsv",
  712. };
  713. #endif
  714.  
  715. #ifndef DOINIT
  716. EXT char *op_desc[];
  717. #else
  718. EXT char *op_desc[] = {
  719.     "null operation",
  720.     "stub",
  721.     "scalar",
  722.     "pushmark",
  723.     "wantarray",
  724.     "constant item",
  725.     "scalar variable",
  726.     "glob value",
  727.     "glob elem",
  728.     "private variable",
  729.     "private array",
  730.     "private hash",
  731.     "private something",
  732.     "push regexp",
  733.     "ref-to-glob cast",
  734.     "scalar deref",
  735.     "array length",
  736.     "subroutine deref",
  737.     "anonymous subroutine",
  738.     "subroutine prototype",
  739.     "reference constructor",
  740.     "scalar ref constructor",
  741.     "reference-type operator",
  742.     "bless",
  743.     "backticks",
  744.     "glob",
  745.     "<HANDLE>",
  746.     "append I/O operator",
  747.     "regexp comp once",
  748.     "regexp reset interpolation flag",
  749.     "regexp compilation",
  750.     "pattern match",
  751.     "pattern quote",
  752.     "substitution",
  753.     "substitution cont",
  754.     "character translation",
  755.     "scalar assignment",
  756.     "list assignment",
  757.     "chop",
  758.     "scalar chop",
  759.     "safe chop",
  760.     "scalar safe chop",
  761.     "defined operator",
  762.     "undef operator",
  763.     "study",
  764.     "match position",
  765.     "preincrement",
  766.     "integer preincrement",
  767.     "predecrement",
  768.     "integer predecrement",
  769.     "postincrement",
  770.     "integer postincrement",
  771.     "postdecrement",
  772.     "integer postdecrement",
  773.     "exponentiation",
  774.     "multiplication",
  775.     "integer multiplication",
  776.     "division",
  777.     "integer division",
  778.     "modulus",
  779.     "integer modulus",
  780.     "repeat",
  781.     "addition",
  782.     "integer addition",
  783.     "subtraction",
  784.     "integer subtraction",
  785.     "concatenation",
  786.     "string",
  787.     "left bitshift",
  788.     "right bitshift",
  789.     "numeric lt",
  790.     "integer lt",
  791.     "numeric gt",
  792.     "integer gt",
  793.     "numeric le",
  794.     "integer le",
  795.     "numeric ge",
  796.     "integer ge",
  797.     "numeric eq",
  798.     "integer eq",
  799.     "numeric ne",
  800.     "integer ne",
  801.     "spaceship operator",
  802.     "integer spaceship",
  803.     "string lt",
  804.     "string gt",
  805.     "string le",
  806.     "string ge",
  807.     "string eq",
  808.     "string ne",
  809.     "string comparison",
  810.     "bitwise and",
  811.     "bitwise xor",
  812.     "bitwise or",
  813.     "negate",
  814.     "integer negate",
  815.     "not",
  816.     "1's complement",
  817.     "atan2",
  818.     "sin",
  819.     "cos",
  820.     "rand",
  821.     "srand",
  822.     "exp",
  823.     "log",
  824.     "sqrt",
  825.     "int",
  826.     "hex",
  827.     "oct",
  828.     "abs",
  829.     "length",
  830.     "substr",
  831.     "vec",
  832.     "index",
  833.     "rindex",
  834.     "sprintf",
  835.     "formline",
  836.     "ord",
  837.     "chr",
  838.     "crypt",
  839.     "upper case first",
  840.     "lower case first",
  841.     "upper case",
  842.     "lower case",
  843.     "quote metachars",
  844.     "array deref",
  845.     "known array element",
  846.     "array element",
  847.     "array slice",
  848.     "each",
  849.     "values",
  850.     "keys",
  851.     "delete",
  852.     "exists operator",
  853.     "hash deref",
  854.     "hash elem",
  855.     "hash slice",
  856.     "unpack",
  857.     "pack",
  858.     "split",
  859.     "join",
  860.     "list",
  861.     "list slice",
  862.     "anonymous list",
  863.     "anonymous hash",
  864.     "splice",
  865.     "push",
  866.     "pop",
  867.     "shift",
  868.     "unshift",
  869.     "sort",
  870.     "reverse",
  871.     "grep",
  872.     "grep iterator",
  873.     "map",
  874.     "map iterator",
  875.     "flipflop",
  876.     "range (or flip)",
  877.     "range (or flop)",
  878.     "logical and",
  879.     "logical or",
  880.     "logical xor",
  881.     "conditional expression",
  882.     "logical and assignment",
  883.     "logical or assignment",
  884.     "method lookup",
  885.     "subroutine entry",
  886.     "subroutine exit",
  887.     "caller",
  888.     "warn",
  889.     "die",
  890.     "reset",
  891.     "line sequence",
  892.     "next statement",
  893.     "debug next statement",
  894.     "unstack",
  895.     "block entry",
  896.     "block exit",
  897.     "block",
  898.     "foreach loop entry",
  899.     "foreach loop iterator",
  900.     "loop entry",
  901.     "loop exit",
  902.     "return",
  903.     "last",
  904.     "next",
  905.     "redo",
  906.     "dump",
  907.     "goto",
  908.     "exit",
  909.     "open",
  910.     "close",
  911.     "pipe",
  912.     "fileno",
  913.     "umask",
  914.     "binmode",
  915.     "tie",
  916.     "untie",
  917.     "tied",
  918.     "dbmopen",
  919.     "dbmclose",
  920.     "select system call",
  921.     "select",
  922.     "getc",
  923.     "read",
  924.     "write",
  925.     "write exit",
  926.     "printf",
  927.     "print",
  928.     "sysopen",
  929.     "sysseek",
  930.     "sysread",
  931.     "syswrite",
  932.     "send",
  933.     "recv",
  934.     "eof",
  935.     "tell",
  936.     "seek",
  937.     "truncate",
  938.     "fcntl",
  939.     "ioctl",
  940.     "flock",
  941.     "socket",
  942.     "socketpair",
  943.     "bind",
  944.     "connect",
  945.     "listen",
  946.     "accept",
  947.     "shutdown",
  948.     "getsockopt",
  949.     "setsockopt",
  950.     "getsockname",
  951.     "getpeername",
  952.     "lstat",
  953.     "stat",
  954.     "-R",
  955.     "-W",
  956.     "-X",
  957.     "-r",
  958.     "-w",
  959.     "-x",
  960.     "-e",
  961.     "-O",
  962.     "-o",
  963.     "-z",
  964.     "-s",
  965.     "-M",
  966.     "-A",
  967.     "-C",
  968.     "-S",
  969.     "-c",
  970.     "-b",
  971.     "-f",
  972.     "-d",
  973.     "-p",
  974.     "-l",
  975.     "-u",
  976.     "-g",
  977.     "-k",
  978.     "-t",
  979.     "-T",
  980.     "-B",
  981.     "chdir",
  982.     "chown",
  983.     "chroot",
  984.     "unlink",
  985.     "chmod",
  986.     "utime",
  987.     "rename",
  988.     "link",
  989.     "symlink",
  990.     "readlink",
  991.     "mkdir",
  992.     "rmdir",
  993.     "opendir",
  994.     "readdir",
  995.     "telldir",
  996.     "seekdir",
  997.     "rewinddir",
  998.     "closedir",
  999.     "fork",
  1000.     "wait",
  1001.     "waitpid",
  1002.     "system",
  1003.     "exec",
  1004.     "kill",
  1005.     "getppid",
  1006.     "getpgrp",
  1007.     "setpgrp",
  1008.     "getpriority",
  1009.     "setpriority",
  1010.     "time",
  1011.     "times",
  1012.     "localtime",
  1013.     "gmtime",
  1014.     "alarm",
  1015.     "sleep",
  1016.     "shmget",
  1017.     "shmctl",
  1018.     "shmread",
  1019.     "shmwrite",
  1020.     "msgget",
  1021.     "msgctl",
  1022.     "msgsnd",
  1023.     "msgrcv",
  1024.     "semget",
  1025.     "semctl",
  1026.     "semop",
  1027.     "require",
  1028.     "do 'file'",
  1029.     "eval string",
  1030.     "eval exit",
  1031.     "eval block",
  1032.     "eval block exit",
  1033.     "gethostbyname",
  1034.     "gethostbyaddr",
  1035.     "gethostent",
  1036.     "getnetbyname",
  1037.     "getnetbyaddr",
  1038.     "getnetent",
  1039.     "getprotobyname",
  1040.     "getprotobynumber",
  1041.     "getprotoent",
  1042.     "getservbyname",
  1043.     "getservbyport",
  1044.     "getservent",
  1045.     "sethostent",
  1046.     "setnetent",
  1047.     "setprotoent",
  1048.     "setservent",
  1049.     "endhostent",
  1050.     "endnetent",
  1051.     "endprotoent",
  1052.     "endservent",
  1053.     "getpwnam",
  1054.     "getpwuid",
  1055.     "getpwent",
  1056.     "setpwent",
  1057.     "endpwent",
  1058.     "getgrnam",
  1059.     "getgrgid",
  1060.     "getgrent",
  1061.     "setgrent",
  1062.     "endgrent",
  1063.     "getlogin",
  1064.     "syscall",
  1065.     "lock",
  1066.     "per-thread variable",
  1067. };
  1068. #endif
  1069.  
  1070. #ifndef PERL_OBJECT
  1071. START_EXTERN_C
  1072.  
  1073. OP *    ck_anoncode    _((OP* o));
  1074. OP *    ck_bitop    _((OP* o));
  1075. OP *    ck_concat    _((OP* o));
  1076. OP *    ck_delete    _((OP* o));
  1077. OP *    ck_eof        _((OP* o));
  1078. OP *    ck_eval        _((OP* o));
  1079. OP *    ck_exec        _((OP* o));
  1080. OP *    ck_exists    _((OP* o));
  1081. OP *    ck_ftst        _((OP* o));
  1082. OP *    ck_fun        _((OP* o));
  1083. OP *    ck_fun_locale    _((OP* o));
  1084. OP *    ck_glob        _((OP* o));
  1085. OP *    ck_grep        _((OP* o));
  1086. OP *    ck_index    _((OP* o));
  1087. OP *    ck_lengthconst    _((OP* o));
  1088. OP *    ck_lfun        _((OP* o));
  1089. OP *    ck_listiob    _((OP* o));
  1090. OP *    ck_match    _((OP* o));
  1091. OP *    ck_null        _((OP* o));
  1092. OP *    ck_repeat    _((OP* o));
  1093. OP *    ck_require    _((OP* o));
  1094. OP *    ck_rfun        _((OP* o));
  1095. OP *    ck_rvconst    _((OP* o));
  1096. OP *    ck_scmp        _((OP* o));
  1097. OP *    ck_select    _((OP* o));
  1098. OP *    ck_shift    _((OP* o));
  1099. OP *    ck_sort        _((OP* o));
  1100. OP *    ck_spair    _((OP* o));
  1101. OP *    ck_split    _((OP* o));
  1102. OP *    ck_subr        _((OP* o));
  1103. OP *    ck_svconst    _((OP* o));
  1104. OP *    ck_trunc    _((OP* o));
  1105.  
  1106. OP *    pp_null        _((ARGSproto));
  1107. OP *    pp_stub        _((ARGSproto));
  1108. OP *    pp_scalar    _((ARGSproto));
  1109. OP *    pp_pushmark    _((ARGSproto));
  1110. OP *    pp_wantarray    _((ARGSproto));
  1111. OP *    pp_const    _((ARGSproto));
  1112. OP *    pp_gvsv        _((ARGSproto));
  1113. OP *    pp_gv        _((ARGSproto));
  1114. OP *    pp_gelem    _((ARGSproto));
  1115. OP *    pp_padsv    _((ARGSproto));
  1116. OP *    pp_padav    _((ARGSproto));
  1117. OP *    pp_padhv    _((ARGSproto));
  1118. OP *    pp_padany    _((ARGSproto));
  1119. OP *    pp_pushre    _((ARGSproto));
  1120. OP *    pp_rv2gv    _((ARGSproto));
  1121. OP *    pp_rv2sv    _((ARGSproto));
  1122. OP *    pp_av2arylen    _((ARGSproto));
  1123. OP *    pp_rv2cv    _((ARGSproto));
  1124. OP *    pp_anoncode    _((ARGSproto));
  1125. OP *    pp_prototype    _((ARGSproto));
  1126. OP *    pp_refgen    _((ARGSproto));
  1127. OP *    pp_srefgen    _((ARGSproto));
  1128. OP *    pp_ref        _((ARGSproto));
  1129. OP *    pp_bless    _((ARGSproto));
  1130. OP *    pp_backtick    _((ARGSproto));
  1131. OP *    pp_glob        _((ARGSproto));
  1132. OP *    pp_readline    _((ARGSproto));
  1133. OP *    pp_rcatline    _((ARGSproto));
  1134. OP *    pp_regcmaybe    _((ARGSproto));
  1135. OP *    pp_regcreset    _((ARGSproto));
  1136. OP *    pp_regcomp    _((ARGSproto));
  1137. OP *    pp_match    _((ARGSproto));
  1138. OP *    pp_qr        _((ARGSproto));
  1139. OP *    pp_subst    _((ARGSproto));
  1140. OP *    pp_substcont    _((ARGSproto));
  1141. OP *    pp_trans    _((ARGSproto));
  1142. OP *    pp_sassign    _((ARGSproto));
  1143. OP *    pp_aassign    _((ARGSproto));
  1144. OP *    pp_chop        _((ARGSproto));
  1145. OP *    pp_schop    _((ARGSproto));
  1146. OP *    pp_chomp    _((ARGSproto));
  1147. OP *    pp_schomp    _((ARGSproto));
  1148. OP *    pp_defined    _((ARGSproto));
  1149. OP *    pp_undef    _((ARGSproto));
  1150. OP *    pp_study    _((ARGSproto));
  1151. OP *    pp_pos        _((ARGSproto));
  1152. OP *    pp_preinc    _((ARGSproto));
  1153. OP *    pp_i_preinc    _((ARGSproto));
  1154. OP *    pp_predec    _((ARGSproto));
  1155. OP *    pp_i_predec    _((ARGSproto));
  1156. OP *    pp_postinc    _((ARGSproto));
  1157. OP *    pp_i_postinc    _((ARGSproto));
  1158. OP *    pp_postdec    _((ARGSproto));
  1159. OP *    pp_i_postdec    _((ARGSproto));
  1160. OP *    pp_pow        _((ARGSproto));
  1161. OP *    pp_multiply    _((ARGSproto));
  1162. OP *    pp_i_multiply    _((ARGSproto));
  1163. OP *    pp_divide    _((ARGSproto));
  1164. OP *    pp_i_divide    _((ARGSproto));
  1165. OP *    pp_modulo    _((ARGSproto));
  1166. OP *    pp_i_modulo    _((ARGSproto));
  1167. OP *    pp_repeat    _((ARGSproto));
  1168. OP *    pp_add        _((ARGSproto));
  1169. OP *    pp_i_add    _((ARGSproto));
  1170. OP *    pp_subtract    _((ARGSproto));
  1171. OP *    pp_i_subtract    _((ARGSproto));
  1172. OP *    pp_concat    _((ARGSproto));
  1173. OP *    pp_stringify    _((ARGSproto));
  1174. OP *    pp_left_shift    _((ARGSproto));
  1175. OP *    pp_right_shift    _((ARGSproto));
  1176. OP *    pp_lt        _((ARGSproto));
  1177. OP *    pp_i_lt        _((ARGSproto));
  1178. OP *    pp_gt        _((ARGSproto));
  1179. OP *    pp_i_gt        _((ARGSproto));
  1180. OP *    pp_le        _((ARGSproto));
  1181. OP *    pp_i_le        _((ARGSproto));
  1182. OP *    pp_ge        _((ARGSproto));
  1183. OP *    pp_i_ge        _((ARGSproto));
  1184. OP *    pp_eq        _((ARGSproto));
  1185. OP *    pp_i_eq        _((ARGSproto));
  1186. OP *    pp_ne        _((ARGSproto));
  1187. OP *    pp_i_ne        _((ARGSproto));
  1188. OP *    pp_ncmp        _((ARGSproto));
  1189. OP *    pp_i_ncmp    _((ARGSproto));
  1190. OP *    pp_slt        _((ARGSproto));
  1191. OP *    pp_sgt        _((ARGSproto));
  1192. OP *    pp_sle        _((ARGSproto));
  1193. OP *    pp_sge        _((ARGSproto));
  1194. OP *    pp_seq        _((ARGSproto));
  1195. OP *    pp_sne        _((ARGSproto));
  1196. OP *    pp_scmp        _((ARGSproto));
  1197. OP *    pp_bit_and    _((ARGSproto));
  1198. OP *    pp_bit_xor    _((ARGSproto));
  1199. OP *    pp_bit_or    _((ARGSproto));
  1200. OP *    pp_negate    _((ARGSproto));
  1201. OP *    pp_i_negate    _((ARGSproto));
  1202. OP *    pp_not        _((ARGSproto));
  1203. OP *    pp_complement    _((ARGSproto));
  1204. OP *    pp_atan2    _((ARGSproto));
  1205. OP *    pp_sin        _((ARGSproto));
  1206. OP *    pp_cos        _((ARGSproto));
  1207. OP *    pp_rand        _((ARGSproto));
  1208. OP *    pp_srand    _((ARGSproto));
  1209. OP *    pp_exp        _((ARGSproto));
  1210. OP *    pp_log        _((ARGSproto));
  1211. OP *    pp_sqrt        _((ARGSproto));
  1212. OP *    pp_int        _((ARGSproto));
  1213. OP *    pp_hex        _((ARGSproto));
  1214. OP *    pp_oct        _((ARGSproto));
  1215. OP *    pp_abs        _((ARGSproto));
  1216. OP *    pp_length    _((ARGSproto));
  1217. OP *    pp_substr    _((ARGSproto));
  1218. OP *    pp_vec        _((ARGSproto));
  1219. OP *    pp_index    _((ARGSproto));
  1220. OP *    pp_rindex    _((ARGSproto));
  1221. OP *    pp_sprintf    _((ARGSproto));
  1222. OP *    pp_formline    _((ARGSproto));
  1223. OP *    pp_ord        _((ARGSproto));
  1224. OP *    pp_chr        _((ARGSproto));
  1225. OP *    pp_crypt    _((ARGSproto));
  1226. OP *    pp_ucfirst    _((ARGSproto));
  1227. OP *    pp_lcfirst    _((ARGSproto));
  1228. OP *    pp_uc        _((ARGSproto));
  1229. OP *    pp_lc        _((ARGSproto));
  1230. OP *    pp_quotemeta    _((ARGSproto));
  1231. OP *    pp_rv2av    _((ARGSproto));
  1232. OP *    pp_aelemfast    _((ARGSproto));
  1233. OP *    pp_aelem    _((ARGSproto));
  1234. OP *    pp_aslice    _((ARGSproto));
  1235. OP *    pp_each        _((ARGSproto));
  1236. OP *    pp_values    _((ARGSproto));
  1237. OP *    pp_keys        _((ARGSproto));
  1238. OP *    pp_delete    _((ARGSproto));
  1239. OP *    pp_exists    _((ARGSproto));
  1240. OP *    pp_rv2hv    _((ARGSproto));
  1241. OP *    pp_helem    _((ARGSproto));
  1242. OP *    pp_hslice    _((ARGSproto));
  1243. OP *    pp_unpack    _((ARGSproto));
  1244. OP *    pp_pack        _((ARGSproto));
  1245. OP *    pp_split    _((ARGSproto));
  1246. OP *    pp_join        _((ARGSproto));
  1247. OP *    pp_list        _((ARGSproto));
  1248. OP *    pp_lslice    _((ARGSproto));
  1249. OP *    pp_anonlist    _((ARGSproto));
  1250. OP *    pp_anonhash    _((ARGSproto));
  1251. OP *    pp_splice    _((ARGSproto));
  1252. OP *    pp_push        _((ARGSproto));
  1253. OP *    pp_pop        _((ARGSproto));
  1254. OP *    pp_shift    _((ARGSproto));
  1255. OP *    pp_unshift    _((ARGSproto));
  1256. OP *    pp_sort        _((ARGSproto));
  1257. OP *    pp_reverse    _((ARGSproto));
  1258. OP *    pp_grepstart    _((ARGSproto));
  1259. OP *    pp_grepwhile    _((ARGSproto));
  1260. OP *    pp_mapstart    _((ARGSproto));
  1261. OP *    pp_mapwhile    _((ARGSproto));
  1262. OP *    pp_range    _((ARGSproto));
  1263. OP *    pp_flip        _((ARGSproto));
  1264. OP *    pp_flop        _((ARGSproto));
  1265. OP *    pp_and        _((ARGSproto));
  1266. OP *    pp_or        _((ARGSproto));
  1267. OP *    pp_xor        _((ARGSproto));
  1268. OP *    pp_cond_expr    _((ARGSproto));
  1269. OP *    pp_andassign    _((ARGSproto));
  1270. OP *    pp_orassign    _((ARGSproto));
  1271. OP *    pp_method    _((ARGSproto));
  1272. OP *    pp_entersub    _((ARGSproto));
  1273. OP *    pp_leavesub    _((ARGSproto));
  1274. OP *    pp_caller    _((ARGSproto));
  1275. OP *    pp_warn        _((ARGSproto));
  1276. OP *    pp_die        _((ARGSproto));
  1277. OP *    pp_reset    _((ARGSproto));
  1278. OP *    pp_lineseq    _((ARGSproto));
  1279. OP *    pp_nextstate    _((ARGSproto));
  1280. OP *    pp_dbstate    _((ARGSproto));
  1281. OP *    pp_unstack    _((ARGSproto));
  1282. OP *    pp_enter    _((ARGSproto));
  1283. OP *    pp_leave    _((ARGSproto));
  1284. OP *    pp_scope    _((ARGSproto));
  1285. OP *    pp_enteriter    _((ARGSproto));
  1286. OP *    pp_iter        _((ARGSproto));
  1287. OP *    pp_enterloop    _((ARGSproto));
  1288. OP *    pp_leaveloop    _((ARGSproto));
  1289. OP *    pp_return    _((ARGSproto));
  1290. OP *    pp_last        _((ARGSproto));
  1291. OP *    pp_next        _((ARGSproto));
  1292. OP *    pp_redo        _((ARGSproto));
  1293. OP *    pp_dump        _((ARGSproto));
  1294. OP *    pp_goto        _((ARGSproto));
  1295. OP *    pp_exit        _((ARGSproto));
  1296. OP *    pp_open        _((ARGSproto));
  1297. OP *    pp_close    _((ARGSproto));
  1298. OP *    pp_pipe_op    _((ARGSproto));
  1299. OP *    pp_fileno    _((ARGSproto));
  1300. OP *    pp_umask    _((ARGSproto));
  1301. OP *    pp_binmode    _((ARGSproto));
  1302. OP *    pp_tie        _((ARGSproto));
  1303. OP *    pp_untie    _((ARGSproto));
  1304. OP *    pp_tied        _((ARGSproto));
  1305. OP *    pp_dbmopen    _((ARGSproto));
  1306. OP *    pp_dbmclose    _((ARGSproto));
  1307. OP *    pp_sselect    _((ARGSproto));
  1308. OP *    pp_select    _((ARGSproto));
  1309. OP *    pp_getc        _((ARGSproto));
  1310. OP *    pp_read        _((ARGSproto));
  1311. OP *    pp_enterwrite    _((ARGSproto));
  1312. OP *    pp_leavewrite    _((ARGSproto));
  1313. OP *    pp_prtf        _((ARGSproto));
  1314. OP *    pp_print    _((ARGSproto));
  1315. OP *    pp_sysopen    _((ARGSproto));
  1316. OP *    pp_sysseek    _((ARGSproto));
  1317. OP *    pp_sysread    _((ARGSproto));
  1318. OP *    pp_syswrite    _((ARGSproto));
  1319. OP *    pp_send        _((ARGSproto));
  1320. OP *    pp_recv        _((ARGSproto));
  1321. OP *    pp_eof        _((ARGSproto));
  1322. OP *    pp_tell        _((ARGSproto));
  1323. OP *    pp_seek        _((ARGSproto));
  1324. OP *    pp_truncate    _((ARGSproto));
  1325. OP *    pp_fcntl    _((ARGSproto));
  1326. OP *    pp_ioctl    _((ARGSproto));
  1327. OP *    pp_flock    _((ARGSproto));
  1328. OP *    pp_socket    _((ARGSproto));
  1329. OP *    pp_sockpair    _((ARGSproto));
  1330. OP *    pp_bind        _((ARGSproto));
  1331. OP *    pp_connect    _((ARGSproto));
  1332. OP *    pp_listen    _((ARGSproto));
  1333. OP *    pp_accept    _((ARGSproto));
  1334. OP *    pp_shutdown    _((ARGSproto));
  1335. OP *    pp_gsockopt    _((ARGSproto));
  1336. OP *    pp_ssockopt    _((ARGSproto));
  1337. OP *    pp_getsockname    _((ARGSproto));
  1338. OP *    pp_getpeername    _((ARGSproto));
  1339. OP *    pp_lstat    _((ARGSproto));
  1340. OP *    pp_stat        _((ARGSproto));
  1341. OP *    pp_ftrread    _((ARGSproto));
  1342. OP *    pp_ftrwrite    _((ARGSproto));
  1343. OP *    pp_ftrexec    _((ARGSproto));
  1344. OP *    pp_fteread    _((ARGSproto));
  1345. OP *    pp_ftewrite    _((ARGSproto));
  1346. OP *    pp_fteexec    _((ARGSproto));
  1347. OP *    pp_ftis        _((ARGSproto));
  1348. OP *    pp_fteowned    _((ARGSproto));
  1349. OP *    pp_ftrowned    _((ARGSproto));
  1350. OP *    pp_ftzero    _((ARGSproto));
  1351. OP *    pp_ftsize    _((ARGSproto));
  1352. OP *    pp_ftmtime    _((ARGSproto));
  1353. OP *    pp_ftatime    _((ARGSproto));
  1354. OP *    pp_ftctime    _((ARGSproto));
  1355. OP *    pp_ftsock    _((ARGSproto));
  1356. OP *    pp_ftchr    _((ARGSproto));
  1357. OP *    pp_ftblk    _((ARGSproto));
  1358. OP *    pp_ftfile    _((ARGSproto));
  1359. OP *    pp_ftdir    _((ARGSproto));
  1360. OP *    pp_ftpipe    _((ARGSproto));
  1361. OP *    pp_ftlink    _((ARGSproto));
  1362. OP *    pp_ftsuid    _((ARGSproto));
  1363. OP *    pp_ftsgid    _((ARGSproto));
  1364. OP *    pp_ftsvtx    _((ARGSproto));
  1365. OP *    pp_fttty    _((ARGSproto));
  1366. OP *    pp_fttext    _((ARGSproto));
  1367. OP *    pp_ftbinary    _((ARGSproto));
  1368. OP *    pp_chdir    _((ARGSproto));
  1369. OP *    pp_chown    _((ARGSproto));
  1370. OP *    pp_chroot    _((ARGSproto));
  1371. OP *    pp_unlink    _((ARGSproto));
  1372. OP *    pp_chmod    _((ARGSproto));
  1373. OP *    pp_utime    _((ARGSproto));
  1374. OP *    pp_rename    _((ARGSproto));
  1375. OP *    pp_link        _((ARGSproto));
  1376. OP *    pp_symlink    _((ARGSproto));
  1377. OP *    pp_readlink    _((ARGSproto));
  1378. OP *    pp_mkdir    _((ARGSproto));
  1379. OP *    pp_rmdir    _((ARGSproto));
  1380. OP *    pp_open_dir    _((ARGSproto));
  1381. OP *    pp_readdir    _((ARGSproto));
  1382. OP *    pp_telldir    _((ARGSproto));
  1383. OP *    pp_seekdir    _((ARGSproto));
  1384. OP *    pp_rewinddir    _((ARGSproto));
  1385. OP *    pp_closedir    _((ARGSproto));
  1386. OP *    pp_fork        _((ARGSproto));
  1387. OP *    pp_wait        _((ARGSproto));
  1388. OP *    pp_waitpid    _((ARGSproto));
  1389. OP *    pp_system    _((ARGSproto));
  1390. OP *    pp_exec        _((ARGSproto));
  1391. OP *    pp_kill        _((ARGSproto));
  1392. OP *    pp_getppid    _((ARGSproto));
  1393. OP *    pp_getpgrp    _((ARGSproto));
  1394. OP *    pp_setpgrp    _((ARGSproto));
  1395. OP *    pp_getpriority    _((ARGSproto));
  1396. OP *    pp_setpriority    _((ARGSproto));
  1397. OP *    pp_time        _((ARGSproto));
  1398. OP *    pp_tms        _((ARGSproto));
  1399. OP *    pp_localtime    _((ARGSproto));
  1400. OP *    pp_gmtime    _((ARGSproto));
  1401. OP *    pp_alarm    _((ARGSproto));
  1402. OP *    pp_sleep    _((ARGSproto));
  1403. OP *    pp_shmget    _((ARGSproto));
  1404. OP *    pp_shmctl    _((ARGSproto));
  1405. OP *    pp_shmread    _((ARGSproto));
  1406. OP *    pp_shmwrite    _((ARGSproto));
  1407. OP *    pp_msgget    _((ARGSproto));
  1408. OP *    pp_msgctl    _((ARGSproto));
  1409. OP *    pp_msgsnd    _((ARGSproto));
  1410. OP *    pp_msgrcv    _((ARGSproto));
  1411. OP *    pp_semget    _((ARGSproto));
  1412. OP *    pp_semctl    _((ARGSproto));
  1413. OP *    pp_semop    _((ARGSproto));
  1414. OP *    pp_require    _((ARGSproto));
  1415. OP *    pp_dofile    _((ARGSproto));
  1416. OP *    pp_entereval    _((ARGSproto));
  1417. OP *    pp_leaveeval    _((ARGSproto));
  1418. OP *    pp_entertry    _((ARGSproto));
  1419. OP *    pp_leavetry    _((ARGSproto));
  1420. OP *    pp_ghbyname    _((ARGSproto));
  1421. OP *    pp_ghbyaddr    _((ARGSproto));
  1422. OP *    pp_ghostent    _((ARGSproto));
  1423. OP *    pp_gnbyname    _((ARGSproto));
  1424. OP *    pp_gnbyaddr    _((ARGSproto));
  1425. OP *    pp_gnetent    _((ARGSproto));
  1426. OP *    pp_gpbyname    _((ARGSproto));
  1427. OP *    pp_gpbynumber    _((ARGSproto));
  1428. OP *    pp_gprotoent    _((ARGSproto));
  1429. OP *    pp_gsbyname    _((ARGSproto));
  1430. OP *    pp_gsbyport    _((ARGSproto));
  1431. OP *    pp_gservent    _((ARGSproto));
  1432. OP *    pp_shostent    _((ARGSproto));
  1433. OP *    pp_snetent    _((ARGSproto));
  1434. OP *    pp_sprotoent    _((ARGSproto));
  1435. OP *    pp_sservent    _((ARGSproto));
  1436. OP *    pp_ehostent    _((ARGSproto));
  1437. OP *    pp_enetent    _((ARGSproto));
  1438. OP *    pp_eprotoent    _((ARGSproto));
  1439. OP *    pp_eservent    _((ARGSproto));
  1440. OP *    pp_gpwnam    _((ARGSproto));
  1441. OP *    pp_gpwuid    _((ARGSproto));
  1442. OP *    pp_gpwent    _((ARGSproto));
  1443. OP *    pp_spwent    _((ARGSproto));
  1444. OP *    pp_epwent    _((ARGSproto));
  1445. OP *    pp_ggrnam    _((ARGSproto));
  1446. OP *    pp_ggrgid    _((ARGSproto));
  1447. OP *    pp_ggrent    _((ARGSproto));
  1448. OP *    pp_sgrent    _((ARGSproto));
  1449. OP *    pp_egrent    _((ARGSproto));
  1450. OP *    pp_getlogin    _((ARGSproto));
  1451. OP *    pp_syscall    _((ARGSproto));
  1452. OP *    pp_lock        _((ARGSproto));
  1453. OP *    pp_threadsv    _((ARGSproto));
  1454.  
  1455. END_EXTERN_C
  1456. #endif    /* PERL_OBJECT */
  1457.  
  1458. #ifndef DOINIT
  1459. EXT OP * (CPERLscope(*ppaddr)[])(ARGSproto);
  1460. #else
  1461. #ifndef PERL_OBJECT
  1462. EXT OP * (CPERLscope(*ppaddr)[])(ARGSproto) = {
  1463.     pp_null,
  1464.     pp_stub,
  1465.     pp_scalar,
  1466.     pp_pushmark,
  1467.     pp_wantarray,
  1468.     pp_const,
  1469.     pp_gvsv,
  1470.     pp_gv,
  1471.     pp_gelem,
  1472.     pp_padsv,
  1473.     pp_padav,
  1474.     pp_padhv,
  1475.     pp_padany,
  1476.     pp_pushre,
  1477.     pp_rv2gv,
  1478.     pp_rv2sv,
  1479.     pp_av2arylen,
  1480.     pp_rv2cv,
  1481.     pp_anoncode,
  1482.     pp_prototype,
  1483.     pp_refgen,
  1484.     pp_srefgen,
  1485.     pp_ref,
  1486.     pp_bless,
  1487.     pp_backtick,
  1488.     pp_glob,
  1489.     pp_readline,
  1490.     pp_rcatline,
  1491.     pp_regcmaybe,
  1492.     pp_regcreset,
  1493.     pp_regcomp,
  1494.     pp_match,
  1495.     pp_qr,
  1496.     pp_subst,
  1497.     pp_substcont,
  1498.     pp_trans,
  1499.     pp_sassign,
  1500.     pp_aassign,
  1501.     pp_chop,
  1502.     pp_schop,
  1503.     pp_chomp,
  1504.     pp_schomp,
  1505.     pp_defined,
  1506.     pp_undef,
  1507.     pp_study,
  1508.     pp_pos,
  1509.     pp_preinc,
  1510.     pp_i_preinc,
  1511.     pp_predec,
  1512.     pp_i_predec,
  1513.     pp_postinc,
  1514.     pp_i_postinc,
  1515.     pp_postdec,
  1516.     pp_i_postdec,
  1517.     pp_pow,
  1518.     pp_multiply,
  1519.     pp_i_multiply,
  1520.     pp_divide,
  1521.     pp_i_divide,
  1522.     pp_modulo,
  1523.     pp_i_modulo,
  1524.     pp_repeat,
  1525.     pp_add,
  1526.     pp_i_add,
  1527.     pp_subtract,
  1528.     pp_i_subtract,
  1529.     pp_concat,
  1530.     pp_stringify,
  1531.     pp_left_shift,
  1532.     pp_right_shift,
  1533.     pp_lt,
  1534.     pp_i_lt,
  1535.     pp_gt,
  1536.     pp_i_gt,
  1537.     pp_le,
  1538.     pp_i_le,
  1539.     pp_ge,
  1540.     pp_i_ge,
  1541.     pp_eq,
  1542.     pp_i_eq,
  1543.     pp_ne,
  1544.     pp_i_ne,
  1545.     pp_ncmp,
  1546.     pp_i_ncmp,
  1547.     pp_slt,
  1548.     pp_sgt,
  1549.     pp_sle,
  1550.     pp_sge,
  1551.     pp_seq,
  1552.     pp_sne,
  1553.     pp_scmp,
  1554.     pp_bit_and,
  1555.     pp_bit_xor,
  1556.     pp_bit_or,
  1557.     pp_negate,
  1558.     pp_i_negate,
  1559.     pp_not,
  1560.     pp_complement,
  1561.     pp_atan2,
  1562.     pp_sin,
  1563.     pp_cos,
  1564.     pp_rand,
  1565.     pp_srand,
  1566.     pp_exp,
  1567.     pp_log,
  1568.     pp_sqrt,
  1569.     pp_int,
  1570.     pp_hex,
  1571.     pp_oct,
  1572.     pp_abs,
  1573.     pp_length,
  1574.     pp_substr,
  1575.     pp_vec,
  1576.     pp_index,
  1577.     pp_rindex,
  1578.     pp_sprintf,
  1579.     pp_formline,
  1580.     pp_ord,
  1581.     pp_chr,
  1582.     pp_crypt,
  1583.     pp_ucfirst,
  1584.     pp_lcfirst,
  1585.     pp_uc,
  1586.     pp_lc,
  1587.     pp_quotemeta,
  1588.     pp_rv2av,
  1589.     pp_aelemfast,
  1590.     pp_aelem,
  1591.     pp_aslice,
  1592.     pp_each,
  1593.     pp_values,
  1594.     pp_keys,
  1595.     pp_delete,
  1596.     pp_exists,
  1597.     pp_rv2hv,
  1598.     pp_helem,
  1599.     pp_hslice,
  1600.     pp_unpack,
  1601.     pp_pack,
  1602.     pp_split,
  1603.     pp_join,
  1604.     pp_list,
  1605.     pp_lslice,
  1606.     pp_anonlist,
  1607.     pp_anonhash,
  1608.     pp_splice,
  1609.     pp_push,
  1610.     pp_pop,
  1611.     pp_shift,
  1612.     pp_unshift,
  1613.     pp_sort,
  1614.     pp_reverse,
  1615.     pp_grepstart,
  1616.     pp_grepwhile,
  1617.     pp_mapstart,
  1618.     pp_mapwhile,
  1619.     pp_range,
  1620.     pp_flip,
  1621.     pp_flop,
  1622.     pp_and,
  1623.     pp_or,
  1624.     pp_xor,
  1625.     pp_cond_expr,
  1626.     pp_andassign,
  1627.     pp_orassign,
  1628.     pp_method,
  1629.     pp_entersub,
  1630.     pp_leavesub,
  1631.     pp_caller,
  1632.     pp_warn,
  1633.     pp_die,
  1634.     pp_reset,
  1635.     pp_lineseq,
  1636.     pp_nextstate,
  1637.     pp_dbstate,
  1638.     pp_unstack,
  1639.     pp_enter,
  1640.     pp_leave,
  1641.     pp_scope,
  1642.     pp_enteriter,
  1643.     pp_iter,
  1644.     pp_enterloop,
  1645.     pp_leaveloop,
  1646.     pp_return,
  1647.     pp_last,
  1648.     pp_next,
  1649.     pp_redo,
  1650.     pp_dump,
  1651.     pp_goto,
  1652.     pp_exit,
  1653.     pp_open,
  1654.     pp_close,
  1655.     pp_pipe_op,
  1656.     pp_fileno,
  1657.     pp_umask,
  1658.     pp_binmode,
  1659.     pp_tie,
  1660.     pp_untie,
  1661.     pp_tied,
  1662.     pp_dbmopen,
  1663.     pp_dbmclose,
  1664.     pp_sselect,
  1665.     pp_select,
  1666.     pp_getc,
  1667.     pp_read,
  1668.     pp_enterwrite,
  1669.     pp_leavewrite,
  1670.     pp_prtf,
  1671.     pp_print,
  1672.     pp_sysopen,
  1673.     pp_sysseek,
  1674.     pp_sysread,
  1675.     pp_syswrite,
  1676.     pp_send,
  1677.     pp_recv,
  1678.     pp_eof,
  1679.     pp_tell,
  1680.     pp_seek,
  1681.     pp_truncate,
  1682.     pp_fcntl,
  1683.     pp_ioctl,
  1684.     pp_flock,
  1685.     pp_socket,
  1686.     pp_sockpair,
  1687.     pp_bind,
  1688.     pp_connect,
  1689.     pp_listen,
  1690.     pp_accept,
  1691.     pp_shutdown,
  1692.     pp_gsockopt,
  1693.     pp_ssockopt,
  1694.     pp_getsockname,
  1695.     pp_getpeername,
  1696.     pp_lstat,
  1697.     pp_stat,
  1698.     pp_ftrread,
  1699.     pp_ftrwrite,
  1700.     pp_ftrexec,
  1701.     pp_fteread,
  1702.     pp_ftewrite,
  1703.     pp_fteexec,
  1704.     pp_ftis,
  1705.     pp_fteowned,
  1706.     pp_ftrowned,
  1707.     pp_ftzero,
  1708.     pp_ftsize,
  1709.     pp_ftmtime,
  1710.     pp_ftatime,
  1711.     pp_ftctime,
  1712.     pp_ftsock,
  1713.     pp_ftchr,
  1714.     pp_ftblk,
  1715.     pp_ftfile,
  1716.     pp_ftdir,
  1717.     pp_ftpipe,
  1718.     pp_ftlink,
  1719.     pp_ftsuid,
  1720.     pp_ftsgid,
  1721.     pp_ftsvtx,
  1722.     pp_fttty,
  1723.     pp_fttext,
  1724.     pp_ftbinary,
  1725.     pp_chdir,
  1726.     pp_chown,
  1727.     pp_chroot,
  1728.     pp_unlink,
  1729.     pp_chmod,
  1730.     pp_utime,
  1731.     pp_rename,
  1732.     pp_link,
  1733.     pp_symlink,
  1734.     pp_readlink,
  1735.     pp_mkdir,
  1736.     pp_rmdir,
  1737.     pp_open_dir,
  1738.     pp_readdir,
  1739.     pp_telldir,
  1740.     pp_seekdir,
  1741.     pp_rewinddir,
  1742.     pp_closedir,
  1743.     pp_fork,
  1744.     pp_wait,
  1745.     pp_waitpid,
  1746.     pp_system,
  1747.     pp_exec,
  1748.     pp_kill,
  1749.     pp_getppid,
  1750.     pp_getpgrp,
  1751.     pp_setpgrp,
  1752.     pp_getpriority,
  1753.     pp_setpriority,
  1754.     pp_time,
  1755.     pp_tms,
  1756.     pp_localtime,
  1757.     pp_gmtime,
  1758.     pp_alarm,
  1759.     pp_sleep,
  1760.     pp_shmget,
  1761.     pp_shmctl,
  1762.     pp_shmread,
  1763.     pp_shmwrite,
  1764.     pp_msgget,
  1765.     pp_msgctl,
  1766.     pp_msgsnd,
  1767.     pp_msgrcv,
  1768.     pp_semget,
  1769.     pp_semctl,
  1770.     pp_semop,
  1771.     pp_require,
  1772.     pp_dofile,
  1773.     pp_entereval,
  1774.     pp_leaveeval,
  1775.     pp_entertry,
  1776.     pp_leavetry,
  1777.     pp_ghbyname,
  1778.     pp_ghbyaddr,
  1779.     pp_ghostent,
  1780.     pp_gnbyname,
  1781.     pp_gnbyaddr,
  1782.     pp_gnetent,
  1783.     pp_gpbyname,
  1784.     pp_gpbynumber,
  1785.     pp_gprotoent,
  1786.     pp_gsbyname,
  1787.     pp_gsbyport,
  1788.     pp_gservent,
  1789.     pp_shostent,
  1790.     pp_snetent,
  1791.     pp_sprotoent,
  1792.     pp_sservent,
  1793.     pp_ehostent,
  1794.     pp_enetent,
  1795.     pp_eprotoent,
  1796.     pp_eservent,
  1797.     pp_gpwnam,
  1798.     pp_gpwuid,
  1799.     pp_gpwent,
  1800.     pp_spwent,
  1801.     pp_epwent,
  1802.     pp_ggrnam,
  1803.     pp_ggrgid,
  1804.     pp_ggrent,
  1805.     pp_sgrent,
  1806.     pp_egrent,
  1807.     pp_getlogin,
  1808.     pp_syscall,
  1809.     pp_lock,
  1810.     pp_threadsv,
  1811. };
  1812. #endif    /* PERL_OBJECT */
  1813. #endif
  1814.  
  1815. #ifndef DOINIT
  1816. EXT OP * (CPERLscope(*check)[]) _((OP *op));
  1817. #else
  1818. #ifndef PERL_OBJECT
  1819. EXT OP * (CPERLscope(*check)[]) _((OP *op)) = {
  1820.     ck_null,    /* null */
  1821.     ck_null,    /* stub */
  1822.     ck_fun,        /* scalar */
  1823.     ck_null,    /* pushmark */
  1824.     ck_null,    /* wantarray */
  1825.     ck_svconst,    /* const */
  1826.     ck_null,    /* gvsv */
  1827.     ck_null,    /* gv */
  1828.     ck_null,    /* gelem */
  1829.     ck_null,    /* padsv */
  1830.     ck_null,    /* padav */
  1831.     ck_null,    /* padhv */
  1832.     ck_null,    /* padany */
  1833.     ck_null,    /* pushre */
  1834.     ck_rvconst,    /* rv2gv */
  1835.     ck_rvconst,    /* rv2sv */
  1836.     ck_null,    /* av2arylen */
  1837.     ck_rvconst,    /* rv2cv */
  1838.     ck_anoncode,    /* anoncode */
  1839.     ck_null,    /* prototype */
  1840.     ck_spair,    /* refgen */
  1841.     ck_null,    /* srefgen */
  1842.     ck_fun,        /* ref */
  1843.     ck_fun,        /* bless */
  1844.     ck_null,    /* backtick */
  1845.     ck_glob,    /* glob */
  1846.     ck_null,    /* readline */
  1847.     ck_null,    /* rcatline */
  1848.     ck_fun,        /* regcmaybe */
  1849.     ck_fun,        /* regcreset */
  1850.     ck_null,    /* regcomp */
  1851.     ck_match,    /* match */
  1852.     ck_match,    /* qr */
  1853.     ck_null,    /* subst */
  1854.     ck_null,    /* substcont */
  1855.     ck_null,    /* trans */
  1856.     ck_null,    /* sassign */
  1857.     ck_null,    /* aassign */
  1858.     ck_spair,    /* chop */
  1859.     ck_null,    /* schop */
  1860.     ck_spair,    /* chomp */
  1861.     ck_null,    /* schomp */
  1862.     ck_rfun,    /* defined */
  1863.     ck_lfun,    /* undef */
  1864.     ck_fun,        /* study */
  1865.     ck_lfun,    /* pos */
  1866.     ck_lfun,    /* preinc */
  1867.     ck_lfun,    /* i_preinc */
  1868.     ck_lfun,    /* predec */
  1869.     ck_lfun,    /* i_predec */
  1870.     ck_lfun,    /* postinc */
  1871.     ck_lfun,    /* i_postinc */
  1872.     ck_lfun,    /* postdec */
  1873.     ck_lfun,    /* i_postdec */
  1874.     ck_null,    /* pow */
  1875.     ck_null,    /* multiply */
  1876.     ck_null,    /* i_multiply */
  1877.     ck_null,    /* divide */
  1878.     ck_null,    /* i_divide */
  1879.     ck_null,    /* modulo */
  1880.     ck_null,    /* i_modulo */
  1881.     ck_repeat,    /* repeat */
  1882.     ck_null,    /* add */
  1883.     ck_null,    /* i_add */
  1884.     ck_null,    /* subtract */
  1885.     ck_null,    /* i_subtract */
  1886.     ck_concat,    /* concat */
  1887.     ck_fun,        /* stringify */
  1888.     ck_bitop,    /* left_shift */
  1889.     ck_bitop,    /* right_shift */
  1890.     ck_null,    /* lt */
  1891.     ck_null,    /* i_lt */
  1892.     ck_null,    /* gt */
  1893.     ck_null,    /* i_gt */
  1894.     ck_null,    /* le */
  1895.     ck_null,    /* i_le */
  1896.     ck_null,    /* ge */
  1897.     ck_null,    /* i_ge */
  1898.     ck_null,    /* eq */
  1899.     ck_null,    /* i_eq */
  1900.     ck_null,    /* ne */
  1901.     ck_null,    /* i_ne */
  1902.     ck_null,    /* ncmp */
  1903.     ck_null,    /* i_ncmp */
  1904.     ck_scmp,    /* slt */
  1905.     ck_scmp,    /* sgt */
  1906.     ck_scmp,    /* sle */
  1907.     ck_scmp,    /* sge */
  1908.     ck_null,    /* seq */
  1909.     ck_null,    /* sne */
  1910.     ck_scmp,    /* scmp */
  1911.     ck_bitop,    /* bit_and */
  1912.     ck_bitop,    /* bit_xor */
  1913.     ck_bitop,    /* bit_or */
  1914.     ck_null,    /* negate */
  1915.     ck_null,    /* i_negate */
  1916.     ck_null,    /* not */
  1917.     ck_bitop,    /* complement */
  1918.     ck_fun,        /* atan2 */
  1919.     ck_fun,        /* sin */
  1920.     ck_fun,        /* cos */
  1921.     ck_fun,        /* rand */
  1922.     ck_fun,        /* srand */
  1923.     ck_fun,        /* exp */
  1924.     ck_fun,        /* log */
  1925.     ck_fun,        /* sqrt */
  1926.     ck_fun,        /* int */
  1927.     ck_fun,        /* hex */
  1928.     ck_fun,        /* oct */
  1929.     ck_fun,        /* abs */
  1930.     ck_lengthconst,    /* length */
  1931.     ck_fun,        /* substr */
  1932.     ck_fun,        /* vec */
  1933.     ck_index,    /* index */
  1934.     ck_index,    /* rindex */
  1935.     ck_fun_locale,    /* sprintf */
  1936.     ck_fun,        /* formline */
  1937.     ck_fun,        /* ord */
  1938.     ck_fun,        /* chr */
  1939.     ck_fun,        /* crypt */
  1940.     ck_fun_locale,    /* ucfirst */
  1941.     ck_fun_locale,    /* lcfirst */
  1942.     ck_fun_locale,    /* uc */
  1943.     ck_fun_locale,    /* lc */
  1944.     ck_fun,        /* quotemeta */
  1945.     ck_rvconst,    /* rv2av */
  1946.     ck_null,    /* aelemfast */
  1947.     ck_null,    /* aelem */
  1948.     ck_null,    /* aslice */
  1949.     ck_fun,        /* each */
  1950.     ck_fun,        /* values */
  1951.     ck_fun,        /* keys */
  1952.     ck_delete,    /* delete */
  1953.     ck_exists,    /* exists */
  1954.     ck_rvconst,    /* rv2hv */
  1955.     ck_null,    /* helem */
  1956.     ck_null,    /* hslice */
  1957.     ck_fun,        /* unpack */
  1958.     ck_fun,        /* pack */
  1959.     ck_split,    /* split */
  1960.     ck_fun,        /* join */
  1961.     ck_null,    /* list */
  1962.     ck_null,    /* lslice */
  1963.     ck_fun,        /* anonlist */
  1964.     ck_fun,        /* anonhash */
  1965.     ck_fun,        /* splice */
  1966.     ck_fun,        /* push */
  1967.     ck_shift,    /* pop */
  1968.     ck_shift,    /* shift */
  1969.     ck_fun,        /* unshift */
  1970.     ck_sort,    /* sort */
  1971.     ck_fun,        /* reverse */
  1972.     ck_grep,    /* grepstart */
  1973.     ck_null,    /* grepwhile */
  1974.     ck_grep,    /* mapstart */
  1975.     ck_null,    /* mapwhile */
  1976.     ck_null,    /* range */
  1977.     ck_null,    /* flip */
  1978.     ck_null,    /* flop */
  1979.     ck_null,    /* and */
  1980.     ck_null,    /* or */
  1981.     ck_null,    /* xor */
  1982.     ck_null,    /* cond_expr */
  1983.     ck_null,    /* andassign */
  1984.     ck_null,    /* orassign */
  1985.     ck_null,    /* method */
  1986.     ck_subr,    /* entersub */
  1987.     ck_null,    /* leavesub */
  1988.     ck_fun,        /* caller */
  1989.     ck_fun,        /* warn */
  1990.     ck_fun,        /* die */
  1991.     ck_fun,        /* reset */
  1992.     ck_null,    /* lineseq */
  1993.     ck_null,    /* nextstate */
  1994.     ck_null,    /* dbstate */
  1995.     ck_null,    /* unstack */
  1996.     ck_null,    /* enter */
  1997.     ck_null,    /* leave */
  1998.     ck_null,    /* scope */
  1999.     ck_null,    /* enteriter */
  2000.     ck_null,    /* iter */
  2001.     ck_null,    /* enterloop */
  2002.     ck_null,    /* leaveloop */
  2003.     ck_null,    /* return */
  2004.     ck_null,    /* last */
  2005.     ck_null,    /* next */
  2006.     ck_null,    /* redo */
  2007.     ck_null,    /* dump */
  2008.     ck_null,    /* goto */
  2009.     ck_fun,        /* exit */
  2010.     ck_fun,        /* open */
  2011.     ck_fun,        /* close */
  2012.     ck_fun,        /* pipe_op */
  2013.     ck_fun,        /* fileno */
  2014.     ck_fun,        /* umask */
  2015.     ck_fun,        /* binmode */
  2016.     ck_fun,        /* tie */
  2017.     ck_fun,        /* untie */
  2018.     ck_fun,        /* tied */
  2019.     ck_fun,        /* dbmopen */
  2020.     ck_fun,        /* dbmclose */
  2021.     ck_select,    /* sselect */
  2022.     ck_select,    /* select */
  2023.     ck_eof,        /* getc */
  2024.     ck_fun,        /* read */
  2025.     ck_fun,        /* enterwrite */
  2026.     ck_null,    /* leavewrite */
  2027.     ck_listiob,    /* prtf */
  2028.     ck_listiob,    /* print */
  2029.     ck_fun,        /* sysopen */
  2030.     ck_fun,        /* sysseek */
  2031.     ck_fun,        /* sysread */
  2032.     ck_fun,        /* syswrite */
  2033.     ck_fun,        /* send */
  2034.     ck_fun,        /* recv */
  2035.     ck_eof,        /* eof */
  2036.     ck_fun,        /* tell */
  2037.     ck_fun,        /* seek */
  2038.     ck_trunc,    /* truncate */
  2039.     ck_fun,        /* fcntl */
  2040.     ck_fun,        /* ioctl */
  2041.     ck_fun,        /* flock */
  2042.     ck_fun,        /* socket */
  2043.     ck_fun,        /* sockpair */
  2044.     ck_fun,        /* bind */
  2045.     ck_fun,        /* connect */
  2046.     ck_fun,        /* listen */
  2047.     ck_fun,        /* accept */
  2048.     ck_fun,        /* shutdown */
  2049.     ck_fun,        /* gsockopt */
  2050.     ck_fun,        /* ssockopt */
  2051.     ck_fun,        /* getsockname */
  2052.     ck_fun,        /* getpeername */
  2053.     ck_ftst,    /* lstat */
  2054.     ck_ftst,    /* stat */
  2055.     ck_ftst,    /* ftrread */
  2056.     ck_ftst,    /* ftrwrite */
  2057.     ck_ftst,    /* ftrexec */
  2058.     ck_ftst,    /* fteread */
  2059.     ck_ftst,    /* ftewrite */
  2060.     ck_ftst,    /* fteexec */
  2061.     ck_ftst,    /* ftis */
  2062.     ck_ftst,    /* fteowned */
  2063.     ck_ftst,    /* ftrowned */
  2064.     ck_ftst,    /* ftzero */
  2065.     ck_ftst,    /* ftsize */
  2066.     ck_ftst,    /* ftmtime */
  2067.     ck_ftst,    /* ftatime */
  2068.     ck_ftst,    /* ftctime */
  2069.     ck_ftst,    /* ftsock */
  2070.     ck_ftst,    /* ftchr */
  2071.     ck_ftst,    /* ftblk */
  2072.     ck_ftst,    /* ftfile */
  2073.     ck_ftst,    /* ftdir */
  2074.     ck_ftst,    /* ftpipe */
  2075.     ck_ftst,    /* ftlink */
  2076.     ck_ftst,    /* ftsuid */
  2077.     ck_ftst,    /* ftsgid */
  2078.     ck_ftst,    /* ftsvtx */
  2079.     ck_ftst,    /* fttty */
  2080.     ck_ftst,    /* fttext */
  2081.     ck_ftst,    /* ftbinary */
  2082.     ck_fun,        /* chdir */
  2083.     ck_fun,        /* chown */
  2084.     ck_fun,        /* chroot */
  2085.     ck_fun,        /* unlink */
  2086.     ck_fun,        /* chmod */
  2087.     ck_fun,        /* utime */
  2088.     ck_fun,        /* rename */
  2089.     ck_fun,        /* link */
  2090.     ck_fun,        /* symlink */
  2091.     ck_fun,        /* readlink */
  2092.     ck_fun,        /* mkdir */
  2093.     ck_fun,        /* rmdir */
  2094.     ck_fun,        /* open_dir */
  2095.     ck_fun,        /* readdir */
  2096.     ck_fun,        /* telldir */
  2097.     ck_fun,        /* seekdir */
  2098.     ck_fun,        /* rewinddir */
  2099.     ck_fun,        /* closedir */
  2100.     ck_null,    /* fork */
  2101.     ck_null,    /* wait */
  2102.     ck_fun,        /* waitpid */
  2103.     ck_exec,    /* system */
  2104.     ck_exec,    /* exec */
  2105.     ck_fun,        /* kill */
  2106.     ck_null,    /* getppid */
  2107.     ck_fun,        /* getpgrp */
  2108.     ck_fun,        /* setpgrp */
  2109.     ck_fun,        /* getpriority */
  2110.     ck_fun,        /* setpriority */
  2111.     ck_null,    /* time */
  2112.     ck_null,    /* tms */
  2113.     ck_fun,        /* localtime */
  2114.     ck_fun,        /* gmtime */
  2115.     ck_fun,        /* alarm */
  2116.     ck_fun,        /* sleep */
  2117.     ck_fun,        /* shmget */
  2118.     ck_fun,        /* shmctl */
  2119.     ck_fun,        /* shmread */
  2120.     ck_fun,        /* shmwrite */
  2121.     ck_fun,        /* msgget */
  2122.     ck_fun,        /* msgctl */
  2123.     ck_fun,        /* msgsnd */
  2124.     ck_fun,        /* msgrcv */
  2125.     ck_fun,        /* semget */
  2126.     ck_fun,        /* semctl */
  2127.     ck_fun,        /* semop */
  2128.     ck_require,    /* require */
  2129.     ck_fun,        /* dofile */
  2130.     ck_eval,    /* entereval */
  2131.     ck_null,    /* leaveeval */
  2132.     ck_null,    /* entertry */
  2133.     ck_null,    /* leavetry */
  2134.     ck_fun,        /* ghbyname */
  2135.     ck_fun,        /* ghbyaddr */
  2136.     ck_null,    /* ghostent */
  2137.     ck_fun,        /* gnbyname */
  2138.     ck_fun,        /* gnbyaddr */
  2139.     ck_null,    /* gnetent */
  2140.     ck_fun,        /* gpbyname */
  2141.     ck_fun,        /* gpbynumber */
  2142.     ck_null,    /* gprotoent */
  2143.     ck_fun,        /* gsbyname */
  2144.     ck_fun,        /* gsbyport */
  2145.     ck_null,    /* gservent */
  2146.     ck_fun,        /* shostent */
  2147.     ck_fun,        /* snetent */
  2148.     ck_fun,        /* sprotoent */
  2149.     ck_fun,        /* sservent */
  2150.     ck_null,    /* ehostent */
  2151.     ck_null,    /* enetent */
  2152.     ck_null,    /* eprotoent */
  2153.     ck_null,    /* eservent */
  2154.     ck_fun,        /* gpwnam */
  2155.     ck_fun,        /* gpwuid */
  2156.     ck_null,    /* gpwent */
  2157.     ck_null,    /* spwent */
  2158.     ck_null,    /* epwent */
  2159.     ck_fun,        /* ggrnam */
  2160.     ck_fun,        /* ggrgid */
  2161.     ck_null,    /* ggrent */
  2162.     ck_null,    /* sgrent */
  2163.     ck_null,    /* egrent */
  2164.     ck_null,    /* getlogin */
  2165.     ck_fun,        /* syscall */
  2166.     ck_rfun,    /* lock */
  2167.     ck_null,    /* threadsv */
  2168. };
  2169. #endif    /* PERL_OBJECT */
  2170. #endif
  2171.  
  2172. #ifndef DOINIT
  2173. EXT U32 opargs[];
  2174. #else
  2175. EXT U32 opargs[] = {
  2176.     0x00000000,    /* null */
  2177.     0x00000000,    /* stub */
  2178.     0x00001c04,    /* scalar */
  2179.     0x00000004,    /* pushmark */
  2180.     0x00000014,    /* wantarray */
  2181.     0x00000704,    /* const */
  2182.     0x00000844,    /* gvsv */
  2183.     0x00000844,    /* gv */
  2184.     0x00011240,    /* gelem */
  2185.     0x00000044,    /* padsv */
  2186.     0x00000040,    /* padav */
  2187.     0x00000040,    /* padhv */
  2188.     0x00000040,    /* padany */
  2189.     0x00000640,    /* pushre */
  2190.     0x00000144,    /* rv2gv */
  2191.     0x00000144,    /* rv2sv */
  2192.     0x00000114,    /* av2arylen */
  2193.     0x00000140,    /* rv2cv */
  2194.     0x00000700,    /* anoncode */
  2195.     0x00001c04,    /* prototype */
  2196.     0x00002101,    /* refgen */
  2197.     0x00001106,    /* srefgen */
  2198.     0x00009c8c,    /* ref */
  2199.     0x00091504,    /* bless */
  2200.     0x00000c08,    /* backtick */
  2201.     0x00099508,    /* glob */
  2202.     0x00000c08,    /* readline */
  2203.     0x00000c08,    /* rcatline */
  2204.     0x00001104,    /* regcmaybe */
  2205.     0x00001104,    /* regcreset */
  2206.     0x00001304,    /* regcomp */
  2207.     0x00000640,    /* match */
  2208.     0x00000604,    /* qr */
  2209.     0x00001654,    /* subst */
  2210.     0x00000354,    /* substcont */
  2211.     0x00001914,    /* trans */
  2212.     0x00000004,    /* sassign */
  2213.     0x00022208,    /* aassign */
  2214.     0x00002c0d,    /* chop */
  2215.     0x00009c8c,    /* schop */
  2216.     0x00002c0d,    /* chomp */
  2217.     0x00009c8c,    /* schomp */
  2218.     0x00009c94,    /* defined */
  2219.     0x00009c04,    /* undef */
  2220.     0x00009c84,    /* study */
  2221.     0x00009c8c,    /* pos */
  2222.     0x00001164,    /* preinc */
  2223.     0x00001154,    /* i_preinc */
  2224.     0x00001164,    /* predec */
  2225.     0x00001154,    /* i_predec */
  2226.     0x0000116c,    /* postinc */
  2227.     0x0000115c,    /* i_postinc */
  2228.     0x0000116c,    /* postdec */
  2229.     0x0000115c,    /* i_postdec */
  2230.     0x0001120e,    /* pow */
  2231.     0x0001122e,    /* multiply */
  2232.     0x0001121e,    /* i_multiply */
  2233.     0x0001122e,    /* divide */
  2234.     0x0001121e,    /* i_divide */
  2235.     0x0001123e,    /* modulo */
  2236.     0x0001121e,    /* i_modulo */
  2237.     0x00012209,    /* repeat */
  2238.     0x0001122e,    /* add */
  2239.     0x0001121e,    /* i_add */
  2240.     0x0001122e,    /* subtract */
  2241.     0x0001121e,    /* i_subtract */
  2242.     0x0001120e,    /* concat */
  2243.     0x0000150e,    /* stringify */
  2244.     0x0001120e,    /* left_shift */
  2245.     0x0001120e,    /* right_shift */
  2246.     0x00011236,    /* lt */
  2247.     0x00011216,    /* i_lt */
  2248.     0x00011236,    /* gt */
  2249.     0x00011216,    /* i_gt */
  2250.     0x00011236,    /* le */
  2251.     0x00011216,    /* i_le */
  2252.     0x00011236,    /* ge */
  2253.     0x00011216,    /* i_ge */
  2254.     0x00011236,    /* eq */
  2255.     0x00011216,    /* i_eq */
  2256.     0x00011236,    /* ne */
  2257.     0x00011216,    /* i_ne */
  2258.     0x0001123e,    /* ncmp */
  2259.     0x0001121e,    /* i_ncmp */
  2260.     0x00011216,    /* slt */
  2261.     0x00011216,    /* sgt */
  2262.     0x00011216,    /* sle */
  2263.     0x00011216,    /* sge */
  2264.     0x00011216,    /* seq */
  2265.     0x00011216,    /* sne */
  2266.     0x0001121e,    /* scmp */
  2267.     0x0001120e,    /* bit_and */
  2268.     0x0001120e,    /* bit_xor */
  2269.     0x0001120e,    /* bit_or */
  2270.     0x0000112e,    /* negate */
  2271.     0x0000111e,    /* i_negate */
  2272.     0x00001116,    /* not */
  2273.     0x0000110e,    /* complement */
  2274.     0x0001150e,    /* atan2 */
  2275.     0x00009c8e,    /* sin */
  2276.     0x00009c8e,    /* cos */
  2277.     0x00009c0c,    /* rand */
  2278.     0x00009c04,    /* srand */
  2279.     0x00009c8e,    /* exp */
  2280.     0x00009c8e,    /* log */
  2281.     0x00009c8e,    /* sqrt */
  2282.     0x00009c8e,    /* int */
  2283.     0x00009c8e,    /* hex */
  2284.     0x00009c8e,    /* oct */
  2285.     0x00009c8e,    /* abs */
  2286.     0x00009c9c,    /* length */
  2287.     0x0991150c,    /* substr */
  2288.     0x0011151c,    /* vec */
  2289.     0x0091151c,    /* index */
  2290.     0x0091151c,    /* rindex */
  2291.     0x0002150f,    /* sprintf */
  2292.     0x00021505,    /* formline */
  2293.     0x00009c9e,    /* ord */
  2294.     0x00009c8e,    /* chr */
  2295.     0x0001150e,    /* crypt */
  2296.     0x00009c8e,    /* ucfirst */
  2297.     0x00009c8e,    /* lcfirst */
  2298.     0x00009c8e,    /* uc */
  2299.     0x00009c8e,    /* lc */
  2300.     0x00009c8e,    /* quotemeta */
  2301.     0x00000148,    /* rv2av */
  2302.     0x00013804,    /* aelemfast */
  2303.     0x00013204,    /* aelem */
  2304.     0x00023501,    /* aslice */
  2305.     0x00004c08,    /* each */
  2306.     0x00004c08,    /* values */
  2307.     0x00004c08,    /* keys */
  2308.     0x00001c00,    /* delete */
  2309.     0x00001c14,    /* exists */
  2310.     0x00000148,    /* rv2hv */
  2311.     0x00014204,    /* helem */
  2312.     0x00024501,    /* hslice */
  2313.     0x00011500,    /* unpack */
  2314.     0x0002150d,    /* pack */
  2315.     0x00111508,    /* split */
  2316.     0x0002150d,    /* join */
  2317.     0x00002501,    /* list */
  2318.     0x00224200,    /* lslice */
  2319.     0x00002505,    /* anonlist */
  2320.     0x00002505,    /* anonhash */
  2321.     0x02993501,    /* splice */
  2322.     0x0002351d,    /* push */
  2323.     0x00003c14,    /* pop */
  2324.     0x00003c04,    /* shift */
  2325.     0x0002351d,    /* unshift */
  2326.     0x0002d501,    /* sort */
  2327.     0x00002509,    /* reverse */
  2328.     0x00025541,    /* grepstart */
  2329.     0x00000348,    /* grepwhile */
  2330.     0x00025541,    /* mapstart */
  2331.     0x00000348,    /* mapwhile */
  2332.     0x00011400,    /* range */
  2333.     0x00011100,    /* flip */
  2334.     0x00000100,    /* flop */
  2335.     0x00000300,    /* and */
  2336.     0x00000300,    /* or */
  2337.     0x00011306,    /* xor */
  2338.     0x00000440,    /* cond_expr */
  2339.     0x00000304,    /* andassign */
  2340.     0x00000304,    /* orassign */
  2341.     0x00000140,    /* method */
  2342.     0x00002149,    /* entersub */
  2343.     0x00000100,    /* leavesub */
  2344.     0x00009c08,    /* caller */
  2345.     0x0000251d,    /* warn */
  2346.     0x0000255d,    /* die */
  2347.     0x00009c14,    /* reset */
  2348.     0x00000500,    /* lineseq */
  2349.     0x00000b04,    /* nextstate */
  2350.     0x00000b04,    /* dbstate */
  2351.     0x00000004,    /* unstack */
  2352.     0x00000000,    /* enter */
  2353.     0x00000500,    /* leave */
  2354.     0x00000500,    /* scope */
  2355.     0x00000a40,    /* enteriter */
  2356.     0x00000000,    /* iter */
  2357.     0x00000a40,    /* enterloop */
  2358.     0x00000200,    /* leaveloop */
  2359.     0x00002541,    /* return */
  2360.     0x00000e44,    /* last */
  2361.     0x00000e44,    /* next */
  2362.     0x00000e44,    /* redo */
  2363.     0x00000e44,    /* dump */
  2364.     0x00000e44,    /* goto */
  2365.     0x00009c44,    /* exit */
  2366.     0x0009651c,    /* open */
  2367.     0x0000ec14,    /* close */
  2368.     0x00066514,    /* pipe_op */
  2369.     0x00006c1c,    /* fileno */
  2370.     0x00009c1c,    /* umask */
  2371.     0x00006c04,    /* binmode */
  2372.     0x00217555,    /* tie */
  2373.     0x00007c14,    /* untie */
  2374.     0x00007c04,    /* tied */
  2375.     0x00114514,    /* dbmopen */
  2376.     0x00004c14,    /* dbmclose */
  2377.     0x01111508,    /* sselect */
  2378.     0x0000e50c,    /* select */
  2379.     0x0000ec0c,    /* getc */
  2380.     0x0917651d,    /* read */
  2381.     0x0000ec54,    /* enterwrite */
  2382.     0x00000100,    /* leavewrite */
  2383.     0x0002e515,    /* prtf */
  2384.     0x0002e515,    /* print */
  2385.     0x09116504,    /* sysopen */
  2386.     0x00116504,    /* sysseek */
  2387.     0x0917651d,    /* sysread */
  2388.     0x0911651d,    /* syswrite */
  2389.     0x0911651d,    /* send */
  2390.     0x0117651d,    /* recv */
  2391.     0x0000ec14,    /* eof */
  2392.     0x0000ec0c,    /* tell */
  2393.     0x00116504,    /* seek */
  2394.     0x00011514,    /* truncate */
  2395.     0x0011650c,    /* fcntl */
  2396.     0x0011650c,    /* ioctl */
  2397.     0x0001651c,    /* flock */
  2398.     0x01116514,    /* socket */
  2399.     0x11166514,    /* sockpair */
  2400.     0x00016514,    /* bind */
  2401.     0x00016514,    /* connect */
  2402.     0x00016514,    /* listen */
  2403.     0x0006651c,    /* accept */
  2404.     0x0001651c,    /* shutdown */
  2405.     0x00116514,    /* gsockopt */
  2406.     0x01116514,    /* ssockopt */
  2407.     0x00006c14,    /* getsockname */
  2408.     0x00006c14,    /* getpeername */
  2409.     0x00006d80,    /* lstat */
  2410.     0x00006d80,    /* stat */
  2411.     0x00006d94,    /* ftrread */
  2412.     0x00006d94,    /* ftrwrite */
  2413.     0x00006d94,    /* ftrexec */
  2414.     0x00006d94,    /* fteread */
  2415.     0x00006d94,    /* ftewrite */
  2416.     0x00006d94,    /* fteexec */
  2417.     0x00006d94,    /* ftis */
  2418.     0x00006d94,    /* fteowned */
  2419.     0x00006d94,    /* ftrowned */
  2420.     0x00006d94,    /* ftzero */
  2421.     0x00006d9c,    /* ftsize */
  2422.     0x00006d8c,    /* ftmtime */
  2423.     0x00006d8c,    /* ftatime */
  2424.     0x00006d8c,    /* ftctime */
  2425.     0x00006d94,    /* ftsock */
  2426.     0x00006d94,    /* ftchr */
  2427.     0x00006d94,    /* ftblk */
  2428.     0x00006d94,    /* ftfile */
  2429.     0x00006d94,    /* ftdir */
  2430.     0x00006d94,    /* ftpipe */
  2431.     0x00006d94,    /* ftlink */
  2432.     0x00006d94,    /* ftsuid */
  2433.     0x00006d94,    /* ftsgid */
  2434.     0x00006d94,    /* ftsvtx */
  2435.     0x00006d14,    /* fttty */
  2436.     0x00006d94,    /* fttext */
  2437.     0x00006d94,    /* ftbinary */
  2438.     0x00009c1c,    /* chdir */
  2439.     0x0000251d,    /* chown */
  2440.     0x00009c9c,    /* chroot */
  2441.     0x0000259d,    /* unlink */
  2442.     0x0000251d,    /* chmod */
  2443.     0x0000251d,    /* utime */
  2444.     0x0001151c,    /* rename */
  2445.     0x0001151c,    /* link */
  2446.     0x0001151c,    /* symlink */
  2447.     0x00009c8c,    /* readlink */
  2448.     0x0001151c,    /* mkdir */
  2449.     0x00009c9c,    /* rmdir */
  2450.     0x00016514,    /* open_dir */
  2451.     0x00006c00,    /* readdir */
  2452.     0x00006c0c,    /* telldir */
  2453.     0x00016504,    /* seekdir */
  2454.     0x00006c04,    /* rewinddir */
  2455.     0x00006c14,    /* closedir */
  2456.     0x0000001c,    /* fork */
  2457.     0x0000001c,    /* wait */
  2458.     0x0001151c,    /* waitpid */
  2459.     0x0002951d,    /* system */
  2460.     0x0002955d,    /* exec */
  2461.     0x0000255d,    /* kill */
  2462.     0x0000001c,    /* getppid */
  2463.     0x00009c1c,    /* getpgrp */
  2464.     0x0009951c,    /* setpgrp */
  2465.     0x0001151c,    /* getpriority */
  2466.     0x0011151c,    /* setpriority */
  2467.     0x0000001c,    /* time */
  2468.     0x00000000,    /* tms */
  2469.     0x00009c08,    /* localtime */
  2470.     0x00009c08,    /* gmtime */
  2471.     0x00009c9c,    /* alarm */
  2472.     0x00009c1c,    /* sleep */
  2473.     0x0011151d,    /* shmget */
  2474.     0x0011151d,    /* shmctl */
  2475.     0x0111151d,    /* shmread */
  2476.     0x0111151d,    /* shmwrite */
  2477.     0x0001151d,    /* msgget */
  2478.     0x0011151d,    /* msgctl */
  2479.     0x0011151d,    /* msgsnd */
  2480.     0x1111151d,    /* msgrcv */
  2481.     0x0011151d,    /* semget */
  2482.     0x0111151d,    /* semctl */
  2483.     0x0001151d,    /* semop */
  2484.     0x00009cc0,    /* require */
  2485.     0x00001140,    /* dofile */
  2486.     0x00001c40,    /* entereval */
  2487.     0x00001100,    /* leaveeval */
  2488.     0x00000300,    /* entertry */
  2489.     0x00000500,    /* leavetry */
  2490.     0x00001c00,    /* ghbyname */
  2491.     0x00011500,    /* ghbyaddr */
  2492.     0x00000000,    /* ghostent */
  2493.     0x00001c00,    /* gnbyname */
  2494.     0x00011500,    /* gnbyaddr */
  2495.     0x00000000,    /* gnetent */
  2496.     0x00001c00,    /* gpbyname */
  2497.     0x00001500,    /* gpbynumber */
  2498.     0x00000000,    /* gprotoent */
  2499.     0x00011500,    /* gsbyname */
  2500.     0x00011500,    /* gsbyport */
  2501.     0x00000000,    /* gservent */
  2502.     0x00001c14,    /* shostent */
  2503.     0x00001c14,    /* snetent */
  2504.     0x00001c14,    /* sprotoent */
  2505.     0x00001c14,    /* sservent */
  2506.     0x00000014,    /* ehostent */
  2507.     0x00000014,    /* enetent */
  2508.     0x00000014,    /* eprotoent */
  2509.     0x00000014,    /* eservent */
  2510.     0x00001c00,    /* gpwnam */
  2511.     0x00001c00,    /* gpwuid */
  2512.     0x00000000,    /* gpwent */
  2513.     0x00000014,    /* spwent */
  2514.     0x00000014,    /* epwent */
  2515.     0x00001c00,    /* ggrnam */
  2516.     0x00001c00,    /* ggrgid */
  2517.     0x00000000,    /* ggrent */
  2518.     0x00000014,    /* sgrent */
  2519.     0x00000014,    /* egrent */
  2520.     0x0000000c,    /* getlogin */
  2521.     0x0002151d,    /* syscall */
  2522.     0x00001c04,    /* lock */
  2523.     0x00000044,    /* threadsv */
  2524. };
  2525. #endif
  2526.