develooper Front page | perl.cvs.parrot | Postings from December 2008

[svn:parrot] r34732 - in trunk: compilers/imcc src

From:
infinoid
Date:
December 31, 2008 18:16
Subject:
[svn:parrot] r34732 - in trunk: compilers/imcc src
Message ID:
20090101021600.CAD43CB9FA@x12.develooper.com
Author: infinoid
Date: Wed Dec 31 18:15:58 2008
New Revision: 34732

Modified:
   trunk/compilers/imcc/symreg.c
   trunk/src/inter_call.c
   trunk/src/inter_misc.c
   trunk/src/pmc.c
   trunk/src/utils.c

Log:
[core] Add argument assertions to another 145 functions.

Modified: trunk/compilers/imcc/symreg.c
==============================================================================
--- trunk/compilers/imcc/symreg.c	(original)
+++ trunk/compilers/imcc/symreg.c	Wed Dec 31 18:15:58 2008
@@ -121,6 +121,7 @@
 push_namespace(SHIM_INTERP, ARGIN(const char *name))
 {
     Namespace * const ns = mem_allocate_zeroed_typed(Namespace);
+    ASSERT_ARGS(push_namespace);
 
     ns->parent = _namespace;
     ns->name   = str_dup(name);
@@ -143,6 +144,7 @@
 pop_namespace(PARROT_INTERP, ARGIN(const char *name))
 {
     Namespace * const ns = _namespace;
+    ASSERT_ARGS(pop_namespace);
 
     if (!ns)
         IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR, "pop() on empty namespace stack\n");
@@ -179,6 +181,7 @@
 {
     SymReg            *p;
     const unsigned int i = hash_str(name) % hsh->size;
+    ASSERT_ARGS(_get_sym_typed);
 
     for (p = hsh->data[i]; p; p = p->next) {
         if ((t == p->set) && STREQ(name, p->name))
@@ -207,6 +210,7 @@
 _mk_symreg(ARGMOD(SymHash *hsh), ARGIN(const char *name), int t)
 {
     SymReg * r = _get_sym_typed(hsh, name, t);
+    ASSERT_ARGS(_mk_symreg);
 
     if (!r) {
         r             = mem_allocate_zeroed_typed(SymReg);
@@ -239,6 +243,7 @@
 mk_symreg(PARROT_INTERP, ARGIN(const char *name), int t)
 {
     IMC_Unit * const unit = IMCC_INFO(interp)->last_unit;
+    ASSERT_ARGS(mk_symreg);
     return _mk_symreg(&unit->hash, name, t);
 }
 
@@ -263,6 +268,7 @@
      * may be included in the sprintf output (for now) */
     char * const buf = (char *)mem_sys_allocate(250 + strlen(s->name));
     const int    t   = s->type;
+    ASSERT_ARGS(symreg_to_str);
 
     sprintf(buf, "symbol [%s]  set [%c]  color [" INTVAL_FMT "]  type [",
                  s->name, s->set, s->color);
@@ -302,6 +308,7 @@
 {
     char       buf[30];
     static int temp;
+    ASSERT_ARGS(mk_temp_reg);
 
     snprintf(buf, sizeof (buf), "__imcc_temp_%d", ++temp);
     return mk_symreg(interp, buf, t);
@@ -326,6 +333,7 @@
 {
     IMC_Unit * const unit = IMCC_INFO(interp)->last_unit;
     SymReg   * const r    = _mk_symreg(&unit->hash, name, proto);
+    ASSERT_ARGS(mk_pcc_sub);
 
     r->type    = VT_PCC_SUB;
     r->pcc_sub = mem_allocate_zeroed_typed(pcc_sub_t);
@@ -348,6 +356,7 @@
 add_namespace(PARROT_INTERP, ARGMOD(IMC_Unit *unit))
 {
     SymReg * const ns = IMCC_INFO(interp)->cur_namespace;
+    ASSERT_ARGS(add_namespace);
 
     if (!ns)
         return;
@@ -386,6 +395,7 @@
 {
     pcc_sub_t * const sub = r->pcc_sub;
     const int         n   = sub->nargs;
+    ASSERT_ARGS(add_pcc_arg);
 
     mem_realloc_n_typed(sub->args,      n + 1, SymReg *);
     mem_realloc_n_typed(sub->arg_flags, n + 1, int);
@@ -414,6 +424,7 @@
 {
     pcc_sub_t * const sub = r->pcc_sub;
     const int         n   = sub->nret;
+    ASSERT_ARGS(add_pcc_result);
 
     mem_realloc_n_typed(sub->ret,       n + 1, SymReg *);
     mem_realloc_n_typed(sub->ret_flags, n + 1, int);
@@ -444,6 +455,7 @@
 {
     pcc_sub_t * const sub = r->pcc_sub;
     const int n           = sub->nmulti;
+    ASSERT_ARGS(add_pcc_multi);
 
     mem_realloc_n_typed(sub->multi, n + 1, SymReg *);
     sub->multi[n] = arg;
@@ -464,6 +476,7 @@
 void
 add_pcc_sub(ARGMOD(SymReg *r), ARGIN(SymReg *arg))
 {
+    ASSERT_ARGS(add_pcc_sub);
     r->pcc_sub->sub = arg;
 }
 
@@ -481,6 +494,7 @@
 void
 add_pcc_cc(ARGMOD(SymReg *r), ARGIN(SymReg *arg))
 {
+    ASSERT_ARGS(add_pcc_cc);
     r->pcc_sub->cc = arg;
 }
 
@@ -501,6 +515,7 @@
 mk_pasm_reg(PARROT_INTERP, ARGIN(const char *name))
 {
     SymReg *r    = _get_sym(&IMCC_INFO(interp)->cur_unit->hash, name);
+    ASSERT_ARGS(mk_pasm_reg);
 
     if (!r) {
         r        = mk_symreg(interp, name, *name);
@@ -535,6 +550,7 @@
 static char *
 _mk_fullname(ARGIN_NULLOK(const Namespace *ns), ARGIN(const char *name))
 {
+    ASSERT_ARGS(_mk_fullname);
     if (ns) {
         const size_t len = strlen(name) + strlen(ns->name) + 3;
         char *result = (char *) mem_sys_allocate(len);
@@ -563,6 +579,7 @@
 {
     char   * const fullname = _mk_fullname(_namespace, name);
     SymReg        *r        = mk_symreg(interp, fullname, t);
+    ASSERT_ARGS(mk_ident);
 
     r->type = VTIDENTIFIER;
 
@@ -601,6 +618,7 @@
 mk_ident_ur(PARROT_INTERP, ARGIN(const char *name), int t)
 {
     SymReg * const r = mk_ident(interp, name, t);
+    ASSERT_ARGS(mk_ident_ur);
     r->usage        |= U_NON_VOLATILE;
 
     return r;
@@ -627,6 +645,7 @@
     SymReg *r[3];
     char   *name;
     int     len;
+    ASSERT_ARGS(mk_pmc_const_2);
 
     if (IMCC_INFO(interp)->state->pasm_file)
         IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR,
@@ -680,6 +699,7 @@
         ARGMOD(SymReg *val), int global)
 {
     SymReg *r;
+    ASSERT_ARGS(mk_const_ident);
 
     /*
      * Forbid assigning a string to anything other than a string
@@ -730,6 +750,7 @@
 _mk_const(ARGMOD(SymHash *hsh), ARGIN(const char *name), int t)
 {
     SymReg * const r = _mk_symreg(hsh, name, t);
+    ASSERT_ARGS(_mk_const);
     r->type          = VTCONST;
 
     if (t == 'U') {
@@ -753,6 +774,7 @@
 int_overflows(ARGIN(const SymReg *r))
 {
     INTVAL i;
+    ASSERT_ARGS(int_overflows);
     errno = 0;
 
     if (r->type & VT_CONSTP)
@@ -790,6 +812,7 @@
 mk_const(PARROT_INTERP, ARGIN(const char *name), int t)
 {
     SymHash * const h = &IMCC_INFO(interp)->ghash;
+    ASSERT_ARGS(mk_const);
 
     if (!h->data)
         create_symhash(h);
@@ -816,6 +839,7 @@
 {
     size_t len, l;
     char *ns_name, *p;
+    ASSERT_ARGS(add_ns);
 
     if (!IMCC_INFO(interp)->cur_namespace
     || (l = strlen(IMCC_INFO(interp)->cur_namespace->name)) <= 2)
@@ -860,6 +884,7 @@
 _mk_address(PARROT_INTERP, ARGMOD(SymHash *hsh), ARGIN(const char *name), int uniq)
 {
     SymReg *r;
+    ASSERT_ARGS(_mk_address);
 
     if (uniq == U_add_all) {
         r       = mem_allocate_zeroed_typed(SymReg);
@@ -920,6 +945,7 @@
 {
     SymReg * const s = _mk_address(interp, &IMCC_INFO(interp)->ghash,
             name, U_add_uniq_sub);
+    ASSERT_ARGS(mk_sub_label);
 
     s->usage |= U_FIXUP;
 
@@ -944,6 +970,7 @@
 {
     SymReg * const s = _mk_address(interp, &IMCC_INFO(interp)->ghash,
             name, U_add_all);
+    ASSERT_ARGS(mk_sub_address);
 
     s->usage |= U_FIXUP;
 
@@ -967,6 +994,7 @@
 mk_local_label(PARROT_INTERP, ARGIN(const char *name))
 {
     IMC_Unit * const unit = IMCC_INFO(interp)->last_unit;
+    ASSERT_ARGS(mk_local_label);
     return _mk_address(interp, &unit->hash, name, U_add_uniq_label);
 }
 
@@ -987,6 +1015,7 @@
 mk_label_address(PARROT_INTERP, ARGIN(const char *name))
 {
     IMC_Unit * const unit = IMCC_INFO(interp)->last_unit;
+    ASSERT_ARGS(mk_label_address);
     return _mk_address(interp, &unit->hash, name, U_add_once);
 }
 
@@ -1041,6 +1070,7 @@
 dup_sym(ARGIN(const SymReg *r))
 {
     SymReg * const new_sym = mem_allocate_zeroed_typed(SymReg);
+    ASSERT_ARGS(dup_sym);
     STRUCT_COPY(new_sym, r);
     new_sym->name = str_dup(r->name);
 
@@ -1077,6 +1107,7 @@
     SymHash * const h = IMCC_INFO(interp)->cur_unit
                       ? &IMCC_INFO(interp)->cur_unit->hash
                       : &IMCC_INFO(interp)->ghash;
+    ASSERT_ARGS(link_keys);
 
     if (nargs == 0)
         IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR, "link_keys: huh? no keys\n");
@@ -1161,6 +1192,7 @@
 free_sym(ARGMOD(SymReg *r))
 {
     pcc_sub_t * const sub = r->pcc_sub;
+    ASSERT_ARGS(free_sym);
 
     if (sub) {
         mem_sys_free(sub->multi);
@@ -1204,6 +1236,7 @@
 void
 create_symhash(ARGOUT(SymHash *hash))
 {
+    ASSERT_ARGS(create_symhash);
     hash->data    = mem_allocate_n_zeroed_typed(16, SymReg *);
     hash->size    = 16;
     hash->entries = 0;
@@ -1228,6 +1261,7 @@
     SymReg     **next_r   = mem_allocate_n_zeroed_typed(n_next, SymReg *);
     SymHash      nh;                        /* new symbol table */
     unsigned int i;
+    ASSERT_ARGS(resize_symhash);
 
     nh.data = mem_allocate_n_zeroed_typed(new_size, SymReg *);
 
@@ -1283,6 +1317,7 @@
 _store_symreg(ARGMOD(SymHash *hsh), ARGMOD(SymReg *r))
 {
     const int i = hash_str(r->name) % hsh->size;
+    ASSERT_ARGS(_store_symreg);
 #if IMC_TRACE_HIGH
     printf("    store [%s]\n", r->name);
 #endif
@@ -1309,6 +1344,7 @@
 void
 store_symreg(PARROT_INTERP, ARGMOD(SymReg *r))
 {
+    ASSERT_ARGS(store_symreg);
     _store_symreg(&IMCC_INFO(interp)->cur_unit->hash, r);
 }
 
@@ -1330,6 +1366,7 @@
 {
     SymReg   *p;
     const unsigned int i = hash_str(name) % hsh->size;
+    ASSERT_ARGS(_get_sym);
 
     for (p = hsh->data[i]; p; p = p->next) {
 #if IMC_TRACE_HIGH
@@ -1357,6 +1394,7 @@
 SymReg *
 get_sym(PARROT_INTERP, ARGIN(const char *name))
 {
+    ASSERT_ARGS(get_sym);
     return _get_sym(&IMCC_INFO(interp)->cur_unit->hash, name);
 }
 
@@ -1379,6 +1417,7 @@
 {
     const Namespace *ns;
     SymReg          *p;
+    ASSERT_ARGS(_find_sym);
 
     for (ns = nspace; ns; ns = ns->parent) {
         char * const fullname = _mk_fullname(ns, name);
@@ -1420,6 +1459,7 @@
 SymReg *
 find_sym(PARROT_INTERP, ARGIN(const char *name))
 {
+    ASSERT_ARGS(find_sym);
     if (IMCC_INFO(interp)->cur_unit)
         return _find_sym(interp, _namespace,
             &IMCC_INFO(interp)->cur_unit->hash, name);
@@ -1442,6 +1482,7 @@
 clear_sym_hash(ARGMOD(SymHash *hsh))
 {
     unsigned int i;
+    ASSERT_ARGS(clear_sym_hash);
 
     if (!hsh->data)
         return;
@@ -1479,6 +1520,7 @@
 debug_dump_sym_hash(ARGIN(const SymHash *hsh))
 {
     unsigned int i;
+    ASSERT_ARGS(debug_dump_sym_hash);
 
     for (i = 0; i < hsh->size; i++) {
         const SymReg *p = hsh->data[i];
@@ -1505,6 +1547,7 @@
 {
     SymHash * const hsh = &unit->hash;
     unsigned int    i;
+    ASSERT_ARGS(clear_locals);
 
     for (i = 0; i < hsh->size; i++) {
         SymReg *p;
@@ -1540,6 +1583,7 @@
 clear_globals(PARROT_INTERP)
 {
     SymHash * const hsh = &IMCC_INFO(interp)->ghash;
+    ASSERT_ARGS(clear_globals);
 
     if (hsh->data)
         clear_sym_hash(hsh);
@@ -1564,6 +1608,7 @@
 {
     unsigned long  key = 0;
     const    char *s;
+    ASSERT_ARGS(hash_str);
 
     for (s = str; *s; s++)
         key = key * 65599 + *s;

Modified: trunk/src/inter_call.c
==============================================================================
--- trunk/src/inter_call.c	(original)
+++ trunk/src/inter_call.c	Wed Dec 31 18:15:58 2008
@@ -333,6 +333,7 @@
 Parrot_init_arg_nci(PARROT_INTERP, ARGOUT(call_state *st),
     ARGIN(const char *sig))
 {
+    ASSERT_ARGS(Parrot_init_arg_nci);
     init_call_stats(st);
 
     if (PMC_IS_NULL(interp->args_signature))
@@ -363,6 +364,7 @@
 {
     Parrot_Context *ctx                 = CONTEXT(interp);
     PMC            * const current_cont = ctx->current_cont;
+    ASSERT_ARGS(Parrot_init_ret_nci);
 
     /* if this NCI call was a taicall, return results to caller's get_results
      * this also means that we pass the caller's register base pointer */
@@ -405,6 +407,7 @@
         ARGIN_NULLOK(opcode_t *indexes), ARGIN_NULLOK(PMC *sig_pmc),
         ARGMOD(call_state_item *sti))
 {
+    ASSERT_ARGS(Parrot_init_arg_indexes_and_sig_pmc);
     if (!sig_pmc && indexes) {
         ++indexes;
         sig_pmc = ctx->constants[*indexes]->u.key;
@@ -452,6 +455,7 @@
     ARGIN_NULLOK(opcode_t *pc), ARGIN(call_state_item *sti))
 {
     PMC *sig_pmc = PMCNULL;
+    ASSERT_ARGS(Parrot_init_arg_op);
 
     if (pc) {
         ++pc;
@@ -481,6 +485,7 @@
     ARGIN(const char *sig), ARGIN_NULLOK(void *ap),
     ARGMOD(call_state_item *sti))
 {
+    ASSERT_ARGS(Parrot_init_arg_sig);
     sti->used = 1;
     sti->i    = 0;
     sti->n    = 0;
@@ -516,6 +521,7 @@
 static void
 start_flatten(PARROT_INTERP, ARGMOD(call_state *st), ARGIN(PMC *p_arg))
 {
+    ASSERT_ARGS(start_flatten);
     if (PARROT_ARG_NAME_ISSET(st->src.sig)) {
 
         /* src ought to be an hash */
@@ -561,6 +567,7 @@
 static void
 next_arg_sig(ARGMOD(call_state_item *sti))
 {
+    ASSERT_ARGS(next_arg_sig);
     switch (sti->mode & CALL_S_D_MASK) {
         case CALL_STATE_OP:
             sti->sig = SIG_ITEM(sti->u.op.signature, sti->i);
@@ -604,6 +611,7 @@
 fetch_arg_sig(PARROT_INTERP, ARGMOD(call_state *st))
 {
     va_list * const ap = (va_list *)(st->src.u.sig.ap);
+    ASSERT_ARGS(fetch_arg_sig);
 
     switch (st->src.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:
@@ -666,6 +674,7 @@
 {
     const int    constant = PARROT_ARG_CONSTANT_ISSET(st->src.sig);
     const INTVAL idx      = st->src.u.op.pc[st->src.i];
+    ASSERT_ARGS(fetch_arg_op);
 
     switch (PARROT_ARG_TYPE_MASK_MASK(st->src.sig)) {
         case PARROT_ARG_INTVAL:
@@ -735,6 +744,7 @@
 int
 Parrot_fetch_arg(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(Parrot_fetch_arg);
     if (!st->src.used)
         return 1;
 
@@ -814,6 +824,7 @@
 int
 Parrot_fetch_arg_nci(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(Parrot_fetch_arg_nci);
     next_arg_sig(&st->dest);
 
     if (st->dest.sig & PARROT_ARG_SLURPY_ARRAY) {
@@ -854,6 +865,7 @@
 static void
 convert_arg_from_int(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(convert_arg_from_int);
     switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_FLOATVAL:
             UVal_num(st->val) = (FLOATVAL)UVal_int(st->val);
@@ -889,6 +901,7 @@
 static void
 convert_arg_from_num(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(convert_arg_from_num);
     switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:
             UVal_int(st->val) = (INTVAL)UVal_num(st->val);
@@ -925,6 +938,7 @@
 static void
 convert_arg_from_str(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(convert_arg_from_str);
     switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:
             UVal_int(st->val) = string_to_int(interp, UVal_str(st->val));
@@ -960,6 +974,7 @@
 static void
 convert_arg_from_pmc(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(convert_arg_from_pmc);
     switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:
             UVal_int(st->val) = VTABLE_get_integer(interp, UVal_pmc(st->val));
@@ -992,6 +1007,7 @@
 {
     INTVAL idx;
     call_state_item * const dest = &st->dest;
+    ASSERT_ARGS(check_for_opt_flag);
 
     ++st->optionals;
 
@@ -1034,6 +1050,7 @@
 clone_key_arg(PARROT_INTERP, ARGMOD(call_state *st))
 {
     PMC *key = UVal_pmc(st->val);
+    ASSERT_ARGS(clone_key_arg);
 
     if (!key)
         return;
@@ -1070,6 +1087,7 @@
 init_first_dest_named(PARROT_INTERP, ARGMOD(call_state *st))
 {
     int i, n_named;
+    ASSERT_ARGS(init_first_dest_named);
 
     if (st->dest.mode & CALL_STATE_SIG)
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1135,6 +1153,7 @@
 {
     int i;
     int n_named = -1;
+    ASSERT_ARGS(locate_named_named);
 
     for (i = st->first_named; i < st->dest.n; ++i) {
         int idx;
@@ -1186,6 +1205,7 @@
 static void
 store_arg(ARGIN(const call_state *st), INTVAL idx)
 {
+    ASSERT_ARGS(store_arg);
     switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:
             CTX_REG_INT(st->dest.ctx, idx) = UVal_int(st->val);
@@ -1222,6 +1242,7 @@
 Parrot_store_arg(SHIM_INTERP, ARGIN(const call_state *st))
 {
     INTVAL idx;
+    ASSERT_ARGS(Parrot_store_arg);
     if (st->dest.i >= st->dest.n)
         return 0;
 
@@ -1249,6 +1270,7 @@
 {
     const int max_expected_args = st->params;
     const int min_expected_args = max_expected_args - st->optionals;
+    ASSERT_ARGS(too_few);
 
     if (st->n_actual_args < min_expected_args) {
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1275,6 +1297,7 @@
 {
     const int max_expected_args = st->params;
     const int min_expected_args = max_expected_args - st->optionals;
+    ASSERT_ARGS(too_many);
 
     if (st->n_actual_args > max_expected_args) {
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1299,6 +1322,7 @@
 static void
 null_val(int sig, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(null_val);
     switch (sig & PARROT_ARG_TYPE_MASK) {
         case PARROT_ARG_INTVAL:   UVal_int(st->val) = 0;       break;
         case PARROT_ARG_FLOATVAL: UVal_num(st->val) = 0.0;     break;
@@ -1334,6 +1358,7 @@
 {
     int i;
     int n_named = -1;
+    ASSERT_ARGS(check_named);
 
     for (i = st->first_named; i < st->dest.n; ++i) {
         /* verify that a name exists */
@@ -1415,6 +1440,7 @@
 static void
 init_call_stats(ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(init_call_stats);
     /* initial guess, adjusted for :flat args */
     st->n_actual_args = st->src.n;
 
@@ -1448,6 +1474,7 @@
 
     const char * const action = (param_or_result == PARROT_PASS_RESULTS)
         ? "results" : "params";
+    ASSERT_ARGS(Parrot_process_args);
 
     /* Check if we should be throwing errors. This can be configured separately
      * for parameters and return values. */
@@ -1649,6 +1676,7 @@
 void
 Parrot_convert_arg(PARROT_INTERP, ARGMOD(call_state *st))
 {
+    ASSERT_ARGS(Parrot_convert_arg);
     /* register key args have to be cloned */
     if ((st->src.sig & PARROT_ARG_TYPE_MASK) == PARROT_ARG_PMC)
         clone_key_arg(interp, st);
@@ -1697,6 +1725,7 @@
 {
     call_state st;
     PMC *src_signature, *dest_signature;
+    ASSERT_ARGS(parrot_pass_args);
 
     if (param_or_result == PARROT_PASS_PARAMS) {
         src_signature            = interp->args_signature;
@@ -1744,6 +1773,7 @@
         ARGMOD(opcode_t *dest), ARGIN(Parrot_Context *old_ctxp), va_list ap)
 {
     call_state st;
+    ASSERT_ARGS(parrot_pass_args_fromc);
 
     Parrot_init_arg_op(interp, CONTEXT(interp), dest, &st.dest);
     Parrot_init_arg_sig(interp, old_ctxp, sig, PARROT_VA_TO_VAPTR(ap), &st.src);
@@ -1769,6 +1799,7 @@
 {
     opcode_t * const src_pc = interp->current_returns;
     int              todo   = Parrot_init_arg_op(interp, ctx, src_pc, &st->src);
+    ASSERT_ARGS(set_retval_util);
 
     interp->current_returns = NULL;
 
@@ -1804,6 +1835,7 @@
 set_retval(PARROT_INTERP, int sig_ret, ARGIN(Parrot_Context *ctx))
 {
     call_state st;
+    ASSERT_ARGS(set_retval);
 
     if (!sig_ret || sig_ret == 'v')
         return NULL;
@@ -1838,6 +1870,7 @@
 set_retval_i(PARROT_INTERP, int sig_ret, ARGIN(Parrot_Context *ctx))
 {
     call_state st;
+    ASSERT_ARGS(set_retval_i);
 
     if (sig_ret != 'I')
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1865,6 +1898,7 @@
 set_retval_f(PARROT_INTERP, int sig_ret, ARGIN(Parrot_Context *ctx))
 {
     call_state st;
+    ASSERT_ARGS(set_retval_f);
 
     if (sig_ret != 'N')
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1894,6 +1928,7 @@
 set_retval_s(PARROT_INTERP, int sig_ret, ARGIN(Parrot_Context *ctx))
 {
     call_state st;
+    ASSERT_ARGS(set_retval_s);
 
     if (sig_ret != 'S')
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1923,6 +1958,7 @@
 set_retval_p(PARROT_INTERP, int sig_ret, ARGIN(Parrot_Context *ctx))
 {
     call_state st;
+    ASSERT_ARGS(set_retval_p);
 
     if (sig_ret != 'P')
         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -1953,6 +1989,7 @@
     ARGIN_NULLOK(PMC *pmc), ARGIN(va_list *list))
 {
     int reg_offset = 0;
+    ASSERT_ARGS(commit_last_arg);
 
     /* invocant already commited, just return */
     if (seen_arrow == 0 && index == 0 && pmc)
@@ -2029,6 +2066,7 @@
 
     /* # of args, # of results */
     int arg_ret_cnt[2]       = { 0, 0 };
+    ASSERT_ARGS(count_signature_elements);
 
     /* Increment these values if we are not calling from a CallSignature
        PMC */
@@ -2116,6 +2154,7 @@
     ARGIN(PMC *sig_obj))
 {
     int reg_offset = 0;
+    ASSERT_ARGS(commit_last_arg_sig_object);
 
     /* calculate arg's register offset */
     switch (cur & PARROT_ARG_TYPE_MASK) { /* calc reg offset */
@@ -2182,6 +2221,7 @@
     STRING       *empty_string = CONST_STRING(interp, "");
     unsigned int  index        = 0;
     unsigned int  seen_arrow   = 1;
+    ASSERT_ARGS(set_context_sig_returns);
 
     /* result_accessors perform the arg accessor function,
      * assigning the corresponding registers to the result variables */
@@ -2252,6 +2292,7 @@
     unsigned int index = 0;
     unsigned int seen_arrow = 1;
     const char *x;
+    ASSERT_ARGS(set_context_sig_returns_varargs);
 
     /* result_accessors perform the arg accessor function,
      * assigning the corresponding registers to the result variables */
@@ -2321,6 +2362,7 @@
     int cur        =  0;
     const char *ret_x = 0;
     const char *x;
+    ASSERT_ARGS(set_context_sig_params);
 
     for (x = signature; *x != '\0'; x++) {
         /* detect -> separator */
@@ -2416,6 +2458,7 @@
 {
     PMC *sig_obj;
     va_list args;
+    ASSERT_ARGS(Parrot_pcc_invoke_sub_from_c_args);
     va_start(args, sig);
     sig_obj = Parrot_build_sig_object_from_varargs(interp, sig, args);
     va_end(args);
@@ -2520,6 +2563,7 @@
     int         cur   =  0;
 
     va_list list;
+    ASSERT_ARGS(Parrot_PCCINVOKE);
     va_start(list, signature);
 
     indexes[0] = arg_indexes;
@@ -2696,6 +2740,7 @@
     PMC *sigs[2];
 
     const char *ret_x  = NULL;
+    ASSERT_ARGS(Parrot_pcc_invoke_sub_from_sig_object);
 
     indexes[0] = arg_indexes;
     indexes[1] = result_indexes;

Modified: trunk/src/inter_misc.c
==============================================================================
--- trunk/src/inter_misc.c	(original)
+++ trunk/src/inter_misc.c	Wed Dec 31 18:15:58 2008
@@ -50,6 +50,7 @@
     PMC    * const method      = pmc_new(interp, enum_class_NCI);
     STRING * const method_name = string_make(interp, name, strlen(name),
         NULL, PObj_constant_FLAG|PObj_external_FLAG);
+    ASSERT_ARGS(register_nci_method);
 
     /* create call func */
     VTABLE_set_pointer_keyed_str(interp, method,
@@ -81,6 +82,7 @@
     PMC    * const method      = pmc_new(interp, enum_class_NCI);
     STRING * const method_name = string_make(interp, name, strlen(name),
         NULL, PObj_constant_FLAG|PObj_external_FLAG);
+    ASSERT_ARGS(register_raw_nci_method_in_ns);
 
     /* setup call func */
     VTABLE_set_pointer(interp, method, func);
@@ -108,6 +110,7 @@
     PMC    *const pmc_true = pmc_new(interp, enum_class_Integer);
     PMC    *const method   = VTABLE_get_pmc_keyed_str(
         interp, interp->vtables[type]->_namespace, str_name);
+    ASSERT_ARGS(Parrot_mark_method_writes);
     VTABLE_set_integer_native(interp, pmc_true, 1);
     VTABLE_setprop(interp, method, CONST_STRING(interp, "write"), pmc_true);
 }
@@ -132,6 +135,7 @@
     STRING     *sc      = CONST_STRING(interp, "PJt");
     PMC        *hash    = VTABLE_get_pmc_keyed_int(interp, interp->iglobals,
                               IGLOBALS_COMPREG_HASH);
+    ASSERT_ARGS(Parrot_compreg);
 
     if (!hash) {
         hash = pmc_new_noinit(interp, enum_class_Hash);
@@ -163,6 +167,7 @@
 Parrot_compile_string(PARROT_INTERP, ARGIN(STRING *type),
         ARGIN(const char *code), ARGOUT(STRING **error))
 {
+    ASSERT_ARGS(Parrot_compile_string);
     if (string_compare(interp, CONST_STRING(interp, "PIR"), type) == 0)
         return IMCC_compile_pir_s(interp, code, error);
 
@@ -188,6 +193,7 @@
 void *
 Parrot_compile_file(PARROT_INTERP, ARGIN(const char *fullname), ARGOUT(STRING **error))
 {
+    ASSERT_ARGS(Parrot_compile_file);
     return IMCC_compile_file_s(interp, fullname, error);
 }
 
@@ -228,6 +234,7 @@
     INTVAL ret = 0;
     int j;
     Arenas *arena_base = interp->arena_base;
+    ASSERT_ARGS(interpinfo);
 
     switch (what) {
         case TOTAL_MEM_ALLOC:
@@ -315,6 +322,7 @@
 PMC*
 interpinfo_p(PARROT_INTERP, INTVAL what)
 {
+    ASSERT_ARGS(interpinfo_p);
     switch (what) {
         case CURRENT_SUB:
             return CONTEXT(interp)->current_sub;
@@ -357,6 +365,7 @@
 STRING*
 interpinfo_s(PARROT_INTERP, INTVAL what)
 {
+    ASSERT_ARGS(interpinfo_s);
     switch (what) {
         case EXECUTABLE_FULLNAME:
         {
@@ -427,6 +436,7 @@
 INTVAL
 sysinfo_i(SHIM_INTERP, INTVAL info_wanted)
 {
+    ASSERT_ARGS(sysinfo_i);
     switch (info_wanted) {
         case PARROT_INTSIZE:
             return sizeof (INTVAL);
@@ -468,6 +478,7 @@
 STRING *
 sysinfo_s(PARROT_INTERP, INTVAL info_wanted)
 {
+    ASSERT_ARGS(sysinfo_s);
     switch (info_wanted) {
         case PARROT_OS:
             return const_string(interp, BUILD_OS_NAME);

Modified: trunk/src/pmc.c
==============================================================================
--- trunk/src/pmc.c	(original)
+++ trunk/src/pmc.c	Wed Dec 31 18:15:58 2008
@@ -79,6 +79,7 @@
 INTVAL
 PMC_is_null(SHIM_INTERP, ARGIN_NULLOK(const PMC *pmc))
 {
+    ASSERT_ARGS(PMC_is_null);
 #if PARROT_CATCH_NULL
     return pmc == PMCNULL || pmc == NULL;
 #else
@@ -105,6 +106,7 @@
 PMC *
 pmc_new(PARROT_INTERP, INTVAL base_type)
 {
+    ASSERT_ARGS(pmc_new);
     PARROT_ASSERT(interp->vtables[base_type]);
     {
         PMC *const classobj = interp->vtables[base_type]->pmc_class;
@@ -141,6 +143,7 @@
 {
     VTABLE *new_vtable;
     INTVAL  has_ext, new_flags;
+    ASSERT_ARGS(pmc_reuse);
 
     if (pmc->vtable->base_type == new_type)
         return pmc;
@@ -229,6 +232,7 @@
     PMC    *pmc;
     VTABLE *vtable = interp->vtables[base_type];
     UINTVAL vtable_flags;
+    ASSERT_ARGS(get_new_pmc_header);
 
     /* This is usually because you either didn't call init_world early enough,
      * you added a new PMC class without adding Parrot_(classname)_class_init
@@ -326,6 +330,7 @@
 pmc_new_noinit(PARROT_INTERP, INTVAL base_type)
 {
     PMC *const classobj = interp->vtables[base_type]->pmc_class;
+    ASSERT_ARGS(pmc_new_noinit);
 
     if (!PMC_IS_NULL(classobj) && PObj_is_class_TEST(classobj))
         return VTABLE_instantiate(interp, classobj, PMCNULL);
@@ -349,6 +354,7 @@
 PMC *
 constant_pmc_new_noinit(PARROT_INTERP, INTVAL base_type)
 {
+    ASSERT_ARGS(constant_pmc_new_noinit);
     return get_new_pmc_header(interp, base_type, PObj_constant_FLAG);
 }
 
@@ -369,6 +375,7 @@
 constant_pmc_new(PARROT_INTERP, INTVAL base_type)
 {
     PMC * const pmc = get_new_pmc_header(interp, base_type, PObj_constant_FLAG);
+    ASSERT_ARGS(constant_pmc_new);
     VTABLE_init(interp, pmc);
     return pmc;
 }
@@ -390,6 +397,7 @@
 pmc_new_init(PARROT_INTERP, INTVAL base_type, ARGOUT(PMC *init))
 {
     PMC *const classobj = interp->vtables[base_type]->pmc_class;
+    ASSERT_ARGS(pmc_new_init);
 
     if (!PMC_IS_NULL(classobj) && PObj_is_class_TEST(classobj))
         return VTABLE_instantiate(interp, classobj, init);
@@ -418,6 +426,7 @@
 constant_pmc_new_init(PARROT_INTERP, INTVAL base_type, ARGIN_NULLOK(PMC *init))
 {
     PMC * const pmc = get_new_pmc_header(interp, base_type, PObj_constant_FLAG);
+    ASSERT_ARGS(constant_pmc_new_init);
     VTABLE_init_pmc(interp, pmc, init);
     return pmc;
 }
@@ -452,6 +461,7 @@
 temporary_pmc_new(PARROT_INTERP, INTVAL base_type)
 {
     PMC * const pmc = get_new_pmc_header(interp, base_type, PObj_constant_FLAG);
+    ASSERT_ARGS(temporary_pmc_new);
     VTABLE_init(interp, pmc);
     return pmc;
 }
@@ -474,6 +484,7 @@
 pmc_free_to_pool(PARROT_INTERP, ARGMOD(PMC *pmc),
     ARGMOD(Small_Object_Pool *pool))
 {
+    ASSERT_ARGS(pmc_free_to_pool);
     if (PObj_active_destroy_TEST(pmc))
         VTABLE_destroy(interp, pmc);
 
@@ -490,6 +501,7 @@
 temporary_pmc_free(PARROT_INTERP, ARGMOD(PMC *pmc))
 {
     Small_Object_Pool *pool = interp->arena_base->constant_pmc_pool;
+    ASSERT_ARGS(temporary_pmc_free);
     pmc_free_to_pool(interp, pmc, pool);
 }
 
@@ -497,6 +509,7 @@
 pmc_free(PARROT_INTERP, ARGMOD(PMC *pmc))
 {
     Small_Object_Pool *pool = interp->arena_base->pmc_pool;
+    ASSERT_ARGS(pmc_free);
     pmc_free_to_pool(interp, pmc, pool);
 
 }
@@ -506,6 +519,7 @@
 get_new_vtable_index(PARROT_INTERP)
 {
     const INTVAL typeid = interp->n_vtable_max++;
+    ASSERT_ARGS(get_new_vtable_index);
 
     /* Have we overflowed the table? */
     if (typeid >= interp->n_vtable_alloced)
@@ -532,6 +546,7 @@
     /* If they're looking to register an existing class, return that
        class' type number */
     INTVAL type = pmc_type(interp, name);
+    ASSERT_ARGS(pmc_register);
 
     if (type > enum_type_undef)
         return type;
@@ -564,6 +579,7 @@
 INTVAL
 pmc_type(PARROT_INTERP, ARGIN_NULLOK(STRING *name))
 {
+    ASSERT_ARGS(pmc_type);
     if (!name)
         return enum_type_undef;
     else {
@@ -600,6 +616,7 @@
     PMC * const classname_hash = interp->class_hash;
     PMC * const item           =
         (PMC *)VTABLE_get_pointer_keyed(interp, classname_hash, name);
+    ASSERT_ARGS(pmc_type_p);
 
     if (!PMC_IS_NULL(item))
         return VTABLE_get_integer(interp, item);
@@ -632,6 +649,7 @@
      */
     PMC * const _class = get_new_pmc_header(interp, type,
                                            PObj_constant_FLAG);
+    ASSERT_ARGS(create_class_pmc);
 
     /* If we are a second thread, we may get the same object as the
      * original because we have a singleton. Just set the singleton to
@@ -676,6 +694,7 @@
     VTABLE *vtable   = interp->vtables[type];
     PMC    *mro_list = vtable->mro;
     INTVAL  i, count;
+    ASSERT_ARGS(Parrot_create_mro);
 
     /* this should never be PMCNULL */
     PARROT_ASSERT(!PMC_IS_NULL(mro_list));
@@ -742,6 +761,7 @@
 void
 dod_register_pmc(PARROT_INTERP, ARGIN(PMC *pmc))
 {
+    ASSERT_ARGS(dod_register_pmc);
     /* Better not trigger a DOD run with a potentially unanchored PMC */
     Parrot_block_GC_mark(interp);
 
@@ -765,6 +785,7 @@
 void
 dod_unregister_pmc(PARROT_INTERP, ARGIN(PMC *pmc))
 {
+    ASSERT_ARGS(dod_unregister_pmc);
     PARROT_ASSERT(interp->DOD_registry);
 
     VTABLE_delete_keyed(interp, interp->DOD_registry, pmc);

Modified: trunk/src/utils.c
==============================================================================
--- trunk/src/utils.c	(original)
+++ trunk/src/utils.c	Wed Dec 31 18:15:58 2008
@@ -120,6 +120,7 @@
 intval_mod(INTVAL i2, INTVAL i3)
 {
     INTVAL z = i3;
+    ASSERT_ARGS(intval_mod);
 
     if (z == 0)
         return i2;
@@ -171,6 +172,7 @@
    * adding a temporary variable makes it pass the test.
    */
   const FLOATVAL temp = n3 * floor(n2 / n3);
+  ASSERT_ARGS(floatval_mod);
 
   return !FLOAT_IS_ZERO(n3)
      ? (n2 - temp)
@@ -233,6 +235,7 @@
 {
     unsigned short lo, mid, hi;
     unsigned int t;
+    ASSERT_ARGS(next_rand);
 
     /* 48 bit mul, one short at a time */
     t = X[0] * a[0] + c;
@@ -264,6 +267,7 @@
 _erand48(_rand_buf buf)
 {
     FLOATVAL r;
+    ASSERT_ARGS(_erand48);
     next_rand(buf);
     r = ((buf[0] / 65536.0 + buf[1]) / 65536.0 + buf[2]) / 65536.0;
     return r;
@@ -282,6 +286,7 @@
 static FLOATVAL
 _drand48(void)
 {
+    ASSERT_ARGS(_drand48);
     return _erand48(last_rand);
 }
 
@@ -299,6 +304,7 @@
 _jrand48(_rand_buf buf)
 {
     long ret;
+    ASSERT_ARGS(_jrand48);
     next_rand(buf);
     ret = buf[2] << 16 | buf[1];
     return ret;
@@ -317,6 +323,7 @@
 static long
 _nrand48(_rand_buf buf)
 {
+    ASSERT_ARGS(_nrand48);
     return _jrand48(buf) & 0x7fffffff;
 }
 
@@ -333,6 +340,7 @@
 static long
 _lrand48(void)
 {
+    ASSERT_ARGS(_lrand48);
     return _nrand48(last_rand);
 }
 
@@ -349,6 +357,7 @@
 static long
 _mrand48(void)
 {
+    ASSERT_ARGS(_mrand48);
     return _jrand48(last_rand);
 }
 
@@ -366,6 +375,7 @@
 static void
 _srand48(long seed)
 {
+    ASSERT_ARGS(_srand48);
     last_rand[0] = SEED_LO;
     last_rand[1] = (unsigned short)(seed & 0xffff);
     last_rand[2] = (unsigned short)((seed >> 16) & 0xffff);
@@ -410,6 +420,7 @@
 FLOATVAL
 Parrot_float_rand(INTVAL how_random)
 {
+    ASSERT_ARGS(Parrot_float_rand);
     UNUSED(how_random);
 
     return _drand48();          /* [0.0..1.0] */
@@ -431,6 +442,7 @@
 INTVAL
 Parrot_uint_rand(INTVAL how_random)
 {
+    ASSERT_ARGS(Parrot_uint_rand);
     UNUSED(how_random);
 
     return _lrand48();          /* [0..2^31] */
@@ -452,6 +464,7 @@
 INTVAL
 Parrot_int_rand(INTVAL how_random)
 {
+    ASSERT_ARGS(Parrot_int_rand);
     UNUSED(how_random);
 
     return _mrand48();          /* [-2^31..2^31] */
@@ -473,6 +486,7 @@
 INTVAL
 Parrot_range_rand(INTVAL from, INTVAL to, INTVAL how_random)
 {
+    ASSERT_ARGS(Parrot_range_rand);
     return (INTVAL)(from + ((double)(to - from))
                      * Parrot_float_rand(how_random));
 }
@@ -491,6 +505,7 @@
 void
 Parrot_srand(INTVAL seed)
 {
+    ASSERT_ARGS(Parrot_srand);
     _srand48(seed);
 }
 
@@ -525,8 +540,7 @@
 tm_to_array(PARROT_INTERP, ARGIN(const struct tm *tm))
 {
     PMC * const Array = pmc_new(interp, enum_class_Array);
-
-    PARROT_ASSERT(tm);
+    ASSERT_ARGS(tm_to_array);
 
     VTABLE_set_integer_native(interp, Array, 9);
     VTABLE_set_integer_keyed_int(interp, Array, 0, tm->tm_sec);
@@ -568,6 +582,7 @@
     const char        *str_pos    = str_start + start_offset;
     INTVAL             len_remain = str_len   - start_offset;
     const char        *search_pos;
+    ASSERT_ARGS(Parrot_byte_index);
 
     /* find the next position of the first character in the search string
      * Parrot strings can have NULLs, so strchr() won't work here */
@@ -612,6 +627,7 @@
     const char * const search_start = search->strstart;
     UINTVAL max_possible_offset     = (base->strlen - search->strlen);
     INTVAL current_offset;
+    ASSERT_ARGS(Parrot_byte_rindex);
 
     if (start_offset && start_offset < max_possible_offset)
         max_possible_offset = start_offset;
@@ -658,6 +674,7 @@
     const int node = c->dest_regs[node_index];
     const int pred = c->src_regs[node_index];
     const int pred_index = c->reg_to_index[pred];
+    ASSERT_ARGS(rec_climb_back_and_mark);
 
     if (pred_index < 0) { /* pred has no predecessor */
         move_reg(pred, node, c);
@@ -703,6 +720,7 @@
         c->mov_alt
             ? c->mov_alt(c->interp, c->dest_regs[node_index], pred, c->info)
             : 0;
+    ASSERT_ARGS(process_cycle_without_exit);
 
     if (0 == alt) { /* use temp reg */
         move_reg(c->dest_regs[node_index], c->temp_reg, c);
@@ -784,6 +802,7 @@
     int* backup       = NULL;
     int* reg_to_index = NULL;
     parrot_prm_context c;
+    ASSERT_ARGS(Parrot_register_move);
 
     if (n_regs == 0)
         return;
@@ -865,6 +884,7 @@
 static INTVAL
 COMPARE(PARROT_INTERP, ARGIN(void *a), ARGIN(void *b), ARGIN(PMC *cmp))
 {
+    ASSERT_ARGS(COMPARE);
     if (PMC_IS_NULL(cmp))
         return VTABLE_cmp(interp, (PMC *)a, (PMC *)b);
 
@@ -880,6 +900,7 @@
 void
 Parrot_quicksort(PARROT_INTERP, ARGMOD(void **data), UINTVAL n, ARGIN(PMC *cmp))
 {
+    ASSERT_ARGS(Parrot_quicksort);
     while (n > 1) {
         UINTVAL i, j, ln, rn;
         void *temp;



nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About