proto.h

   1 #ifndef PERL_CALLCONV
   2 #  define PERL_CALLCONV
   3 #endif
   4
   5 #ifdef PERL_OBJECT
   6 #define VIRTUAL virtual PERL_CALLCONV
   7 #else
   8 #define VIRTUAL PERL_CALLCONV
   9 START_EXTERN_C
  10 #endif
  11
  12 /* NOTE!!! When new virtual functions are added, they must be added at
  13  * the end of this file to maintain binary compatibility with PERL_OBJECT
  14  */
  15
  16
  17 #ifndef NEXT30_NO_ATTRIBUTE
  18 #ifndef HASATTRIBUTE       /* disable GNU-cc attribute checking? */
  19 #ifdef  __attribute__      /* Avoid possible redefinition errors */
  20 #undef  __attribute__
  21 #endif
  22 #define __attribute__(attr)
  23 #endif
  24 #endif
  25 VIRTUAL SV*     amagic_call (SV* left,SV* right,int method,int dir);
  26 VIRTUAL bool    Gv_AMupdate (HV* stash);
  27 VIRTUAL OP*     append_elem (I32 optype, OP* head, OP* tail);
  28 VIRTUAL OP*     append_list (I32 optype, LISTOP* first, LISTOP* last);
  29 VIRTUAL I32     apply (I32 type, SV** mark, SV** sp);
  30 VIRTUAL void    assertref (OP* o);
  31 VIRTUAL bool    avhv_exists_ent (AV *ar, SV* keysv, U32 hash);
  32 VIRTUAL SV**    avhv_fetch_ent (AV *ar, SV* keysv, I32 lval, U32 hash);
  33 VIRTUAL HE*     avhv_iternext (AV *ar);
  34 VIRTUAL SV*     avhv_iterval (AV *ar, HE* entry);
  35 VIRTUAL HV*     avhv_keys (AV *ar);
  36 VIRTUAL void    av_clear (AV* ar);
  37 VIRTUAL void    av_extend (AV* ar, I32 key);
  38 VIRTUAL AV*     av_fake (I32 size, SV** svp);
  39 VIRTUAL SV**    av_fetch (AV* ar, I32 key, I32 lval);
  40 VIRTUAL void    av_fill (AV* ar, I32 fill);
  41 VIRTUAL I32     av_len (AV* ar);
  42 VIRTUAL AV*     av_make (I32 size, SV** svp);
  43 VIRTUAL SV*     av_pop (AV* ar);
  44 VIRTUAL void    av_push (AV* ar, SV* val);
  45 VIRTUAL void    av_reify (AV* ar);
  46 VIRTUAL SV*     av_shift (AV* ar);
  47 VIRTUAL SV**    av_store (AV* ar, I32 key, SV* val);
  48 VIRTUAL void    av_undef (AV* ar);
  49 VIRTUAL void    av_unshift (AV* ar, I32 num);
  50 VIRTUAL OP*     bind_match (I32 type, OP* left, OP* pat);
  51 VIRTUAL OP*     block_end (I32 floor, OP* seq);
  52 VIRTUAL I32     block_gimme (void);
  53 VIRTUAL int     block_start (int full);
  54 VIRTUAL void    boot_core_UNIVERSAL (void);
  55 VIRTUAL void    call_list (I32 oldscope, AV* av_list);
  56 VIRTUAL I32     cando (I32 bit, I32 effective, Stat_t* statbufp);
  57 VIRTUAL U32     cast_ulong (double f);
  58 VIRTUAL I32     cast_i32 (double f);
  59 VIRTUAL IV      cast_iv (double f);
  60 VIRTUAL UV      cast_uv (double f);
  61 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
  62 VIRTUAL I32     my_chsize (int fd, Off_t length);
  63 #endif
  64
  65 #ifdef USE_THREADS
  66 VIRTUAL MAGIC * condpair_magic (SV *sv);
  67 #endif
  68 VIRTUAL OP*     convert (I32 optype, I32 flags, OP* o);
  69 VIRTUAL void    croak (const char* pat,...) __attribute__((noreturn));
  70 VIRTUAL void    cv_ckproto (CV* cv, GV* gv, char* p);
  71 VIRTUAL CV*     cv_clone (CV* proto);
  72 VIRTUAL SV*     cv_const_sv (CV* cv);
  73 VIRTUAL SV*     op_const_sv (OP* o, CV* cv);
  74 VIRTUAL void    cv_undef (CV* cv);
  75 VIRTUAL void    cx_dump (PERL_CONTEXT* cs);
  76 VIRTUAL SV*     filter_add (filter_t funcp, SV* datasv);
  77 VIRTUAL void    filter_del (filter_t funcp);
  78 VIRTUAL I32     filter_read (int idx, SV* buffer, int maxlen);
  79 VIRTUAL char ** get_op_descs (void);
  80 VIRTUAL char ** get_op_names (void);
  81 VIRTUAL char *  get_no_modify (void);
  82 VIRTUAL U32 *   get_opargs (void);
  83 VIRTUAL I32     cxinc (void);
  84 VIRTUAL void    deb (const char* pat,...);
  85 VIRTUAL void    deb_growlevel (void);
  86 VIRTUAL void    debprofdump (void);
  87 VIRTUAL I32     debop (OP* o);
  88 VIRTUAL I32     debstack (void);
  89 VIRTUAL I32     debstackptrs (void);
  90 VIRTUAL char*   delimcpy (char* to, char* toend, char* from, char* fromend,
  91                     int delim, I32* retlen);
  92 VIRTUAL void    deprecate (char* s);
  93 VIRTUAL OP*     die (const char* pat,...);
  94 VIRTUAL OP*     die_where (char* message, STRLEN msglen);
  95 VIRTUAL void    dounwind (I32 cxix);
  96 VIRTUAL bool    do_aexec (SV* really, SV** mark, SV** sp);
  97 VIRTUAL int     do_binmode (PerlIO *fp, int iotype, int flag);
  98 VIRTUAL void    do_chop (SV* asv, SV* sv);
  99 VIRTUAL bool    do_close (GV* gv, bool not_implicit);
 100 VIRTUAL bool    do_eof (GV* gv);
 101 VIRTUAL bool    do_exec (char* cmd);
 102 #ifndef WIN32
 103 VIRTUAL bool    do_exec3 (char* cmd, int fd, int flag);
 104 #endif
 105 VIRTUAL void    do_execfree (void);
 106 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 107 I32     do_ipcctl (I32 optype, SV** mark, SV** sp);
 108 I32     do_ipcget (I32 optype, SV** mark, SV** sp);
 109 #endif
 110 VIRTUAL void    do_join (SV* sv, SV* del, SV** mark, SV** sp);
 111 VIRTUAL OP*     do_kv (ARGSproto);
 112 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 113 I32     do_msgrcv (SV** mark, SV** sp);
 114 I32     do_msgsnd (SV** mark, SV** sp);
 115 #endif
 116 VIRTUAL bool    do_open (GV* gv, char* name, I32 len,
 117                    int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp);
 118 VIRTUAL void    do_pipe (SV* sv, GV* rgv, GV* wgv);
 119 VIRTUAL bool    do_print (SV* sv, PerlIO* fp);
 120 VIRTUAL OP*     do_readline (void);
 121 VIRTUAL I32     do_chomp (SV* sv);
 122 VIRTUAL bool    do_seek (GV* gv, Off_t pos, int whence);
 123 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 124 I32     do_semop (SV** mark, SV** sp);
 125 I32     do_shmio (I32 optype, SV** mark, SV** sp);
 126 #endif
 127 VIRTUAL void    do_sprintf (SV* sv, I32 len, SV** sarg);
 128 VIRTUAL Off_t   do_sysseek (GV* gv, Off_t pos, int whence);
 129 VIRTUAL Off_t   do_tell (GV* gv);
 130 VIRTUAL I32     do_trans (SV* sv);
 131 VIRTUAL void    do_vecset (SV* sv);
 132 VIRTUAL void    do_vop (I32 optype, SV* sv, SV* left, SV* right);
 133 VIRTUAL OP*     dofile (OP* term);
 134 VIRTUAL I32     dowantarray (void);
 135 VIRTUAL void    dump_all (void);
 136 VIRTUAL void    dump_eval (void);
 137 #ifdef DUMP_FDS  /* See util.c */
 138 VIRTUAL void    dump_fds (char* s);
 139 #endif
 140 VIRTUAL void    dump_form (GV* gv);
 141 VIRTUAL void    gv_dump (GV* gv);
 142 #ifdef MYMALLOC
 143 VIRTUAL void    dump_mstats (char* s);
 144 #endif
 145 VIRTUAL void    op_dump (OP* arg);
 146 VIRTUAL void    pmop_dump (PMOP* pm);
 147 VIRTUAL void    dump_packsubs (HV* stash);
 148 VIRTUAL void    dump_sub (GV* gv);
 149 VIRTUAL void    fbm_compile (SV* sv, U32 flags);
 150 VIRTUAL char*   fbm_instr (unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags);
 151 VIRTUAL char*   find_script (char *scriptname, bool dosearch, char **search_ext, I32 flags);
 152 #ifdef USE_THREADS
 153 VIRTUAL PADOFFSET       find_threadsv (const char *name);
 154 #endif
 155 VIRTUAL OP*     force_list (OP* arg);
 156 VIRTUAL OP*     fold_constants (OP* arg);
 157 VIRTUAL char*   form (const char* pat, ...);
 158 VIRTUAL void    free_tmps (void);
 159 VIRTUAL OP*     gen_constant_list (OP* o);
 160 #ifndef HAS_GETENV_LEN
 161 VIRTUAL char*   getenv_len (char* key, unsigned long *len);
 162 #endif
 163 VIRTUAL void    gp_free (GV* gv);
 164 VIRTUAL GP*     gp_ref (GP* gp);
 165 VIRTUAL GV*     gv_AVadd (GV* gv);
 166 VIRTUAL GV*     gv_HVadd (GV* gv);
 167 VIRTUAL GV*     gv_IOadd (GV* gv);
 168 VIRTUAL GV*     gv_autoload4 (HV* stash, const char* name, STRLEN len, I32 method);
 169 VIRTUAL void    gv_check (HV* stash);
 170 VIRTUAL void    gv_efullname (SV* sv, GV* gv);
 171 VIRTUAL void    gv_efullname3 (SV* sv, GV* gv, const char* prefix);
 172 VIRTUAL GV*     gv_fetchfile (const char* name);
 173 VIRTUAL GV*     gv_fetchmeth (HV* stash, const char* name, STRLEN len, I32 level);
 174 VIRTUAL GV*     gv_fetchmethod (HV* stash, const char* name);
 175 VIRTUAL GV*     gv_fetchmethod_autoload (HV* stash, const char* name, I32 autoload);
 176 VIRTUAL GV*     gv_fetchpv (const char* name, I32 add, I32 sv_type);
 177 VIRTUAL void    gv_fullname (SV* sv, GV* gv);
 178 VIRTUAL void    gv_fullname3 (SV* sv, GV* gv, const char* prefix);
 179 VIRTUAL void    gv_init (GV* gv, HV* stash, const char* name, STRLEN len, int multi);
 180 VIRTUAL HV*     gv_stashpv (const char* name, I32 create);
 181 VIRTUAL HV*     gv_stashpvn (const char* name, U32 namelen, I32 create);
 182 VIRTUAL HV*     gv_stashsv (SV* sv, I32 create);
 183 VIRTUAL void    hv_clear (HV* tb);
 184 VIRTUAL void    hv_delayfree_ent (HV* hv, HE* entry);
 185 VIRTUAL SV*     hv_delete (HV* tb, const char* key, U32 klen, I32 flags);
 186 VIRTUAL SV*     hv_delete_ent (HV* tb, SV* key, I32 flags, U32 hash);
 187 VIRTUAL bool    hv_exists (HV* tb, const char* key, U32 klen);
 188 VIRTUAL bool    hv_exists_ent (HV* tb, SV* key, U32 hash);
 189 VIRTUAL SV**    hv_fetch (HV* tb, const char* key, U32 klen, I32 lval);
 190 VIRTUAL HE*     hv_fetch_ent (HV* tb, SV* key, I32 lval, U32 hash);
 191 VIRTUAL void    hv_free_ent (HV* hv, HE* entry);
 192 VIRTUAL I32     hv_iterinit (HV* tb);
 193 VIRTUAL char*   hv_iterkey (HE* entry, I32* retlen);
 194 VIRTUAL SV*     hv_iterkeysv (HE* entry);
 195 VIRTUAL HE*     hv_iternext (HV* tb);
 196 VIRTUAL SV*     hv_iternextsv (HV* hv, char** key, I32* retlen);
 197 VIRTUAL SV*     hv_iterval (HV* tb, HE* entry);
 198 VIRTUAL void    hv_ksplit (HV* hv, IV newmax);
 199 VIRTUAL void    hv_magic (HV* hv, GV* gv, int how);
 200 VIRTUAL SV**    hv_store (HV* tb, const char* key, U32 klen, SV* val, U32 hash);
 201 VIRTUAL HE*     hv_store_ent (HV* tb, SV* key, SV* val, U32 hash);
 202 VIRTUAL void    hv_undef (HV* tb);
 203 VIRTUAL I32     ibcmp (const char* a, const char* b, I32 len);
 204 VIRTUAL I32     ibcmp_locale (const char* a, const char* b, I32 len);
 205 VIRTUAL I32     ingroup (I32 testgid, I32 effective);
 206 VIRTUAL void    init_stacks (ARGSproto);
 207 VIRTUAL U32     intro_my (void);
 208 VIRTUAL char*   instr (const char* big, const char* little);
 209 VIRTUAL bool    io_close (IO* io);
 210 VIRTUAL OP*     invert (OP* cmd);
 211 VIRTUAL bool    is_uni_alnum (U32 c);
 212 VIRTUAL bool    is_uni_idfirst (U32 c);
 213 VIRTUAL bool    is_uni_alpha (U32 c);
 214 VIRTUAL bool    is_uni_space (U32 c);
 215 VIRTUAL bool    is_uni_digit (U32 c);
 216 VIRTUAL bool    is_uni_upper (U32 c);
 217 VIRTUAL bool    is_uni_lower (U32 c);
 218 VIRTUAL bool    is_uni_print (U32 c);
 219 VIRTUAL U32     to_uni_upper (U32 c);
 220 VIRTUAL U32     to_uni_title (U32 c);
 221 VIRTUAL U32     to_uni_lower (U32 c);
 222 VIRTUAL bool    is_uni_alnum_lc (U32 c);
 223 VIRTUAL bool    is_uni_idfirst_lc (U32 c);
 224 VIRTUAL bool    is_uni_alpha_lc (U32 c);
 225 VIRTUAL bool    is_uni_space_lc (U32 c);
 226 VIRTUAL bool    is_uni_digit_lc (U32 c);
 227 VIRTUAL bool    is_uni_upper_lc (U32 c);
 228 VIRTUAL bool    is_uni_lower_lc (U32 c);
 229 VIRTUAL bool    is_uni_print_lc (U32 c);
 230 VIRTUAL U32     to_uni_upper_lc (U32 c);
 231 VIRTUAL U32     to_uni_title_lc (U32 c);
 232 VIRTUAL U32     to_uni_lower_lc (U32 c);
 233 VIRTUAL bool    is_utf8_alnum (U8 *p);
 234 VIRTUAL bool    is_utf8_idfirst (U8 *p);
 235 VIRTUAL bool    is_utf8_alpha (U8 *p);
 236 VIRTUAL bool    is_utf8_space (U8 *p);
 237 VIRTUAL bool    is_utf8_digit (U8 *p);
 238 VIRTUAL bool    is_utf8_upper (U8 *p);
 239 VIRTUAL bool    is_utf8_lower (U8 *p);
 240 VIRTUAL bool    is_utf8_print (U8 *p);
 241 VIRTUAL bool    is_utf8_mark (U8 *p);
 242 VIRTUAL OP*     jmaybe (OP* arg);
 243 VIRTUAL I32     keyword (char* d, I32 len);
 244 VIRTUAL void    leave_scope (I32 base);
 245 VIRTUAL void    lex_end (void);
 246 VIRTUAL void    lex_start (SV* line);
 247 VIRTUAL OP*     linklist (OP* o);
 248 VIRTUAL OP*     list (OP* o);
 249 VIRTUAL OP*     listkids (OP* o);
 250 VIRTUAL OP*     localize (OP* arg, I32 lexical);
 251 VIRTUAL I32     looks_like_number (SV* sv);
 252 VIRTUAL int     magic_clearenv  (SV* sv, MAGIC* mg);
 253 VIRTUAL int     magic_clear_all_env (SV* sv, MAGIC* mg);
 254 VIRTUAL int     magic_clearpack (SV* sv, MAGIC* mg);
 255 VIRTUAL int     magic_clearsig  (SV* sv, MAGIC* mg);
 256 VIRTUAL int     magic_existspack (SV* sv, MAGIC* mg);
 257 VIRTUAL int     magic_freeregexp (SV* sv, MAGIC* mg);
 258 VIRTUAL int     magic_get       (SV* sv, MAGIC* mg);
 259 VIRTUAL int     magic_getarylen (SV* sv, MAGIC* mg);
 260 VIRTUAL int     magic_getdefelem (SV* sv, MAGIC* mg);
 261 VIRTUAL int     magic_getglob   (SV* sv, MAGIC* mg);
 262 VIRTUAL int     magic_getnkeys  (SV* sv, MAGIC* mg);
 263 VIRTUAL int     magic_getpack   (SV* sv, MAGIC* mg);
 264 VIRTUAL int     magic_getpos    (SV* sv, MAGIC* mg);
 265 VIRTUAL int     magic_getsig    (SV* sv, MAGIC* mg);
 266 VIRTUAL int     magic_getsubstr (SV* sv, MAGIC* mg);
 267 VIRTUAL int     magic_gettaint  (SV* sv, MAGIC* mg);
 268 VIRTUAL int     magic_getuvar   (SV* sv, MAGIC* mg);
 269 VIRTUAL int     magic_getvec    (SV* sv, MAGIC* mg);
 270 VIRTUAL U32     magic_len       (SV* sv, MAGIC* mg);
 271 #ifdef USE_THREADS
 272 VIRTUAL int     magic_mutexfree (SV* sv, MAGIC* mg);
 273 #endif /* USE_THREADS */
 274 VIRTUAL int     magic_nextpack  (SV* sv, MAGIC* mg, SV* key);
 275 VIRTUAL U32     magic_regdata_cnt       (SV* sv, MAGIC* mg);
 276 VIRTUAL int     magic_regdatum_get      (SV* sv, MAGIC* mg);
 277 VIRTUAL int     magic_set       (SV* sv, MAGIC* mg);
 278 VIRTUAL int     magic_setamagic (SV* sv, MAGIC* mg);
 279 VIRTUAL int     magic_setarylen (SV* sv, MAGIC* mg);
 280 VIRTUAL int     magic_setbm     (SV* sv, MAGIC* mg);
 281 VIRTUAL int     magic_setdbline (SV* sv, MAGIC* mg);
 282 #ifdef USE_LOCALE_COLLATE
 283 VIRTUAL int     magic_setcollxfrm (SV* sv, MAGIC* mg);
 284 #endif
 285 VIRTUAL int     magic_setdefelem (SV* sv, MAGIC* mg);
 286 VIRTUAL int     magic_setenv    (SV* sv, MAGIC* mg);
 287 VIRTUAL int     magic_setfm     (SV* sv, MAGIC* mg);
 288 VIRTUAL int     magic_setisa    (SV* sv, MAGIC* mg);
 289 VIRTUAL int     magic_setglob   (SV* sv, MAGIC* mg);
 290 VIRTUAL int     magic_setmglob  (SV* sv, MAGIC* mg);
 291 VIRTUAL int     magic_setnkeys  (SV* sv, MAGIC* mg);
 292 VIRTUAL int     magic_setpack   (SV* sv, MAGIC* mg);
 293 VIRTUAL int     magic_setpos    (SV* sv, MAGIC* mg);
 294 VIRTUAL int     magic_setsig    (SV* sv, MAGIC* mg);
 295 VIRTUAL int     magic_setsubstr (SV* sv, MAGIC* mg);
 296 VIRTUAL int     magic_settaint  (SV* sv, MAGIC* mg);
 297 VIRTUAL int     magic_setuvar   (SV* sv, MAGIC* mg);
 298 VIRTUAL int     magic_setvec    (SV* sv, MAGIC* mg);
 299 VIRTUAL int     magic_set_all_env (SV* sv, MAGIC* mg);
 300 VIRTUAL U32     magic_sizepack  (SV* sv, MAGIC* mg);
 301 VIRTUAL int     magic_wipepack  (SV* sv, MAGIC* mg);
 302 VIRTUAL void    magicname (char* sym, char* name, I32 namlen);
 303 int     main (int argc, char** argv, char** env);
 304 #ifdef MYMALLOC
 305 VIRTUAL MEM_SIZE        malloced_size (void *p);
 306 #endif
 307 VIRTUAL void    markstack_grow (void);
 308 #ifdef USE_LOCALE_COLLATE
 309 VIRTUAL char*   mem_collxfrm (const char* s, STRLEN len, STRLEN* xlen);
 310 #endif
 311 VIRTUAL SV*     mess (const char* pat, va_list* args);
 312 VIRTUAL int     mg_clear (SV* sv);
 313 VIRTUAL int     mg_copy (SV* sv, SV* nsv, const char* key, I32 klen);
 314 VIRTUAL MAGIC*  mg_find (SV* sv, int type);
 315 VIRTUAL int     mg_free (SV* sv);
 316 VIRTUAL int     mg_get (SV* sv);
 317 VIRTUAL U32     mg_length (SV* sv);
 318 VIRTUAL void    mg_magical (SV* sv);
 319 VIRTUAL int     mg_set (SV* sv);
 320 VIRTUAL I32     mg_size (SV* sv);
 321 VIRTUAL OP*     mod (OP* o, I32 type);
 322 VIRTUAL char*   moreswitches (char* s);
 323 VIRTUAL OP*     my (OP* o);
 324 #if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY)
 325 VIRTUAL char*   my_bcopy (const char* from, char* to, I32 len);
 326 #endif
 327 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
 328 char*   my_bzero (char* loc, I32 len);
 329 #endif
 330 VIRTUAL void    my_exit (U32 status) __attribute__((noreturn));
 331 VIRTUAL void    my_failure_exit (void) __attribute__((noreturn));
 332 VIRTUAL I32     my_fflush_all (void);
 333 VIRTUAL I32     my_lstat (ARGSproto);
 334 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
 335 VIRTUAL I32     my_memcmp (const char* s1, const char* s2, I32 len);
 336 #endif
 337 #if !defined(HAS_MEMSET)
 338 VIRTUAL void*   my_memset (char* loc, I32 ch, I32 len);
 339 #endif
 340 #ifndef PERL_OBJECT
 341 VIRTUAL I32     my_pclose (PerlIO* ptr);
 342 VIRTUAL PerlIO* my_popen (char* cmd, char* mode);
 343 #endif
 344 VIRTUAL void    my_setenv (char* nam, char* val);
 345 VIRTUAL I32     my_stat (ARGSproto);
 346 #ifdef MYSWAP
 347 VIRTUAL short   my_swap (short s);
 348 VIRTUAL long    my_htonl (long l);
 349 VIRTUAL long    my_ntohl (long l);
 350 #endif
 351 VIRTUAL void    my_unexec (void);
 352 VIRTUAL OP*     newANONLIST (OP* o);
 353 VIRTUAL OP*     newANONHASH (OP* o);
 354 VIRTUAL OP*     newANONSUB (I32 floor, OP* proto, OP* block);
 355 VIRTUAL OP*     newASSIGNOP (I32 flags, OP* left, I32 optype, OP* right);
 356 VIRTUAL OP*     newCONDOP (I32 flags, OP* expr, OP* trueop, OP* falseop);
 357 VIRTUAL void    newCONSTSUB (HV* stash, char* name, SV* sv);
 358 VIRTUAL void    newFORM (I32 floor, OP* o, OP* block);
 359 VIRTUAL OP*     newFOROP (I32 flags, char* label, line_t forline, OP* sclr, OP* expr, OP*block, OP*cont);
 360 VIRTUAL OP*     newLOGOP (I32 optype, I32 flags, OP* left, OP* right);
 361 VIRTUAL OP*     newLOOPEX (I32 type, OP* label);
 362 VIRTUAL OP*     newLOOPOP (I32 flags, I32 debuggable, OP* expr, OP* block);
 363 VIRTUAL OP*     newNULLLIST (void);
 364 VIRTUAL OP*     newOP (I32 optype, I32 flags);
 365 VIRTUAL void    newPROG (OP* o);
 366 VIRTUAL OP*     newRANGE (I32 flags, OP* left, OP* right);
 367 VIRTUAL OP*     newSLICEOP (I32 flags, OP* subscript, OP* listop);
 368 VIRTUAL OP*     newSTATEOP (I32 flags, char* label, OP* o);
 369 VIRTUAL CV*     newSUB (I32 floor, OP* o, OP* proto, OP* block);
 370 VIRTUAL CV*     newXS (char* name, void (*subaddr)(CV* cv _CPERLproto), char* filename);
 371 VIRTUAL AV*     newAV (void);
 372 VIRTUAL OP*     newAVREF (OP* o);
 373 VIRTUAL OP*     newBINOP (I32 type, I32 flags, OP* first, OP* last);
 374 VIRTUAL OP*     newCVREF (I32 flags, OP* o);
 375 VIRTUAL OP*     newGVOP (I32 type, I32 flags, GV* gv);
 376 VIRTUAL GV*     newGVgen (char* pack);
 377 VIRTUAL OP*     newGVREF (I32 type, OP* o);
 378 VIRTUAL OP*     newHVREF (OP* o);
 379 VIRTUAL HV*     newHV (void);
 380 VIRTUAL HV*     newHVhv (HV* hv);
 381 VIRTUAL IO*     newIO (void);
 382 VIRTUAL OP*     newLISTOP (I32 type, I32 flags, OP* first, OP* last);
 383 VIRTUAL OP*     newPMOP (I32 type, I32 flags);
 384 VIRTUAL OP*     newPVOP (I32 type, I32 flags, char* pv);
 385 VIRTUAL SV*     newRV (SV* pref);
 386 VIRTUAL SV*     newRV_noinc (SV *sv);
 387 VIRTUAL SV*     newSV (STRLEN len);
 388 VIRTUAL OP*     newSVREF (OP* o);
 389 VIRTUAL OP*     newSVOP (I32 type, I32 flags, SV* sv);
 390 VIRTUAL SV*     newSViv (IV i);
 391 VIRTUAL SV*     newSVnv (double n);
 392 VIRTUAL SV*     newSVpv (const char* s, STRLEN len);
 393 VIRTUAL SV*     newSVpvn (const char *s, STRLEN len);
 394 VIRTUAL SV*     newSVpvf (const char* pat, ...);
 395 VIRTUAL SV*     newSVrv (SV* rv, const char* classname);
 396 VIRTUAL SV*     newSVsv (SV* old);
 397 VIRTUAL OP*     newUNOP (I32 type, I32 flags, OP* first);
 398 VIRTUAL OP*     newWHILEOP (I32 flags, I32 debuggable, LOOP* loop,
 399                       I32 whileline, OP* expr, OP* block, OP* cont);
 400 #ifdef USE_THREADS
 401 VIRTUAL struct perl_thread *    new_struct_thread (struct perl_thread *t);
 402 #endif
 403 VIRTUAL PERL_SI *       new_stackinfo (I32 stitems, I32 cxitems);
 404 VIRTUAL PerlIO* nextargv (GV* gv);
 405 VIRTUAL char*   ninstr (const char* big, const char* bigend, const char* little, const char* lend);
 406 VIRTUAL OP*     oopsCV (OP* o);
 407 VIRTUAL void    op_free (OP* arg);
 408 VIRTUAL void    package (OP* o);
 409 VIRTUAL PADOFFSET       pad_alloc (I32 optype, U32 tmptype);
 410 VIRTUAL PADOFFSET       pad_allocmy (char* name);
 411 VIRTUAL PADOFFSET       pad_findmy (char* name);
 412 VIRTUAL OP*     oopsAV (OP* o);
 413 VIRTUAL OP*     oopsHV (OP* o);
 414 VIRTUAL void    pad_leavemy (I32 fill);
 415 VIRTUAL SV*     pad_sv (PADOFFSET po);
 416 VIRTUAL void    pad_free (PADOFFSET po);
 417 VIRTUAL void    pad_reset (void);
 418 VIRTUAL void    pad_swipe (PADOFFSET po);
 419 VIRTUAL void    peep (OP* o);
 420 #ifndef PERL_OBJECT
 421 PerlInterpreter*        perl_alloc (void);
 422 #endif
 423 #ifdef PERL_OBJECT
 424 VIRTUAL void    perl_atexit (void(*fn)(CPerlObj *, void *), void* ptr);
 425 #else
 426 void    perl_atexit (void(*fn)(void *), void*);
 427 #endif
 428 VIRTUAL I32     perl_call_argv (const char* sub_name, I32 flags, char** argv);
 429 VIRTUAL I32     perl_call_method (const char* methname, I32 flags);
 430 VIRTUAL I32     perl_call_pv (const char* sub_name, I32 flags);
 431 VIRTUAL I32     perl_call_sv (SV* sv, I32 flags);
 432 #ifdef PERL_OBJECT
 433 VIRTUAL void    perl_construct (void);
 434 VIRTUAL void    perl_destruct (void);
 435 #else
 436 void    perl_construct (PerlInterpreter* sv_interp);
 437 void    perl_destruct (PerlInterpreter* sv_interp);
 438 #endif
 439 VIRTUAL SV*     perl_eval_pv (const char* p, I32 croak_on_error);
 440 VIRTUAL I32     perl_eval_sv (SV* sv, I32 flags);
 441 #ifdef PERL_OBJECT
 442 VIRTUAL void    perl_free (void);
 443 #else
 444 void    perl_free (PerlInterpreter* sv_interp);
 445 #endif
 446 VIRTUAL SV*     perl_get_sv (const char* name, I32 create);
 447 VIRTUAL AV*     perl_get_av (const char* name, I32 create);
 448 VIRTUAL HV*     perl_get_hv (const char* name, I32 create);
 449 VIRTUAL CV*     perl_get_cv (const char* name, I32 create);
 450 VIRTUAL int     perl_init_i18nl10n (int printwarn);
 451 VIRTUAL int     perl_init_i18nl14n (int printwarn);
 452 VIRTUAL void    perl_new_collate (const char* newcoll);
 453 VIRTUAL void    perl_new_ctype (const char* newctype);
 454 VIRTUAL void    perl_new_numeric (const char* newcoll);
 455 VIRTUAL void    perl_set_numeric_local (void);
 456 VIRTUAL void    perl_set_numeric_standard (void);
 457 #ifdef PERL_OBJECT
 458 VIRTUAL int     perl_parse (void(*xsinit)(CPerlObj*), int argc, char** argv, char** env);
 459 #else
 460 int     perl_parse (PerlInterpreter* sv_interp, void(*xsinit)(void), int argc, char** argv, char** env);
 461 #endif
 462 VIRTUAL void    perl_require_pv (const char* pv);
 463 #define perl_requirepv perl_require_pv
 464 #ifdef PERL_OBJECT
 465 VIRTUAL int     perl_run (void);
 466 #else
 467 int     perl_run (PerlInterpreter* sv_interp);
 468 #endif
 469 VIRTUAL void    pidgone (int pid, int status);
 470 VIRTUAL void    pmflag (U16* pmfl, int ch);
 471 VIRTUAL OP*     pmruntime (OP* pm, OP* expr, OP* repl);
 472 VIRTUAL OP*     pmtrans (OP* o, OP* expr, OP* repl);
 473 VIRTUAL OP*     pop_return (void);
 474 VIRTUAL void    pop_scope (void);
 475 VIRTUAL OP*     prepend_elem (I32 optype, OP* head, OP* tail);
 476 VIRTUAL void    push_return (OP* o);
 477 VIRTUAL void    push_scope (void);
 478 VIRTUAL OP*     ref (OP* o, I32 type);
 479 VIRTUAL OP*     refkids (OP* o, I32 type);
 480 VIRTUAL void    regdump (regexp* r);
 481 VIRTUAL I32     pregexec (regexp* prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave);
 482 VIRTUAL void    pregfree (struct regexp* r);
 483 VIRTUAL regexp* pregcomp (char* exp, char* xend, PMOP* pm);
 484 VIRTUAL I32     regexec_flags (regexp* prog, char* stringarg, char* strend,
 485                          char* strbeg, I32 minend, SV* screamer,
 486                          void* data, U32 flags);
 487 VIRTUAL regnode* regnext (regnode* p);
 488 VIRTUAL void    regprop (SV* sv, regnode* o);
 489 VIRTUAL void    repeatcpy (char* to, const char* from, I32 len, I32 count);
 490 VIRTUAL char*   rninstr (const char* big, const char* bigend, const char* little, const char* lend);
 491 VIRTUAL Sighandler_t rsignal (int i, Sighandler_t t);
 492 VIRTUAL int     rsignal_restore (int i, Sigsave_t* t);
 493 VIRTUAL int     rsignal_save (int i, Sighandler_t t1, Sigsave_t* t2);
 494 VIRTUAL Sighandler_t rsignal_state (int i);
 495 VIRTUAL void    rxres_free (void** rsp);
 496 VIRTUAL void    rxres_restore (void** rsp, REGEXP* prx);
 497 VIRTUAL void    rxres_save (void** rsp, REGEXP* prx);
 498 #ifndef HAS_RENAME
 499 VIRTUAL I32     same_dirent (char* a, char* b);
 500 #endif
 501 VIRTUAL char*   savepv (const char* sv);
 502 VIRTUAL char*   savepvn (const char* sv, I32 len);
 503 VIRTUAL void    savestack_grow (void);
 504 VIRTUAL void    save_aelem (AV* av, I32 idx, SV **sptr);
 505 VIRTUAL I32     save_alloc (I32 size, I32 pad);
 506 VIRTUAL void    save_aptr (AV** aptr);
 507 VIRTUAL AV*     save_ary (GV* gv);
 508 VIRTUAL void    save_clearsv (SV** svp);
 509 VIRTUAL void    save_delete (HV* hv, char* key, I32 klen);
 510 #ifndef titan  /* TitanOS cc can't handle this */
 511 #ifdef PERL_OBJECT
 512 typedef void (CPerlObj::*DESTRUCTORFUNC) (void*);
 513 VIRTUAL void    save_destructor (DESTRUCTORFUNC f, void* p);
 514 #else
 515 void    save_destructor (void (*f)(void*), void* p);
 516 #endif
 517 #endif /* titan */
 518 VIRTUAL void    save_freesv (SV* sv);
 519 VIRTUAL void    save_freeop (OP* o);
 520 VIRTUAL void    save_freepv (char* pv);
 521 VIRTUAL void    save_generic_svref (SV** sptr);
 522 VIRTUAL void    save_gp (GV* gv, I32 empty);
 523 VIRTUAL HV*     save_hash (GV* gv);
 524 VIRTUAL void    save_helem (HV* hv, SV *key, SV **sptr);
 525 VIRTUAL void    save_hints (void);
 526 VIRTUAL void    save_hptr (HV** hptr);
 527 VIRTUAL void    save_I16 (I16* intp);
 528 VIRTUAL void    save_I32 (I32* intp);
 529 VIRTUAL void    save_int (int* intp);
 530 VIRTUAL void    save_item (SV* item);
 531 VIRTUAL void    save_iv (IV* iv);
 532 VIRTUAL void    save_list (SV** sarg, I32 maxsarg);
 533 VIRTUAL void    save_long (long* longp);
 534 VIRTUAL void    save_nogv (GV* gv);
 535 VIRTUAL void    save_op (void);
 536 VIRTUAL SV*     save_scalar (GV* gv);
 537 VIRTUAL void    save_pptr (char** pptr);
 538 VIRTUAL void    save_re_context (void);
 539 VIRTUAL void    save_sptr (SV** sptr);
 540 VIRTUAL SV*     save_svref (SV** sptr);
 541 VIRTUAL SV**    save_threadsv (PADOFFSET i);
 542 VIRTUAL OP*     sawparens (OP* o);
 543 VIRTUAL OP*     scalar (OP* o);
 544 VIRTUAL OP*     scalarkids (OP* o);
 545 VIRTUAL OP*     scalarseq (OP* o);
 546 VIRTUAL OP*     scalarvoid (OP* o);
 547 VIRTUAL UV      scan_bin (char* start, I32 len, I32* retlen);
 548 VIRTUAL UV      scan_hex (char* start, I32 len, I32* retlen);
 549 VIRTUAL char*   scan_num (char* s);
 550 VIRTUAL UV      scan_oct (char* start, I32 len, I32* retlen);
 551 VIRTUAL OP*     scope (OP* o);
 552 VIRTUAL char*   screaminstr (SV* bigsv, SV* littlesv, I32 start_shift, I32 end_shift, I32 *state, I32 last);
 553 #ifndef VMS
 554 VIRTUAL I32     setenv_getix (char* nam);
 555 #endif
 556 VIRTUAL void    setdefout (GV* gv);
 557 VIRTUAL char*   sharepvn (const char* sv, I32 len, U32 hash);
 558 VIRTUAL HEK*    share_hek (const char* sv, I32 len, U32 hash);
 559 VIRTUAL Signal_t sighandler (int sig);
 560 VIRTUAL SV**    stack_grow (SV** sp, SV**p, int n);
 561 VIRTUAL I32     start_subparse (I32 is_format, U32 flags);
 562 VIRTUAL void    sub_crush_depth (CV* cv);
 563 VIRTUAL bool    sv_2bool (SV* sv);
 564 VIRTUAL CV*     sv_2cv (SV* sv, HV** st, GV** gvp, I32 lref);
 565 VIRTUAL IO*     sv_2io (SV* sv);
 566 VIRTUAL IV      sv_2iv (SV* sv);
 567 VIRTUAL SV*     sv_2mortal (SV* sv);
 568 VIRTUAL double  sv_2nv (SV* sv);
 569 VIRTUAL char*   sv_2pv (SV* sv, STRLEN* lp);
 570 VIRTUAL UV      sv_2uv (SV* sv);
 571 VIRTUAL IV      sv_iv (SV* sv);
 572 VIRTUAL UV      sv_uv (SV* sv);
 573 VIRTUAL double  sv_nv (SV* sv);
 574 VIRTUAL char *  sv_pvn (SV *sv, STRLEN *len);
 575 VIRTUAL I32     sv_true (SV *sv);
 576 VIRTUAL void    sv_add_arena (char* ptr, U32 size, U32 flags);
 577 VIRTUAL int     sv_backoff (SV* sv);
 578 VIRTUAL SV*     sv_bless (SV* sv, HV* stash);
 579 VIRTUAL void    sv_catpvf (SV* sv, const char* pat, ...);
 580 VIRTUAL void    sv_catpv (SV* sv, const char* ptr);
 581 VIRTUAL void    sv_catpvn (SV* sv, const char* ptr, STRLEN len);
 582 VIRTUAL void    sv_catsv (SV* dsv, SV* ssv);
 583 VIRTUAL void    sv_chop (SV* sv, char* ptr);
 584 VIRTUAL void    sv_clean_all (void);
 585 VIRTUAL void    sv_clean_objs (void);
 586 VIRTUAL void    sv_clear (SV* sv);
 587 VIRTUAL I32     sv_cmp (SV* sv1, SV* sv2);
 588 VIRTUAL I32     sv_cmp_locale (SV* sv1, SV* sv2);
 589 #ifdef USE_LOCALE_COLLATE
 590 VIRTUAL char*   sv_collxfrm (SV* sv, STRLEN* nxp);
 591 #endif
 592 VIRTUAL OP*     sv_compile_2op (SV* sv, OP** startp, char* code, AV** avp);
 593 VIRTUAL void    sv_dec (SV* sv);
 594 VIRTUAL void    sv_dump (SV* sv);
 595 VIRTUAL bool    sv_derived_from (SV* sv, const char* name);
 596 VIRTUAL I32     sv_eq (SV* sv1, SV* sv2);
 597 VIRTUAL void    sv_free (SV* sv);
 598 VIRTUAL void    sv_free_arenas (void);
 599 VIRTUAL char*   sv_gets (SV* sv, PerlIO* fp, I32 append);
 600 VIRTUAL char*   sv_grow (SV* sv, STRLEN newlen);
 601 VIRTUAL void    sv_inc (SV* sv);
 602 VIRTUAL void    sv_insert (SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen);
 603 VIRTUAL int     sv_isa (SV* sv, const char* name);
 604 VIRTUAL int     sv_isobject (SV* sv);
 605 VIRTUAL STRLEN  sv_len (SV* sv);
 606 VIRTUAL STRLEN  sv_len_utf8 (SV* sv);
 607 VIRTUAL void    sv_magic (SV* sv, SV* obj, int how, const char* name, I32 namlen);
 608 VIRTUAL SV*     sv_mortalcopy (SV* oldsv);
 609 VIRTUAL SV*     sv_newmortal (void);
 610 VIRTUAL SV*     sv_newref (SV* sv);
 611 VIRTUAL char*   sv_peek (SV* sv);
 612 VIRTUAL void    sv_pos_u2b (SV* sv, I32* offsetp, I32* lenp);
 613 VIRTUAL void    sv_pos_b2u (SV* sv, I32* offsetp);
 614 VIRTUAL char*   sv_pvn_force (SV* sv, STRLEN* lp);
 615 VIRTUAL char*   sv_reftype (SV* sv, int ob);
 616 VIRTUAL void    sv_replace (SV* sv, SV* nsv);
 617 VIRTUAL void    sv_report_used (void);
 618 VIRTUAL void    sv_reset (char* s, HV* stash);
 619 VIRTUAL void    sv_setpvf (SV* sv, const char* pat, ...);
 620 VIRTUAL void    sv_setiv (SV* sv, IV num);
 621 VIRTUAL void    sv_setpviv (SV* sv, IV num);
 622 VIRTUAL void    sv_setuv (SV* sv, UV num);
 623 VIRTUAL void    sv_setnv (SV* sv, double num);
 624 VIRTUAL SV*     sv_setref_iv (SV* rv, const char* classname, IV iv);
 625 VIRTUAL SV*     sv_setref_nv (SV* rv, const char* classname, double nv);
 626 VIRTUAL SV*     sv_setref_pv (SV* rv, const char* classname, void* pv);
 627 VIRTUAL SV*     sv_setref_pvn (SV* rv, const char* classname, char* pv, STRLEN n);
 628 VIRTUAL void    sv_setpv (SV* sv, const char* ptr);
 629 VIRTUAL void    sv_setpvn (SV* sv, const char* ptr, STRLEN len);
 630 VIRTUAL void    sv_setsv (SV* dsv, SV* ssv);
 631 VIRTUAL void    sv_taint (SV* sv);
 632 VIRTUAL bool    sv_tainted (SV* sv);
 633 VIRTUAL int     sv_unmagic (SV* sv, int type);
 634 VIRTUAL void    sv_unref (SV* sv);
 635 VIRTUAL void    sv_untaint (SV* sv);
 636 VIRTUAL bool    sv_upgrade (SV* sv, U32 mt);
 637 VIRTUAL void    sv_usepvn (SV* sv, char* ptr, STRLEN len);
 638 VIRTUAL void    sv_vcatpvfn (SV* sv, const char* pat, STRLEN patlen,
 639                        va_list* args, SV** svargs, I32 svmax,
 640                        bool *used_locale);
 641 VIRTUAL void    sv_vsetpvfn (SV* sv, const char* pat, STRLEN patlen,
 642                        va_list* args, SV** svargs, I32 svmax,
 643                        bool *used_locale);
 644 VIRTUAL SV*     swash_init (char* pkg, char* name, SV* listsv, I32 minbits, I32 none);
 645 VIRTUAL UV      swash_fetch (SV *sv, U8 *ptr);
 646 VIRTUAL void    taint_env (void);
 647 VIRTUAL void    taint_proper (const char* f, char* s);
 648 VIRTUAL UV      to_utf8_lower (U8 *p);
 649 VIRTUAL UV      to_utf8_upper (U8 *p);
 650 VIRTUAL UV      to_utf8_title (U8 *p);
 651 #ifdef UNLINK_ALL_VERSIONS
 652 VIRTUAL I32     unlnk (char* f);
 653 #endif
 654 #ifdef USE_THREADS
 655 VIRTUAL void    unlock_condpair (void* svv);
 656 #endif
 657 VIRTUAL void    unsharepvn (const char* sv, I32 len, U32 hash);
 658 VIRTUAL void    unshare_hek (HEK* hek);
 659 VIRTUAL void    utilize (int aver, I32 floor, OP* version, OP* id, OP* arg);
 660 VIRTUAL U8*     utf16_to_utf8 (U16* p, U8 *d, I32 bytelen);
 661 VIRTUAL U8*     utf16_to_utf8_reversed (U16* p, U8 *d, I32 bytelen);
 662 VIRTUAL I32     utf8_distance (U8 *a, U8 *b);
 663 VIRTUAL U8*     utf8_hop (U8 *s, I32 off);
 664 VIRTUAL UV      utf8_to_uv (U8 *s, I32* retlen);
 665 VIRTUAL U8*     uv_to_utf8 (U8 *d, UV uv);
 666 VIRTUAL void    vivify_defelem (SV* sv);
 667 VIRTUAL void    vivify_ref (SV* sv, U32 to_what);
 668 VIRTUAL I32     wait4pid (int pid, int* statusp, int flags);
 669 VIRTUAL void    warn (const char* pat,...);
 670 VIRTUAL void    warner (U32 err, const char* pat,...);
 671 VIRTUAL void    watch (char** addr);
 672 VIRTUAL I32     whichsig (char* sig);
 673 VIRTUAL int     yyerror (char* s);
 674 #ifdef USE_PURE_BISON
 675 # define PERL_YYLEX_PARAM_DECL YYSTYPE *lvalp, int *lcharp
 676 #else
 677 # define PERL_YYLEX_PARAM_DECL void
 678 #endif
 679 VIRTUAL int     yylex (PERL_YYLEX_PARAM_DECL);
 680 VIRTUAL int     yyparse (void);
 681 VIRTUAL int     yywarn (char* s);
 682
 683 VIRTUAL Malloc_t safesysmalloc (MEM_SIZE nbytes);
 684 VIRTUAL Malloc_t safesyscalloc (MEM_SIZE elements, MEM_SIZE size);
 685 VIRTUAL Malloc_t safesysrealloc (Malloc_t where, MEM_SIZE nbytes);
 686 VIRTUAL Free_t   safesysfree (Malloc_t where);
 687
 688 #ifdef LEAKTEST
 689 VIRTUAL Malloc_t safexmalloc (I32 x, MEM_SIZE size);
 690 VIRTUAL Malloc_t safexcalloc (I32 x, MEM_SIZE elements, MEM_SIZE size);
 691 VIRTUAL Malloc_t safexrealloc (Malloc_t where, MEM_SIZE size);
 692 VIRTUAL void     safexfree (Malloc_t where);
 693 #endif
 694
 695 #ifdef PERL_GLOBAL_STRUCT
 696 VIRTUAL struct perl_vars *Perl_GetVars (void);
 697 #endif
 698
 699 #ifdef PERL_OBJECT
 700 protected:
 701 void hsplit (HV *hv);
 702 void hfreeentries (HV *hv);
 703 void more_he (void);
 704 HE* new_he (void);
 705 void del_he (HE *p);
 706 HEK *save_hek (const char *str, I32 len, U32 hash);
 707 SV *mess_alloc (void);
 708 void gv_init_sv (GV *gv, I32 sv_type);
 709 SV *save_scalar_at (SV **sptr);
 710 IV asIV (SV* sv);
 711 UV asUV (SV* sv);
 712 SV *more_sv (void);
 713 void more_xiv (void);
 714 void more_xnv (void);
 715 void more_xpv (void);
 716 void more_xrv (void);
 717 XPVIV *new_xiv (void);
 718 XPVNV *new_xnv (void);
 719 XPV *new_xpv (void);
 720 XRV *new_xrv (void);
 721 void del_xiv (XPVIV* p);
 722 void del_xnv (XPVNV* p);
 723 void del_xpv (XPV* p);
 724 void del_xrv (XRV* p);
 725 void sv_unglob (SV* sv);
 726 I32 avhv_index_sv (SV* sv);
 727
 728 void do_report_used (SV *sv);
 729 void do_clean_objs (SV *sv);
 730 void do_clean_named_objs (SV *sv);
 731 void do_clean_all (SV *sv);
 732 void not_a_number (SV *sv);
 733 void* my_safemalloc (MEM_SIZE size);
 734
 735 typedef void (CPerlObj::*SVFUNC) (SV*);
 736 void visit (SVFUNC f);
 737
 738 typedef I32 (CPerlObj::*SVCOMPARE) (SV*, SV*);
 739 void qsortsv (SV ** array, size_t num_elts, SVCOMPARE f);
 740 I32 sortcv (SV *a, SV *b);
 741 void save_magic (I32 mgs_ix, SV *sv);
 742 int magic_methpack (SV *sv, MAGIC *mg, char *meth);
 743 int magic_methcall (SV *sv, MAGIC *mg, char *meth, I32 f, int n, SV *val);
 744 int magic_methcall (MAGIC *mg, char *meth, I32 flags, int n, SV *val);
 745 OP * doform (CV *cv, GV *gv, OP *retop);
 746 void doencodes (SV* sv, char* s, I32 len);
 747 SV* refto (SV* sv);
 748 U32 seed (void);
 749 OP *docatch (OP *o);
 750 void *docatch_body (va_list args);
 751 void *perl_parse_body (va_list args);
 752 void *perl_run_body (va_list args);
 753 void *perl_call_body (va_list args);
 754 void perl_call_xbody (OP *myop, int is_eval);
 755 void *call_list_body (va_list args);
 756 OP *dofindlabel (OP *o, char *label, OP **opstack, OP **oplimit);
 757 void doparseform (SV *sv);
 758 I32 dopoptoeval (I32 startingblock);
 759 I32 dopoptolabel (char *label);
 760 I32 dopoptoloop (I32 startingblock);
 761 I32 dopoptosub (I32 startingblock);
 762 I32 dopoptosub_at (PERL_CONTEXT* cxstk, I32 startingblock);
 763 void free_closures (void);
 764 void save_lines (AV *array, SV *sv);
 765 OP *doeval (int gimme, OP** startop);
 766 PerlIO *doopen_pmc (const char *name, const char *mode);
 767 I32 sv_ncmp (SV *a, SV *b);
 768 I32 sv_i_ncmp (SV *a, SV *b);
 769 I32 amagic_ncmp (SV *a, SV *b);
 770 I32 amagic_i_ncmp (SV *a, SV *b);
 771 I32 amagic_cmp (SV *str1, SV *str2);
 772 I32 amagic_cmp_locale (SV *str1, SV *str2);
 773
 774 SV *mul128 (SV *sv, U8 m);
 775 SV *is_an_int (char *s, STRLEN l);
 776 int div128 (SV *pnum, bool *done);
 777
 778 int runops_standard (void);
 779 int runops_debug (void);
 780
 781 void check_uni (void);
 782 void  force_next (I32 type);
 783 char *force_version (char *start);
 784 char *force_word (char *start, int token, int check_keyword, int allow_pack, int allow_tick);
 785 SV *tokeq (SV *sv);
 786 char *scan_const (char *start);
 787 char *scan_formline (char *s);
 788 char *scan_heredoc (char *s);
 789 char *scan_ident (char *s, char *send, char *dest, STRLEN destlen, I32 ck_uni);
 790 char *scan_inputsymbol (char *start);
 791 char *scan_pat (char *start, I32 type);
 792 char *scan_str (char *start);
 793 char *scan_subst (char *start);
 794 char *scan_trans (char *start);
 795 char *scan_word (char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp);
 796 char *skipspace (char *s);
 797 void checkcomma (char *s, char *name, char *what);
 798 void force_ident (char *s, int kind);
 799 void incline (char *s);
 800 int intuit_method (char *s, GV *gv);
 801 int intuit_more (char *s);
 802 I32 lop (I32 f, expectation x, char *s);
 803 void missingterm (char *s);
 804 void no_op (char *what, char *s);
 805 void set_csh (void);
 806 I32 sublex_done (void);
 807 I32 sublex_push (void);
 808 I32 sublex_start (void);
 809 #ifdef CRIPPLED_CC
 810 int uni (I32 f, char *s);
 811 #endif
 812 char * filter_gets (SV *sv, PerlIO *fp, STRLEN append);
 813 SV *new_constant (char *s, STRLEN len, char *key, SV *sv, SV *pv, char *type);
 814 int ao (int toketype);
 815 void depcom (void);
 816 #ifdef WIN32
 817 I32 win32_textfilter (int idx, SV *sv, int maxlen);
 818 #endif
 819 char* incl_perldb (void);
 820 SV *isa_lookup (HV *stash, const char *name, int len, int level);
 821 CV *get_db_sub (SV **svp, CV *cv);
 822 I32 list_assignment (OP *o);
 823 void bad_type (I32 n, char *t, char *name, OP *kid);
 824 OP *modkids (OP *o, I32 type);
 825 void no_bareword_allowed (OP *o);
 826 OP *no_fh_allowed (OP *o);
 827 OP *scalarboolean (OP *o);
 828 OP *too_few_arguments (OP *o, char* name);
 829 OP *too_many_arguments (OP *o, char* name);
 830 void null (OP* o);
 831 PADOFFSET pad_findlex (char* name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix, I32 saweval, U32 flags);
 832 OP *newDEFSVOP (void);
 833 char* gv_ename (GV *gv);
 834 CV *cv_clone2 (CV *proto, CV *outside);
 835
 836 void find_beginning (void);
 837 void forbid_setid (char *);
 838 void incpush (char *, int);
 839 void init_interp (void);
 840 void init_ids (void);
 841 void init_debugger (void);
 842 void init_lexer (void);
 843 void init_main_stash (void);
 844 #ifdef USE_THREADS
 845 struct perl_thread * init_main_thread (void);
 846 #endif /* USE_THREADS */
 847 void init_perllib (void);
 848 void init_postdump_symbols (int, char **, char **);
 849 void init_predump_symbols (void);
 850 void my_exit_jump (void) __attribute__((noreturn));
 851 void nuke_stacks (void);
 852 void open_script (char *, bool, SV *, int *fd);
 853 void usage (char *);
 854 void validate_suid (char *, char*, int);
 855 int emulate_eaccess (const char* path, int mode);
 856
 857 regnode *reg (I32, I32 *);
 858 regnode *reganode (U8, U32);
 859 regnode *regatom (I32 *);
 860 regnode *regbranch (I32 *, I32);
 861 void regc (U8, char *);
 862 void reguni (UV, char *, I32*);
 863 regnode *regclass (void);
 864 regnode *regclassutf8 (void);
 865 I32 regcurly (char *);
 866 regnode *reg_node (U8);
 867 regnode *regpiece (I32 *);
 868 void reginsert (U8, regnode *);
 869 void regoptail (regnode *, regnode *);
 870 void regset (char *, I32);
 871 void regtail (regnode *, regnode *);
 872 char* regwhite (char *, char *);
 873 char* nextchar (void);
 874 regnode *dumpuntil (regnode *start, regnode *node, regnode *last, SV* sv, I32 l);
 875 void scan_commit (scan_data_t *data);
 876 I32 study_chunk (regnode **scanp, I32 *deltap, regnode *last, scan_data_t *data, U32 flags);
 877 I32 add_data (I32 n, char *s);
 878 void    re_croak2 (const char* pat1,const char* pat2,...) __attribute__((noreturn));
 879 char* regpposixcc (I32 value);
 880 void clear_re (void *r);
 881 I32 regmatch (regnode *prog);
 882 I32 regrepeat (regnode *p, I32 max);
 883 I32 regrepeat_hard (regnode *p, I32 max, I32 *lp);
 884 I32 regtry (regexp *prog, char *startpos);
 885 bool reginclass (char *p, I32 c);
 886 bool reginclassutf8 (regnode *f, U8* p);
 887 CHECKPOINT regcppush (I32 parenfloor);
 888 char * regcppop (void);
 889 char * regcp_set_to (I32 ss);
 890 void cache_re (regexp *prog);
 891 void restore_pos (void *arg);
 892 U8 * reghop (U8 *pos, I32 off);
 893 U8 * reghopmaybe (U8 *pos, I32 off);
 894 void dump (char *pat,...);
 895 #ifdef WIN32
 896 int do_aspawn (void *vreally, void **vmark, void **vsp);
 897 #endif
 898
 899 #ifdef DEBUGGING
 900 void del_sv (SV *p);
 901 #endif
 902 void debprof (OP *o);
 903
 904 OP *new_logop (I32 type, I32 flags, OP **firstp, OP **otherp);
 905 void simplify_sort (OP *o);
 906 bool is_handle_constructor (OP *o, I32 argnum);
 907 void sv_add_backref (SV *tsv, SV *sv);
 908 void sv_del_backref (SV *sv);
 909
 910 I32 do_trans_CC_simple (SV *sv);
 911 I32 do_trans_CC_count (SV *sv);
 912 I32 do_trans_CC_complex (SV *sv);
 913 I32 do_trans_UU_simple (SV *sv);
 914 I32 do_trans_UU_count (SV *sv);
 915 I32 do_trans_UU_complex (SV *sv);
 916 I32 do_trans_UC_simple (SV *sv);
 917 I32 do_trans_CU_simple (SV *sv);
 918 I32 do_trans_UC_trivial (SV *sv);
 919 I32 do_trans_CU_trivial (SV *sv);
 920
 921 #undef PERL_CKDEF
 922 #undef PERL_PPDEF
 923 #define PERL_CKDEF(s) OP* s (OP *o);
 924 #define PERL_PPDEF(s) OP* s (ARGSproto);
 925 public:
 926
 927 #include "pp_proto.h"
 928
 929 void unwind_handler_stack (void *p);
 930 void restore_magic (void *p);
 931 void restore_rsfp (void *f);
 932 void restore_expect (void *e);
 933 void restore_lex_expect (void *e);
 934 void yydestruct (void *ptr);
 935 VIRTUAL int fprintf (PerlIO *pf, const char *pat, ...);
 936
 937 #ifdef WIN32
 938 VIRTUAL int&    ErrorNo (void);
 939 #endif  /* WIN32 */
 940 #else   /* !PERL_OBJECT */
 941 END_EXTERN_C
 942 #endif  /* PERL_OBJECT */
 943
 944 VIRTUAL void    sv_catpvf_mg (SV *sv, const char* pat, ...);
 945 VIRTUAL void    sv_catpv_mg (SV *sv, const char *ptr);
 946 VIRTUAL void    sv_catpvn_mg (SV *sv, const char *ptr, STRLEN len);
 947 VIRTUAL void    sv_catsv_mg (SV *dstr, SV *sstr);
 948 VIRTUAL void    sv_setpvf_mg (SV *sv, const char* pat, ...);
 949 VIRTUAL void    sv_setiv_mg (SV *sv, IV i);
 950 VIRTUAL void    sv_setpviv_mg (SV *sv, IV iv);
 951 VIRTUAL void    sv_setuv_mg (SV *sv, UV u);
 952 VIRTUAL void    sv_setnv_mg (SV *sv, double num);
 953 VIRTUAL void    sv_setpv_mg (SV *sv, const char *ptr);
 954 VIRTUAL void    sv_setpvn_mg (SV *sv, const char *ptr, STRLEN len);
 955 VIRTUAL void    sv_setsv_mg (SV *dstr, SV *sstr);
 956 VIRTUAL void    sv_usepvn_mg (SV *sv, char *ptr, STRLEN len);
 957
 958 VIRTUAL MGVTBL* get_vtbl (int vtbl_id);
 959
 960 /* New virtual functions must be added here to maintain binary
 961  * compatablity with PERL_OBJECT
 962  */
 963
 964 VIRTUAL char* pv_display (SV *sv, char *pv, STRLEN cur, STRLEN len, STRLEN pvlim);
 965 VIRTUAL void dump_indent (I32 level, PerlIO *file, const char* pat, ...);
 966
 967 VIRTUAL void do_gv_dump (I32 level, PerlIO *file, char *name, GV *sv);
 968 VIRTUAL void do_gvgv_dump (I32 level, PerlIO *file, char *name, GV *sv);
 969 VIRTUAL void do_hv_dump (I32 level, PerlIO *file, char *name, HV *sv);
 970 VIRTUAL void do_magic_dump (I32 level, PerlIO *file, MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim);
 971 VIRTUAL void do_op_dump (I32 level, PerlIO *file, OP *o);
 972 VIRTUAL void do_pmop_dump (I32 level, PerlIO *file, PMOP *pm);
 973 VIRTUAL void do_sv_dump (I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim);
 974 VIRTUAL void magic_dump (MAGIC *mg);
 975 VIRTUAL void* default_protect (int *excpt, protect_body_t body, ...);
 976 VIRTUAL void reginitcolors (void);
 977 VIRTUAL char* sv_2pv_nolen (SV* sv);
 978 VIRTUAL char* sv_pv (SV *sv);
 979 VIRTUAL void sv_force_normal (SV *sv);
 980 VIRTUAL void tmps_grow (I32 n);
 981 VIRTUAL void *bset_obj_store (void *obj, I32 ix);
 982
 983 VIRTUAL SV* sv_rvweaken (SV *sv);
 984 VIRTUAL int magic_killbackrefs (SV *sv, MAGIC *mg);