include/parrot/interpreter.h

   1 /* interpreter.h
   2  *  Copyright (C) 2001-2010, Parrot Foundation.
   3  *  SVN Info
   4  *     $Id$
   5  *  Overview:
   6  *     The interpreter API handles running the operations
   7  */
   8
   9 #ifndef PARROT_INTERPRETER_H_GUARD
  10 #define PARROT_INTERPRETER_H_GUARD
  11
  12 /* These should be visible to embedders. */
  13
  14 /* General flags */
  15 /* &gen_from_enum(interpflags.pasm) */
  16 typedef enum {
  17     PARROT_NO_FLAGS         = 0x00,
  18     PARROT_BOUNDS_FLAG      = 0x04,  /* We're tracking byte code bounds */
  19     PARROT_PROFILE_FLAG     = 0x08,  /* gathering profile information */
  20     PARROT_GC_DEBUG_FLAG    = 0x10,  /* debugging memory management */
  21
  22     PARROT_EXTERN_CODE_FLAG = 0x100, /* reusing another interp's code */
  23     PARROT_DESTROY_FLAG     = 0x200, /* the last interpreter shall cleanup */
  24
  25     PARROT_IS_THREAD        = 0x1000, /* interpreter is a thread */
  26     PARROT_THR_COPY_INTERP  = 0x2000, /* thread start copies interp state */
  27     PARROT_THR_THREAD_POOL  = 0x4000, /* type3 threads */
  28
  29 } Parrot_Interp_flag;
  30 /* &end_gen */
  31
  32 /* &gen_from_enum(interpdebug.pasm) */
  33 typedef enum {
  34     PARROT_NO_DEBUG                 = 0x00,
  35     PARROT_MEM_STAT_DEBUG_FLAG      = 0x01,  /* memory usage summary */
  36     PARROT_BACKTRACE_DEBUG_FLAG     = 0x02,  /* print bt in exception */
  37     PARROT_JIT_DEBUG_FLAG           = 0x04,  /* create jit stabs file */
  38     PARROT_START_DEBUG_FLAG         = 0x08,
  39     PARROT_THREAD_DEBUG_FLAG        = 0x10,
  40     PARROT_EVAL_DEBUG_FLAG          = 0x20,  /* create EVAL_n file */
  41     PARROT_REG_DEBUG_FLAG           = 0x40,  /* fill I,N with garbage */
  42     PARROT_CTX_DESTROY_DEBUG_FLAG   = 0x80,  /* ctx of a sub is gone */
  43     PARROT_ALL_DEBUG_FLAGS          = 0xffff
  44 } Parrot_debug_flags;
  45 /* &end_gen */
  46
  47 /* &gen_from_enum(interptrace.pasm) */
  48 typedef enum {
  49     PARROT_NO_TRACE                 = 0x00,
  50     PARROT_TRACE_OPS_FLAG           = 0x01,  /* op execution trace */
  51     PARROT_TRACE_FIND_METH_FLAG     = 0x02,  /* find_method */
  52     PARROT_TRACE_SUB_CALL_FLAG      = 0x04,  /* invoke/retcc */
  53     PARROT_ALL_TRACE_FLAGS          = 0xffff
  54 } Parrot_trace_flags;
  55 /* &end_gen */
  56
  57 /* &gen_from_enum(interpcores.pasm) */
  58 typedef enum {
  59     PARROT_SLOW_CORE,                       /* slow bounds/trace/profile core */
  60     PARROT_FUNCTION_CORE    = PARROT_SLOW_CORE,
  61     PARROT_FAST_CORE        = 0x01,         /* fast DO_OP core */
  62     PARROT_EXEC_CORE        = 0x20,         /* TODO Parrot_exec_run variants */
  63     PARROT_GC_DEBUG_CORE    = 0x40,         /* run GC before each op */
  64     PARROT_DEBUGGER_CORE    = 0x80,         /* used by parrot debugger */
  65     PARROT_PROFILING_CORE   = 0x160         /* used by parrot debugger */
  66 } Parrot_Run_core_t;
  67 /* &end_gen */
  68
  69 /* &gen_from_enum(cloneflags.pasm) */
  70 typedef enum {
  71     PARROT_CLONE_CODE = 0x1,        /* active code segments
  72                                      * XXX interaction with lexicals
  73                                      */
  74     PARROT_CLONE_GLOBALS = 0x2,     /* global stash */
  75     PARROT_CLONE_RUNOPS = 0x4,      /* runops choice */
  76     PARROT_CLONE_INTERP_FLAGS = 0x8, /* bounds checking and
  77                                      * debugging flags */
  78     PARROT_CLONE_HLL = 0x10,        /* clone HLL setting */
  79     PARROT_CLONE_CLASSES = 0x20,    /* clone usermade classes */
  80     PARROT_CLONE_LIBRARIES = 0x40,  /* clone loaded library set */
  81     /* flags that won't be initially implemented */
  82     PARROT_CLONE_CC = 0x80,         /* clone current continuation --
  83                                      * fork()-like cloning (requires
  84                                      * cloned code segments); probably
  85                                      * would only work if runloop_level is 1 */
  86
  87     /* combinations of flags */
  88     PARROT_CLONE_DEFAULT = 0x7f /* everything but CC */
  89 } Parrot_clone_flags;
  90 /* &end_gen */
  91
  92 struct parrot_interp_t;
  93
  94 /* One of the most common shim arguments is the interpreter itself, so it
  95  * gets its own macro. */
  96 #define PARROT_INTERP /*@notnull@*/ /*@in@*/ Parrot_Interp interp
  97 #define NULLOK_INTERP /*@null@*/    /*@in@*/ Parrot_Interp interp
  98 #define SHIM_INTERP   /*@unused@*/ /*@null@*/ Parrot_Interp interp_unused __attribute__unused__
  99
 100
 101 #ifdef PARROT_IN_CORE
 102
 103 #define Parrot_Language Parrot_Int
 104 #define Parrot_Vtable struct _vtable*
 105
 106 typedef Parrot_Interp_flag Interp_flags;
 107 typedef Parrot_Run_core_t Run_Cores;
 108
 109 #define Interp_flags_SET(interp, flag)   ((interp)->flags |= (flag))
 110 #define Interp_flags_CLEAR(interp, flag) ((interp)->flags &= ~(flag))
 111 #define Interp_flags_TEST(interp, flag)  ((interp)->flags & (flag))
 112
 113 #define Interp_debug_SET(interp, flag)   ((interp)->debug_flags |= (flag))
 114 #define Interp_debug_CLEAR(interp, flag) ((interp)->debug_flags &= ~(flag))
 115 #define Interp_debug_TEST(interp, flag)  ((interp)->debug_flags & (flag))
 116
 117 #define Interp_trace_SET(interp, flag)   Parrot_pcc_trace_flags_on(interp, interp->ctx, (flag))
 118 #define Interp_trace_CLEAR(interp, flag) Parrot_pcc_trace_flags_off(interp, interp->ctx, (flag))
 119 #define Interp_trace_TEST(interp, flag)  Parrot_pcc_trace_flags_test(interp, interp->ctx, (flag))
 120
 121 #define Interp_core_SET(interp, core)   ((interp)->run_core = (core))
 122 #define Interp_core_TEST(interp, core)  ((interp)->run_core == (core))
 123
 124 #include "parrot/context.h"
 125 #include "parrot/parrot.h"
 126 #include "parrot/warnings.h"
 127
 128 #include "parrot/op.h"
 129 #include "parrot/oplib.h"
 130
 131 #include "parrot/debugger.h"
 132 #include "parrot/multidispatch.h"
 133 #include "parrot/call.h"
 134
 135 typedef struct warnings_t {
 136     Warnings_classes classes;
 137 } *Warnings;
 138
 139 /* Forward declaration for imc_info_t -- the actual struct is
 140  * defined in imcc/imc.h */
 141 struct _imc_info_t;
 142
 143
 144 struct _Thread_data;    /* in thread.h */
 145 struct _Caches;         /* caches .h */
 146
 147 /* Get Context from interpreter */
 148 #define CONTEXT(interp)         Parrot_pcc_get_context_struct((interp), (interp)->ctx)
 149
 150 /*
 151  * Helper macros to fetch fields from context.
 152  *
 153  * Not considered as part of public API. Should be replaced with proper accessor
 154  * functions to manipulate Context.
 155  */
 156 #define CURRENT_CONTEXT(interp) ((interp)->ctx)
 157
 158
 159 typedef struct _context_mem {
 160     void **free_list;               /* array of free-lists, per size free slots */
 161     int n_free_slots;               /* amount of allocated */
 162 } context_mem;
 163
 164 struct _handler_node_t; /* forward def - exit.h */
 165
 166 /* The actual interpreter structure */
 167 struct parrot_interp_t {
 168     PMC           *ctx;                       /* current Context */
 169
 170     struct Memory_Pools *mem_pools;                /* Pointer to this interpreter's
 171                                                * arena */
 172
 173     struct GC_Subsystem *gc_sys;              /*functions and data specific
 174                                                   to current GC subsystem*/
 175
 176     PMC *gc_registry;                         /* root set of registered PMCs */
 177
 178     PMC     *class_hash;                      /* Hash of classes */
 179     VTABLE **vtables;                         /* array of vtable ptrs */
 180     int      n_vtable_max;                    /* highest used type */
 181     int      n_vtable_alloced;                /* alloced vtable space */
 182
 183     struct _ParrotIOData   *piodata;          /* interpreter's IO system */
 184
 185     op_lib_t  *op_lib;                        /* Opcode library */
 186     size_t     op_count;                      /* The number of ops */
 187     op_info_t *op_info_table;                 /* Opcode info table
 188                                                * (name, nargs, arg types) */
 189
 190     op_func_t *op_func_table;                  /* opcode dispatch table
 191                                                 * (functions, labels, or nothing
 192                                                 * (e.g. switched core), which
 193                                                 * the interpreter is currently
 194                                                 * running */
 195
 196     op_func_t *evc_func_table;                /* event check opcode dispatch */
 197     op_func_t *save_func_table;               /* for restoring op_func_table */
 198
 199     int         n_libs;                       /* count of libs below */
 200     op_lib_t  **all_op_libs;                  /* all loaded opcode libraries */
 201
 202     INTVAL flags;                             /* Various interpreter flags that
 203                                                * signal that runops should do
 204                                                * something */
 205
 206     UINTVAL debug_flags;                      /* debug settings */
 207
 208     struct runcore_t  *run_core;              /* type of core to run the ops */
 209     struct runcore_t **cores;                 /* array of known runcores */
 210     UINTVAL            num_cores;             /* number of known runcores */
 211
 212     INTVAL resume_flag;
 213     size_t resume_offset;
 214
 215     PackFile_ByteCode *code;                  /* The code we are executing */
 216     struct PackFile          *initial_pf;     /* first created PF  */
 217
 218     struct _imc_info_t *imc_info;             /* imcc data */
 219
 220     const char *output_file;                  /* where to write output */
 221
 222     PDB_t  *pdb;                              /* debug /trace system */
 223
 224     PMC * dynamic_env;                        /* Dynamic environment stack */
 225
 226     void *lo_var_ptr;                         /* Pointer to memory on runops
 227                                                * system stack */
 228
 229     Interp *parent_interpreter;
 230
 231     /* per interpreter global vars */
 232     INTVAL world_inited;                      /* world_init_once() is done */
 233
 234     UINTVAL hash_seed;                        /* STRING hash seed */
 235
 236     PMC *iglobals;                      /* FixedPMCArray of PMCs, containing: */
 237     /* 0:   PMC *Parrot_base_classname_hash; hash containing name->base_type */
 238     /* 1:   PMC *Parrot_compreg_hash;    hash containing assembler/compilers */
 239     /* 2:   PMC *Argv;                   list of argv */
 240     /* 3:   PMC *NCI func hash           hash of NCI funcs */
 241     /* 4:   PMC *ParrotInterpreter       that's me */
 242     /* 5:   PMC *Dyn_libs                dynamically loaded ParrotLibrary */
 243     /* 6:   PMC *Config_Hash             Hash of config settings  */
 244     /* 7:   PMC *Lib_Paths               LoL of search paths  */
 245     /* 8:   PMC *PBC_Libs                Hash of load_bytecode cde */
 246     /* 9:   PMC *Executable              String PMC with name from argv[0]. */
 247
 248
 249     PMC *HLL_info;                            /* HLL names and types */
 250     PMC *HLL_namespace;                       /* cache of HLL toplevel ns */
 251
 252     PMC *root_namespace;                      /* namespace hash */
 253     PMC *scheduler;                           /* concurrency scheduler */
 254
 255     MMD_Cache *op_mmd_cache;                  /* MMD cache for builtins. */
 256
 257     struct _Caches * caches;                  /* see caches.h */
 258
 259     STRING     **const_cstring_table;         /* CONST_STRING(x) items */
 260     Hash        *const_cstring_hash;          /* cache of const_string items */
 261
 262     struct QUEUE* task_queue;                 /* per interpreter queue */
 263     struct _handler_node_t *exit_handler_list;/* exit.c */
 264     int sleeping;                             /* used during sleep in events */
 265
 266     struct parrot_runloop_t *current_runloop;   /* internal runloop jump point stack */
 267     struct parrot_runloop_t *runloop_jmp_free_list; /* and free list */
 268
 269     int current_runloop_level;                /* for reentering run loop */
 270     int current_runloop_id;
 271
 272     struct _Thread_data *thread_data;         /* thread specific items */
 273
 274     UINTVAL recursion_limit;                  /* Sub call resursion limit */
 275
 276     /* during a call sequencer the caller fills these objects
 277      * inside the invoke these get moved to the context structure */
 278     PMC *current_cont;                        /* the return continuation PMC */
 279 };
 280
 281 /* typedef struct parrot_interp_t Interp;    done in parrot.h so that
 282                                              interpreter.h's prereq headers can
 283                                              use 'Interp' */
 284
 285 typedef enum {
 286     RESUME_NONE         = 0x00,
 287     RESUME_RESTART      = 0x01,
 288     RESUME_ISJ          = 0x02,
 289     RESUME_INITIAL      = 0x04
 290 } resume_flag_enum;
 291
 292 /* &gen_from_enum(iglobals.pasm) */
 293 typedef enum {
 294     IGLOBALS_CLASSNAME_HASH,
 295     IGLOBALS_COMPREG_HASH,
 296     IGLOBALS_ARGV_LIST,
 297     IGLOBALS_NCI_FUNCS,
 298     IGLOBALS_NCI_FB_CB,
 299     IGLOBALS_NCI_FB_UD,
 300     IGLOBALS_INTERPRETER,       /* this interpreter as ParrotInterpreter PMC */
 301     IGLOBALS_DYN_LIBS,          /* Hash of ParrotLibrary loaded dynamic ext */
 302     IGLOBALS_CONFIG_HASH,
 303     IGLOBALS_LIB_PATHS,         /* LoL of search paths and dynamic ext */
 304     IGLOBALS_PBC_LIBS,          /* Hash of load_bytecode cde */
 305     IGLOBALS_EXECUTABLE,        /* How Parrot was invoked (from argv[0]) */
 306
 307     IGLOBALS_SIZE
 308 } iglobals_enum;
 309 /* &end_gen */
 310
 311 #define PCONST(i) PF_CONST(interp->code, (i))
 312 #define PNCONST   PF_NCONST(interp->code)
 313
 314 /* TODO - Make this a config option */
 315 #ifndef PARROT_CATCH_NULL
 316 #  ifdef S_SPLINT_S
 317 #    define PARROT_CATCH_NULL 0
 318 #  else
 319 #    define PARROT_CATCH_NULL 1
 320 #  endif
 321 #endif
 322
 323 /* Maybe PMC_IS_NULL(interp, pmc) ? */
 324 #if PARROT_CATCH_NULL
 325 PARROT_DATA PMC    *PMCNULL;    /* Holds single Null PMC */
 326 PARROT_DATA STRING *STRINGNULL; /* a single Null STRING */
 327 #  define PMC_IS_NULL(pmc)  ((pmc) == PMCNULL || (pmc) == NULL)
 328 #  define STRING_IS_NULL(s) ((s) == STRINGNULL || (s) == NULL)
 329 #else
 330 #  define PMCNULL ((PMC *)NULL)
 331 #  define STRINGNULL ((STRING *)NULL)
 332 #  define PMC_IS_NULL(pmc)       ((pmc) == NULL)
 333 #  define STRING_IS_NULL(string) ((string) == NULL)
 334 #endif /* PARROT_CATCH_NULL */
 335
 336 #define STRING_IS_EMPTY(s) ((s)->strlen == 0)
 337
 338 /* &gen_from_def(sysinfo.pasm) prefix(SYSINFO_) */
 339
 340 #define PARROT_INTSIZE               1
 341 #define PARROT_FLOATSIZE             2
 342 #define PARROT_POINTERSIZE           3
 343 #define PARROT_OS                    4
 344 #define PARROT_OS_VERSION            5
 345 #define PARROT_OS_VERSION_NUMBER     6
 346 #define CPU_ARCH                     7
 347 #define CPU_TYPE                     8
 348 #define PARROT_INTMAX                9
 349 #define PARROT_INTMIN               10
 350
 351 /* &end_gen */
 352
 353 typedef opcode_t *(*native_func_t)(PARROT_INTERP,
 354                                    opcode_t * cur_opcode,
 355                                    opcode_t * start_code);
 356
 357 VAR_SCOPE native_func_t run_native;
 358
 359 typedef PMC *(*Parrot_compiler_func_t)(PARROT_INTERP,
 360                                        const char * program);
 361
 362 /* HEADERIZER BEGIN: src/interp/inter_create.c */
 363 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 364
 365 PARROT_EXPORT
 366 PARROT_CANNOT_RETURN_NULL
 367 PARROT_MALLOC
 368 Parrot_Interp allocate_interpreter(
 369     ARGIN_NULLOK(Interp *parent),
 370     INTVAL flags);
 371
 372 PARROT_EXPORT
 373 PARROT_CANNOT_RETURN_NULL
 374 Parrot_Interp initialize_interpreter(PARROT_INTERP, ARGIN(void *stacktop))
 375         __attribute__nonnull__(1)
 376         __attribute__nonnull__(2);
 377
 378 PARROT_EXPORT
 379 PARROT_CANNOT_RETURN_NULL
 380 PARROT_MALLOC
 381 Parrot_Interp make_interpreter(ARGIN_NULLOK(Interp *parent), INTVAL flags);
 382
 383 PARROT_EXPORT
 384 void Parrot_destroy(PARROT_INTERP)
 385         __attribute__nonnull__(1);
 386
 387 void Parrot_really_destroy(PARROT_INTERP,
 388     NULLOK(int exit_code),
 389     SHIM(void *arg))
 390         __attribute__nonnull__(1);
 391
 392 #define ASSERT_ARGS_allocate_interpreter __attribute__unused__ int _ASSERT_ARGS_CHECK = (0)
 393 #define ASSERT_ARGS_initialize_interpreter __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 394        PARROT_ASSERT_ARG(interp) \
 395     , PARROT_ASSERT_ARG(stacktop))
 396 #define ASSERT_ARGS_make_interpreter __attribute__unused__ int _ASSERT_ARGS_CHECK = (0)
 397 #define ASSERT_ARGS_Parrot_destroy __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 398        PARROT_ASSERT_ARG(interp))
 399 #define ASSERT_ARGS_Parrot_really_destroy __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 400        PARROT_ASSERT_ARG(interp))
 401 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 402 /* HEADERIZER END: src/interp/inter_create.c */
 403
 404 /* HEADERIZER BEGIN: src/interp/inter_cb.c */
 405 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 406
 407 PARROT_EXPORT
 408 void Parrot_callback_C(
 409     ARGIN(char *external_data),
 410     ARGMOD_NULLOK(PMC *user_data))
 411         __attribute__nonnull__(1)
 412         FUNC_MODIFIES(*user_data);
 413
 414 PARROT_EXPORT
 415 void Parrot_callback_D(
 416     ARGMOD(PMC *user_data),
 417     ARGMOD_NULLOK(char *external_data))
 418         __attribute__nonnull__(1)
 419         FUNC_MODIFIES(*user_data)
 420         FUNC_MODIFIES(*external_data);
 421
 422 PARROT_EXPORT
 423 PARROT_CANNOT_RETURN_NULL
 424 PARROT_WARN_UNUSED_RESULT
 425 PMC* Parrot_make_cb(PARROT_INTERP,
 426     ARGMOD(PMC* sub),
 427     ARGIN(PMC* user_data),
 428     ARGIN(STRING *cb_signature))
 429         __attribute__nonnull__(1)
 430         __attribute__nonnull__(2)
 431         __attribute__nonnull__(3)
 432         __attribute__nonnull__(4)
 433         FUNC_MODIFIES(* sub);
 434
 435 PARROT_EXPORT
 436 void Parrot_run_callback(PARROT_INTERP,
 437     ARGMOD(PMC* user_data),
 438     ARGIN(char* external_data))
 439         __attribute__nonnull__(1)
 440         __attribute__nonnull__(2)
 441         __attribute__nonnull__(3)
 442         FUNC_MODIFIES(* user_data);
 443
 444 #define ASSERT_ARGS_Parrot_callback_C __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 445        PARROT_ASSERT_ARG(external_data))
 446 #define ASSERT_ARGS_Parrot_callback_D __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 447        PARROT_ASSERT_ARG(user_data))
 448 #define ASSERT_ARGS_Parrot_make_cb __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 449        PARROT_ASSERT_ARG(interp) \
 450     , PARROT_ASSERT_ARG(sub) \
 451     , PARROT_ASSERT_ARG(user_data) \
 452     , PARROT_ASSERT_ARG(cb_signature))
 453 #define ASSERT_ARGS_Parrot_run_callback __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 454        PARROT_ASSERT_ARG(interp) \
 455     , PARROT_ASSERT_ARG(user_data) \
 456     , PARROT_ASSERT_ARG(external_data))
 457 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 458 /* HEADERIZER END: src/interp/inter_cb.c */
 459
 460 /* HEADERIZER BEGIN: src/interp/inter_misc.c */
 461 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 462
 463 PARROT_EXPORT
 464 PARROT_WARN_UNUSED_RESULT
 465 INTVAL interpinfo(PARROT_INTERP, INTVAL what)
 466         __attribute__nonnull__(1);
 467
 468 PARROT_EXPORT
 469 PARROT_WARN_UNUSED_RESULT
 470 PARROT_CANNOT_RETURN_NULL
 471 PMC* interpinfo_p(PARROT_INTERP, INTVAL what)
 472         __attribute__nonnull__(1);
 473
 474 PARROT_EXPORT
 475 PARROT_WARN_UNUSED_RESULT
 476 PARROT_CANNOT_RETURN_NULL
 477 STRING* interpinfo_s(PARROT_INTERP, INTVAL what)
 478         __attribute__nonnull__(1);
 479
 480 PARROT_EXPORT
 481 PARROT_CANNOT_RETURN_NULL
 482 void * Parrot_compile_file(PARROT_INTERP,
 483     ARGIN(const char *fullname),
 484     ARGOUT(STRING **error))
 485         __attribute__nonnull__(1)
 486         __attribute__nonnull__(2)
 487         __attribute__nonnull__(3)
 488         FUNC_MODIFIES(*error);
 489
 490 PARROT_EXPORT
 491 void Parrot_compreg(PARROT_INTERP,
 492     ARGIN(STRING *type),
 493     ARGIN(Parrot_compiler_func_t func))
 494         __attribute__nonnull__(1)
 495         __attribute__nonnull__(2)
 496         __attribute__nonnull__(3);
 497
 498 PARROT_EXPORT
 499 void Parrot_mark_method_writes(PARROT_INTERP,
 500     int type,
 501     ARGIN(const char *name))
 502         __attribute__nonnull__(1)
 503         __attribute__nonnull__(3);
 504
 505 PARROT_EXPORT
 506 void register_nci_method(PARROT_INTERP,
 507     const int type,
 508     ARGIN(void *func),
 509     ARGIN(const char *name),
 510     ARGIN(const char *proto))
 511         __attribute__nonnull__(1)
 512         __attribute__nonnull__(3)
 513         __attribute__nonnull__(4)
 514         __attribute__nonnull__(5);
 515
 516 PARROT_EXPORT
 517 void register_raw_nci_method_in_ns(PARROT_INTERP,
 518     const int type,
 519     ARGIN(void *func),
 520     ARGIN(STRING *name))
 521         __attribute__nonnull__(1)
 522         __attribute__nonnull__(3)
 523         __attribute__nonnull__(4);
 524
 525 #define ASSERT_ARGS_interpinfo __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 526        PARROT_ASSERT_ARG(interp))
 527 #define ASSERT_ARGS_interpinfo_p __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 528        PARROT_ASSERT_ARG(interp))
 529 #define ASSERT_ARGS_interpinfo_s __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 530        PARROT_ASSERT_ARG(interp))
 531 #define ASSERT_ARGS_Parrot_compile_file __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 532        PARROT_ASSERT_ARG(interp) \
 533     , PARROT_ASSERT_ARG(fullname) \
 534     , PARROT_ASSERT_ARG(error))
 535 #define ASSERT_ARGS_Parrot_compreg __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 536        PARROT_ASSERT_ARG(interp) \
 537     , PARROT_ASSERT_ARG(type) \
 538     , PARROT_ASSERT_ARG(func))
 539 #define ASSERT_ARGS_Parrot_mark_method_writes __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 540        PARROT_ASSERT_ARG(interp) \
 541     , PARROT_ASSERT_ARG(name))
 542 #define ASSERT_ARGS_register_nci_method __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 543        PARROT_ASSERT_ARG(interp) \
 544     , PARROT_ASSERT_ARG(func) \
 545     , PARROT_ASSERT_ARG(name) \
 546     , PARROT_ASSERT_ARG(proto))
 547 #define ASSERT_ARGS_register_raw_nci_method_in_ns __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 548        PARROT_ASSERT_ARG(interp) \
 549     , PARROT_ASSERT_ARG(func) \
 550     , PARROT_ASSERT_ARG(name))
 551 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 552 /* HEADERIZER END: src/interp/inter_misc.c */
 553
 554
 555 /* parrotinterpreter.pmc */
 556 /* XXX Would be nice if this could live in some headerized grouping */
 557 void clone_interpreter(Parrot_Interp dest, Parrot_Interp self, INTVAL flags);
 558
 559 #else /* !PARROT_IN_CORE */
 560
 561 typedef void * *(*native_func_t)(PARROT_INTERP,
 562                                  void *cur_opcode,
 563                                  void *start_code);
 564
 565 #endif   /* PARROT_IN_CORE */
 566
 567 #ifndef PMC_IS_NULL
 568 #  define PMC_IS_NULL(pmc) Parrot_pmc_is_null(NULL, (pmc))
 569 #endif
 570 #ifndef STRING_IS_NULL
 571 #  define STRING_IS_NULL(s) ((s) == NULL || Parrot_str_is_null(NULL, (s))
 572 #endif
 573
 574 #endif   /* PARROT_INTERPRETER_H_GUARD */
 575
 576 /*
 577  * Local variables:
 578  *   c-file-style: "parrot"
 579  * End:
 580  * vim: expandtab shiftwidth=4:
 581  */