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

[svn:parrot] r34720 - in trunk: compilers/imcc include/parrot include/parrot/stm src src/charset src/encodings src/gc src/io src/packfile src/stm

From:
infinoid
Date:
December 31, 2008 11:20
Subject:
[svn:parrot] r34720 - in trunk: compilers/imcc include/parrot include/parrot/stm src src/charset src/encodings src/gc src/io src/packfile src/stm
Message ID:
20081231191944.354FFCB9FA@x12.develooper.com
Author: infinoid
Date: Wed Dec 31 11:19:36 2008
New Revision: 34720

Modified:
   trunk/compilers/imcc/cfg.c
   trunk/compilers/imcc/cfg.h
   trunk/compilers/imcc/debug.h
   trunk/compilers/imcc/imc.c
   trunk/compilers/imcc/imc.h
   trunk/compilers/imcc/imcc.y
   trunk/compilers/imcc/instructions.c
   trunk/compilers/imcc/instructions.h
   trunk/compilers/imcc/main.c
   trunk/compilers/imcc/optimizer.c
   trunk/compilers/imcc/optimizer.h
   trunk/compilers/imcc/parser_util.c
   trunk/compilers/imcc/pbc.c
   trunk/compilers/imcc/pbc.h
   trunk/compilers/imcc/pcc.c
   trunk/compilers/imcc/reg_alloc.c
   trunk/compilers/imcc/sets.h
   trunk/compilers/imcc/symreg.c
   trunk/compilers/imcc/symreg.h
   trunk/include/parrot/charset.h
   trunk/include/parrot/datatypes.h
   trunk/include/parrot/debugger.h
   trunk/include/parrot/dod.h
   trunk/include/parrot/dynext.h
   trunk/include/parrot/encoding.h
   trunk/include/parrot/events.h
   trunk/include/parrot/exceptions.h
   trunk/include/parrot/exit.h
   trunk/include/parrot/extend.h
   trunk/include/parrot/global.h
   trunk/include/parrot/global_setup.h
   trunk/include/parrot/hash.h
   trunk/include/parrot/headers.h
   trunk/include/parrot/hll.h
   trunk/include/parrot/inter_call.h
   trunk/include/parrot/interpreter.h
   trunk/include/parrot/intlist.h
   trunk/include/parrot/io.h
   trunk/include/parrot/io_portable.h
   trunk/include/parrot/io_unix.h
   trunk/include/parrot/io_win32.h
   trunk/include/parrot/key.h
   trunk/include/parrot/library.h
   trunk/include/parrot/list.h
   trunk/include/parrot/longopt.h
   trunk/include/parrot/memory.h
   trunk/include/parrot/misc.h
   trunk/include/parrot/multidispatch.h
   trunk/include/parrot/oo.h
   trunk/include/parrot/packfile.h
   trunk/include/parrot/pic.h
   trunk/include/parrot/pmc.h
   trunk/include/parrot/pmc_freeze.h
   trunk/include/parrot/register.h
   trunk/include/parrot/resources.h
   trunk/include/parrot/scheduler.h
   trunk/include/parrot/smallobject.h
   trunk/include/parrot/stacks.h
   trunk/include/parrot/stm/backend.h
   trunk/include/parrot/string_funcs.h
   trunk/include/parrot/string_primitives.h
   trunk/include/parrot/sub.h
   trunk/include/parrot/thread.h
   trunk/include/parrot/tsq.h
   trunk/include/parrot/vtables.h
   trunk/include/parrot/warnings.h
   trunk/src/charset.c
   trunk/src/charset/ascii.c
   trunk/src/charset/ascii.h
   trunk/src/charset/binary.c
   trunk/src/charset/binary.h
   trunk/src/charset/iso-8859-1.c
   trunk/src/charset/iso-8859-1.h
   trunk/src/charset/unicode.c
   trunk/src/charset/unicode.h
   trunk/src/cpu_dep.c
   trunk/src/debug.c
   trunk/src/dynext.c
   trunk/src/embed.c
   trunk/src/encoding.c
   trunk/src/encodings/fixed_8.c
   trunk/src/encodings/fixed_8.h
   trunk/src/encodings/ucs2.c
   trunk/src/encodings/ucs2.h
   trunk/src/encodings/utf16.c
   trunk/src/encodings/utf16.h
   trunk/src/encodings/utf8.c
   trunk/src/encodings/utf8.h
   trunk/src/events.c
   trunk/src/exceptions.c
   trunk/src/gc/dod.c
   trunk/src/gc/gc_gms.c
   trunk/src/gc/gc_ims.c
   trunk/src/gc/register.c
   trunk/src/gc/resources.c
   trunk/src/gc/smallobject.c
   trunk/src/global.c
   trunk/src/global_setup.c
   trunk/src/hash.c
   trunk/src/headers.c
   trunk/src/hll.c
   trunk/src/inter_call.c
   trunk/src/inter_cb.c
   trunk/src/inter_create.c
   trunk/src/inter_run.c
   trunk/src/interpreter.c
   trunk/src/io/buffer.c
   trunk/src/io/portable.c
   trunk/src/io/unix.c
   trunk/src/io/win32.c
   trunk/src/library.c
   trunk/src/list.c
   trunk/src/longopt.c
   trunk/src/multidispatch.c
   trunk/src/oo.c
   trunk/src/packdump.c
   trunk/src/packfile.c
   trunk/src/packfile/pf_items.c
   trunk/src/pbc_merge.c
   trunk/src/pic.c
   trunk/src/pic_jit.c
   trunk/src/pmc.c
   trunk/src/pmc_freeze.c
   trunk/src/runops_cores.c
   trunk/src/runops_cores.h
   trunk/src/scheduler.c
   trunk/src/spf_render.c
   trunk/src/spf_vtable.c
   trunk/src/stacks.c
   trunk/src/stm/backend.c
   trunk/src/stm/stm_waitlist.h
   trunk/src/stm/waitlist.c
   trunk/src/string.c
   trunk/src/thread.c
   trunk/src/trace.c
   trunk/src/trace.h
   trunk/src/utils.c
   trunk/src/warnings.c

Log:
[headerizer] Run headerizer and apply the resulting changes to headerizer's
output.  (Minus some minor preprocessor tweaks, see RT #53990.)

Modified: trunk/compilers/imcc/cfg.c
==============================================================================
--- trunk/compilers/imcc/cfg.c	(original)
+++ trunk/compilers/imcc/cfg.c	Wed Dec 31 11:19:36 2008
@@ -144,6 +144,40 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_analyse_life_block assert(bb); \
+                                       assert(r);
+#define ASSERT_ARGS_analyse_life_symbol assert(unit); \
+                                        assert(r);
+#define ASSERT_ARGS_bb_add_edge assert(unit); \
+                                assert(from); \
+                                assert(to);
+#define ASSERT_ARGS_bb_check_set_addr assert(interp); \
+                                      assert(unit); \
+                                      assert(bb); \
+                                      assert(label);
+#define ASSERT_ARGS_bb_findadd_edge assert(interp); \
+                                    assert(unit); \
+                                    assert(from); \
+                                    assert(label);
+#define ASSERT_ARGS_bb_remove_edge assert(unit); \
+                                   assert(edge);
+#define ASSERT_ARGS_check_invoke_type assert(interp); \
+                                      assert(unit); \
+                                      assert(ins);
+#define ASSERT_ARGS_free_dominance_frontiers assert(unit);
+#define ASSERT_ARGS_free_dominators assert(unit);
+#define ASSERT_ARGS_free_edge assert(unit);
+#define ASSERT_ARGS_free_loops assert(unit);
+#define ASSERT_ARGS_init_basic_blocks assert(unit);
+#define ASSERT_ARGS_make_basic_block assert(unit); \
+                                     assert(ins);
+#define ASSERT_ARGS_mark_loop assert(interp); \
+                              assert(unit); \
+                              assert(e);
+#define ASSERT_ARGS_propagate_need assert(bb); \
+                                   assert(r);
+#define ASSERT_ARGS_sort_loops assert(interp); \
+                               assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/cfg.h
==============================================================================
--- trunk/compilers/imcc/cfg.h	(original)
+++ trunk/compilers/imcc/cfg.h	Wed Dec 31 11:19:36 2008
@@ -119,6 +119,29 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*s);
 
+#define ASSERT_ARGS_blocks_are_connected assert(from); \
+                                         assert(to);
+#define ASSERT_ARGS_build_cfg assert(interp); \
+                              assert(unit);
+#define ASSERT_ARGS_clear_basic_blocks assert(unit);
+#define ASSERT_ARGS_compute_dominance_frontiers assert(interp); \
+                                                assert(unit);
+#define ASSERT_ARGS_compute_dominators assert(interp); \
+                                       assert(unit);
+#define ASSERT_ARGS_edge_count assert(unit);
+#define ASSERT_ARGS_find_basic_blocks assert(interp); \
+                                      assert(unit);
+#define ASSERT_ARGS_find_loops assert(interp); \
+                               assert(unit);
+#define ASSERT_ARGS_free_life_info assert(unit); \
+                                   assert(r);
+#define ASSERT_ARGS_life_analysis assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_make_life_range assert(r);
+#define ASSERT_ARGS_natural_preheader assert(unit); \
+                                      assert(loop_info);
+#define ASSERT_ARGS_search_predecessors_not_in assert(node); \
+                                               assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/cfg.c */
 

Modified: trunk/compilers/imcc/debug.h
==============================================================================
--- trunk/compilers/imcc/debug.h	(original)
+++ trunk/compilers/imcc/debug.h	Wed Dec 31 11:19:36 2008
@@ -112,6 +112,32 @@
 void dump_symreg(ARGIN(const IMC_Unit *unit))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_IMCC_debug assert(interp); \
+                               assert(fmt);
+#define ASSERT_ARGS_IMCC_fatal assert(interp); \
+                               assert(fmt);
+#define ASSERT_ARGS_IMCC_fatal_standalone assert(interp); \
+                                          assert(fmt);
+#define ASSERT_ARGS_IMCC_fataly assert(interp); \
+                                assert(fmt);
+#define ASSERT_ARGS_IMCC_fataly_standalone assert(interp); \
+                                           assert(fmt);
+#define ASSERT_ARGS_IMCC_info assert(interp); \
+                              assert(fmt);
+#define ASSERT_ARGS_IMCC_warning assert(interp); \
+                                 assert(fmt);
+#define ASSERT_ARGS_dump_cfg assert(unit);
+#define ASSERT_ARGS_dump_dominance_frontiers assert(unit);
+#define ASSERT_ARGS_dump_dominators assert(unit);
+#define ASSERT_ARGS_dump_instructions assert(interp); \
+                                      assert(unit);
+#define ASSERT_ARGS_dump_interference_graph assert(unit);
+#define ASSERT_ARGS_dump_labels assert(unit);
+#define ASSERT_ARGS_dump_liveness_status assert(unit);
+#define ASSERT_ARGS_dump_liveness_status_var assert(unit); \
+                                             assert(r);
+#define ASSERT_ARGS_dump_loops assert(unit);
+#define ASSERT_ARGS_dump_symreg assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/debug.c */
 

Modified: trunk/compilers/imcc/imc.c
==============================================================================
--- trunk/compilers/imcc/imc.c	(original)
+++ trunk/compilers/imcc/imc.c	Wed Dec 31 11:19:36 2008
@@ -41,6 +41,9 @@
 PARROT_MALLOC
 static IMC_Unit * imc_new_unit(IMC_Unit_Type t);
 
+#define ASSERT_ARGS_imc_free_unit assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_imc_new_unit
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/imc.h
==============================================================================
--- trunk/compilers/imcc/imc.h	(original)
+++ trunk/compilers/imcc/imc.h	Wed Dec 31 11:19:36 2008
@@ -97,6 +97,12 @@
 IMC_Unit * imc_open_unit(PARROT_INTERP, IMC_Unit_Type t)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_imc_cleanup assert(interp);
+#define ASSERT_ARGS_imc_compile_all_units assert(interp);
+#define ASSERT_ARGS_imc_compile_unit assert(interp); \
+                                     assert(unit);
+#define ASSERT_ARGS_imc_close_unit assert(interp);
+#define ASSERT_ARGS_imc_open_unit assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/imc.c */
 
@@ -119,6 +125,11 @@
 void imc_reg_alloc(PARROT_INTERP, ARGIN_NULLOK(IMC_Unit *unit))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_free_reglist assert(unit);
+#define ASSERT_ARGS_graph_coloring_reg_alloc assert(interp); \
+                                             assert(unit);
+#define ASSERT_ARGS_ig_test assert(graph);
+#define ASSERT_ARGS_imc_reg_alloc assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/reg_alloc.c */
 
@@ -323,6 +334,57 @@
         FUNC_MODIFIES(*unit)
         FUNC_MODIFIES(*r);
 
+#define ASSERT_ARGS_do_yylex_init assert(interp); \
+                                  assert(yyscanner);
+#define ASSERT_ARGS_imcc_destroy assert(interp);
+#define ASSERT_ARGS_imcc_init assert(interp);
+#define ASSERT_ARGS_check_op assert(interp); \
+                             assert(fullname); \
+                             assert(name); \
+                             assert(r);
+#define ASSERT_ARGS_imcc_compile assert(interp); \
+                                 assert(s); \
+                                 assert(error_message);
+#define ASSERT_ARGS_IMCC_compile_file assert(interp); \
+                                      assert(s);
+#define ASSERT_ARGS_IMCC_compile_file_s assert(interp); \
+                                        assert(s); \
+                                        assert(error_message);
+#define ASSERT_ARGS_imcc_compile_pasm assert(interp); \
+                                      assert(s);
+#define ASSERT_ARGS_imcc_compile_pasm_ex assert(interp); \
+                                         assert(s);
+#define ASSERT_ARGS_IMCC_compile_pasm_s assert(interp); \
+                                        assert(s); \
+                                        assert(error_message);
+#define ASSERT_ARGS_imcc_compile_pir assert(interp); \
+                                     assert(s);
+#define ASSERT_ARGS_imcc_compile_pir_ex assert(interp); \
+                                        assert(s);
+#define ASSERT_ARGS_IMCC_compile_pir_s assert(interp); \
+                                       assert(s); \
+                                       assert(error_message);
+#define ASSERT_ARGS_imcc_vfprintf assert(interp); \
+                                  assert(io); \
+                                  assert(format);
+#define ASSERT_ARGS_iNEW assert(interp); \
+                         assert(unit); \
+                         assert(r0); \
+                         assert(type);
+#define ASSERT_ARGS_INS assert(interp); \
+                        assert(unit); \
+                        assert(name); \
+                        assert(r);
+#define ASSERT_ARGS_is_op assert(interp); \
+                          assert(name);
+#define ASSERT_ARGS_op_fullname assert(dest); \
+                                assert(name); \
+                                assert(args);
+#define ASSERT_ARGS_register_compilers assert(interp);
+#define ASSERT_ARGS_try_find_op assert(interp); \
+                                assert(unit); \
+                                assert(name); \
+                                assert(r);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/parser_util.c */
 
@@ -371,6 +433,19 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_expand_pcc_sub assert(interp); \
+                                   assert(unit); \
+                                   assert(ins);
+#define ASSERT_ARGS_expand_pcc_sub_call assert(interp); \
+                                        assert(unit); \
+                                        assert(ins);
+#define ASSERT_ARGS_expand_pcc_sub_ret assert(interp); \
+                                       assert(unit); \
+                                       assert(ins);
+#define ASSERT_ARGS_get_const assert(interp); \
+                              assert(name);
+#define ASSERT_ARGS_get_pasm_reg assert(interp); \
+                                 assert(name);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/pcc.c */
 

Modified: trunk/compilers/imcc/imcc.y
==============================================================================
--- trunk/compilers/imcc/imcc.y	(original)
+++ trunk/compilers/imcc/imcc.y	Wed Dec 31 11:19:36 2008
@@ -221,6 +221,68 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*r);
 
+#define ASSERT_ARGS_add_pcc_named_arg assert(interp); \
+                                      assert(cur_call); \
+                                      assert(name); \
+                                      assert(value);
+#define ASSERT_ARGS_add_pcc_named_param assert(interp); \
+                                        assert(cur_call); \
+                                        assert(name); \
+                                        assert(value);
+#define ASSERT_ARGS_add_pcc_named_result assert(interp); \
+                                         assert(cur_call); \
+                                         assert(name); \
+                                         assert(value);
+#define ASSERT_ARGS_add_pcc_named_return assert(interp); \
+                                         assert(cur_call); \
+                                         assert(name); \
+                                         assert(value);
+#define ASSERT_ARGS_adv_named_set assert(interp); \
+                                  assert(name);
+#define ASSERT_ARGS_begin_return_or_yield assert(interp);
+#define ASSERT_ARGS_clear_state assert(interp);
+#define ASSERT_ARGS_do_loadlib assert(interp); \
+                               assert(lib);
+#define ASSERT_ARGS_func_ins assert(interp); \
+                             assert(unit); \
+                             assert(lhs); \
+                             assert(op); \
+                             assert(r);
+#define ASSERT_ARGS_iINDEXFETCH assert(interp); \
+                                assert(unit); \
+                                assert(r0); \
+                                assert(r1); \
+                                assert(r2);
+#define ASSERT_ARGS_iINDEXSET assert(interp); \
+                              assert(unit); \
+                              assert(r0); \
+                              assert(r1); \
+                              assert(r2);
+#define ASSERT_ARGS_iLABEL assert(interp); \
+                           assert(r0);
+#define ASSERT_ARGS_inv_op assert(op);
+#define ASSERT_ARGS_iSUBROUTINE assert(interp); \
+                                assert(r);
+#define ASSERT_ARGS_MK_I assert(interp); \
+                         assert(unit); \
+                         assert(fmt);
+#define ASSERT_ARGS_mk_pmc_const assert(interp); \
+                                 assert(unit); \
+                                 assert(type); \
+                                 assert(left); \
+                                 assert(constant);
+#define ASSERT_ARGS_mk_pmc_const_named assert(interp); \
+                                       assert(unit); \
+                                       assert(name); \
+                                       assert(left); \
+                                       assert(constant);
+#define ASSERT_ARGS_mk_sub_address_fromc assert(interp); \
+                                         assert(name);
+#define ASSERT_ARGS_mk_sub_address_u assert(interp); \
+                                     assert(name);
+#define ASSERT_ARGS_set_lexical assert(interp); \
+                                assert(r); \
+                                assert(name);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/instructions.c
==============================================================================
--- trunk/compilers/imcc/instructions.c	(original)
+++ trunk/compilers/imcc/instructions.c	Wed Dec 31 11:19:36 2008
@@ -54,6 +54,11 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_e_file_close assert(interp);
+#define ASSERT_ARGS_e_file_emit assert(interp); \
+                                assert(ins);
+#define ASSERT_ARGS_e_file_open assert(interp); \
+                                assert(param);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/instructions.h
==============================================================================
--- trunk/compilers/imcc/instructions.h	(original)
+++ trunk/compilers/imcc/instructions.h	Wed Dec 31 11:19:36 2008
@@ -219,6 +219,40 @@
         FUNC_MODIFIES(*ins)
         FUNC_MODIFIES(*tmp);
 
+#define ASSERT_ARGS_emit_close assert(interp);
+#define ASSERT_ARGS_emit_flush assert(interp); \
+                               assert(unit);
+#define ASSERT_ARGS_emit_open assert(interp);
+#define ASSERT_ARGS__delete_ins assert(unit); \
+                                assert(ins);
+#define ASSERT_ARGS__mk_instruction assert(op); \
+                                    assert(fmt); \
+                                    assert(r);
+#define ASSERT_ARGS_delete_ins assert(unit); \
+                               assert(ins);
+#define ASSERT_ARGS_emitb assert(interp);
+#define ASSERT_ARGS_free_ins assert(ins);
+#define ASSERT_ARGS_get_branch_reg assert(ins);
+#define ASSERT_ARGS_get_branch_regno assert(ins);
+#define ASSERT_ARGS_imcc_init_tables assert(interp);
+#define ASSERT_ARGS_ins_print assert(interp); \
+                              assert(io); \
+                              assert(ins);
+#define ASSERT_ARGS_ins_writes2 assert(ins);
+#define ASSERT_ARGS_insert_ins assert(unit); \
+                               assert(tmp);
+#define ASSERT_ARGS_instruction_reads assert(ins); \
+                                      assert(r);
+#define ASSERT_ARGS_instruction_writes assert(ins); \
+                                       assert(r);
+#define ASSERT_ARGS_move_ins assert(unit); \
+                             assert(ins); \
+                             assert(to);
+#define ASSERT_ARGS_prepend_ins assert(unit); \
+                                assert(tmp);
+#define ASSERT_ARGS_subst_ins assert(unit); \
+                              assert(ins); \
+                              assert(tmp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/instructions.c */
 

Modified: trunk/compilers/imcc/main.c
==============================================================================
--- trunk/compilers/imcc/main.c	(original)
+++ trunk/compilers/imcc/main.c	Wed Dec 31 11:19:36 2008
@@ -98,6 +98,24 @@
         __attribute__nonnull__(1)
         FUNC_MODIFIES(*fp);
 
+#define ASSERT_ARGS_compile_to_bytecode assert(interp); \
+                                        assert(sourcefile);
+#define ASSERT_ARGS_determine_input_file_type assert(interp); \
+                                              assert(sourcefile);
+#define ASSERT_ARGS_determine_output_file_type assert(interp); \
+                                               assert(obj_file); \
+                                               assert(output_file);
+#define ASSERT_ARGS_do_pre_process assert(interp);
+#define ASSERT_ARGS_help
+#define ASSERT_ARGS_help_debug
+#define ASSERT_ARGS_imcc_get_optimization_description assert(opt_desc);
+#define ASSERT_ARGS_imcc_run_pbc assert(interp); \
+                                 assert(argv);
+#define ASSERT_ARGS_imcc_write_pbc assert(interp); \
+                                   assert(output_file);
+#define ASSERT_ARGS_is_all_hex_digits assert(s);
+#define ASSERT_ARGS_Parrot_version assert(interp);
+#define ASSERT_ARGS_usage assert(fp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/optimizer.c
==============================================================================
--- trunk/compilers/imcc/optimizer.c	(original)
+++ trunk/compilers/imcc/optimizer.c	Wed Dec 31 11:19:36 2008
@@ -199,6 +199,47 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*unit);
 
+#define ASSERT_ARGS__is_ins_save assert(unit); \
+                                 assert(check_ins); \
+                                 assert(r);
+#define ASSERT_ARGS_branch_branch assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_branch_cond_loop assert(interp); \
+                                     assert(unit);
+#define ASSERT_ARGS_branch_cond_loop_swap assert(interp); \
+                                          assert(unit); \
+                                          assert(branch); \
+                                          assert(start); \
+                                          assert(cond);
+#define ASSERT_ARGS_branch_reorg assert(interp); \
+                                 assert(unit);
+#define ASSERT_ARGS_constant_propagation assert(interp); \
+                                         assert(unit);
+#define ASSERT_ARGS_dead_code_remove assert(interp); \
+                                     assert(unit);
+#define ASSERT_ARGS_eval_ins assert(interp); \
+                             assert(op); \
+                             assert(r);
+#define ASSERT_ARGS_if_branch assert(interp); \
+                              assert(unit);
+#define ASSERT_ARGS_is_ins_save assert(interp); \
+                                assert(unit); \
+                                assert(ins); \
+                                assert(r);
+#define ASSERT_ARGS_is_invariant assert(interp); \
+                                 assert(unit); \
+                                 assert(ins);
+#define ASSERT_ARGS_loop_one assert(interp); \
+                             assert(unit);
+#define ASSERT_ARGS_loop_optimization assert(interp); \
+                                      assert(unit);
+#define ASSERT_ARGS_max_loop_depth assert(unit);
+#define ASSERT_ARGS_strength_reduce assert(interp); \
+                                    assert(unit);
+#define ASSERT_ARGS_unused_label assert(interp); \
+                                 assert(unit);
+#define ASSERT_ARGS_used_once assert(interp); \
+                              assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/optimizer.h
==============================================================================
--- trunk/compilers/imcc/optimizer.h	(original)
+++ trunk/compilers/imcc/optimizer.h	Wed Dec 31 11:19:36 2008
@@ -84,6 +84,29 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*unit);
 
+#define ASSERT_ARGS_cfg_optimize assert(interp); \
+                                 assert(unit);
+#define ASSERT_ARGS_find_outer assert(unit); \
+                               assert(blk);
+#define ASSERT_ARGS_get_neg_op assert(op); \
+                               assert(n);
+#define ASSERT_ARGS_IMCC_subst_constants assert(interp); \
+                                         assert(unit); \
+                                         assert(name); \
+                                         assert(r); \
+                                         assert(ok);
+#define ASSERT_ARGS_IMCC_subst_constants_umix assert(interp); \
+                                              assert(unit); \
+                                              assert(name); \
+                                              assert(r);
+#define ASSERT_ARGS_move_ins_out assert(interp); \
+                                 assert(unit); \
+                                 assert(ins); \
+                                 assert(bb);
+#define ASSERT_ARGS_optimize assert(interp); \
+                             assert(unit);
+#define ASSERT_ARGS_pre_optimize assert(interp); \
+                                 assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/optimizer.c */
 

Modified: trunk/compilers/imcc/parser_util.c
==============================================================================
--- trunk/compilers/imcc/parser_util.c	(original)
+++ trunk/compilers/imcc/parser_util.c	Wed Dec 31 11:19:36 2008
@@ -92,6 +92,19 @@
         FUNC_MODIFIES(*unit)
         FUNC_MODIFIES(*r);
 
+#define ASSERT_ARGS_change_op assert(interp); \
+                              assert(unit); \
+                              assert(r);
+#define ASSERT_ARGS_imcc_compile_file assert(interp); \
+                                      assert(fullname); \
+                                      assert(error_message);
+#define ASSERT_ARGS_imcc_destroy_macro_values assert(value);
+#define ASSERT_ARGS_try_rev_cmp assert(name); \
+                                assert(r);
+#define ASSERT_ARGS_var_arg_ins assert(interp); \
+                                assert(unit); \
+                                assert(name); \
+                                assert(r);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/pbc.c
==============================================================================
--- trunk/compilers/imcc/pbc.c	(original)
+++ trunk/compilers/imcc/pbc.c	Wed Dec 31 11:19:36 2008
@@ -206,6 +206,61 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_add_1_const assert(interp); \
+                                assert(r);
+#define ASSERT_ARGS_add_const_key assert(interp); \
+                                  assert(key); \
+                                  assert(s_key);
+#define ASSERT_ARGS_add_const_num assert(interp);
+#define ASSERT_ARGS_add_const_pmc_sub assert(interp); \
+                                      assert(r);
+#define ASSERT_ARGS_add_const_str assert(interp); \
+                                  assert(r);
+#define ASSERT_ARGS_add_const_table assert(interp);
+#define ASSERT_ARGS_add_const_table_key assert(interp); \
+                                        assert(key);
+#define ASSERT_ARGS_add_const_table_pmc assert(interp); \
+                                        assert(pmc);
+#define ASSERT_ARGS_build_key assert(interp); \
+                              assert(key_reg);
+#define ASSERT_ARGS_constant_folding assert(interp); \
+                                     assert(unit);
+#define ASSERT_ARGS_create_lexinfo assert(interp); \
+                                   assert(unit); \
+                                   assert(sub);
+#define ASSERT_ARGS_find_global_label assert(interp); \
+                                      assert(name); \
+                                      assert(sym); \
+                                      assert(pc);
+#define ASSERT_ARGS_find_outer assert(interp); \
+                               assert(unit);
+#define ASSERT_ARGS_find_sub_by_subid assert(interp); \
+                                      assert(lookup); \
+                                      assert(sym); \
+                                      assert(pc);
+#define ASSERT_ARGS_fixup_globals assert(interp);
+#define ASSERT_ARGS_get_codesize assert(interp); \
+                                 assert(unit); \
+                                 assert(src_lines);
+#define ASSERT_ARGS_get_old_size assert(interp); \
+                                 assert(ins_line);
+#define ASSERT_ARGS_imcc_globals_destroy assert(interp);
+#define ASSERT_ARGS_make_new_sub assert(interp); \
+                                 assert(unit);
+#define ASSERT_ARGS_make_pmc_const assert(interp); \
+                                   assert(r);
+#define ASSERT_ARGS_mk_multi_sig assert(interp); \
+                                 assert(r);
+#define ASSERT_ARGS_old_blocks assert(interp);
+#define ASSERT_ARGS_slice_deb
+#define ASSERT_ARGS_store_fixup assert(interp); \
+                                assert(r);
+#define ASSERT_ARGS_store_key_const assert(interp); \
+                                    assert(str);
+#define ASSERT_ARGS_store_sub_size assert(interp);
+#define ASSERT_ARGS_verify_signature assert(interp); \
+                                     assert(ins); \
+                                     assert(pc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/pbc.h
==============================================================================
--- trunk/compilers/imcc/pbc.h	(original)
+++ trunk/compilers/imcc/pbc.h	Wed Dec 31 11:19:36 2008
@@ -53,6 +53,23 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_e_pbc_close assert(interp);
+#define ASSERT_ARGS_e_pbc_emit assert(interp); \
+                               assert(unit); \
+                               assert(ins);
+#define ASSERT_ARGS_e_pbc_end_sub assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_e_pbc_new_sub assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_e_pbc_open assert(interp);
+#define ASSERT_ARGS_IMCC_int_from_reg assert(interp); \
+                                      assert(r);
+#define ASSERT_ARGS_IMCC_string_from__STRINGC assert(interp); \
+                                              assert(buf);
+#define ASSERT_ARGS_IMCC_string_from_reg assert(interp); \
+                                         assert(r);
+#define ASSERT_ARGS_make_jit_info assert(interp); \
+                                  assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/pbc.c */
 

Modified: trunk/compilers/imcc/pcc.c
==============================================================================
--- trunk/compilers/imcc/pcc.c	(original)
+++ trunk/compilers/imcc/pcc.c	Wed Dec 31 11:19:36 2008
@@ -113,6 +113,33 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_insert_tail_call assert(interp); \
+                                     assert(unit); \
+                                     assert(ins); \
+                                     assert(sub); \
+                                     assert(meth);
+#define ASSERT_ARGS_insINS assert(interp); \
+                           assert(unit); \
+                           assert(ins); \
+                           assert(name); \
+                           assert(regs);
+#define ASSERT_ARGS_move_regs assert(interp); \
+                              assert(unit); \
+                              assert(ins); \
+                              assert(dest); \
+                              assert(src);
+#define ASSERT_ARGS_pcc_get_args assert(interp); \
+                                 assert(unit); \
+                                 assert(ins); \
+                                 assert(op_name);
+#define ASSERT_ARGS_pcc_reg_mov assert(interp); \
+                                assert(vinfo);
+#define ASSERT_ARGS_recursive_tail_call assert(interp); \
+                                        assert(unit); \
+                                        assert(ins); \
+                                        assert(sub);
+#define ASSERT_ARGS_unshift_self assert(sub); \
+                                 assert(obj);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/reg_alloc.c
==============================================================================
--- trunk/compilers/imcc/reg_alloc.c	(original)
+++ trunk/compilers/imcc/reg_alloc.c	Wed Dec 31 11:19:36 2008
@@ -158,6 +158,43 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*unit);
 
+#define ASSERT_ARGS_allocate_lexicals assert(interp); \
+                                      assert(unit);
+#define ASSERT_ARGS_allocate_non_volatile assert(interp); \
+                                          assert(unit);
+#define ASSERT_ARGS_allocate_uniq assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_build_interference_graph assert(interp); \
+                                             assert(unit);
+#define ASSERT_ARGS_build_reglist assert(unit);
+#define ASSERT_ARGS_compute_du_chain assert(unit);
+#define ASSERT_ARGS_compute_one_du_chain assert(r); \
+                                         assert(unit);
+#define ASSERT_ARGS_first_avail assert(unit);
+#define ASSERT_ARGS_ig_allocate
+#define ASSERT_ARGS_ig_find_color assert(unit); \
+                                  assert(avail);
+#define ASSERT_ARGS_ig_get_word assert(graph); \
+                                assert(bit_ofs);
+#define ASSERT_ARGS_ig_set assert(graph);
+#define ASSERT_ARGS_imc_stat_init assert(unit);
+#define ASSERT_ARGS_interferes assert(interp); \
+                               assert(unit); \
+                               assert(r0); \
+                               assert(r1);
+#define ASSERT_ARGS_make_stat assert(unit);
+#define ASSERT_ARGS_map_colors assert(unit); \
+                               assert(graph); \
+                               assert(avail);
+#define ASSERT_ARGS_print_stat assert(interp); \
+                               assert(unit);
+#define ASSERT_ARGS_rebuild_reglist assert(unit);
+#define ASSERT_ARGS_reg_sort_f assert(a); \
+                               assert(b);
+#define ASSERT_ARGS_sort_reglist assert(unit);
+#define ASSERT_ARGS_try_allocate assert(interp); \
+                                 assert(unit);
+#define ASSERT_ARGS_vanilla_reg_alloc assert(unit);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/sets.h
==============================================================================
--- trunk/compilers/imcc/sets.h	(original)
+++ trunk/compilers/imcc/sets.h	Wed Dec 31 11:19:36 2008
@@ -70,6 +70,22 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_set_add assert(s);
+#define ASSERT_ARGS_set_clear assert(s);
+#define ASSERT_ARGS_set_contains assert(s);
+#define ASSERT_ARGS_set_copy assert(s);
+#define ASSERT_ARGS_set_equal assert(s1); \
+                              assert(s2);
+#define ASSERT_ARGS_set_first_zero assert(s);
+#define ASSERT_ARGS_set_free assert(s);
+#define ASSERT_ARGS_set_intersec assert(s1); \
+                                 assert(s2);
+#define ASSERT_ARGS_set_intersec_inplace assert(s1); \
+                                         assert(s2);
+#define ASSERT_ARGS_set_make
+#define ASSERT_ARGS_set_make_full
+#define ASSERT_ARGS_set_union assert(s1); \
+                              assert(s2);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/sets.c */
 

Modified: trunk/compilers/imcc/symreg.c
==============================================================================
--- trunk/compilers/imcc/symreg.c	(original)
+++ trunk/compilers/imcc/symreg.c	Wed Dec 31 11:19:36 2008
@@ -91,6 +91,19 @@
         __attribute__nonnull__(1)
         FUNC_MODIFIES(*hsh);
 
+#define ASSERT_ARGS__get_sym_typed assert(hsh); \
+                                   assert(name);
+#define ASSERT_ARGS__mk_fullname assert(name);
+#define ASSERT_ARGS__mk_symreg assert(hsh); \
+                               assert(name);
+#define ASSERT_ARGS_add_ns assert(interp); \
+                           assert(name);
+#define ASSERT_ARGS_int_overflows assert(r);
+#define ASSERT_ARGS_mk_pmc_const_2 assert(interp); \
+                                   assert(unit); \
+                                   assert(left); \
+                                   assert(rhs);
+#define ASSERT_ARGS_resize_symhash assert(hsh);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/compilers/imcc/symreg.h
==============================================================================
--- trunk/compilers/imcc/symreg.h	(original)
+++ trunk/compilers/imcc/symreg.h	Wed Dec 31 11:19:36 2008
@@ -333,6 +333,73 @@
 char * symreg_to_str(ARGIN(const SymReg *s))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS__find_sym assert(interp); \
+                              assert(hsh); \
+                              assert(name);
+#define ASSERT_ARGS__get_sym assert(hsh); \
+                             assert(name);
+#define ASSERT_ARGS__mk_address assert(interp); \
+                                assert(hsh); \
+                                assert(name);
+#define ASSERT_ARGS__mk_const assert(hsh); \
+                              assert(name);
+#define ASSERT_ARGS__store_symreg assert(hsh); \
+                                  assert(r);
+#define ASSERT_ARGS_add_namespace assert(interp); \
+                                  assert(unit);
+#define ASSERT_ARGS_add_pcc_arg assert(r); \
+                                assert(arg);
+#define ASSERT_ARGS_add_pcc_cc assert(r); \
+                               assert(arg);
+#define ASSERT_ARGS_add_pcc_multi assert(r);
+#define ASSERT_ARGS_add_pcc_result assert(r); \
+                                   assert(arg);
+#define ASSERT_ARGS_add_pcc_sub assert(r); \
+                                assert(arg);
+#define ASSERT_ARGS_clear_globals assert(interp);
+#define ASSERT_ARGS_clear_locals
+#define ASSERT_ARGS_clear_sym_hash assert(hsh);
+#define ASSERT_ARGS_create_symhash assert(hash);
+#define ASSERT_ARGS_debug_dump_sym_hash assert(hsh);
+#define ASSERT_ARGS_dup_sym assert(r);
+#define ASSERT_ARGS_find_sym assert(interp); \
+                             assert(name);
+#define ASSERT_ARGS_free_sym assert(r);
+#define ASSERT_ARGS_get_sym assert(interp); \
+                            assert(name);
+#define ASSERT_ARGS_hash_str assert(str);
+#define ASSERT_ARGS_link_keys assert(interp); \
+                              assert(keys);
+#define ASSERT_ARGS_mk_const assert(interp); \
+                             assert(name);
+#define ASSERT_ARGS_mk_const_ident assert(interp); \
+                                   assert(name); \
+                                   assert(val);
+#define ASSERT_ARGS_mk_ident assert(interp); \
+                             assert(name);
+#define ASSERT_ARGS_mk_ident_ur assert(interp); \
+                                assert(name);
+#define ASSERT_ARGS_mk_label_address assert(interp); \
+                                     assert(name);
+#define ASSERT_ARGS_mk_local_label assert(interp); \
+                                   assert(name);
+#define ASSERT_ARGS_mk_pasm_reg assert(interp); \
+                                assert(name);
+#define ASSERT_ARGS_mk_pcc_sub assert(interp); \
+                               assert(name);
+#define ASSERT_ARGS_mk_sub_address assert(interp); \
+                                   assert(name);
+#define ASSERT_ARGS_mk_sub_label assert(interp); \
+                                 assert(name);
+#define ASSERT_ARGS_mk_symreg assert(interp); \
+                              assert(name);
+#define ASSERT_ARGS_mk_temp_reg assert(interp);
+#define ASSERT_ARGS_pop_namespace assert(interp); \
+                                  assert(name);
+#define ASSERT_ARGS_push_namespace assert(name);
+#define ASSERT_ARGS_store_symreg assert(interp); \
+                                 assert(r);
+#define ASSERT_ARGS_symreg_to_str assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: compilers/imcc/symreg.c */
 

Modified: trunk/include/parrot/charset.h
==============================================================================
--- trunk/include/parrot/charset.h	(original)
+++ trunk/include/parrot/charset.h	Wed Dec 31 11:19:36 2008
@@ -168,6 +168,28 @@
         __attribute__nonnull__(3)
         __attribute__nonnull__(4);
 
+#define ASSERT_ARGS_Parrot_charset_c_name
+#define ASSERT_ARGS_Parrot_charset_name
+#define ASSERT_ARGS_Parrot_charset_number assert(interp); \
+                                          assert(charsetname);
+#define ASSERT_ARGS_Parrot_charset_number_of_str assert(src);
+#define ASSERT_ARGS_Parrot_charsets_encodings_deinit
+#define ASSERT_ARGS_Parrot_charsets_encodings_init assert(interp);
+#define ASSERT_ARGS_Parrot_default_charset
+#define ASSERT_ARGS_Parrot_find_charset assert(charsetname);
+#define ASSERT_ARGS_Parrot_find_charset_converter assert(lhs); \
+                                                  assert(rhs);
+#define ASSERT_ARGS_Parrot_get_charset
+#define ASSERT_ARGS_Parrot_load_charset assert(interp); \
+                                        assert(charsetname);
+#define ASSERT_ARGS_Parrot_make_default_charset assert(charset);
+#define ASSERT_ARGS_Parrot_new_charset
+#define ASSERT_ARGS_Parrot_register_charset assert(interp); \
+                                            assert(charsetname); \
+                                            assert(charset);
+#define ASSERT_ARGS_Parrot_register_charset_converter assert(lhs); \
+                                                      assert(rhs); \
+                                                      assert(func);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/charset.c */
 

Modified: trunk/include/parrot/datatypes.h
==============================================================================
--- trunk/include/parrot/datatypes.h	(original)
+++ trunk/include/parrot/datatypes.h	Wed Dec 31 11:19:36 2008
@@ -141,6 +141,9 @@
 STRING * Parrot_get_datatype_name(PARROT_INTERP, INTVAL type)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_get_datatype_enum assert(interp); \
+                                             assert(type_name);
+#define ASSERT_ARGS_Parrot_get_datatype_name assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/datatypes.c */
 

Modified: trunk/include/parrot/debugger.h
==============================================================================
--- trunk/include/parrot/debugger.h	(original)
+++ trunk/include/parrot/debugger.h	Wed Dec 31 11:19:36 2008
@@ -353,6 +353,66 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_debugger_break assert(interp); \
+                                          assert(cur_opcode);
+#define ASSERT_ARGS_Parrot_debugger_destroy assert(interp);
+#define ASSERT_ARGS_Parrot_debugger_init assert(interp);
+#define ASSERT_ARGS_Parrot_debugger_load assert(interp);
+#define ASSERT_ARGS_Parrot_debugger_start assert(interp); \
+                                          assert(cur_opcode);
+#define ASSERT_ARGS_PDB_load_source assert(interp); \
+                                    assert(command);
+#define ASSERT_ARGS_PDB_script_file assert(interp); \
+                                    assert(command);
+#define ASSERT_ARGS_PDB_add_label assert(file); \
+                                  assert(cur_opcode);
+#define ASSERT_ARGS_PDB_backtrace assert(interp);
+#define ASSERT_ARGS_PDB_break assert(interp);
+#define ASSERT_ARGS_PDB_check_condition assert(interp); \
+                                        assert(condition);
+#define ASSERT_ARGS_PDB_compile assert(interp); \
+                                assert(command);
+#define ASSERT_ARGS_PDB_cond assert(interp); \
+                             assert(command);
+#define ASSERT_ARGS_PDB_continue assert(interp);
+#define ASSERT_ARGS_PDB_delete_breakpoint assert(interp); \
+                                          assert(command);
+#define ASSERT_ARGS_PDB_delete_condition assert(breakpoint);
+#define ASSERT_ARGS_PDB_disable_breakpoint assert(interp); \
+                                           assert(command);
+#define ASSERT_ARGS_PDB_disassemble assert(interp);
+#define ASSERT_ARGS_PDB_disassemble_op assert(interp); \
+                                       assert(dest); \
+                                       assert(info); \
+                                       assert(op);
+#define ASSERT_ARGS_PDB_enable_breakpoint assert(interp); \
+                                          assert(command);
+#define ASSERT_ARGS_PDB_escape assert(string);
+#define ASSERT_ARGS_PDB_eval assert(interp); \
+                             assert(command);
+#define ASSERT_ARGS_PDB_find_breakpoint assert(interp); \
+                                        assert(command);
+#define ASSERT_ARGS_PDB_free_file
+#define ASSERT_ARGS_PDB_get_command assert(interp);
+#define ASSERT_ARGS_PDB_hasinstruction assert(c);
+#define ASSERT_ARGS_PDB_help assert(interp); \
+                             assert(command);
+#define ASSERT_ARGS_PDB_info assert(interp);
+#define ASSERT_ARGS_PDB_init assert(interp);
+#define ASSERT_ARGS_PDB_list assert(interp); \
+                             assert(command);
+#define ASSERT_ARGS_PDB_next assert(interp);
+#define ASSERT_ARGS_PDB_print assert(interp); \
+                              assert(command);
+#define ASSERT_ARGS_PDB_program_end assert(interp);
+#define ASSERT_ARGS_PDB_run_command assert(interp); \
+                                    assert(command);
+#define ASSERT_ARGS_PDB_set_break assert(interp);
+#define ASSERT_ARGS_PDB_skip_breakpoint assert(interp);
+#define ASSERT_ARGS_PDB_trace assert(interp);
+#define ASSERT_ARGS_PDB_unescape assert(string);
+#define ASSERT_ARGS_PDB_watchpoint assert(interp); \
+                                   assert(command);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/debug.c */
 

Modified: trunk/include/parrot/dod.h
==============================================================================
--- trunk/include/parrot/dod.h	(original)
+++ trunk/include/parrot/dod.h	Wed Dec 31 11:19:36 2008
@@ -134,6 +134,33 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*pool);
 
+#define ASSERT_ARGS_pobject_lives assert(interp); \
+                                  assert(obj);
+#define ASSERT_ARGS_clear_cow assert(interp); \
+                              assert(pool);
+#define ASSERT_ARGS_Parrot_do_dod_run assert(interp);
+#define ASSERT_ARGS_Parrot_dod_clear_live_bits assert(interp);
+#define ASSERT_ARGS_Parrot_dod_free_buffer assert(pool); \
+                                           assert(b);
+#define ASSERT_ARGS_Parrot_dod_free_buffer_malloc assert(b);
+#define ASSERT_ARGS_Parrot_dod_free_pmc assert(interp); \
+                                        assert(p);
+#define ASSERT_ARGS_Parrot_dod_free_sysmem assert(b);
+#define ASSERT_ARGS_Parrot_dod_ms_run assert(interp);
+#define ASSERT_ARGS_Parrot_dod_ms_run_init assert(interp);
+#define ASSERT_ARGS_Parrot_dod_profile_end assert(interp);
+#define ASSERT_ARGS_Parrot_dod_profile_start assert(interp);
+#define ASSERT_ARGS_Parrot_dod_sweep assert(interp); \
+                                     assert(pool);
+#define ASSERT_ARGS_Parrot_dod_trace_children assert(interp);
+#define ASSERT_ARGS_Parrot_dod_trace_pmc_data assert(interp); \
+                                              assert(p);
+#define ASSERT_ARGS_Parrot_dod_trace_root assert(interp);
+#define ASSERT_ARGS_Parrot_free_pmc_ext assert(interp); \
+                                        assert(p);
+#define ASSERT_ARGS_trace_mem_block assert(interp);
+#define ASSERT_ARGS_used_cow assert(interp); \
+                             assert(pool);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/dod.c */
 
@@ -144,6 +171,7 @@
 void trace_system_areas(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_trace_system_areas assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/cpu_dep.c */
 
@@ -190,6 +218,19 @@
         __attribute__nonnull__(5)
         __attribute__nonnull__(6);
 
+#define ASSERT_ARGS_Parrot_gc_gms_init assert(interp);
+#define ASSERT_ARGS_parrot_gc_gms_pobject_lives assert(interp); \
+                                                assert(obj);
+#define ASSERT_ARGS_parrot_gc_gms_wb assert(interp); \
+                                     assert(agg); \
+                                     assert(old); \
+                                     assert(_new);
+#define ASSERT_ARGS_parrot_gc_gms_wb_key assert(interp); \
+                                         assert(agg); \
+                                         assert(old); \
+                                         assert(old_key); \
+                                         assert(_new); \
+                                         assert(new_key);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/gc_gms.c */
 
@@ -206,6 +247,10 @@
 void Parrot_gc_ims_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_dod_ims_wb assert(interp); \
+                                      assert(agg); \
+                                      assert(_new);
+#define ASSERT_ARGS_Parrot_gc_ims_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/gc_ims.c */
 

Modified: trunk/include/parrot/dynext.h
==============================================================================
--- trunk/include/parrot/dynext.h	(original)
+++ trunk/include/parrot/dynext.h	Wed Dec 31 11:19:36 2008
@@ -44,6 +44,11 @@
     SHIM(PMC *initializer))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_clone_lib_into assert(d); \
+                                          assert(s); \
+                                          assert(lib_pmc);
+#define ASSERT_ARGS_Parrot_init_lib assert(interp);
+#define ASSERT_ARGS_Parrot_load_lib assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/dynext.c */
 

Modified: trunk/include/parrot/encoding.h
==============================================================================
--- trunk/include/parrot/encoding.h	(original)
+++ trunk/include/parrot/encoding.h	Wed Dec 31 11:19:36 2008
@@ -153,6 +153,26 @@
 
 void parrot_deinit_encodings(void);
 void parrot_init_encodings_2(void);
+#define ASSERT_ARGS_Parrot_default_encoding
+#define ASSERT_ARGS_Parrot_encoding_c_name
+#define ASSERT_ARGS_Parrot_encoding_name
+#define ASSERT_ARGS_Parrot_encoding_number assert(interp); \
+                                           assert(encodingname);
+#define ASSERT_ARGS_Parrot_encoding_number_of_str assert(src);
+#define ASSERT_ARGS_Parrot_find_encoding assert(encodingname);
+#define ASSERT_ARGS_Parrot_find_encoding_converter assert(interp); \
+                                                   assert(lhs); \
+                                                   assert(rhs);
+#define ASSERT_ARGS_Parrot_get_encoding
+#define ASSERT_ARGS_Parrot_load_encoding assert(interp); \
+                                         assert(encodingname);
+#define ASSERT_ARGS_Parrot_make_default_encoding assert(encoding);
+#define ASSERT_ARGS_Parrot_new_encoding
+#define ASSERT_ARGS_Parrot_register_encoding assert(interp); \
+                                             assert(encodingname); \
+                                             assert(encoding);
+#define ASSERT_ARGS_parrot_deinit_encodings
+#define ASSERT_ARGS_parrot_init_encodings_2
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/encoding.c */
 

Modified: trunk/include/parrot/events.h
==============================================================================
--- trunk/include/parrot/events.h	(original)
+++ trunk/include/parrot/events.h	Wed Dec 31 11:19:36 2008
@@ -169,6 +169,26 @@
 void Parrot_schedule_broadcast_qentry(ARGIN(struct QUEUE_ENTRY *entry))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_del_timer_event assert(interp); \
+                                           assert(timer);
+#define ASSERT_ARGS_Parrot_do_check_events assert(interp);
+#define ASSERT_ARGS_Parrot_do_handle_events assert(interp);
+#define ASSERT_ARGS_Parrot_event_add_io_event assert(interp);
+#define ASSERT_ARGS_Parrot_init_events assert(interp);
+#define ASSERT_ARGS_Parrot_init_signals
+#define ASSERT_ARGS_Parrot_kill_event_loop assert(interp);
+#define ASSERT_ARGS_Parrot_new_cb_event assert(interp); \
+                                        assert(cbi); \
+                                        assert(ext);
+#define ASSERT_ARGS_Parrot_new_suspend_for_gc_event assert(interp);
+#define ASSERT_ARGS_Parrot_new_terminate_event assert(interp);
+#define ASSERT_ARGS_Parrot_new_timer_event assert(interp);
+#define ASSERT_ARGS_Parrot_schedule_event assert(interp); \
+                                          assert(ev);
+#define ASSERT_ARGS_Parrot_schedule_interp_qentry assert(interp); \
+                                                  assert(entry);
+#define ASSERT_ARGS_Parrot_sleep_on_event assert(interp);
+#define ASSERT_ARGS_Parrot_schedule_broadcast_qentry assert(entry);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/events.c */
 

Modified: trunk/include/parrot/exceptions.h
==============================================================================
--- trunk/include/parrot/exceptions.h	(original)
+++ trunk/include/parrot/exceptions.h	Wed Dec 31 11:19:36 2008
@@ -221,6 +221,33 @@
     unsigned int line);
 
 void Parrot_print_backtrace(void);
+#define ASSERT_ARGS_exit_fatal assert(format);
+#define ASSERT_ARGS_Parrot_assert assert(condition_string); \
+                                  assert(file);
+#define ASSERT_ARGS_Parrot_confess assert(cond); \
+                                   assert(file);
+#define ASSERT_ARGS_Parrot_ex_add_c_handler assert(interp); \
+                                            assert(jp);
+#define ASSERT_ARGS_Parrot_ex_build_exception assert(interp);
+#define ASSERT_ARGS_Parrot_ex_calc_handler_offset assert(interp);
+#define ASSERT_ARGS_Parrot_ex_mark_unhandled assert(interp); \
+                                             assert(exception);
+#define ASSERT_ARGS_Parrot_ex_rethrow_from_c assert(interp); \
+                                             assert(exception);
+#define ASSERT_ARGS_Parrot_ex_rethrow_from_op assert(interp); \
+                                              assert(exception);
+#define ASSERT_ARGS_Parrot_ex_throw_from_c assert(interp); \
+                                           assert(exception);
+#define ASSERT_ARGS_Parrot_ex_throw_from_c_args assert(interp); \
+                                                assert(format);
+#define ASSERT_ARGS_Parrot_ex_throw_from_op assert(interp); \
+                                            assert(exception);
+#define ASSERT_ARGS_Parrot_ex_throw_from_op_args assert(interp); \
+                                                 assert(format);
+#define ASSERT_ARGS_die_from_exception assert(interp); \
+                                       assert(exception);
+#define ASSERT_ARGS_do_panic
+#define ASSERT_ARGS_Parrot_print_backtrace
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/exceptions.c */
 

Modified: trunk/include/parrot/exit.h
==============================================================================
--- trunk/include/parrot/exit.h	(original)
+++ trunk/include/parrot/exit.h	Wed Dec 31 11:19:36 2008
@@ -39,6 +39,9 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_exit assert(interp);
+#define ASSERT_ARGS_Parrot_on_exit assert(interp); \
+                                   assert(function);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/exit.c */
 

Modified: trunk/include/parrot/extend.h
==============================================================================
--- trunk/include/parrot/extend.h	(original)
+++ trunk/include/parrot/extend.h	Wed Dec 31 11:19:36 2008
@@ -408,6 +408,77 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_call_method assert(interp); \
+                                       assert(signature);
+#define ASSERT_ARGS_Parrot_call_method_ret_float assert(interp); \
+                                                 assert(signature);
+#define ASSERT_ARGS_Parrot_call_method_ret_int assert(interp); \
+                                               assert(signature);
+#define ASSERT_ARGS_Parrot_call_sub assert(interp); \
+                                    assert(signature);
+#define ASSERT_ARGS_Parrot_call_sub_ret_float assert(interp); \
+                                              assert(signature);
+#define ASSERT_ARGS_Parrot_call_sub_ret_int assert(interp); \
+                                            assert(signature);
+#define ASSERT_ARGS_Parrot_eprintf assert(s);
+#define ASSERT_ARGS_Parrot_find_language
+#define ASSERT_ARGS_Parrot_fprintf assert(interp); \
+                                   assert(pio); \
+                                   assert(s);
+#define ASSERT_ARGS_Parrot_free_cstring
+#define ASSERT_ARGS_Parrot_get_intreg assert(interp);
+#define ASSERT_ARGS_Parrot_get_numreg assert(interp);
+#define ASSERT_ARGS_Parrot_get_pmcreg assert(interp);
+#define ASSERT_ARGS_Parrot_get_strreg assert(interp);
+#define ASSERT_ARGS_Parrot_get_vtable assert(interp);
+#define ASSERT_ARGS_Parrot_new_string assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_delete_pmckey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_cstring assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_cstring_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_cstringn assert(interp); \
+                                            assert(pmc); \
+                                            assert(length);
+#define ASSERT_ARGS_Parrot_PMC_get_cstringn_intkey assert(interp); \
+                                                   assert(pmc); \
+                                                   assert(length);
+#define ASSERT_ARGS_Parrot_PMC_get_intval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_intval_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_intval_pmckey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_numval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_numval_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_pmc_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_pointer_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_get_string_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_new assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_null
+#define ASSERT_ARGS_Parrot_PMC_push_intval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_push_numval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_cstring assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_cstring_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_cstringn assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_cstringn_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_intval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_intval_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_numval assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_numval_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_pmc_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_pmc_pmckey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_pointer_intkey assert(interp); \
+                                                  assert(pmc);
+#define ASSERT_ARGS_Parrot_PMC_set_string assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_string_intkey assert(interp);
+#define ASSERT_ARGS_Parrot_PMC_set_vtable
+#define ASSERT_ARGS_Parrot_PMC_typenum assert(interp);
+#define ASSERT_ARGS_Parrot_printf assert(s);
+#define ASSERT_ARGS_Parrot_register_pmc assert(interp);
+#define ASSERT_ARGS_Parrot_set_intreg assert(interp);
+#define ASSERT_ARGS_Parrot_set_numreg assert(interp);
+#define ASSERT_ARGS_Parrot_set_pmcreg assert(interp);
+#define ASSERT_ARGS_Parrot_set_strreg assert(interp);
+#define ASSERT_ARGS_Parrot_unregister_pmc assert(interp);
+#define ASSERT_ARGS_Parrot_vfprintf assert(interp); \
+                                    assert(pio); \
+                                    assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/extend.c */
 

Modified: trunk/include/parrot/global.h
==============================================================================
--- trunk/include/parrot/global.h	(original)
+++ trunk/include/parrot/global.h	Wed Dec 31 11:19:36 2008
@@ -170,6 +170,36 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_find_global_cur assert(interp);
+#define ASSERT_ARGS_Parrot_find_global_k assert(interp); \
+                                         assert(globalname);
+#define ASSERT_ARGS_Parrot_find_global_n assert(interp);
+#define ASSERT_ARGS_Parrot_find_global_op assert(interp); \
+                                          assert(ns);
+#define ASSERT_ARGS_Parrot_find_global_s assert(interp);
+#define ASSERT_ARGS_Parrot_find_name_op assert(interp); \
+                                        assert(name);
+#define ASSERT_ARGS_Parrot_get_global assert(interp);
+#define ASSERT_ARGS_Parrot_get_namespace_autobase assert(interp);
+#define ASSERT_ARGS_Parrot_get_namespace_keyed assert(interp); \
+                                               assert(base_ns);
+#define ASSERT_ARGS_Parrot_get_namespace_keyed_str assert(interp); \
+                                                   assert(base_ns);
+#define ASSERT_ARGS_Parrot_make_namespace_autobase assert(interp);
+#define ASSERT_ARGS_Parrot_make_namespace_keyed assert(interp); \
+                                                assert(base_ns);
+#define ASSERT_ARGS_Parrot_make_namespace_keyed_str assert(interp); \
+                                                    assert(base_ns);
+#define ASSERT_ARGS_Parrot_ns_get_name assert(interp); \
+                                       assert(_namespace);
+#define ASSERT_ARGS_Parrot_set_global assert(interp);
+#define ASSERT_ARGS_Parrot_store_global_cur assert(interp);
+#define ASSERT_ARGS_Parrot_store_global_k assert(interp); \
+                                          assert(pmc_key);
+#define ASSERT_ARGS_Parrot_store_global_n assert(interp);
+#define ASSERT_ARGS_Parrot_store_global_s assert(interp);
+#define ASSERT_ARGS_Parrot_store_sub_in_namespace assert(interp); \
+                                                  assert(sub);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/global.c */
 

Modified: trunk/include/parrot/global_setup.h
==============================================================================
--- trunk/include/parrot/global_setup.h	(original)
+++ trunk/include/parrot/global_setup.h	Wed Dec 31 11:19:36 2008
@@ -35,6 +35,10 @@
 void parrot_global_setup_2(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_set_config_hash_internal assert(parrot_config);
+#define ASSERT_ARGS_init_world assert(interp);
+#define ASSERT_ARGS_init_world_once assert(interp);
+#define ASSERT_ARGS_parrot_global_setup_2 assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/global_setup.c */
 

Modified: trunk/include/parrot/hash.h
==============================================================================
--- trunk/include/parrot/hash.h	(original)
+++ trunk/include/parrot/hash.h	Wed Dec 31 11:19:36 2008
@@ -256,6 +256,59 @@
         __attribute__nonnull__(6)
         FUNC_MODIFIES(*container);
 
+#define ASSERT_ARGS_parrot_dump_hash assert(hash);
+#define ASSERT_ARGS_parrot_hash_clone assert(interp); \
+                                      assert(hash); \
+                                      assert(dest);
+#define ASSERT_ARGS_parrot_hash_delete assert(interp); \
+                                       assert(hash); \
+                                       assert(key);
+#define ASSERT_ARGS_parrot_hash_destroy assert(hash);
+#define ASSERT_ARGS_parrot_hash_exists assert(interp); \
+                                       assert(hash); \
+                                       assert(key);
+#define ASSERT_ARGS_parrot_hash_get assert(interp); \
+                                    assert(hash); \
+                                    assert(key);
+#define ASSERT_ARGS_parrot_hash_get_bucket assert(interp); \
+                                           assert(hash); \
+                                           assert(key);
+#define ASSERT_ARGS_parrot_hash_get_idx assert(hash); \
+                                        assert(key);
+#define ASSERT_ARGS_parrot_hash_put assert(interp); \
+                                    assert(hash); \
+                                    assert(key);
+#define ASSERT_ARGS_parrot_hash_size assert(interp); \
+                                     assert(hash);
+#define ASSERT_ARGS_parrot_hash_visit assert(interp); \
+                                      assert(hash); \
+                                      assert(pinfo);
+#define ASSERT_ARGS_parrot_mark_hash assert(interp); \
+                                     assert(hash);
+#define ASSERT_ARGS_parrot_new_cstring_hash assert(interp); \
+                                            assert(hptr);
+#define ASSERT_ARGS_parrot_new_hash assert(interp); \
+                                    assert(hptr);
+#define ASSERT_ARGS_Parrot_new_INTVAL_hash assert(interp);
+#define ASSERT_ARGS_parrot_new_pmc_hash assert(interp); \
+                                        assert(container);
+#define ASSERT_ARGS_parrot_new_pointer_hash assert(interp); \
+                                            assert(hptr);
+#define ASSERT_ARGS_int_compare
+#define ASSERT_ARGS_key_hash_int assert(value);
+#define ASSERT_ARGS_parrot_chash_destroy assert(interp); \
+                                         assert(hash);
+#define ASSERT_ARGS_parrot_chash_destroy_values assert(interp); \
+                                                assert(hash); \
+                                                assert(func);
+#define ASSERT_ARGS_parrot_new_hash_x assert(interp); \
+                                      assert(hptr); \
+                                      assert(compare); \
+                                      assert(keyhash);
+#define ASSERT_ARGS_parrot_new_pmc_hash_x assert(interp); \
+                                          assert(container); \
+                                          assert(compare); \
+                                          assert(keyhash);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/hash.c */
 

Modified: trunk/include/parrot/headers.h
==============================================================================
--- trunk/include/parrot/headers.h	(original)
+++ trunk/include/parrot/headers.h	Wed Dec 31 11:19:36 2008
@@ -159,6 +159,35 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*dest_interp);
 
+#define ASSERT_ARGS_add_pmc_ext assert(interp); \
+                                assert(pmc);
+#define ASSERT_ARGS_add_pmc_sync assert(interp); \
+                                 assert(pmc);
+#define ASSERT_ARGS_get_bufferlike_pool assert(interp);
+#define ASSERT_ARGS_get_max_buffer_address assert(interp);
+#define ASSERT_ARGS_get_max_pmc_address assert(interp);
+#define ASSERT_ARGS_get_min_buffer_address assert(interp);
+#define ASSERT_ARGS_get_min_pmc_address assert(interp);
+#define ASSERT_ARGS_is_buffer_ptr assert(interp); \
+                                  assert(ptr);
+#define ASSERT_ARGS_is_pmc_ptr assert(interp); \
+                               assert(ptr);
+#define ASSERT_ARGS_make_bufferlike_pool assert(interp);
+#define ASSERT_ARGS_new_buffer_header assert(interp);
+#define ASSERT_ARGS_new_buffer_pool assert(interp);
+#define ASSERT_ARGS_new_bufferlike_header assert(interp);
+#define ASSERT_ARGS_new_bufferlike_pool assert(interp);
+#define ASSERT_ARGS_new_pmc_header assert(interp);
+#define ASSERT_ARGS_new_pmc_pool assert(interp);
+#define ASSERT_ARGS_new_string_header assert(interp);
+#define ASSERT_ARGS_new_string_pool assert(interp);
+#define ASSERT_ARGS_Parrot_destroy_header_pools assert(interp);
+#define ASSERT_ARGS_Parrot_forall_header_pools assert(interp); \
+                                               assert(func);
+#define ASSERT_ARGS_Parrot_initialize_header_pool_names assert(interp);
+#define ASSERT_ARGS_Parrot_initialize_header_pools assert(interp);
+#define ASSERT_ARGS_Parrot_merge_header_pools assert(dest_interp); \
+                                              assert(source_interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/headers.c */
 

Modified: trunk/include/parrot/hll.h
==============================================================================
--- trunk/include/parrot/hll.h	(original)
+++ trunk/include/parrot/hll.h	Wed Dec 31 11:19:36 2008
@@ -77,6 +77,19 @@
 void Parrot_init_HLL(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_get_ctx_HLL_namespace assert(interp);
+#define ASSERT_ARGS_Parrot_get_ctx_HLL_type assert(interp);
+#define ASSERT_ARGS_Parrot_get_HLL_id assert(interp);
+#define ASSERT_ARGS_Parrot_get_HLL_name assert(interp);
+#define ASSERT_ARGS_Parrot_get_HLL_namespace assert(interp);
+#define ASSERT_ARGS_Parrot_get_HLL_type assert(interp);
+#define ASSERT_ARGS_Parrot_regenerate_HLL_namespaces assert(interp);
+#define ASSERT_ARGS_Parrot_register_HLL assert(interp); \
+                                        assert(hll_name);
+#define ASSERT_ARGS_Parrot_register_HLL_lib assert(interp); \
+                                            assert(hll_lib);
+#define ASSERT_ARGS_Parrot_register_HLL_type assert(interp);
+#define ASSERT_ARGS_Parrot_init_HLL assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/hll.c */
 

Modified: trunk/include/parrot/inter_call.h
==============================================================================
--- trunk/include/parrot/inter_call.h	(original)
+++ trunk/include/parrot/inter_call.h	Wed Dec 31 11:19:36 2008
@@ -256,6 +256,58 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_convert_arg assert(interp); \
+                                       assert(st);
+#define ASSERT_ARGS_Parrot_fetch_arg assert(interp); \
+                                     assert(st);
+#define ASSERT_ARGS_Parrot_fetch_arg_nci assert(interp); \
+                                         assert(st);
+#define ASSERT_ARGS_Parrot_init_arg_indexes_and_sig_pmc assert(ctx); \
+                                                        assert(sti);
+#define ASSERT_ARGS_Parrot_init_arg_nci assert(interp); \
+                                        assert(st); \
+                                        assert(sig);
+#define ASSERT_ARGS_Parrot_init_arg_op assert(interp); \
+                                       assert(ctx); \
+                                       assert(sti);
+#define ASSERT_ARGS_Parrot_init_arg_sig assert(ctx); \
+                                        assert(sig); \
+                                        assert(sti);
+#define ASSERT_ARGS_Parrot_init_ret_nci assert(interp); \
+                                        assert(st); \
+                                        assert(sig);
+#define ASSERT_ARGS_parrot_pass_args assert(interp); \
+                                     assert(src_ctx); \
+                                     assert(dest_ctx); \
+                                     assert(src_indexes); \
+                                     assert(dest_indexes);
+#define ASSERT_ARGS_Parrot_pcc_invoke_sub_from_c_args assert(interp); \
+                                                      assert(sub_obj); \
+                                                      assert(sig);
+#define ASSERT_ARGS_Parrot_pcc_invoke_sub_from_sig_object assert(interp); \
+                                                          assert(sub_obj); \
+                                                          assert(sig_obj);
+#define ASSERT_ARGS_Parrot_PCCINVOKE assert(interp); \
+                                     assert(pmc); \
+                                     assert(method_name); \
+                                     assert(signature);
+#define ASSERT_ARGS_Parrot_process_args assert(interp); \
+                                        assert(st);
+#define ASSERT_ARGS_Parrot_store_arg assert(st);
+#define ASSERT_ARGS_parrot_pass_args_fromc assert(interp); \
+                                           assert(sig); \
+                                           assert(dest); \
+                                           assert(old_ctxp);
+#define ASSERT_ARGS_set_retval assert(interp); \
+                               assert(ctx);
+#define ASSERT_ARGS_set_retval_f assert(interp); \
+                                 assert(ctx);
+#define ASSERT_ARGS_set_retval_i assert(interp); \
+                                 assert(ctx);
+#define ASSERT_ARGS_set_retval_p assert(interp); \
+                                 assert(ctx);
+#define ASSERT_ARGS_set_retval_s assert(interp); \
+                                 assert(ctx);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/inter_call.c */
 

Modified: trunk/include/parrot/interpreter.h
==============================================================================
--- trunk/include/parrot/interpreter.h	(original)
+++ trunk/include/parrot/interpreter.h	Wed Dec 31 11:19:36 2008
@@ -527,6 +527,9 @@
     SHIM(void *arg))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_make_interpreter
+#define ASSERT_ARGS_Parrot_destroy assert(interp);
+#define ASSERT_ARGS_Parrot_really_destroy assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/inter_create.c */
 
@@ -721,6 +724,60 @@
 void runops(PARROT_INTERP, size_t offs)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_free_runloop_jump_point assert(interp);
+#define ASSERT_ARGS_new_runloop_jump_point assert(interp);
+#define ASSERT_ARGS_Parrot_run_meth_fromc assert(interp); \
+                                          assert(sub);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_arglist assert(interp); \
+                                                  assert(sub); \
+                                                  assert(meth); \
+                                                  assert(sig);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_arglist_retf assert(interp); \
+                                                       assert(sub); \
+                                                       assert(meth); \
+                                                       assert(sig);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_arglist_reti assert(interp); \
+                                                       assert(sub); \
+                                                       assert(meth); \
+                                                       assert(sig);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_args assert(interp); \
+                                               assert(sub); \
+                                               assert(meth); \
+                                               assert(sig);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_args_retf assert(interp); \
+                                                    assert(sub); \
+                                                    assert(meth); \
+                                                    assert(sig);
+#define ASSERT_ARGS_Parrot_run_meth_fromc_args_reti assert(interp); \
+                                                    assert(sub); \
+                                                    assert(meth); \
+                                                    assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc assert(interp); \
+                                        assert(sub);
+#define ASSERT_ARGS_Parrot_runops_fromc_arglist assert(interp); \
+                                                assert(sub); \
+                                                assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_arglist_retf assert(interp); \
+                                                     assert(sub); \
+                                                     assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_arglist_reti assert(interp); \
+                                                     assert(sub); \
+                                                     assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_args assert(interp); \
+                                             assert(sub); \
+                                             assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_args_event assert(interp); \
+                                                   assert(sub); \
+                                                   assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_args_retf assert(interp); \
+                                                  assert(sub); \
+                                                  assert(sig);
+#define ASSERT_ARGS_Parrot_runops_fromc_args_reti assert(interp); \
+                                                  assert(sub); \
+                                                  assert(sig);
+#define ASSERT_ARGS_destroy_runloop_jump_points assert(interp);
+#define ASSERT_ARGS_really_destroy_runloop_jump_points
+#define ASSERT_ARGS_runops assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/inter_run.c */
 
@@ -761,6 +818,17 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(* user_data);
 
+#define ASSERT_ARGS_Parrot_callback_C assert(external_data); \
+                                      assert(user_data);
+#define ASSERT_ARGS_Parrot_callback_D assert(user_data); \
+                                      assert(external_data);
+#define ASSERT_ARGS_Parrot_make_cb assert(interp); \
+                                   assert(sub); \
+                                   assert(user_data); \
+                                   assert(cb_signature);
+#define ASSERT_ARGS_Parrot_run_callback assert(interp); \
+                                        assert(user_data); \
+                                        assert(external_data);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/inter_cb.c */
 
@@ -849,6 +917,30 @@
 STRING * sysinfo_s(PARROT_INTERP, INTVAL info_wanted)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_interpinfo assert(interp);
+#define ASSERT_ARGS_interpinfo_p assert(interp);
+#define ASSERT_ARGS_interpinfo_s assert(interp);
+#define ASSERT_ARGS_Parrot_compile_file assert(interp); \
+                                        assert(fullname); \
+                                        assert(error);
+#define ASSERT_ARGS_Parrot_compile_string assert(interp); \
+                                          assert(type); \
+                                          assert(code); \
+                                          assert(error);
+#define ASSERT_ARGS_Parrot_compreg assert(interp); \
+                                   assert(type); \
+                                   assert(func);
+#define ASSERT_ARGS_Parrot_mark_method_writes assert(interp); \
+                                              assert(name);
+#define ASSERT_ARGS_register_nci_method assert(interp); \
+                                        assert(func); \
+                                        assert(name); \
+                                        assert(proto);
+#define ASSERT_ARGS_register_raw_nci_method_in_ns assert(interp); \
+                                                  assert(func); \
+                                                  assert(name);
+#define ASSERT_ARGS_sysinfo_i
+#define ASSERT_ARGS_sysinfo_s assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/inter_misc.c */
 

Modified: trunk/include/parrot/intlist.h
==============================================================================
--- trunk/include/parrot/intlist.h	(original)
+++ trunk/include/parrot/intlist.h	Wed Dec 31 11:19:36 2008
@@ -96,6 +96,24 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*l);
 
+#define ASSERT_ARGS_intlist_assign assert(interp); \
+                                   assert(l);
+#define ASSERT_ARGS_intlist_clone assert(interp); \
+                                  assert(list);
+#define ASSERT_ARGS_intlist_get assert(interp); \
+                                assert(list);
+#define ASSERT_ARGS_intlist_length assert(list);
+#define ASSERT_ARGS_intlist_mark assert(interp); \
+                                 assert(l);
+#define ASSERT_ARGS_intlist_new assert(interp);
+#define ASSERT_ARGS_intlist_pop assert(interp); \
+                                assert(l);
+#define ASSERT_ARGS_intlist_push assert(interp); \
+                                 assert(l);
+#define ASSERT_ARGS_intlist_shift assert(interp); \
+                                  assert(l);
+#define ASSERT_ARGS_intlist_unshift assert(interp); \
+                                    assert(l);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/intlist.c */
 

Modified: trunk/include/parrot/io.h
==============================================================================
--- trunk/include/parrot/io.h	(original)
+++ trunk/include/parrot/io.h	Wed Dec 31 11:19:36 2008
@@ -131,6 +131,10 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_io_finish assert(interp);
+#define ASSERT_ARGS_Parrot_io_init assert(interp);
+#define ASSERT_ARGS_Parrot_IOData_mark assert(interp); \
+                                       assert(piodata);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/core.c */
 
@@ -319,6 +323,55 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*pmc);
 
+#define ASSERT_ARGS_Parrot_io_close assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_Parrot_io_eof assert(interp); \
+                                  assert(pmc);
+#define ASSERT_ARGS_Parrot_io_eprintf assert(s);
+#define ASSERT_ARGS_Parrot_io_fdopen assert(interp); \
+                                     assert(sflags);
+#define ASSERT_ARGS_Parrot_io_flush assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_Parrot_io_fprintf assert(interp); \
+                                      assert(pmc); \
+                                      assert(s);
+#define ASSERT_ARGS_Parrot_io_getfd assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_Parrot_io_is_closed assert(interp); \
+                                        assert(pmc);
+#define ASSERT_ARGS_Parrot_io_is_tty assert(interp); \
+                                     assert(pmc);
+#define ASSERT_ARGS_Parrot_io_make_offset
+#define ASSERT_ARGS_Parrot_io_new_pmc assert(interp);
+#define ASSERT_ARGS_Parrot_io_open assert(interp); \
+                                   assert(path);
+#define ASSERT_ARGS_Parrot_io_peek assert(interp); \
+                                   assert(pmc); \
+                                   assert(buffer);
+#define ASSERT_ARGS_Parrot_io_printf assert(interp); \
+                                     assert(s);
+#define ASSERT_ARGS_Parrot_io_putps assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_Parrot_io_puts assert(interp); \
+                                   assert(pmc); \
+                                   assert(s);
+#define ASSERT_ARGS_Parrot_io_readline assert(interp); \
+                                       assert(pmc);
+#define ASSERT_ARGS_Parrot_io_reads assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_Parrot_io_seek assert(interp); \
+                                   assert(pmc);
+#define ASSERT_ARGS_Parrot_io_STDERR assert(interp);
+#define ASSERT_ARGS_Parrot_io_STDIN assert(interp);
+#define ASSERT_ARGS_Parrot_io_STDOUT assert(interp);
+#define ASSERT_ARGS_Parrot_io_tell assert(interp); \
+                                   assert(pmc);
+#define ASSERT_ARGS_Parrot_io_write assert(interp); \
+                                    assert(pmc); \
+                                    assert(buffer);
+#define ASSERT_ARGS_Parrot_io_make_offset32
+#define ASSERT_ARGS_Parrot_io_make_offset_pmc assert(interp); \
+                                              assert(pmc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/api.c */
 
@@ -393,6 +446,29 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*filehandle);
 
+#define ASSERT_ARGS_Parrot_io_fill_readbuf assert(interp); \
+                                           assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_flush_buffer assert(interp); \
+                                           assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_init_buffer assert(interp);
+#define ASSERT_ARGS_Parrot_io_peek_buffer assert(interp); \
+                                          assert(filehandle); \
+                                          assert(buf);
+#define ASSERT_ARGS_Parrot_io_read_buffer assert(interp); \
+                                          assert(filehandle); \
+                                          assert(buf);
+#define ASSERT_ARGS_Parrot_io_readline_buffer assert(interp); \
+                                              assert(filehandle); \
+                                              assert(buf);
+#define ASSERT_ARGS_Parrot_io_seek_buffer assert(interp); \
+                                          assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_setbuf assert(interp); \
+                                     assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_setlinebuf assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_write_buffer assert(interp); \
+                                           assert(filehandle); \
+                                           assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/buffer.c */
 
@@ -418,6 +494,12 @@
         FUNC_MODIFIES(*filehandle)
         FUNC_MODIFIES(*s);
 
+#define ASSERT_ARGS_Parrot_io_read_utf8 assert(interp); \
+                                        assert(filehandle); \
+                                        assert(buf);
+#define ASSERT_ARGS_Parrot_io_write_utf8 assert(interp); \
+                                         assert(filehandle); \
+                                         assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/utf8.c */
 
@@ -564,6 +646,38 @@
     ARGIN_NULLOK(unsigned char *new_start))
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_io_close_filehandle assert(interp); \
+                                               assert(pmc);
+#define ASSERT_ARGS_Parrot_io_flush_filehandle assert(interp); \
+                                               assert(pmc);
+#define ASSERT_ARGS_Parrot_io_get_buffer_end
+#define ASSERT_ARGS_Parrot_io_get_buffer_next assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_buffer_start assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_file_position assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_file_size assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_flags assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_last_file_position assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_os_handle assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_is_closed_filehandle assert(interp); \
+                                                   assert(pmc);
+#define ASSERT_ARGS_Parrot_io_is_encoding assert(interp); \
+                                          assert(filehandle); \
+                                          assert(value);
+#define ASSERT_ARGS_Parrot_io_parse_open_flags assert(interp);
+#define ASSERT_ARGS_Parrot_io_set_file_position assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_file_size assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_flags assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_os_handle assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_clear_buffer assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_buffer_flags assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_get_buffer_size assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_make_string assert(interp); \
+                                          assert(buf);
+#define ASSERT_ARGS_Parrot_io_set_buffer_end assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_buffer_flags assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_buffer_next assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_buffer_size assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_set_buffer_start assert(filehandle);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/filehandle.c */
 

Modified: trunk/include/parrot/io_portable.h
==============================================================================
--- trunk/include/parrot/io_portable.h	(original)
+++ trunk/include/parrot/io_portable.h	Wed Dec 31 11:19:36 2008
@@ -95,6 +95,31 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*s);
 
+#define ASSERT_ARGS_Parrot_io_close_portable assert(interp); \
+                                             assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_fdopen_portable assert(interp); \
+                                              assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_flush_portable
+#define ASSERT_ARGS_Parrot_io_getblksize_portable
+#define ASSERT_ARGS_Parrot_io_init_portable assert(interp);
+#define ASSERT_ARGS_Parrot_io_is_closed_portable assert(interp); \
+                                                 assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_open_pipe_portable assert(interp);
+#define ASSERT_ARGS_Parrot_io_open_portable assert(interp); \
+                                            assert(filehandle); \
+                                            assert(path);
+#define ASSERT_ARGS_Parrot_io_peek_portable assert(interp); \
+                                            assert(filehandle); \
+                                            assert(buf);
+#define ASSERT_ARGS_Parrot_io_read_portable assert(interp); \
+                                            assert(buf);
+#define ASSERT_ARGS_Parrot_io_seek_portable assert(interp); \
+                                            assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_tell_portable assert(interp); \
+                                            assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_write_portable assert(interp); \
+                                             assert(filehandle); \
+                                             assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/portable.c */
 

Modified: trunk/include/parrot/io_unix.h
==============================================================================
--- trunk/include/parrot/io_unix.h	(original)
+++ trunk/include/parrot/io_unix.h	Wed Dec 31 11:19:36 2008
@@ -110,6 +110,34 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*s);
 
+#define ASSERT_ARGS_Parrot_io_async_unix assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_close_unix assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_fdopen_unix assert(interp); \
+                                          assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_flush_unix assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_getblksize_unix
+#define ASSERT_ARGS_Parrot_io_init_unix assert(interp);
+#define ASSERT_ARGS_Parrot_io_is_closed_unix assert(interp); \
+                                             assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_open_pipe_unix assert(interp); \
+                                             assert(filehandle); \
+                                             assert(command);
+#define ASSERT_ARGS_Parrot_io_open_unix assert(interp); \
+                                        assert(path);
+#define ASSERT_ARGS_Parrot_io_peek_unix assert(interp);
+#define ASSERT_ARGS_Parrot_io_read_unix assert(interp); \
+                                        assert(filehandle); \
+                                        assert(buf);
+#define ASSERT_ARGS_Parrot_io_seek_unix assert(interp); \
+                                        assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_tell_unix assert(interp); \
+                                        assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_write_unix assert(interp); \
+                                         assert(filehandle); \
+                                         assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/unix.c */
 

Modified: trunk/include/parrot/io_win32.h
==============================================================================
--- trunk/include/parrot/io_win32.h	(original)
+++ trunk/include/parrot/io_win32.h	Wed Dec 31 11:19:36 2008
@@ -96,6 +96,30 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_io_close_win32 assert(interp); \
+                                          assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_fdopen_win32 assert(interp);
+#define ASSERT_ARGS_Parrot_io_flush_win32 assert(interp); \
+                                          assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_getblksize_win32
+#define ASSERT_ARGS_Parrot_io_init_win32 assert(interp);
+#define ASSERT_ARGS_Parrot_io_is_closed_win32 assert(interp); \
+                                              assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_open_pipe_win32 assert(interp);
+#define ASSERT_ARGS_Parrot_io_open_win32 assert(interp); \
+                                         assert(filehandle); \
+                                         assert(path);
+#define ASSERT_ARGS_Parrot_io_peek_win32 assert(interp);
+#define ASSERT_ARGS_Parrot_io_read_win32 assert(interp); \
+                                         assert(filehandle); \
+                                         assert(buf);
+#define ASSERT_ARGS_Parrot_io_seek_win32 assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_tell_win32 assert(interp); \
+                                         assert(filehandle);
+#define ASSERT_ARGS_Parrot_io_write_win32 assert(interp); \
+                                          assert(filehandle); \
+                                          assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/io/win32.c */
 

Modified: trunk/include/parrot/key.h
==============================================================================
--- trunk/include/parrot/key.h	(original)
+++ trunk/include/parrot/key.h	Wed Dec 31 11:19:36 2008
@@ -167,6 +167,38 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_key_append assert(key1); \
+                               assert(key2);
+#define ASSERT_ARGS_key_integer assert(interp); \
+                                assert(key);
+#define ASSERT_ARGS_key_mark assert(interp); \
+                             assert(key);
+#define ASSERT_ARGS_key_new assert(interp);
+#define ASSERT_ARGS_key_new_cstring assert(interp);
+#define ASSERT_ARGS_key_new_integer assert(interp);
+#define ASSERT_ARGS_key_new_number assert(interp);
+#define ASSERT_ARGS_key_new_pmc assert(interp); \
+                                assert(value);
+#define ASSERT_ARGS_key_new_string assert(interp); \
+                                   assert(value);
+#define ASSERT_ARGS_key_next assert(interp); \
+                             assert(key);
+#define ASSERT_ARGS_key_number assert(interp); \
+                               assert(key);
+#define ASSERT_ARGS_key_pmc assert(interp); \
+                            assert(key);
+#define ASSERT_ARGS_key_set_integer assert(key);
+#define ASSERT_ARGS_key_set_number assert(key);
+#define ASSERT_ARGS_key_set_pmc assert(interp); \
+                                assert(key); \
+                                assert(value);
+#define ASSERT_ARGS_key_set_register assert(key);
+#define ASSERT_ARGS_key_set_string assert(key); \
+                                   assert(value);
+#define ASSERT_ARGS_key_set_to_string assert(interp);
+#define ASSERT_ARGS_key_type assert(key);
+#define ASSERT_ARGS_key_string assert(interp); \
+                               assert(key);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/key.c */
 

Modified: trunk/include/parrot/library.h
==============================================================================
--- trunk/include/parrot/library.h	(original)
+++ trunk/include/parrot/library.h	Wed Dec 31 11:19:36 2008
@@ -91,6 +91,19 @@
         FUNC_MODIFIES(*wo_ext)
         FUNC_MODIFIES(*ext);
 
+#define ASSERT_ARGS_Parrot_add_library_path assert(interp); \
+                                            assert(path);
+#define ASSERT_ARGS_Parrot_get_runtime_path assert(interp);
+#define ASSERT_ARGS_Parrot_get_runtime_prefix assert(interp);
+#define ASSERT_ARGS_Parrot_locate_runtime_file assert(interp); \
+                                               assert(file_name);
+#define ASSERT_ARGS_Parrot_locate_runtime_file_str assert(interp); \
+                                                   assert(file);
+#define ASSERT_ARGS_parrot_init_library_paths assert(interp);
+#define ASSERT_ARGS_parrot_split_path_ext assert(interp); \
+                                          assert(in); \
+                                          assert(wo_ext); \
+                                          assert(ext);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/library.c */
 

Modified: trunk/include/parrot/list.h
==============================================================================
--- trunk/include/parrot/list.h	(original)
+++ trunk/include/parrot/list.h	Wed Dec 31 11:19:36 2008
@@ -224,6 +224,46 @@
 INTVAL list_length(SHIM_INTERP, ARGIN(const List *list))
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_ld
+#define ASSERT_ARGS_list_assign assert(interp); \
+                                assert(list); \
+                                assert(item);
+#define ASSERT_ARGS_list_clone assert(interp); \
+                               assert(other);
+#define ASSERT_ARGS_list_delete assert(interp); \
+                                assert(list);
+#define ASSERT_ARGS_list_get assert(interp); \
+                             assert(list);
+#define ASSERT_ARGS_list_insert assert(interp); \
+                                assert(list);
+#define ASSERT_ARGS_list_mark assert(interp); \
+                              assert(list);
+#define ASSERT_ARGS_list_new assert(interp);
+#define ASSERT_ARGS_list_new_init assert(interp); \
+                                  assert(init);
+#define ASSERT_ARGS_list_pmc_new assert(interp); \
+                                 assert(container);
+#define ASSERT_ARGS_list_pmc_new_init assert(interp); \
+                                      assert(container); \
+                                      assert(init);
+#define ASSERT_ARGS_list_pop assert(interp); \
+                             assert(list);
+#define ASSERT_ARGS_list_push assert(interp); \
+                              assert(list); \
+                              assert(item);
+#define ASSERT_ARGS_list_set_length assert(interp); \
+                                    assert(list);
+#define ASSERT_ARGS_list_shift assert(interp); \
+                               assert(list);
+#define ASSERT_ARGS_list_splice assert(interp); \
+                                assert(list);
+#define ASSERT_ARGS_list_unshift assert(interp); \
+                                 assert(list); \
+                                 assert(item);
+#define ASSERT_ARGS_list_visit assert(interp); \
+                               assert(list); \
+                               assert(pinfo);
+#define ASSERT_ARGS_list_length assert(list);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/list.c */
 

Modified: trunk/include/parrot/longopt.h
==============================================================================
--- trunk/include/parrot/longopt.h	(original)
+++ trunk/include/parrot/longopt.h	Wed Dec 31 11:19:36 2008
@@ -59,6 +59,10 @@
         __attribute__nonnull__(5)
         FUNC_MODIFIES(* info_buf);
 
+#define ASSERT_ARGS_longopt_get assert(interp); \
+                                assert(argv[]); \
+                                assert(options[]); \
+                                assert(info_buf);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/longopt.c */
 

Modified: trunk/include/parrot/memory.h
==============================================================================
--- trunk/include/parrot/memory.h	(original)
+++ trunk/include/parrot/memory.h	Wed Dec 31 11:19:36 2008
@@ -114,6 +114,17 @@
 void mem_setup_allocator(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_mem_sys_allocate
+#define ASSERT_ARGS_mem_sys_allocate_zeroed
+#define ASSERT_ARGS_mem_sys_free
+#define ASSERT_ARGS_mem_sys_realloc
+#define ASSERT_ARGS_mem_sys_realloc_zeroed
+#define ASSERT_ARGS_mem__internal_allocate assert(file);
+#define ASSERT_ARGS_mem__internal_allocate_zeroed assert(file);
+#define ASSERT_ARGS_mem__internal_free assert(file);
+#define ASSERT_ARGS_mem__internal_realloc assert(file);
+#define ASSERT_ARGS_mem__internal_realloc_zeroed assert(file);
+#define ASSERT_ARGS_mem_setup_allocator assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/memory.c */
 

Modified: trunk/include/parrot/misc.h
==============================================================================
--- trunk/include/parrot/misc.h	(original)
+++ trunk/include/parrot/misc.h	Wed Dec 31 11:19:36 2008
@@ -101,6 +101,26 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_byte_index assert(base); \
+                                      assert(search);
+#define ASSERT_ARGS_Parrot_byte_rindex assert(base); \
+                                       assert(search);
+#define ASSERT_ARGS_Parrot_float_rand
+#define ASSERT_ARGS_Parrot_int_rand
+#define ASSERT_ARGS_Parrot_range_rand
+#define ASSERT_ARGS_Parrot_register_move assert(interp); \
+                                         assert(dest_regs); \
+                                         assert(src_regs); \
+                                         assert(info);
+#define ASSERT_ARGS_Parrot_srand
+#define ASSERT_ARGS_Parrot_uint_rand
+#define ASSERT_ARGS_floatval_mod
+#define ASSERT_ARGS_intval_mod
+#define ASSERT_ARGS_Parrot_quicksort assert(interp); \
+                                     assert(data); \
+                                     assert(cmp);
+#define ASSERT_ARGS_tm_to_array assert(interp); \
+                                assert(tm);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/utils.c */
 
@@ -180,6 +200,25 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_psprintf assert(interp); \
+                                    assert(pat); \
+                                    assert(ary);
+#define ASSERT_ARGS_Parrot_secret_snprintf assert(buffer); \
+                                           assert(format);
+#define ASSERT_ARGS_Parrot_snprintf assert(interp); \
+                                    assert(targ); \
+                                    assert(pat);
+#define ASSERT_ARGS_Parrot_sprintf_c assert(interp); \
+                                     assert(pat);
+#define ASSERT_ARGS_Parrot_sprintf_s assert(interp); \
+                                     assert(pat);
+#define ASSERT_ARGS_Parrot_vsnprintf assert(interp); \
+                                     assert(targ); \
+                                     assert(pat);
+#define ASSERT_ARGS_Parrot_vsprintf_c assert(interp); \
+                                      assert(pat);
+#define ASSERT_ARGS_Parrot_vsprintf_s assert(interp); \
+                                      assert(pat);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/misc.c */
 
@@ -250,6 +289,9 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_sprintf_format assert(interp); \
+                                          assert(pat); \
+                                          assert(obj);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/spf_render.c */
 

Modified: trunk/include/parrot/multidispatch.h
==============================================================================
--- trunk/include/parrot/multidispatch.h	(original)
+++ trunk/include/parrot/multidispatch.h	Wed Dec 31 11:19:36 2008
@@ -216,6 +216,58 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_build_sig_object_from_varargs assert(interp); \
+                                                         assert(sig);
+#define ASSERT_ARGS_Parrot_mmd_add_multi_from_c_args assert(interp); \
+                                                     assert(sub_name); \
+                                                     assert(short_sig); \
+                                                     assert(long_sig); \
+                                                     assert(multi_func_ptr);
+#define ASSERT_ARGS_Parrot_mmd_add_multi_from_long_sig assert(interp); \
+                                                       assert(sub_name); \
+                                                       assert(long_sig); \
+                                                       assert(sub_obj);
+#define ASSERT_ARGS_Parrot_mmd_add_multi_list_from_c_args assert(interp); \
+                                                          assert(mmd_info);
+#define ASSERT_ARGS_Parrot_mmd_build_type_tuple_from_sig_obj assert(interp); \
+                                                             assert(sig_obj);
+#define ASSERT_ARGS_Parrot_mmd_cache_create assert(interp);
+#define ASSERT_ARGS_Parrot_mmd_cache_destroy assert(interp); \
+                                             assert(cache);
+#define ASSERT_ARGS_Parrot_mmd_cache_lookup_by_types assert(interp); \
+                                                     assert(cache); \
+                                                     assert(name); \
+                                                     assert(types);
+#define ASSERT_ARGS_Parrot_mmd_cache_lookup_by_values assert(interp); \
+                                                      assert(cache); \
+                                                      assert(name); \
+                                                      assert(values);
+#define ASSERT_ARGS_Parrot_mmd_cache_mark assert(interp); \
+                                          assert(cache);
+#define ASSERT_ARGS_Parrot_mmd_cache_store_by_types assert(interp); \
+                                                    assert(cache); \
+                                                    assert(name); \
+                                                    assert(types); \
+                                                    assert(chosen);
+#define ASSERT_ARGS_Parrot_mmd_cache_store_by_values assert(interp); \
+                                                     assert(cache); \
+                                                     assert(name); \
+                                                     assert(values); \
+                                                     assert(chosen);
+#define ASSERT_ARGS_Parrot_mmd_find_multi_from_long_sig assert(interp); \
+                                                        assert(name); \
+                                                        assert(long_sig);
+#define ASSERT_ARGS_Parrot_mmd_find_multi_from_sig_obj assert(interp); \
+                                                       assert(name); \
+                                                       assert(invoke_sig);
+#define ASSERT_ARGS_Parrot_mmd_multi_dispatch_from_c_args assert(interp); \
+                                                          assert(name); \
+                                                          assert(sig);
+#define ASSERT_ARGS_Parrot_mmd_sort_manhattan assert(interp); \
+                                              assert(candidates);
+#define ASSERT_ARGS_Parrot_mmd_sort_manhattan_by_sig_pmc assert(interp); \
+                                                         assert(candidates); \
+                                                         assert(invoke_sig);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/multidispatch.c */
 

Modified: trunk/include/parrot/oo.h
==============================================================================
--- trunk/include/parrot/oo.h	(original)
+++ trunk/include/parrot/oo.h	Wed Dec 31 11:19:36 2008
@@ -198,11 +198,60 @@
         __attribute__nonnull__(2);
 
 PARROT_WARN_UNUSED_RESULT
-INTVAL Parrot_oo_register_type(PARROT_INTERP, ARGIN(PMC *name), ARGIN(PMC *name_space))
+INTVAL Parrot_oo_register_type(PARROT_INTERP,
+    ARGIN(PMC *name),
+    ARGIN(PMC *namespace))
         __attribute__nonnull__(1)
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_Parrot_class_lookup assert(interp); \
+                                        assert(class_name);
+#define ASSERT_ARGS_Parrot_ComposeRole assert(interp); \
+                                       assert(role); \
+                                       assert(exclude); \
+                                       assert(alias); \
+                                       assert(methods_hash); \
+                                       assert(roles_list);
+#define ASSERT_ARGS_Parrot_ComputeMRO_C3 assert(interp); \
+                                         assert(_class);
+#define ASSERT_ARGS_Parrot_find_method_direct assert(interp); \
+                                              assert(_class); \
+                                              assert(method_name);
+#define ASSERT_ARGS_Parrot_find_method_with_cache assert(interp); \
+                                                  assert(_class); \
+                                                  assert(method_name);
+#define ASSERT_ARGS_Parrot_get_vtable_index assert(interp); \
+                                            assert(name);
+#define ASSERT_ARGS_Parrot_invalidate_method_cache assert(interp);
+#define ASSERT_ARGS_Parrot_MMD_method_name
+#define ASSERT_ARGS_Parrot_oo_get_class assert(interp); \
+                                        assert(key);
+#define ASSERT_ARGS_Parrot_oo_get_class_str assert(interp); \
+                                            assert(name);
+#define ASSERT_ARGS_Parrot_remove_parent assert(interp); \
+                                         assert(removed_class); \
+                                         assert(existing_class);
+#define ASSERT_ARGS_destroy_object_cache assert(interp);
+#define ASSERT_ARGS_init_object_cache assert(interp);
+#define ASSERT_ARGS_mark_object_cache assert(interp);
+#define ASSERT_ARGS_Parrot_class_lookup_p assert(interp); \
+                                          assert(class_name);
+#define ASSERT_ARGS_Parrot_oo_extract_methods_from_namespace assert(interp); \
+                                                             assert(self); \
+                                                             assert(ns);
+#define ASSERT_ARGS_Parrot_oo_find_vtable_override assert(interp); \
+                                                   assert(classobj); \
+                                                   assert(name);
+#define ASSERT_ARGS_Parrot_oo_find_vtable_override_for_class assert(interp); \
+                                                             assert(classobj); \
+                                                             assert(name);
+#define ASSERT_ARGS_Parrot_oo_get_namespace assert(classobj);
+#define ASSERT_ARGS_Parrot_oo_newclass_from_str assert(interp); \
+                                                assert(name);
+#define ASSERT_ARGS_Parrot_oo_register_type assert(interp); \
+                                            assert(name); \
+                                            assert(namespace);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/oo.c */
 

Modified: trunk/include/parrot/packfile.h
==============================================================================
--- trunk/include/parrot/packfile.h	(original)
+++ trunk/include/parrot/packfile.h	Wed Dec 31 11:19:36 2008
@@ -322,6 +322,23 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*self);
 
+#define ASSERT_ARGS_PackFile_Constant_pack assert(interp); \
+                                           assert(const_table); \
+                                           assert(self); \
+                                           assert(cursor);
+#define ASSERT_ARGS_PackFile_ConstTable_pack assert(interp); \
+                                             assert(seg); \
+                                             assert(cursor);
+#define ASSERT_ARGS_PackFile_ConstTable_pack_size assert(interp); \
+                                                  assert(seg);
+#define ASSERT_ARGS_PackFile_find_in_const assert(interp); \
+                                           assert(ct); \
+                                           assert(key);
+#define ASSERT_ARGS_PackFile_pack assert(interp); \
+                                  assert(self); \
+                                  assert(cursor);
+#define ASSERT_ARGS_PackFile_pack_size assert(interp); \
+                                       assert(self);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/packout.c */
 
@@ -638,6 +655,85 @@
 void mark_const_subs(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_do_sub_pragmas assert(interp); \
+                                   assert(self);
+#define ASSERT_ARGS_PackFile_add_segment assert(dir); \
+                                         assert(seg);
+#define ASSERT_ARGS_PackFile_Constant_destroy
+#define ASSERT_ARGS_PackFile_Constant_new
+#define ASSERT_ARGS_PackFile_Constant_pack_size assert(interp); \
+                                                assert(self);
+#define ASSERT_ARGS_PackFile_Constant_unpack assert(interp); \
+                                             assert(constt); \
+                                             assert(self); \
+                                             assert(cursor);
+#define ASSERT_ARGS_PackFile_Constant_unpack_key assert(interp); \
+                                                 assert(constt); \
+                                                 assert(self); \
+                                                 assert(cursor);
+#define ASSERT_ARGS_PackFile_Constant_unpack_pmc assert(interp); \
+                                                 assert(constt); \
+                                                 assert(self); \
+                                                 assert(cursor);
+#define ASSERT_ARGS_PackFile_ConstTable_clear assert(interp); \
+                                              assert(self);
+#define ASSERT_ARGS_PackFile_ConstTable_unpack assert(interp); \
+                                               assert(seg); \
+                                               assert(cursor);
+#define ASSERT_ARGS_PackFile_destroy assert(interp);
+#define ASSERT_ARGS_PackFile_find_fixup_entry assert(interp); \
+                                              assert(name);
+#define ASSERT_ARGS_PackFile_find_segment assert(interp); \
+                                          assert(name);
+#define ASSERT_ARGS_PackFile_fixup_subs assert(interp);
+#define ASSERT_ARGS_PackFile_FixupTable_clear assert(interp); \
+                                              assert(self);
+#define ASSERT_ARGS_PackFile_FixupTable_new_entry assert(interp); \
+                                                  assert(label);
+#define ASSERT_ARGS_PackFile_funcs_register assert(pf);
+#define ASSERT_ARGS_PackFile_map_segments assert(interp); \
+                                          assert(dir);
+#define ASSERT_ARGS_PackFile_new assert(interp);
+#define ASSERT_ARGS_PackFile_new_dummy assert(interp); \
+                                       assert(name);
+#define ASSERT_ARGS_PackFile_remove_segment_by_name assert(dir); \
+                                                    assert(name);
+#define ASSERT_ARGS_PackFile_Segment_destroy assert(interp); \
+                                             assert(self);
+#define ASSERT_ARGS_PackFile_Segment_dump assert(interp); \
+                                          assert(self);
+#define ASSERT_ARGS_PackFile_Segment_new
+#define ASSERT_ARGS_PackFile_Segment_new_seg assert(interp); \
+                                             assert(dir); \
+                                             assert(name);
+#define ASSERT_ARGS_PackFile_Segment_pack assert(interp); \
+                                          assert(self); \
+                                          assert(cursor);
+#define ASSERT_ARGS_PackFile_Segment_packed_size assert(interp); \
+                                                 assert(self);
+#define ASSERT_ARGS_PackFile_Segment_unpack assert(interp); \
+                                            assert(self); \
+                                            assert(cursor);
+#define ASSERT_ARGS_PackFile_unpack assert(interp); \
+                                    assert(self); \
+                                    assert(packed);
+#define ASSERT_ARGS_Parrot_debug_add_mapping assert(interp); \
+                                             assert(debug); \
+                                             assert(filename);
+#define ASSERT_ARGS_Parrot_debug_pc_to_filename assert(interp); \
+                                                assert(debug);
+#define ASSERT_ARGS_Parrot_destroy_constants assert(interp);
+#define ASSERT_ARGS_Parrot_load_bytecode assert(interp);
+#define ASSERT_ARGS_Parrot_new_debug_seg assert(interp); \
+                                         assert(cs);
+#define ASSERT_ARGS_Parrot_switch_to_cs assert(interp); \
+                                        assert(new_cs);
+#define ASSERT_ARGS_Parrot_switch_to_cs_by_nr assert(interp);
+#define ASSERT_ARGS_PF_create_default_segs assert(interp); \
+                                           assert(file_name);
+#define ASSERT_ARGS_default_dump_header assert(interp); \
+                                        assert(self);
+#define ASSERT_ARGS_mark_const_subs assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/packfile.c */
 
@@ -657,6 +753,10 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_PackFile_ConstTable_dump assert(interp); \
+                                             assert(self);
+#define ASSERT_ARGS_PackFile_Fixup_dump assert(interp); \
+                                        assert(ft);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/packdump.c */
 
@@ -766,6 +866,27 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*cursor);
 
+#define ASSERT_ARGS_PackFile_assign_transforms assert(pf);
+#define ASSERT_ARGS_PF_fetch_cstring assert(pf); \
+                                     assert(cursor);
+#define ASSERT_ARGS_PF_fetch_integer assert(stream);
+#define ASSERT_ARGS_PF_fetch_number assert(stream);
+#define ASSERT_ARGS_PF_fetch_opcode assert(stream);
+#define ASSERT_ARGS_PF_fetch_string assert(interp); \
+                                    assert(cursor);
+#define ASSERT_ARGS_PF_size_cstring assert(s);
+#define ASSERT_ARGS_PF_size_integer
+#define ASSERT_ARGS_PF_size_number
+#define ASSERT_ARGS_PF_size_opcode
+#define ASSERT_ARGS_PF_size_string assert(s);
+#define ASSERT_ARGS_PF_store_cstring assert(cursor); \
+                                     assert(s);
+#define ASSERT_ARGS_PF_store_integer assert(cursor);
+#define ASSERT_ARGS_PF_store_number assert(cursor); \
+                                    assert(val);
+#define ASSERT_ARGS_PF_store_opcode assert(cursor);
+#define ASSERT_ARGS_PF_store_string assert(cursor); \
+                                    assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/packfile/pf_items.c */
 
@@ -850,6 +971,26 @@
 PARROT_CONST_FUNCTION
 opcode_t fetch_op_le(opcode_t w);
 
+#define ASSERT_ARGS_fetch_buf_be_12 assert(rb); \
+                                    assert(b);
+#define ASSERT_ARGS_fetch_buf_be_16 assert(rb); \
+                                    assert(b);
+#define ASSERT_ARGS_fetch_buf_be_4 assert(rb); \
+                                   assert(b);
+#define ASSERT_ARGS_fetch_buf_be_8 assert(rb); \
+                                   assert(b);
+#define ASSERT_ARGS_fetch_buf_le_12 assert(rb); \
+                                    assert(b);
+#define ASSERT_ARGS_fetch_buf_le_16 assert(rb); \
+                                    assert(b);
+#define ASSERT_ARGS_fetch_buf_le_4 assert(rb); \
+                                   assert(b);
+#define ASSERT_ARGS_fetch_buf_le_8 assert(rb); \
+                                   assert(b);
+#define ASSERT_ARGS_fetch_iv_be
+#define ASSERT_ARGS_fetch_iv_le
+#define ASSERT_ARGS_fetch_op_be
+#define ASSERT_ARGS_fetch_op_le
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/byteorder.c */
 

Modified: trunk/include/parrot/pic.h
==============================================================================
--- trunk/include/parrot/pic.h	(original)
+++ trunk/include/parrot/pic.h	Wed Dec 31 11:19:36 2008
@@ -129,6 +129,22 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*pc_pred);
 
+#define ASSERT_ARGS_parrot_PIC_alloc_mic
+#define ASSERT_ARGS_parrot_PIC_alloc_pic assert(interp);
+#define ASSERT_ARGS_parrot_PIC_alloc_store assert(cs);
+#define ASSERT_ARGS_parrot_pic_check_sig assert(sig1); \
+                                         assert(sig2); \
+                                         assert(type);
+#define ASSERT_ARGS_parrot_PIC_destroy assert(cs);
+#define ASSERT_ARGS_parrot_pic_find_infix_v_pp assert(interp); \
+                                               assert(left); \
+                                               assert(right); \
+                                               assert(mic); \
+                                               assert(cur_opcode);
+#define ASSERT_ARGS_parrot_PIC_op_is_cached
+#define ASSERT_ARGS_parrot_pic_opcode assert(interp);
+#define ASSERT_ARGS_parrot_PIC_prederef assert(interp); \
+                                        assert(pc_pred);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/pic.c */
 
@@ -155,6 +171,13 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_parrot_pic_is_safe_to_jit assert(interp); \
+                                              assert(sub); \
+                                              assert(sig_args); \
+                                              assert(sig_results); \
+                                              assert(flags);
+#define ASSERT_ARGS_parrot_pic_JIT_sub assert(interp); \
+                                       assert(sub);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/pic_jit.c */
 

Modified: trunk/include/parrot/pmc.h
==============================================================================
--- trunk/include/parrot/pmc.h	(original)
+++ trunk/include/parrot/pmc.h	Wed Dec 31 11:19:36 2008
@@ -69,10 +69,6 @@
 PMC * pmc_new_noinit(PARROT_INTERP, INTVAL base_type)
         __attribute__nonnull__(1);
 
-INTVAL
-get_new_vtable_index(PARROT_INTERP)
-        __attribute__nonnull__(1);
-
 PARROT_EXPORT
 INTVAL pmc_register(PARROT_INTERP, ARGIN(STRING *name))
         __attribute__nonnull__(1)
@@ -110,6 +106,29 @@
 PMC * temporary_pmc_new(PARROT_INTERP, INTVAL base_type)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_constant_pmc_new assert(interp);
+#define ASSERT_ARGS_constant_pmc_new_init assert(interp);
+#define ASSERT_ARGS_constant_pmc_new_noinit assert(interp);
+#define ASSERT_ARGS_dod_register_pmc assert(interp); \
+                                     assert(pmc);
+#define ASSERT_ARGS_Parrot_create_mro assert(interp);
+#define ASSERT_ARGS_PMC_is_null
+#define ASSERT_ARGS_pmc_new assert(interp);
+#define ASSERT_ARGS_pmc_new_init assert(interp); \
+                                 assert(init);
+#define ASSERT_ARGS_pmc_new_noinit assert(interp);
+#define ASSERT_ARGS_pmc_register assert(interp); \
+                                 assert(name);
+#define ASSERT_ARGS_pmc_reuse assert(interp); \
+                              assert(pmc);
+#define ASSERT_ARGS_pmc_type assert(interp);
+#define ASSERT_ARGS_pmc_type_p assert(interp); \
+                               assert(name);
+#define ASSERT_ARGS_dod_unregister_pmc assert(interp); \
+                                       assert(pmc);
+#define ASSERT_ARGS_temporary_pmc_free assert(interp); \
+                                       assert(pmc);
+#define ASSERT_ARGS_temporary_pmc_new assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/pmc.c */
 

Modified: trunk/include/parrot/pmc_freeze.h
==============================================================================
--- trunk/include/parrot/pmc_freeze.h	(original)
+++ trunk/include/parrot/pmc_freeze.h	Wed Dec 31 11:19:36 2008
@@ -123,6 +123,16 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_clone assert(interp); \
+                                 assert(pmc);
+#define ASSERT_ARGS_Parrot_freeze assert(interp); \
+                                  assert(pmc);
+#define ASSERT_ARGS_Parrot_freeze_at_destruct assert(interp); \
+                                              assert(pmc);
+#define ASSERT_ARGS_Parrot_thaw assert(interp); \
+                                assert(image);
+#define ASSERT_ARGS_Parrot_thaw_constants assert(interp); \
+                                          assert(image);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/pmc_freeze.c */
 

Modified: trunk/include/parrot/register.h
==============================================================================
--- trunk/include/parrot/register.h	(original)
+++ trunk/include/parrot/register.h	Wed Dec 31 11:19:36 2008
@@ -138,6 +138,26 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_clear_i assert(interp);
+#define ASSERT_ARGS_Parrot_clear_n assert(interp);
+#define ASSERT_ARGS_Parrot_clear_p assert(interp);
+#define ASSERT_ARGS_Parrot_clear_s assert(interp);
+#define ASSERT_ARGS_Parrot_context_ref_trace assert(interp); \
+                                             assert(ctx); \
+                                             assert(file);
+#define ASSERT_ARGS_Parrot_free_context assert(interp); \
+                                        assert(ctx);
+#define ASSERT_ARGS_parrot_gc_context assert(interp);
+#define ASSERT_ARGS_Parrot_pop_context assert(interp);
+#define ASSERT_ARGS_Parrot_push_context assert(interp); \
+                                        assert(n_regs_used);
+#define ASSERT_ARGS_Parrot_set_context_threshold
+#define ASSERT_ARGS_create_initial_context assert(interp);
+#define ASSERT_ARGS_destroy_context assert(interp);
+#define ASSERT_ARGS_Parrot_alloc_context assert(interp); \
+                                         assert(number_regs_used);
+#define ASSERT_ARGS_Parrot_set_new_context assert(interp); \
+                                           assert(number_regs_used);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/register.c */
 

Modified: trunk/include/parrot/resources.h
==============================================================================
--- trunk/include/parrot/resources.h	(original)
+++ trunk/include/parrot/resources.h	Wed Dec 31 11:19:36 2008
@@ -90,6 +90,23 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*str);
 
+#define ASSERT_ARGS_Parrot_allocate assert(interp); \
+                                    assert(buffer);
+#define ASSERT_ARGS_Parrot_allocate_aligned assert(interp); \
+                                            assert(buffer);
+#define ASSERT_ARGS_Parrot_allocate_string assert(interp); \
+                                           assert(str);
+#define ASSERT_ARGS_Parrot_destroy_memory_pools assert(interp);
+#define ASSERT_ARGS_Parrot_go_collect assert(interp);
+#define ASSERT_ARGS_Parrot_in_memory_pool assert(interp); \
+                                          assert(bufstart);
+#define ASSERT_ARGS_Parrot_initialize_memory_pools assert(interp);
+#define ASSERT_ARGS_Parrot_merge_memory_pools assert(dest_interp); \
+                                              assert(source_interp);
+#define ASSERT_ARGS_Parrot_reallocate assert(interp); \
+                                      assert(buffer);
+#define ASSERT_ARGS_Parrot_reallocate_string assert(interp); \
+                                             assert(str);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/resources.c */
 

Modified: trunk/include/parrot/scheduler.h
==============================================================================
--- trunk/include/parrot/scheduler.h	(original)
+++ trunk/include/parrot/scheduler.h	Wed Dec 31 11:19:36 2008
@@ -162,6 +162,52 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_cx_add_handler assert(interp); \
+                                          assert(handler);
+#define ASSERT_ARGS_Parrot_cx_add_handler_local assert(interp); \
+                                                assert(handler);
+#define ASSERT_ARGS_Parrot_cx_broadcast_message assert(interp); \
+                                                assert(messagetype);
+#define ASSERT_ARGS_Parrot_cx_count_handlers_typed assert(interp); \
+                                                   assert(handler_type);
+#define ASSERT_ARGS_Parrot_cx_delete_handler_local assert(interp); \
+                                                   assert(handler_type);
+#define ASSERT_ARGS_Parrot_cx_delete_handler_typed assert(interp); \
+                                                   assert(handler_type);
+#define ASSERT_ARGS_Parrot_cx_delete_suspend_for_gc assert(interp);
+#define ASSERT_ARGS_Parrot_cx_delete_task assert(interp); \
+                                          assert(task);
+#define ASSERT_ARGS_Parrot_cx_find_handler_for_task assert(interp); \
+                                                    assert(task);
+#define ASSERT_ARGS_Parrot_cx_find_handler_local assert(interp); \
+                                                 assert(task);
+#define ASSERT_ARGS_Parrot_cx_handle_tasks assert(interp); \
+                                           assert(scheduler);
+#define ASSERT_ARGS_Parrot_cx_peek_task assert(interp);
+#define ASSERT_ARGS_Parrot_cx_request_suspend_for_gc assert(interp);
+#define ASSERT_ARGS_Parrot_cx_runloop_end assert(interp);
+#define ASSERT_ARGS_Parrot_cx_schedule_callback assert(interp); \
+                                                assert(user_data); \
+                                                assert(ext_data);
+#define ASSERT_ARGS_Parrot_cx_schedule_repeat assert(interp); \
+                                              assert(task);
+#define ASSERT_ARGS_Parrot_cx_schedule_sleep assert(interp);
+#define ASSERT_ARGS_Parrot_cx_schedule_task assert(interp); \
+                                            assert(task);
+#define ASSERT_ARGS_Parrot_cx_schedule_timer assert(interp);
+#define ASSERT_ARGS_Parrot_cx_send_message assert(interp); \
+                                           assert(messagetype);
+#define ASSERT_ARGS_Parrot_cx_check_tasks assert(interp); \
+                                          assert(scheduler);
+#define ASSERT_ARGS_Parrot_cx_init_scheduler assert(interp);
+#define ASSERT_ARGS_Parrot_cx_invoke_callback assert(interp); \
+                                              assert(callback);
+#define ASSERT_ARGS_Parrot_cx_refresh_task_list assert(interp); \
+                                                assert(scheduler);
+#define ASSERT_ARGS_Parrot_cx_runloop_wake assert(interp); \
+                                           assert(scheduler);
+#define ASSERT_ARGS_Parrot_cx_timer_invoke assert(interp); \
+                                           assert(timer);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/scheduler.c */
 

Modified: trunk/include/parrot/smallobject.h
==============================================================================
--- trunk/include/parrot/smallobject.h	(original)
+++ trunk/include/parrot/smallobject.h	Wed Dec 31 11:19:36 2008
@@ -189,6 +189,22 @@
         FUNC_MODIFIES(*dest)
         FUNC_MODIFIES(*source);
 
+#define ASSERT_ARGS_contained_in_pool assert(pool); \
+                                      assert(ptr);
+#define ASSERT_ARGS_gc_pmc_ext_pool_init assert(pool);
+#define ASSERT_ARGS_new_small_object_pool
+#define ASSERT_ARGS_Parrot_add_to_free_list assert(interp); \
+                                            assert(pool); \
+                                            assert(arena);
+#define ASSERT_ARGS_Parrot_append_arena_in_pool assert(interp); \
+                                                assert(pool); \
+                                                assert(new_arena);
+#define ASSERT_ARGS_Parrot_gc_ms_init assert(interp);
+#define ASSERT_ARGS_Parrot_is_const_pmc assert(interp); \
+                                        assert(pmc);
+#define ASSERT_ARGS_Parrot_small_object_pool_merge assert(interp); \
+                                                   assert(dest); \
+                                                   assert(source);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/gc/smallobject.c */
 

Modified: trunk/include/parrot/stacks.h
==============================================================================
--- trunk/include/parrot/stacks.h	(original)
+++ trunk/include/parrot/stacks.h	Wed Dec 31 11:19:36 2008
@@ -165,6 +165,35 @@
 Stack_entry_type get_entry_type(ARGIN(const Stack_Entry_t *entry))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_cst_new_stack_chunk assert(interp); \
+                                        assert(chunk);
+#define ASSERT_ARGS_mark_stack assert(interp); \
+                               assert(chunk);
+#define ASSERT_ARGS_new_stack assert(interp); \
+                              assert(name);
+#define ASSERT_ARGS_Parrot_dump_dynamic_environment assert(interp); \
+                                                    assert(dynamic_env);
+#define ASSERT_ARGS_Parrot_pop_mark assert(interp);
+#define ASSERT_ARGS_Parrot_push_action assert(interp); \
+                                       assert(sub);
+#define ASSERT_ARGS_Parrot_push_mark assert(interp);
+#define ASSERT_ARGS_pop_dest assert(interp);
+#define ASSERT_ARGS_stack_destroy
+#define ASSERT_ARGS_stack_entry assert(stack);
+#define ASSERT_ARGS_stack_height assert(chunk);
+#define ASSERT_ARGS_stack_peek assert(interp); \
+                               assert(stack_base);
+#define ASSERT_ARGS_stack_pop assert(interp); \
+                              assert(stack_p);
+#define ASSERT_ARGS_stack_prepare_pop assert(interp); \
+                                      assert(stack_p);
+#define ASSERT_ARGS_stack_prepare_push assert(interp); \
+                                       assert(stack_p);
+#define ASSERT_ARGS_stack_push assert(interp); \
+                               assert(stack_p); \
+                               assert(thing);
+#define ASSERT_ARGS_stack_system_init
+#define ASSERT_ARGS_get_entry_type assert(entry);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/stacks.c */
 

Modified: trunk/include/parrot/stm/backend.h
==============================================================================
--- trunk/include/parrot/stm/backend.h	(original)
+++ trunk/include/parrot/stm/backend.h	Wed Dec 31 11:19:36 2008
@@ -102,6 +102,31 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_Parrot_freeze_STM_PMC_handle assert(interp); \
+                                                 assert(io); \
+                                                 assert(handle);
+#define ASSERT_ARGS_Parrot_STM_abort assert(interp);
+#define ASSERT_ARGS_Parrot_STM_alloc assert(interp);
+#define ASSERT_ARGS_Parrot_STM_begin_update assert(interp);
+#define ASSERT_ARGS_Parrot_STM_commit assert(interp);
+#define ASSERT_ARGS_Parrot_STM_destroy assert(interp);
+#define ASSERT_ARGS_Parrot_STM_destroy_extracted
+#define ASSERT_ARGS_Parrot_STM_dump_profile assert(interp);
+#define ASSERT_ARGS_Parrot_STM_extract assert(interp);
+#define ASSERT_ARGS_Parrot_STM_mark_extracted assert(interp);
+#define ASSERT_ARGS_Parrot_STM_mark_pmc_handle assert(interp);
+#define ASSERT_ARGS_Parrot_STM_mark_transaction assert(interp);
+#define ASSERT_ARGS_Parrot_STM_merge_profile assert(d); \
+                                             assert(s);
+#define ASSERT_ARGS_Parrot_STM_read assert(interp);
+#define ASSERT_ARGS_Parrot_STM_replay_extracted assert(interp);
+#define ASSERT_ARGS_Parrot_STM_start_transaction assert(interp);
+#define ASSERT_ARGS_Parrot_STM_transaction_depth assert(interp);
+#define ASSERT_ARGS_Parrot_STM_validate assert(interp);
+#define ASSERT_ARGS_Parrot_STM_wait assert(interp);
+#define ASSERT_ARGS_Parrot_STM_write assert(interp);
+#define ASSERT_ARGS_Parrot_thaw_STM_PMC_handle assert(interp); \
+                                               assert(io);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/stm/backend.c */
 

Modified: trunk/include/parrot/string_funcs.h
==============================================================================
--- trunk/include/parrot/string_funcs.h	(original)
+++ trunk/include/parrot/string_funcs.h	Wed Dec 31 11:19:36 2008
@@ -536,6 +536,113 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*tc);
 
+#define ASSERT_ARGS_const_string assert(interp); \
+                                 assert(buffer);
+#define ASSERT_ARGS_Parrot_make_COW_reference assert(interp); \
+                                              assert(s);
+#define ASSERT_ARGS_Parrot_reuse_COW_reference assert(s); \
+                                               assert(d);
+#define ASSERT_ARGS_Parrot_string_cstring assert(str);
+#define ASSERT_ARGS_Parrot_string_find_cclass assert(interp);
+#define ASSERT_ARGS_Parrot_string_find_not_cclass assert(interp);
+#define ASSERT_ARGS_Parrot_string_is_cclass assert(interp); \
+                                            assert(s);
+#define ASSERT_ARGS_Parrot_string_split assert(interp);
+#define ASSERT_ARGS_Parrot_string_trans_charset assert(interp);
+#define ASSERT_ARGS_Parrot_string_trans_encoding assert(interp);
+#define ASSERT_ARGS_Parrot_unmake_COW assert(interp); \
+                                      assert(s);
+#define ASSERT_ARGS_string_append assert(interp);
+#define ASSERT_ARGS_string_bitwise_and assert(interp);
+#define ASSERT_ARGS_string_bitwise_not assert(interp);
+#define ASSERT_ARGS_string_bitwise_or assert(interp);
+#define ASSERT_ARGS_string_bitwise_xor assert(interp);
+#define ASSERT_ARGS_string_bool assert(interp);
+#define ASSERT_ARGS_string_capacity assert(s);
+#define ASSERT_ARGS_string_chopn assert(interp); \
+                                 assert(s);
+#define ASSERT_ARGS_string_chopn_inplace assert(interp); \
+                                         assert(s);
+#define ASSERT_ARGS_string_chr assert(interp);
+#define ASSERT_ARGS_string_compare assert(interp);
+#define ASSERT_ARGS_string_compose assert(interp);
+#define ASSERT_ARGS_string_compute_strlen assert(interp); \
+                                          assert(s);
+#define ASSERT_ARGS_string_concat assert(interp);
+#define ASSERT_ARGS_string_copy assert(interp); \
+                                assert(s);
+#define ASSERT_ARGS_string_cstring_free
+#define ASSERT_ARGS_string_deinit assert(interp);
+#define ASSERT_ARGS_string_downcase assert(interp); \
+                                    assert(s);
+#define ASSERT_ARGS_string_downcase_inplace assert(interp); \
+                                            assert(s);
+#define ASSERT_ARGS_string_equal assert(interp);
+#define ASSERT_ARGS_string_escape_string assert(interp);
+#define ASSERT_ARGS_string_escape_string_delimited assert(interp);
+#define ASSERT_ARGS_string_from_cstring assert(interp);
+#define ASSERT_ARGS_string_from_int assert(interp);
+#define ASSERT_ARGS_string_from_num assert(interp);
+#define ASSERT_ARGS_string_grow assert(interp); \
+                                assert(s);
+#define ASSERT_ARGS_string_hash assert(interp);
+#define ASSERT_ARGS_string_increment assert(interp); \
+                                     assert(s);
+#define ASSERT_ARGS_string_index assert(interp); \
+                                 assert(s);
+#define ASSERT_ARGS_string_init assert(interp);
+#define ASSERT_ARGS_string_join assert(interp); \
+                                assert(ar);
+#define ASSERT_ARGS_string_length assert(s);
+#define ASSERT_ARGS_string_make assert(interp);
+#define ASSERT_ARGS_string_make_direct assert(interp); \
+                                       assert(encoding);
+#define ASSERT_ARGS_string_make_empty assert(interp);
+#define ASSERT_ARGS_string_max_bytes assert(s);
+#define ASSERT_ARGS_string_ord assert(interp);
+#define ASSERT_ARGS_string_pin assert(interp); \
+                               assert(s);
+#define ASSERT_ARGS_string_primary_encoding_for_representation assert(interp);
+#define ASSERT_ARGS_string_printf assert(interp); \
+                                  assert(format);
+#define ASSERT_ARGS_string_rep_compatible assert(a); \
+                                          assert(b); \
+                                          assert(e);
+#define ASSERT_ARGS_string_repeat assert(interp); \
+                                  assert(s);
+#define ASSERT_ARGS_string_replace assert(interp); \
+                                   assert(src); \
+                                   assert(rep);
+#define ASSERT_ARGS_string_set assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_string_split assert(interp); \
+                                 assert(delim); \
+                                 assert(str);
+#define ASSERT_ARGS_string_str_index assert(interp); \
+                                     assert(s); \
+                                     assert(s2);
+#define ASSERT_ARGS_string_substr assert(interp);
+#define ASSERT_ARGS_string_titlecase assert(interp); \
+                                     assert(s);
+#define ASSERT_ARGS_string_titlecase_inplace assert(interp); \
+                                             assert(s);
+#define ASSERT_ARGS_string_to_cstring assert(interp);
+#define ASSERT_ARGS_string_to_cstring_nullable
+#define ASSERT_ARGS_string_to_int
+#define ASSERT_ARGS_string_to_num assert(interp); \
+                                  assert(s);
+#define ASSERT_ARGS_string_unescape_cstring assert(interp); \
+                                            assert(cstring);
+#define ASSERT_ARGS_string_unpin assert(interp); \
+                                 assert(s);
+#define ASSERT_ARGS_string_upcase assert(interp);
+#define ASSERT_ARGS_string_upcase_inplace assert(interp);
+#define ASSERT_ARGS_int_to_str assert(interp); \
+                               assert(tc);
+#define ASSERT_ARGS_string_free assert(interp); \
+                                assert(s);
+#define ASSERT_ARGS_uint_to_str assert(interp); \
+                                assert(tc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/string.c */
 

Modified: trunk/include/parrot/string_primitives.h
==============================================================================
--- trunk/include/parrot/string_primitives.h	(original)
+++ trunk/include/parrot/string_primitives.h	Wed Dec 31 11:19:36 2008
@@ -49,6 +49,14 @@
         FUNC_MODIFIES(*offset)
         FUNC_MODIFIES(*string);
 
+#define ASSERT_ARGS_Parrot_char_digit_value
+#define ASSERT_ARGS_str_dup assert(old);
+#define ASSERT_ARGS_str_dup_remove_quotes assert(old);
+#define ASSERT_ARGS_string_set_data_directory assert(interp); \
+                                              assert(dir);
+#define ASSERT_ARGS_string_unescape_one assert(interp); \
+                                        assert(offset); \
+                                        assert(string);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/string_primitives.c */
 

Modified: trunk/include/parrot/sub.h
==============================================================================
--- trunk/include/parrot/sub.h	(original)
+++ trunk/include/parrot/sub.h	Wed Dec 31 11:19:36 2008
@@ -341,6 +341,35 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_new_ret_continuation_pmc assert(interp);
+#define ASSERT_ARGS_Parrot_Context_get_info assert(interp); \
+                                            assert(ctx); \
+                                            assert(info);
+#define ASSERT_ARGS_Parrot_Context_infostr assert(interp); \
+                                           assert(ctx);
+#define ASSERT_ARGS_Parrot_full_sub_name assert(interp);
+#define ASSERT_ARGS_parrot_new_closure assert(interp); \
+                                       assert(sub_pmc);
+#define ASSERT_ARGS_invalidate_retc_context assert(interp); \
+                                            assert(cont);
+#define ASSERT_ARGS_mark_context assert(interp); \
+                                 assert(ctx);
+#define ASSERT_ARGS_mark_context_start
+#define ASSERT_ARGS_new_closure assert(interp);
+#define ASSERT_ARGS_new_continuation assert(interp);
+#define ASSERT_ARGS_new_coroutine assert(interp);
+#define ASSERT_ARGS_new_ret_continuation assert(interp);
+#define ASSERT_ARGS_new_sub assert(interp);
+#define ASSERT_ARGS_Parrot_capture_lex assert(interp); \
+                                       assert(sub_pmc);
+#define ASSERT_ARGS_Parrot_continuation_check assert(interp); \
+                                              assert(pmc); \
+                                              assert(cc);
+#define ASSERT_ARGS_Parrot_continuation_rewind_environment assert(interp); \
+                                                           assert(cc);
+#define ASSERT_ARGS_Parrot_find_pad assert(interp); \
+                                    assert(lex_name); \
+                                    assert(ctx);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/sub.c */
 

Modified: trunk/include/parrot/thread.h
==============================================================================
--- trunk/include/parrot/thread.h	(original)
+++ trunk/include/parrot/thread.h	Wed Dec 31 11:19:36 2008
@@ -264,6 +264,44 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(d);
 
+#define ASSERT_ARGS_Parrot_shared_DOD_block assert(interp);
+#define ASSERT_ARGS_Parrot_shared_DOD_unblock assert(interp);
+#define ASSERT_ARGS_pt_add_to_interpreters assert(interp);
+#define ASSERT_ARGS_pt_clone_code
+#define ASSERT_ARGS_pt_clone_globals
+#define ASSERT_ARGS_pt_DOD_mark_root_finished assert(interp);
+#define ASSERT_ARGS_pt_DOD_start_mark assert(interp);
+#define ASSERT_ARGS_pt_DOD_stop_mark assert(interp);
+#define ASSERT_ARGS_pt_free_pool assert(interp);
+#define ASSERT_ARGS_pt_join_threads assert(interp);
+#define ASSERT_ARGS_pt_shared_fixup assert(interp); \
+                                    assert(pmc);
+#define ASSERT_ARGS_pt_suspend_self_for_gc assert(interp);
+#define ASSERT_ARGS_pt_thread_detach
+#define ASSERT_ARGS_pt_thread_join assert(parent);
+#define ASSERT_ARGS_pt_thread_kill
+#define ASSERT_ARGS_pt_thread_prepare_for_run
+#define ASSERT_ARGS_pt_thread_run assert(interp); \
+                                  assert(dest_interp); \
+                                  assert(sub);
+#define ASSERT_ARGS_pt_thread_run_1 assert(interp); \
+                                    assert(dest_interp); \
+                                    assert(sub); \
+                                    assert(arg);
+#define ASSERT_ARGS_pt_thread_run_2 assert(interp); \
+                                    assert(dest_interp); \
+                                    assert(sub); \
+                                    assert(arg);
+#define ASSERT_ARGS_pt_thread_run_3 assert(interp); \
+                                    assert(dest_interp); \
+                                    assert(sub); \
+                                    assert(arg);
+#define ASSERT_ARGS_pt_thread_wait_with assert(interp); \
+                                        assert(mutex);
+#define ASSERT_ARGS_pt_thread_yield
+#define ASSERT_ARGS_pt_transfer_sub assert(d); \
+                                    assert(s); \
+                                    assert(sub);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/thread.c */
 

Modified: trunk/include/parrot/tsq.h
==============================================================================
--- trunk/include/parrot/tsq.h	(original)
+++ trunk/include/parrot/tsq.h	Wed Dec 31 11:19:36 2008
@@ -118,6 +118,27 @@
         __attribute__nonnull__(1)
         FUNC_MODIFIES(*queue);
 
+#define ASSERT_ARGS_insert_entry assert(queue); \
+                                 assert(entry);
+#define ASSERT_ARGS_nosync_insert_entry assert(queue); \
+                                        assert(entry);
+#define ASSERT_ARGS_nosync_pop_entry assert(queue);
+#define ASSERT_ARGS_peek_entry assert(queue);
+#define ASSERT_ARGS_pop_entry assert(queue);
+#define ASSERT_ARGS_push_entry assert(queue); \
+                               assert(entry);
+#define ASSERT_ARGS_queue_broadcast assert(queue);
+#define ASSERT_ARGS_queue_destroy assert(queue);
+#define ASSERT_ARGS_queue_init
+#define ASSERT_ARGS_queue_lock assert(queue);
+#define ASSERT_ARGS_queue_signal assert(queue);
+#define ASSERT_ARGS_queue_timedwait assert(queue); \
+                                    assert(abs_time);
+#define ASSERT_ARGS_queue_unlock assert(queue);
+#define ASSERT_ARGS_queue_wait assert(queue);
+#define ASSERT_ARGS_unshift_entry assert(queue); \
+                                  assert(entry);
+#define ASSERT_ARGS_wait_for_entry assert(queue);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/tsq.c */
 

Modified: trunk/include/parrot/vtables.h
==============================================================================
--- trunk/include/parrot/vtables.h	(original)
+++ trunk/include/parrot/vtables.h	Wed Dec 31 11:19:36 2008
@@ -48,6 +48,15 @@
 void parrot_realloc_vtables(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_clone_vtable assert(interp); \
+                                        assert(base_vtable);
+#define ASSERT_ARGS_Parrot_destroy_vtable assert(interp); \
+                                          assert(vtable);
+#define ASSERT_ARGS_Parrot_new_vtable
+#define ASSERT_ARGS_mark_vtables assert(interp);
+#define ASSERT_ARGS_parrot_alloc_vtables assert(interp);
+#define ASSERT_ARGS_parrot_free_vtables assert(interp);
+#define ASSERT_ARGS_parrot_realloc_vtables assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/vtables.c */
 

Modified: trunk/include/parrot/warnings.h
==============================================================================
--- trunk/include/parrot/warnings.h	(original)
+++ trunk/include/parrot/warnings.h	Wed Dec 31 11:19:36 2008
@@ -68,6 +68,9 @@
 void print_pbc_location(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_warn assert(interp); \
+                                assert(message);
+#define ASSERT_ARGS_print_pbc_location assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/warnings.c */
 

Modified: trunk/src/charset.c
==============================================================================
--- trunk/src/charset.c	(original)
+++ trunk/src/charset.c	Wed Dec 31 11:19:36 2008
@@ -73,6 +73,10 @@
 static void register_static_converters(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_register_charset assert(interp); \
+                                     assert(charsetname); \
+                                     assert(charset);
+#define ASSERT_ARGS_register_static_converters assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/charset/ascii.c
==============================================================================
--- trunk/src/charset/ascii.c	(original)
+++ trunk/src/charset/ascii.c	Wed Dec 31 11:19:36 2008
@@ -128,6 +128,34 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_compose assert(interp); \
+                            assert(src);
+#define ASSERT_ARGS_decompose assert(interp); \
+                              assert(src);
+#define ASSERT_ARGS_downcase assert(source_string);
+#define ASSERT_ARGS_downcase_first assert(source_string);
+#define ASSERT_ARGS_find_cclass assert(interp); \
+                                assert(source_string);
+#define ASSERT_ARGS_find_not_cclass assert(interp); \
+                                    assert(source_string);
+#define ASSERT_ARGS_is_cclass assert(interp); \
+                              assert(source_string);
+#define ASSERT_ARGS_set_graphemes assert(interp); \
+                                  assert(source_string); \
+                                  assert(insert_string);
+#define ASSERT_ARGS_string_from_codepoint assert(interp);
+#define ASSERT_ARGS_titlecase assert(source_string);
+#define ASSERT_ARGS_titlecase_first assert(source_string);
+#define ASSERT_ARGS_to_ascii assert(interp); \
+                             assert(src);
+#define ASSERT_ARGS_to_charset assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_to_unicode assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_upcase assert(source_string);
+#define ASSERT_ARGS_upcase_first assert(source_string);
+#define ASSERT_ARGS_validate assert(interp); \
+                             assert(src);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/charset/ascii.h
==============================================================================
--- trunk/src/charset/ascii.h	(original)
+++ trunk/src/charset/ascii.h	Wed Dec 31 11:19:36 2008
@@ -100,6 +100,29 @@
 const CHARSET * Parrot_charset_ascii_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_ascii_compare assert(interp); \
+                                  assert(lhs); \
+                                  assert(rhs);
+#define ASSERT_ARGS_ascii_compute_hash assert(source_string);
+#define ASSERT_ARGS_ascii_cs_index assert(interp); \
+                                   assert(source_string); \
+                                   assert(search_string);
+#define ASSERT_ARGS_ascii_cs_rindex assert(interp); \
+                                    assert(source_string); \
+                                    assert(search_string);
+#define ASSERT_ARGS_ascii_get_graphemes assert(interp); \
+                                        assert(source_string);
+#define ASSERT_ARGS_ascii_get_graphemes_inplace assert(interp); \
+                                                assert(source_string); \
+                                                assert(dest_string);
+#define ASSERT_ARGS_charset_cvt_ascii_to_binary assert(interp); \
+                                                assert(src);
+#define ASSERT_ARGS_charset_cvt_ascii_to_iso_8859_1 assert(interp); \
+                                                    assert(src);
+#define ASSERT_ARGS_mixed_cs_index assert(interp); \
+                                   assert(src); \
+                                   assert(search);
+#define ASSERT_ARGS_Parrot_charset_ascii_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/charset/ascii.c */
 

Modified: trunk/src/charset/binary.c
==============================================================================
--- trunk/src/charset/binary.c	(original)
+++ trunk/src/charset/binary.c	Wed Dec 31 11:19:36 2008
@@ -106,6 +106,27 @@
         __attribute__nonnull__(1);
 
 static UINTVAL validate(SHIM_INTERP, SHIM(STRING *source_string));
+#define ASSERT_ARGS_compare
+#define ASSERT_ARGS_compose assert(interp);
+#define ASSERT_ARGS_cs_index
+#define ASSERT_ARGS_cs_rindex
+#define ASSERT_ARGS_decompose assert(interp);
+#define ASSERT_ARGS_downcase assert(interp);
+#define ASSERT_ARGS_downcase_first assert(interp);
+#define ASSERT_ARGS_find_cclass
+#define ASSERT_ARGS_find_not_cclass
+#define ASSERT_ARGS_is_cclass
+#define ASSERT_ARGS_set_graphemes assert(interp); \
+                                  assert(source_string); \
+                                  assert(insert_string);
+#define ASSERT_ARGS_string_from_codepoint assert(interp);
+#define ASSERT_ARGS_titlecase assert(interp);
+#define ASSERT_ARGS_titlecase_first assert(interp);
+#define ASSERT_ARGS_to_charset assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_upcase assert(interp);
+#define ASSERT_ARGS_upcase_first assert(interp);
+#define ASSERT_ARGS_validate
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/charset/binary.h
==============================================================================
--- trunk/src/charset/binary.h	(original)
+++ trunk/src/charset/binary.h	Wed Dec 31 11:19:36 2008
@@ -20,6 +20,7 @@
 const CHARSET * Parrot_charset_binary_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_charset_binary_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/charset/binary.c */
 

Modified: trunk/src/charset/iso-8859-1.c
==============================================================================
--- trunk/src/charset/iso-8859-1.c	(original)
+++ trunk/src/charset/iso-8859-1.c	Wed Dec 31 11:19:36 2008
@@ -122,6 +122,39 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_compose assert(interp); \
+                            assert(src);
+#define ASSERT_ARGS_decompose assert(interp);
+#define ASSERT_ARGS_downcase assert(interp); \
+                             assert(source_string);
+#define ASSERT_ARGS_downcase_first assert(interp); \
+                                   assert(source_string);
+#define ASSERT_ARGS_find_cclass assert(interp); \
+                                assert(source_string);
+#define ASSERT_ARGS_find_not_cclass assert(interp); \
+                                    assert(source_string);
+#define ASSERT_ARGS_is_cclass assert(interp); \
+                              assert(source_string);
+#define ASSERT_ARGS_set_graphemes assert(interp); \
+                                  assert(source_string); \
+                                  assert(insert_string);
+#define ASSERT_ARGS_string_from_codepoint assert(interp);
+#define ASSERT_ARGS_titlecase assert(interp); \
+                              assert(source_string);
+#define ASSERT_ARGS_titlecase_first assert(interp); \
+                                    assert(source_string);
+#define ASSERT_ARGS_to_charset assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_to_latin1 assert(interp); \
+                              assert(src);
+#define ASSERT_ARGS_to_unicode assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_upcase assert(interp); \
+                           assert(source_string);
+#define ASSERT_ARGS_upcase_first assert(interp); \
+                                 assert(source_string);
+#define ASSERT_ARGS_validate assert(interp); \
+                             assert(src);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/charset/iso-8859-1.h
==============================================================================
--- trunk/src/charset/iso-8859-1.h	(original)
+++ trunk/src/charset/iso-8859-1.h	Wed Dec 31 11:19:36 2008
@@ -28,6 +28,9 @@
 const CHARSET * Parrot_charset_iso_8859_1_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_charset_cvt_iso_8859_1_to_ascii assert(interp); \
+                                                    assert(src);
+#define ASSERT_ARGS_Parrot_charset_iso_8859_1_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/charset/iso-8859-1.c */
 

Modified: trunk/src/charset/unicode.c
==============================================================================
--- trunk/src/charset/unicode.c	(original)
+++ trunk/src/charset/unicode.c	Wed Dec 31 11:19:36 2008
@@ -145,6 +145,44 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_compare assert(interp); \
+                            assert(lhs); \
+                            assert(rhs);
+#define ASSERT_ARGS_compose assert(interp); \
+                            assert(src);
+#define ASSERT_ARGS_compute_hash assert(interp); \
+                                 assert(src);
+#define ASSERT_ARGS_cs_rindex assert(interp);
+#define ASSERT_ARGS_decompose assert(interp);
+#define ASSERT_ARGS_downcase assert(interp); \
+                             assert(src);
+#define ASSERT_ARGS_downcase_first assert(interp);
+#define ASSERT_ARGS_find_cclass assert(interp); \
+                                assert(source_string);
+#define ASSERT_ARGS_find_not_cclass assert(interp); \
+                                    assert(source_string);
+#define ASSERT_ARGS_get_graphemes assert(interp); \
+                                  assert(source_string);
+#define ASSERT_ARGS_get_graphemes_inplace assert(interp); \
+                                          assert(source_string); \
+                                          assert(dest_string);
+#define ASSERT_ARGS_is_cclass assert(interp); \
+                              assert(source_string);
+#define ASSERT_ARGS_set_graphemes assert(interp); \
+                                  assert(source_string); \
+                                  assert(insert_string);
+#define ASSERT_ARGS_string_from_codepoint assert(interp);
+#define ASSERT_ARGS_titlecase assert(interp); \
+                              assert(src);
+#define ASSERT_ARGS_titlecase_first assert(interp);
+#define ASSERT_ARGS_to_charset assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_u_iscclass assert(interp);
+#define ASSERT_ARGS_upcase assert(interp); \
+                           assert(src);
+#define ASSERT_ARGS_upcase_first assert(interp);
+#define ASSERT_ARGS_validate assert(interp); \
+                             assert(src);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/charset/unicode.h
==============================================================================
--- trunk/src/charset/unicode.h	(original)
+++ trunk/src/charset/unicode.h	Wed Dec 31 11:19:36 2008
@@ -25,6 +25,7 @@
 const CHARSET * Parrot_charset_unicode_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_charset_unicode_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/charset/unicode.c */
 

Modified: trunk/src/cpu_dep.c
==============================================================================
--- trunk/src/cpu_dep.c	(original)
+++ trunk/src/cpu_dep.c	Wed Dec 31 11:19:36 2008
@@ -34,6 +34,7 @@
 static void trace_system_stack(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_trace_system_stack assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/debug.c
==============================================================================
--- trunk/src/debug.c	(original)
+++ trunk/src/debug.c	Wed Dec 31 11:19:36 2008
@@ -173,6 +173,25 @@
 static const char * skip_command(ARGIN(const char *str))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_chop_newline assert(buf);
+#define ASSERT_ARGS_close_script_file assert(interp);
+#define ASSERT_ARGS_debugger_cmdline assert(interp);
+#define ASSERT_ARGS_dump_string assert(interp);
+#define ASSERT_ARGS_GDB_P assert(interp); \
+                          assert(s);
+#define ASSERT_ARGS_GDB_print_reg assert(interp);
+#define ASSERT_ARGS_nextarg
+#define ASSERT_ARGS_parse_command assert(command); \
+                                  assert(cmdP);
+#define ASSERT_ARGS_parse_int assert(str); \
+                              assert(intP);
+#define ASSERT_ARGS_parse_key assert(interp); \
+                              assert(str); \
+                              assert(keyP);
+#define ASSERT_ARGS_parse_string assert(interp); \
+                                 assert(str); \
+                                 assert(strP);
+#define ASSERT_ARGS_skip_command assert(str);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/dynext.c
==============================================================================
--- trunk/src/dynext.c	(original)
+++ trunk/src/dynext.c	Wed Dec 31 11:19:36 2008
@@ -93,6 +93,30 @@
         __attribute__nonnull__(4)
         __attribute__nonnull__(5);
 
+#define ASSERT_ARGS_clone_string_into assert(d); \
+                                      assert(s); \
+                                      assert(value);
+#define ASSERT_ARGS_get_path assert(interp); \
+                             assert(lib); \
+                             assert(handle); \
+                             assert(wo_ext);
+#define ASSERT_ARGS_is_loaded assert(interp); \
+                              assert(path);
+#define ASSERT_ARGS_make_string_pmc assert(interp); \
+                                    assert(string);
+#define ASSERT_ARGS_run_init_lib assert(interp); \
+                                 assert(handle); \
+                                 assert(lib_name); \
+                                 assert(wo_ext);
+#define ASSERT_ARGS_set_cstring_prop assert(interp); \
+                                     assert(lib_pmc); \
+                                     assert(what); \
+                                     assert(name);
+#define ASSERT_ARGS_store_lib_pmc assert(interp); \
+                                  assert(lib_pmc); \
+                                  assert(path); \
+                                  assert(type); \
+                                  assert(lib_name);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/embed.c
==============================================================================
--- trunk/src/embed.c	(original)
+++ trunk/src/embed.c	Wed Dec 31 11:19:36 2008
@@ -53,6 +53,15 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_calibrate assert(interp);
+#define ASSERT_ARGS_op_name assert(interp);
+#define ASSERT_ARGS_print_debug assert(interp);
+#define ASSERT_ARGS_print_profile assert(interp);
+#define ASSERT_ARGS_prof_sort_f assert(a); \
+                                assert(b);
+#define ASSERT_ARGS_set_current_sub assert(interp);
+#define ASSERT_ARGS_setup_argv assert(interp); \
+                               assert(argv);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encoding.c
==============================================================================
--- trunk/src/encoding.c	(original)
+++ trunk/src/encoding.c	Wed Dec 31 11:19:36 2008
@@ -31,6 +31,9 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_register_encoding assert(interp); \
+                                      assert(encodingname); \
+                                      assert(encoding);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encodings/fixed_8.c
==============================================================================
--- trunk/src/encodings/fixed_8.c	(original)
+++ trunk/src/encodings/fixed_8.c	Wed Dec 31 11:19:36 2008
@@ -156,6 +156,42 @@
     SHIM(STRING *dest))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_become_encoding assert(interp);
+#define ASSERT_ARGS_bytes assert(source_string);
+#define ASSERT_ARGS_codepoints assert(interp); \
+                               assert(source_string);
+#define ASSERT_ARGS_fixed8_get_next assert(interp); \
+                                    assert(iter);
+#define ASSERT_ARGS_fixed8_set_next assert(interp); \
+                                    assert(iter);
+#define ASSERT_ARGS_fixed8_set_position assert(iter);
+#define ASSERT_ARGS_get_byte assert(interp); \
+                             assert(source_string);
+#define ASSERT_ARGS_get_bytes assert(interp); \
+                              assert(source_string);
+#define ASSERT_ARGS_get_bytes_inplace assert(interp); \
+                                      assert(source_string); \
+                                      assert(return_string);
+#define ASSERT_ARGS_get_codepoint assert(interp); \
+                                  assert(source_string);
+#define ASSERT_ARGS_get_codepoints assert(interp); \
+                                   assert(source_string);
+#define ASSERT_ARGS_get_codepoints_inplace assert(interp); \
+                                           assert(source_string); \
+                                           assert(dest_string);
+#define ASSERT_ARGS_iter_init assert(src); \
+                              assert(iter);
+#define ASSERT_ARGS_set_byte assert(interp); \
+                             assert(source_string);
+#define ASSERT_ARGS_set_bytes assert(interp); \
+                              assert(source_string); \
+                              assert(new_bytes);
+#define ASSERT_ARGS_set_codepoint assert(interp); \
+                                  assert(source_string);
+#define ASSERT_ARGS_set_codepoints assert(interp); \
+                                   assert(source_string); \
+                                   assert(new_codepoints);
+#define ASSERT_ARGS_to_encoding assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encodings/fixed_8.h
==============================================================================
--- trunk/src/encodings/fixed_8.h	(original)
+++ trunk/src/encodings/fixed_8.h	Wed Dec 31 11:19:36 2008
@@ -20,6 +20,7 @@
 ENCODING * Parrot_encoding_fixed_8_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_encoding_fixed_8_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/encodings/fixed_8.c */
 

Modified: trunk/src/encodings/ucs2.c
==============================================================================
--- trunk/src/encodings/ucs2.c	(original)
+++ trunk/src/encodings/ucs2.c	Wed Dec 31 11:19:36 2008
@@ -149,6 +149,35 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*i);
 
+#define ASSERT_ARGS_become_encoding assert(interp);
+#define ASSERT_ARGS_bytes assert(interp); \
+                          assert(src);
+#define ASSERT_ARGS_codepoints assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_get_byte assert(interp);
+#define ASSERT_ARGS_get_bytes assert(interp);
+#define ASSERT_ARGS_get_bytes_inplace assert(interp);
+#define ASSERT_ARGS_get_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_get_codepoints assert(interp); \
+                                   assert(src);
+#define ASSERT_ARGS_get_codepoints_inplace assert(interp);
+#define ASSERT_ARGS_iter_init assert(interp); \
+                              assert(src); \
+                              assert(iter);
+#define ASSERT_ARGS_set_byte assert(interp);
+#define ASSERT_ARGS_set_bytes assert(interp);
+#define ASSERT_ARGS_set_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_set_codepoints assert(interp);
+#define ASSERT_ARGS_to_encoding assert(interp); \
+                                assert(src); \
+                                assert(dest);
+#define ASSERT_ARGS_ucs2_decode_and_advance assert(interp); \
+                                            assert(i);
+#define ASSERT_ARGS_ucs2_encode_and_advance assert(interp); \
+                                            assert(i);
+#define ASSERT_ARGS_ucs2_set_position assert(i);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encodings/ucs2.h
==============================================================================
--- trunk/src/encodings/ucs2.h	(original)
+++ trunk/src/encodings/ucs2.h	Wed Dec 31 11:19:36 2008
@@ -20,6 +20,7 @@
 ENCODING * Parrot_encoding_ucs2_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_encoding_ucs2_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/encodings/ucs2.c */
 

Modified: trunk/src/encodings/utf16.c
==============================================================================
--- trunk/src/encodings/utf16.c	(original)
+++ trunk/src/encodings/utf16.c	Wed Dec 31 11:19:36 2008
@@ -157,6 +157,42 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*i);
 
+#define ASSERT_ARGS_become_encoding assert(interp);
+#define ASSERT_ARGS_bytes assert(src);
+#define ASSERT_ARGS_codepoints assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_get_byte assert(src);
+#define ASSERT_ARGS_get_bytes assert(interp); \
+                              assert(src);
+#define ASSERT_ARGS_get_bytes_inplace assert(interp); \
+                                      assert(src); \
+                                      assert(return_string);
+#define ASSERT_ARGS_get_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_get_codepoints assert(interp); \
+                                   assert(src);
+#define ASSERT_ARGS_get_codepoints_inplace assert(interp); \
+                                           assert(src); \
+                                           assert(return_string);
+#define ASSERT_ARGS_iter_init assert(interp); \
+                              assert(src); \
+                              assert(iter);
+#define ASSERT_ARGS_set_byte assert(interp); \
+                             assert(src);
+#define ASSERT_ARGS_set_bytes assert(interp);
+#define ASSERT_ARGS_set_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_set_codepoints assert(interp); \
+                                   assert(src); \
+                                   assert(new_codepoints);
+#define ASSERT_ARGS_to_encoding assert(interp); \
+                                assert(src);
+#define ASSERT_ARGS_utf16_decode_and_advance assert(interp); \
+                                             assert(i);
+#define ASSERT_ARGS_utf16_encode_and_advance assert(interp); \
+                                             assert(i);
+#define ASSERT_ARGS_utf16_set_position assert(interp); \
+                                       assert(i);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encodings/utf16.h
==============================================================================
--- trunk/src/encodings/utf16.h	(original)
+++ trunk/src/encodings/utf16.h	Wed Dec 31 11:19:36 2008
@@ -20,6 +20,7 @@
 ENCODING * Parrot_encoding_utf16_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_encoding_utf16_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/encodings/utf16.c */
 

Modified: trunk/src/encodings/utf8.c
==============================================================================
--- trunk/src/encodings/utf8.c	(original)
+++ trunk/src/encodings/utf8.c	Wed Dec 31 11:19:36 2008
@@ -173,6 +173,44 @@
 static const void * utf8_skip_forward(ARGIN(const void *ptr), UINTVAL n)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_become_encoding assert(interp);
+#define ASSERT_ARGS_bytes assert(src);
+#define ASSERT_ARGS_codepoints assert(interp); \
+                               assert(src);
+#define ASSERT_ARGS_get_byte assert(src);
+#define ASSERT_ARGS_get_bytes assert(interp); \
+                              assert(src);
+#define ASSERT_ARGS_get_bytes_inplace assert(interp);
+#define ASSERT_ARGS_get_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_get_codepoints assert(interp); \
+                                   assert(src);
+#define ASSERT_ARGS_get_codepoints_inplace assert(interp); \
+                                           assert(src); \
+                                           assert(return_string);
+#define ASSERT_ARGS_iter_init assert(src); \
+                              assert(iter);
+#define ASSERT_ARGS_set_byte assert(interp); \
+                             assert(src);
+#define ASSERT_ARGS_set_bytes assert(interp);
+#define ASSERT_ARGS_set_codepoint assert(interp); \
+                                  assert(src);
+#define ASSERT_ARGS_set_codepoints assert(interp);
+#define ASSERT_ARGS_to_encoding assert(interp); \
+                                assert(src);
+#define ASSERT_ARGS_utf8_characters assert(interp); \
+                                    assert(ptr);
+#define ASSERT_ARGS_utf8_decode assert(interp); \
+                                assert(ptr);
+#define ASSERT_ARGS_utf8_decode_and_advance assert(interp); \
+                                            assert(i);
+#define ASSERT_ARGS_utf8_encode assert(interp); \
+                                assert(ptr);
+#define ASSERT_ARGS_utf8_encode_and_advance assert(interp); \
+                                            assert(i);
+#define ASSERT_ARGS_utf8_set_position assert(i);
+#define ASSERT_ARGS_utf8_skip_backward assert(ptr);
+#define ASSERT_ARGS_utf8_skip_forward assert(ptr);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/encodings/utf8.h
==============================================================================
--- trunk/src/encodings/utf8.h	(original)
+++ trunk/src/encodings/utf8.h	Wed Dec 31 11:19:36 2008
@@ -20,6 +20,7 @@
 ENCODING * Parrot_encoding_utf8_init(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_encoding_utf8_init assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/encodings/utf8.c */
 

Modified: trunk/src/events.c
==============================================================================
--- trunk/src/events.c	(original)
+++ trunk/src/events.c	Wed Dec 31 11:19:36 2008
@@ -103,6 +103,26 @@
     ARGIN_NULLOK(opcode_t *next))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_do_event assert(interp); \
+                             assert(event);
+#define ASSERT_ARGS_dup_entry assert(entry);
+#define ASSERT_ARGS_dup_entry_interval assert(entry);
+#define ASSERT_ARGS_event_thread assert(data);
+#define ASSERT_ARGS_event_to_exception assert(interp); \
+                                       assert(event);
+#define ASSERT_ARGS_init_events_all assert(interp);
+#define ASSERT_ARGS_init_events_first assert(interp);
+#define ASSERT_ARGS_io_thread
+#define ASSERT_ARGS_io_thread_ready_rd assert(ios);
+#define ASSERT_ARGS_Parrot_sigaction assert(handler);
+#define ASSERT_ARGS_Parrot_unblock_signal
+#define ASSERT_ARGS_process_events assert(event_q);
+#define ASSERT_ARGS_schedule_signal_event
+#define ASSERT_ARGS_sig_handler
+#define ASSERT_ARGS_stop_io_thread
+#define ASSERT_ARGS_store_io_event assert(ios); \
+                                   assert(ev);
+#define ASSERT_ARGS_wait_for_wakeup assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/exceptions.c
==============================================================================
--- trunk/src/exceptions.c	(original)
+++ trunk/src/exceptions.c	Wed Dec 31 11:19:36 2008
@@ -51,6 +51,12 @@
         __attribute__nonnull__(3)
         __attribute__nonnull__(4);
 
+#define ASSERT_ARGS_build_exception_from_args assert(interp); \
+                                              assert(format);
+#define ASSERT_ARGS_pass_exception_args assert(interp); \
+                                        assert(sig); \
+                                        assert(dest); \
+                                        assert(old_ctx);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/dod.c
==============================================================================
--- trunk/src/gc/dod.c	(original)
+++ trunk/src/gc/dod.c	Wed Dec 31 11:19:36 2008
@@ -59,6 +59,14 @@
 static int trace_active_PMCs(PARROT_INTERP, int trace_stack)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_clear_live_bits assert(pool);
+#define ASSERT_ARGS_find_common_mask assert(interp);
+#define ASSERT_ARGS_mark_special assert(interp); \
+                                 assert(obj);
+#define ASSERT_ARGS_sweep_cb assert(interp); \
+                             assert(pool); \
+                             assert(arg);
+#define ASSERT_ARGS_trace_active_PMCs assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/gc_gms.c
==============================================================================
--- trunk/src/gc/gc_gms.c	(original)
+++ trunk/src/gc/gc_gms.c	Wed Dec 31 11:19:36 2008
@@ -329,6 +329,71 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_end_cycle_cb assert(interp); \
+                                 assert(pool);
+#define ASSERT_ARGS_gc_gms_add_free_object assert(interp);
+#define ASSERT_ARGS_gc_gms_alloc_objects assert(interp); \
+                                         assert(pool);
+#define ASSERT_ARGS_gc_gms_chain_objects assert(interp); \
+                                         assert(pool); \
+                                         assert(new_arena);
+#define ASSERT_ARGS_gc_gms_clear_hdr_list assert(interp); \
+                                          assert(l);
+#define ASSERT_ARGS_gc_gms_clear_igp assert(interp); \
+                                     assert(gen);
+#define ASSERT_ARGS_gc_gms_create_gen assert(interp); \
+                                      assert(pool);
+#define ASSERT_ARGS_gc_gms_end_cycle assert(interp);
+#define ASSERT_ARGS_gc_gms_find_gen assert(interp); \
+                                    assert(h);
+#define ASSERT_ARGS_gc_gms_get_free_object assert(interp); \
+                                           assert(pool);
+#define ASSERT_ARGS_gc_gms_init_gen assert(interp); \
+                                    assert(pool);
+#define ASSERT_ARGS_gc_gms_init_mark assert(interp);
+#define ASSERT_ARGS_gc_gms_merge_gen assert(interp); \
+                                     assert(pool);
+#define ASSERT_ARGS_gc_gms_more_objects assert(interp); \
+                                        assert(pool);
+#define ASSERT_ARGS_gc_gms_pool_init assert(interp); \
+                                     assert(pool);
+#define ASSERT_ARGS_gc_gms_promote assert(interp); \
+                                   assert(h);
+#define ASSERT_ARGS_gc_gms_set_gen assert(interp);
+#define ASSERT_ARGS_gc_gms_setto_black assert(interp); \
+                                       assert(h);
+#define ASSERT_ARGS_gc_gms_setto_gray assert(interp); \
+                                      assert(h);
+#define ASSERT_ARGS_gc_gms_store_hdr_list assert(interp); \
+                                          assert(l); \
+                                          assert(h);
+#define ASSERT_ARGS_gc_gms_store_igp assert(interp); \
+                                     assert(h);
+#define ASSERT_ARGS_gc_gms_sweep assert(interp);
+#define ASSERT_ARGS_gc_gms_trace_children assert(interp);
+#define ASSERT_ARGS_gc_gms_trace_root assert(interp);
+#define ASSERT_ARGS_gc_gms_use_gen assert(interp); \
+                                   assert(pool); \
+                                   assert(plan);
+#define ASSERT_ARGS_gms_debug_verify assert(interp); \
+                                     assert(pool); \
+                                     assert(action);
+#define ASSERT_ARGS_init_mark_cb assert(interp); \
+                                 assert(pool); \
+                                 assert(arg);
+#define ASSERT_ARGS_parrot_gc_gms_deinit assert(interp);
+#define ASSERT_ARGS_parrot_gc_gms_run assert(interp);
+#define ASSERT_ARGS_set_gen_cb assert(interp); \
+                               assert(pool); \
+                               assert(arg);
+#define ASSERT_ARGS_sweep_cb_buf assert(interp); \
+                                 assert(pool);
+#define ASSERT_ARGS_sweep_cb_pmc assert(interp); \
+                                 assert(pool);
+#define ASSERT_ARGS_trace_children_cb assert(interp); \
+                                      assert(pool);
+#define ASSERT_ARGS_trace_igp_cb assert(interp); \
+                                 assert(pool);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/gc_ims.c
==============================================================================
--- trunk/src/gc/gc_ims.c	(original)
+++ trunk/src/gc/gc_ims.c	Wed Dec 31 11:19:36 2008
@@ -407,6 +407,27 @@
         __attribute__nonnull__(4)
         FUNC_MODIFIES(*pool);
 
+#define ASSERT_ARGS_collect_cb assert(interp); \
+                               assert(pool); \
+                               assert(arg);
+#define ASSERT_ARGS_gc_ims_add_free_object assert(interp); \
+                                           assert(pool); \
+                                           assert(to_add);
+#define ASSERT_ARGS_gc_ims_alloc_objects assert(interp); \
+                                         assert(pool);
+#define ASSERT_ARGS_gc_ims_get_free_object assert(interp); \
+                                           assert(pool);
+#define ASSERT_ARGS_gc_ims_pool_init assert(pool);
+#define ASSERT_ARGS_parrot_gc_ims_collect assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_deinit assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_mark assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_reinit assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_run assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_run_increment assert(interp);
+#define ASSERT_ARGS_parrot_gc_ims_sweep assert(interp);
+#define ASSERT_ARGS_sweep_cb assert(interp); \
+                             assert(pool); \
+                             assert(arg);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/register.c
==============================================================================
--- trunk/src/gc/register.c	(original)
+++ trunk/src/gc/register.c	Wed Dec 31 11:19:36 2008
@@ -48,6 +48,10 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*ctx);
 
+#define ASSERT_ARGS_clear_regs assert(interp); \
+                               assert(ctx);
+#define ASSERT_ARGS_init_context assert(interp); \
+                                 assert(ctx);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/resources.c
==============================================================================
--- trunk/src/gc/resources.c	(original)
+++ trunk/src/gc/resources.c	Wed Dec 31 11:19:36 2008
@@ -97,6 +97,24 @@
     size_t min_block,
     NULLOK(compact_f compact));
 
+#define ASSERT_ARGS_aligned_mem assert(buffer); \
+                                assert(mem);
+#define ASSERT_ARGS_aligned_size assert(buffer);
+#define ASSERT_ARGS_aligned_string_size
+#define ASSERT_ARGS_alloc_new_block assert(interp); \
+                                    assert(pool); \
+                                    assert(why);
+#define ASSERT_ARGS_buffer_location assert(interp); \
+                                    assert(b);
+#define ASSERT_ARGS_compact_pool assert(interp); \
+                                 assert(pool);
+#define ASSERT_ARGS_debug_print_buf assert(interp); \
+                                    assert(b);
+#define ASSERT_ARGS_mem_allocate assert(interp); \
+                                 assert(pool);
+#define ASSERT_ARGS_merge_pools assert(dest); \
+                                assert(source);
+#define ASSERT_ARGS_new_memory_pool
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/gc/smallobject.c
==============================================================================
--- trunk/src/gc/smallobject.c	(original)
+++ trunk/src/gc/smallobject.c	Wed Dec 31 11:19:36 2008
@@ -72,6 +72,19 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*pool);
 
+#define ASSERT_ARGS_gc_ms_add_free_object assert(pool); \
+                                          assert(to_add);
+#define ASSERT_ARGS_gc_ms_add_free_pmc_ext assert(pool); \
+                                           assert(to_add);
+#define ASSERT_ARGS_gc_ms_alloc_objects assert(interp); \
+                                        assert(pool);
+#define ASSERT_ARGS_gc_ms_get_free_object assert(interp); \
+                                          assert(pool);
+#define ASSERT_ARGS_gc_ms_get_free_pmc_ext assert(interp); \
+                                           assert(pool);
+#define ASSERT_ARGS_gc_ms_pool_init assert(pool);
+#define ASSERT_ARGS_more_traceable_objects assert(interp); \
+                                           assert(pool);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/global.c
==============================================================================
--- trunk/src/global.c	(original)
+++ trunk/src/global.c	Wed Dec 31 11:19:36 2008
@@ -76,6 +76,23 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_get_namespace_pmc assert(interp); \
+                                      assert(sub);
+#define ASSERT_ARGS_internal_ns_keyed assert(interp); \
+                                      assert(base_ns); \
+                                      assert(pmc_key);
+#define ASSERT_ARGS_internal_ns_keyed_key assert(interp); \
+                                          assert(ns); \
+                                          assert(key);
+#define ASSERT_ARGS_internal_ns_keyed_str assert(interp); \
+                                          assert(base_ns); \
+                                          assert(key);
+#define ASSERT_ARGS_internal_ns_maybe_create assert(interp); \
+                                             assert(ns); \
+                                             assert(key);
+#define ASSERT_ARGS_store_sub_in_multi assert(interp); \
+                                       assert(sub); \
+                                       assert(ns);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/global_setup.c
==============================================================================
--- trunk/src/global_setup.c	(original)
+++ trunk/src/global_setup.c	Wed Dec 31 11:19:36 2008
@@ -41,6 +41,7 @@
 static void parrot_set_config_hash_interpreter(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_parrot_set_config_hash_interpreter assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/hash.c
==============================================================================
--- trunk/src/hash.c	(original)
+++ trunk/src/hash.c	Wed Dec 31 11:19:36 2008
@@ -125,6 +125,32 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_create_hash assert(interp); \
+                                assert(compare); \
+                                assert(keyhash);
+#define ASSERT_ARGS_cstring_compare assert(a); \
+                                    assert(b);
+#define ASSERT_ARGS_expand_hash assert(interp); \
+                                assert(hash);
+#define ASSERT_ARGS_hash_freeze assert(interp); \
+                                assert(hash); \
+                                assert(info);
+#define ASSERT_ARGS_hash_thaw assert(interp); \
+                              assert(hash); \
+                              assert(info);
+#define ASSERT_ARGS_key_hash_cstring assert(value);
+#define ASSERT_ARGS_key_hash_pointer assert(value);
+#define ASSERT_ARGS_key_hash_STRING assert(interp); \
+                                    assert(s);
+#define ASSERT_ARGS_parrot_mark_hash_both assert(interp); \
+                                          assert(hash);
+#define ASSERT_ARGS_parrot_mark_hash_keys assert(interp); \
+                                          assert(hash);
+#define ASSERT_ARGS_parrot_mark_hash_values assert(interp); \
+                                            assert(hash);
+#define ASSERT_ARGS_pointer_compare
+#define ASSERT_ARGS_STRING_compare assert(interp); \
+                                   assert(search_key);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/headers.c
==============================================================================
--- trunk/src/headers.c	(original)
+++ trunk/src/headers.c	Wed Dec 31 11:19:36 2008
@@ -61,6 +61,17 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*pool);
 
+#define ASSERT_ARGS_fix_pmc_syncs assert(dest_interp); \
+                                  assert(pool);
+#define ASSERT_ARGS_free_pool assert(pool);
+#define ASSERT_ARGS_get_free_buffer assert(interp); \
+                                    assert(pool);
+#define ASSERT_ARGS_new_pmc_ext assert(interp);
+#define ASSERT_ARGS_sweep_cb_buf assert(interp); \
+                                 assert(pool); \
+                                 assert(arg);
+#define ASSERT_ARGS_sweep_cb_pmc assert(interp); \
+                                 assert(pool);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/hll.c
==============================================================================
--- trunk/src/hll.c	(original)
+++ trunk/src/hll.c	Wed Dec 31 11:19:36 2008
@@ -43,6 +43,7 @@
 static PMC* new_hll_entry(PARROT_INTERP, ARGIN_NULLOK(STRING *entry_name))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_new_hll_entry assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/inter_call.c
==============================================================================
--- trunk/src/inter_call.c	(original)
+++ trunk/src/inter_call.c	Wed Dec 31 11:19:36 2008
@@ -230,6 +230,77 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_check_for_opt_flag assert(st);
+#define ASSERT_ARGS_check_named assert(interp); \
+                                assert(st);
+#define ASSERT_ARGS_clone_key_arg assert(interp); \
+                                  assert(st);
+#define ASSERT_ARGS_commit_last_arg assert(interp); \
+                                    assert(n_regs_used); \
+                                    assert(sigs); \
+                                    assert(indexes); \
+                                    assert(ctx); \
+                                    assert(list);
+#define ASSERT_ARGS_commit_last_arg_sig_object assert(interp); \
+                                               assert(n_regs_used); \
+                                               assert(sigs); \
+                                               assert(indexes); \
+                                               assert(ctx); \
+                                               assert(sig_obj);
+#define ASSERT_ARGS_convert_arg_from_int assert(interp); \
+                                         assert(st);
+#define ASSERT_ARGS_convert_arg_from_num assert(interp); \
+                                         assert(st);
+#define ASSERT_ARGS_convert_arg_from_pmc assert(interp); \
+                                         assert(st);
+#define ASSERT_ARGS_convert_arg_from_str assert(interp); \
+                                         assert(st);
+#define ASSERT_ARGS_count_signature_elements assert(interp); \
+                                             assert(signature); \
+                                             assert(args_sig); \
+                                             assert(results_sig);
+#define ASSERT_ARGS_fetch_arg_op assert(interp); \
+                                 assert(st);
+#define ASSERT_ARGS_fetch_arg_sig assert(interp); \
+                                  assert(st);
+#define ASSERT_ARGS_init_call_stats assert(st);
+#define ASSERT_ARGS_init_first_dest_named assert(interp); \
+                                          assert(st);
+#define ASSERT_ARGS_locate_named_named assert(interp); \
+                                       assert(st);
+#define ASSERT_ARGS_next_arg_sig assert(sti);
+#define ASSERT_ARGS_null_val assert(st);
+#define ASSERT_ARGS_set_context_sig_params assert(interp); \
+                                           assert(signature); \
+                                           assert(n_regs_used); \
+                                           assert(sigs); \
+                                           assert(indexes); \
+                                           assert(ctx); \
+                                           assert(sig_obj);
+#define ASSERT_ARGS_set_context_sig_returns assert(interp); \
+                                            assert(ctx); \
+                                            assert(indexes); \
+                                            assert(ret_x); \
+                                            assert(result_list);
+#define ASSERT_ARGS_set_context_sig_returns_varargs assert(interp); \
+                                                    assert(ctx); \
+                                                    assert(indexes); \
+                                                    assert(ret_x); \
+                                                    assert(returns);
+#define ASSERT_ARGS_set_retval_util assert(interp); \
+                                    assert(sig); \
+                                    assert(ctx); \
+                                    assert(st);
+#define ASSERT_ARGS_start_flatten assert(interp); \
+                                  assert(st); \
+                                  assert(p_arg);
+#define ASSERT_ARGS_store_arg assert(st);
+#define ASSERT_ARGS_too_few assert(interp); \
+                            assert(st); \
+                            assert(action);
+#define ASSERT_ARGS_too_many assert(interp); \
+                             assert(st); \
+                             assert(action);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/inter_cb.c
==============================================================================
--- trunk/src/inter_cb.c	(original)
+++ trunk/src/inter_cb.c	Wed Dec 31 11:19:36 2008
@@ -46,6 +46,11 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*user_data);
 
+#define ASSERT_ARGS_callback_CD assert(interp); \
+                                assert(external_data); \
+                                assert(user_data);
+#define ASSERT_ARGS_verify_CD assert(external_data); \
+                              assert(user_data);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/inter_create.c
==============================================================================
--- trunk/src/inter_create.c	(original)
+++ trunk/src/inter_create.c	Wed Dec 31 11:19:36 2008
@@ -36,6 +36,8 @@
 static void setup_default_compreg(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_is_env_var_set assert(var);
+#define ASSERT_ARGS_setup_default_compreg assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/inter_run.c
==============================================================================
--- trunk/src/inter_run.c	(original)
+++ trunk/src/inter_run.c	Wed Dec 31 11:19:36 2008
@@ -39,6 +39,9 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(5);
 
+#define ASSERT_ARGS_runops_args assert(interp); \
+                                assert(sub); \
+                                assert(sig);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/interpreter.c
==============================================================================
--- trunk/src/interpreter.c	(original)
+++ trunk/src/interpreter.c	Wed Dec 31 11:19:36 2008
@@ -126,6 +126,28 @@
 static void turn_ev_check(PARROT_INTERP, int on)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_dynop_register_switch
+#define ASSERT_ARGS_dynop_register_xx assert(interp);
+#define ASSERT_ARGS_get_core_op_lib_init assert(interp);
+#define ASSERT_ARGS_get_dynamic_op_lib_init assert(lib);
+#define ASSERT_ARGS_init_prederef assert(interp);
+#define ASSERT_ARGS_load_prederef assert(interp);
+#define ASSERT_ARGS_notify_func_table assert(interp); \
+                                      assert(table);
+#define ASSERT_ARGS_prederef_args assert(pc_prederef); \
+                                  assert(interp); \
+                                  assert(pc); \
+                                  assert(opinfo);
+#define ASSERT_ARGS_runops_cgp assert(interp); \
+                               assert(pc);
+#define ASSERT_ARGS_runops_exec assert(interp); \
+                                assert(pc);
+#define ASSERT_ARGS_runops_jit assert(interp); \
+                               assert(pc);
+#define ASSERT_ARGS_runops_switch assert(interp); \
+                                  assert(pc);
+#define ASSERT_ARGS_stop_prederef assert(interp);
+#define ASSERT_ARGS_turn_ev_check assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/io/buffer.c
==============================================================================
--- trunk/src/io/buffer.c	(original)
+++ trunk/src/io/buffer.c	Wed Dec 31 11:19:36 2008
@@ -28,6 +28,7 @@
 static INTVAL io_is_end_of_line(ARGIN(const char *c))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_io_is_end_of_line assert(c);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/io/portable.c
==============================================================================
--- trunk/src/io/portable.c	(original)
+++ trunk/src/io/portable.c	Wed Dec 31 11:19:36 2008
@@ -37,6 +37,8 @@
 static const char * convert_flags_to_stdio(INTVAL flags);
 
 static INTVAL io_is_tty_portable(PIOHANDLE fptr);
+#define ASSERT_ARGS_convert_flags_to_stdio
+#define ASSERT_ARGS_io_is_tty_portable
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/io/unix.c
==============================================================================
--- trunk/src/io/unix.c	(original)
+++ trunk/src/io/unix.c	Wed Dec 31 11:19:36 2008
@@ -42,6 +42,8 @@
 static INTVAL convert_flags_to_unix(INTVAL flags);
 
 static INTVAL io_is_tty_unix(PIOHANDLE fd);
+#define ASSERT_ARGS_convert_flags_to_unix
+#define ASSERT_ARGS_io_is_tty_unix
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/io/win32.c
==============================================================================
--- trunk/src/io/win32.c	(original)
+++ trunk/src/io/win32.c	Wed Dec 31 11:19:36 2008
@@ -50,6 +50,10 @@
 PARROT_WARN_UNUSED_RESULT
 static INTVAL io_is_tty_win32(PIOHANDLE fd);
 
+#define ASSERT_ARGS_convert_flags_to_win32 assert(fdwAccess); \
+                                           assert(fdwShareMode); \
+                                           assert(fdwCreate);
+#define ASSERT_ARGS_io_is_tty_win32
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/library.c
==============================================================================
--- trunk/src/library.c	(original)
+++ trunk/src/library.c	Wed Dec 31 11:19:36 2008
@@ -91,6 +91,23 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(* path);
 
+#define ASSERT_ARGS_cnv_to_win32_filesep assert(path);
+#define ASSERT_ARGS_get_search_paths assert(interp);
+#define ASSERT_ARGS_is_abs_path assert(file);
+#define ASSERT_ARGS_path_append assert(interp); \
+                                assert(l_path); \
+                                assert(r_path);
+#define ASSERT_ARGS_path_concat assert(interp); \
+                                assert(l_path); \
+                                assert(r_path);
+#define ASSERT_ARGS_path_finalize assert(interp); \
+                                  assert(path);
+#define ASSERT_ARGS_path_guarantee_trailing_separator assert(interp); \
+                                                      assert(path);
+#define ASSERT_ARGS_try_bytecode_extensions assert(interp); \
+                                            assert(path);
+#define ASSERT_ARGS_try_load_path assert(interp); \
+                                  assert(path);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/list.c
==============================================================================
--- trunk/src/list.c	(original)
+++ trunk/src/list.c	Wed Dec 31 11:19:36 2008
@@ -290,6 +290,32 @@
         FUNC_MODIFIES(*list)
         FUNC_MODIFIES(*chunk);
 
+#define ASSERT_ARGS_add_chunk assert(interp); \
+                              assert(list);
+#define ASSERT_ARGS_alloc_next_size assert(interp); \
+                                    assert(list);
+#define ASSERT_ARGS_allocate_chunk assert(interp); \
+                                   assert(list);
+#define ASSERT_ARGS_get_chunk assert(interp); \
+                              assert(list); \
+                              assert(idx);
+#define ASSERT_ARGS_list_append assert(interp); \
+                                assert(list);
+#define ASSERT_ARGS_list_item assert(interp); \
+                              assert(list);
+#define ASSERT_ARGS_list_set assert(interp); \
+                             assert(list); \
+                             assert(item);
+#define ASSERT_ARGS_rebuild_chunk_list assert(interp); \
+                                       assert(list);
+#define ASSERT_ARGS_rebuild_chunk_ptrs assert(list);
+#define ASSERT_ARGS_rebuild_fix_ends assert(list);
+#define ASSERT_ARGS_rebuild_other assert(interp); \
+                                  assert(list);
+#define ASSERT_ARGS_rebuild_sparse assert(list);
+#define ASSERT_ARGS_split_chunk assert(interp); \
+                                assert(list); \
+                                assert(chunk);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/longopt.c
==============================================================================
--- trunk/src/longopt.c	(original)
+++ trunk/src/longopt.c	Wed Dec 31 11:19:36 2008
@@ -48,6 +48,14 @@
         __attribute__nonnull__(5)
         FUNC_MODIFIES(* info_buf);
 
+#define ASSERT_ARGS_longopt_get_longopt assert(interp); \
+                                        assert(argv[]); \
+                                        assert(options[]); \
+                                        assert(info_buf);
+#define ASSERT_ARGS_longopt_get_shortopt assert(interp); \
+                                         assert(argv[]); \
+                                         assert(options[]); \
+                                         assert(info_buf);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/multidispatch.c
==============================================================================
--- trunk/src/multidispatch.c	(original)
+++ trunk/src/multidispatch.c	Wed Dec 31 11:19:36 2008
@@ -175,6 +175,54 @@
         __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_distance_cmp
+#define ASSERT_ARGS_mmd_add_multi_global assert(interp); \
+                                         assert(sub_name); \
+                                         assert(sub_obj);
+#define ASSERT_ARGS_mmd_add_multi_to_namespace assert(interp); \
+                                               assert(ns_name); \
+                                               assert(sub_name); \
+                                               assert(sub_obj);
+#define ASSERT_ARGS_mmd_build_type_tuple_from_long_sig assert(interp); \
+                                                       assert(long_sig);
+#define ASSERT_ARGS_mmd_build_type_tuple_from_type_list assert(interp); \
+                                                        assert(type_list);
+#define ASSERT_ARGS_mmd_cache_key_from_types assert(interp); \
+                                             assert(name); \
+                                             assert(types);
+#define ASSERT_ARGS_mmd_cache_key_from_values assert(interp); \
+                                              assert(name); \
+                                              assert(values);
+#define ASSERT_ARGS_mmd_cvt_to_types assert(interp); \
+                                     assert(multi_sig);
+#define ASSERT_ARGS_mmd_distance assert(interp); \
+                                 assert(pmc); \
+                                 assert(arg_tuple);
+#define ASSERT_ARGS_mmd_search_by_sig_obj assert(interp); \
+                                          assert(name); \
+                                          assert(sig_obj); \
+                                          assert(candidates);
+#define ASSERT_ARGS_mmd_search_global assert(interp); \
+                                      assert(name); \
+                                      assert(cl);
+#define ASSERT_ARGS_mmd_search_local assert(interp); \
+                                     assert(name); \
+                                     assert(candidates);
+#define ASSERT_ARGS_Parrot_mmd_arg_tuple_func assert(interp);
+#define ASSERT_ARGS_Parrot_mmd_get_cached_multi_sig assert(interp); \
+                                                    assert(sub);
+#define ASSERT_ARGS_Parrot_mmd_maybe_candidate assert(interp); \
+                                               assert(pmc); \
+                                               assert(cl);
+#define ASSERT_ARGS_Parrot_mmd_search_classes assert(interp); \
+                                              assert(meth); \
+                                              assert(arg_tuple); \
+                                              assert(cl);
+#define ASSERT_ARGS_Parrot_mmd_search_scopes assert(interp); \
+                                             assert(meth);
+#define ASSERT_ARGS_Parrot_mmd_sort_candidates assert(interp); \
+                                               assert(arg_tuple); \
+                                               assert(cl);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/oo.c
==============================================================================
--- trunk/src/oo.c	(original)
+++ trunk/src/oo.c	Wed Dec 31 11:19:36 2008
@@ -64,6 +64,18 @@
 static void invalidate_type_caches(PARROT_INTERP, UINTVAL type)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_C3_merge assert(interp); \
+                             assert(merge_list);
+#define ASSERT_ARGS_debug_trace_find_meth assert(interp); \
+                                          assert(_class); \
+                                          assert(name);
+#define ASSERT_ARGS_fail_if_type_exists assert(interp); \
+                                        assert(name);
+#define ASSERT_ARGS_find_method_direct_1 assert(interp); \
+                                         assert(_class); \
+                                         assert(method_name);
+#define ASSERT_ARGS_invalidate_all_caches assert(interp);
+#define ASSERT_ARGS_invalidate_type_caches assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 
@@ -483,7 +495,7 @@
 
 /*
 
-=item C<static void fail_if_type_exists>
+=item C<static INTVAL fail_if_type_exists>
 
 This function throws an exception if a PMC or class with the same name *
 already exists in the global type registry. The global type registry

Modified: trunk/src/packdump.c
==============================================================================
--- trunk/src/packdump.c	(original)
+++ trunk/src/packdump.c	Wed Dec 31 11:19:36 2008
@@ -38,6 +38,10 @@
 static void pobj_flag_dump(PARROT_INTERP, ARGIN_NULLOK(long flags))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_PackFile_Constant_dump assert(interp); \
+                                           assert(ct); \
+                                           assert(self);
+#define ASSERT_ARGS_pobj_flag_dump assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/packfile.c
==============================================================================
--- trunk/src/packfile.c	(original)
+++ trunk/src/packfile.c	Wed Dec 31 11:19:36 2008
@@ -317,6 +317,85 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_byte_code_destroy assert(self);
+#define ASSERT_ARGS_byte_code_new
+#define ASSERT_ARGS_clone_constant assert(interp); \
+                                   assert(old_const);
+#define ASSERT_ARGS_const_destroy assert(interp); \
+                                  assert(self);
+#define ASSERT_ARGS_const_new
+#define ASSERT_ARGS_create_seg assert(interp); \
+                               assert(dir); \
+                               assert(name); \
+                               assert(file_name);
+#define ASSERT_ARGS_default_destroy assert(self);
+#define ASSERT_ARGS_default_dump assert(interp); \
+                                 assert(self);
+#define ASSERT_ARGS_default_pack assert(self); \
+                                 assert(dest);
+#define ASSERT_ARGS_default_packed_size assert(self);
+#define ASSERT_ARGS_default_unpack assert(self); \
+                                   assert(cursor);
+#define ASSERT_ARGS_directory_destroy assert(interp); \
+                                      assert(self);
+#define ASSERT_ARGS_directory_dump assert(interp); \
+                                   assert(self);
+#define ASSERT_ARGS_directory_new
+#define ASSERT_ARGS_directory_pack assert(interp); \
+                                   assert(self); \
+                                   assert(cursor);
+#define ASSERT_ARGS_directory_packed_size assert(interp); \
+                                          assert(self);
+#define ASSERT_ARGS_directory_unpack assert(interp); \
+                                     assert(segp); \
+                                     assert(cursor);
+#define ASSERT_ARGS_do_1_sub_pragma assert(interp); \
+                                    assert(sub_pmc);
+#define ASSERT_ARGS_find_const_iter assert(interp); \
+                                    assert(seg);
+#define ASSERT_ARGS_find_constants assert(interp); \
+                                   assert(ct);
+#define ASSERT_ARGS_find_fixup assert(ft); \
+                               assert(name);
+#define ASSERT_ARGS_find_fixup_iter assert(interp); \
+                                    assert(seg); \
+                                    assert(user_data);
+#define ASSERT_ARGS_fixup_destroy assert(interp); \
+                                  assert(self);
+#define ASSERT_ARGS_fixup_new
+#define ASSERT_ARGS_fixup_pack assert(interp); \
+                               assert(self); \
+                               assert(cursor);
+#define ASSERT_ARGS_fixup_packed_size assert(interp); \
+                                      assert(self);
+#define ASSERT_ARGS_fixup_unpack assert(interp); \
+                                 assert(seg); \
+                                 assert(cursor);
+#define ASSERT_ARGS_make_code_pointers assert(seg);
+#define ASSERT_ARGS_mark_1_seg assert(interp); \
+                               assert(ct);
+#define ASSERT_ARGS_PackFile_append_pbc assert(interp);
+#define ASSERT_ARGS_PackFile_set_header assert(header);
+#define ASSERT_ARGS_pf_debug_destroy assert(self);
+#define ASSERT_ARGS_pf_debug_dump assert(interp); \
+                                  assert(self);
+#define ASSERT_ARGS_pf_debug_new
+#define ASSERT_ARGS_pf_debug_pack assert(self); \
+                                  assert(cursor);
+#define ASSERT_ARGS_pf_debug_packed_size assert(self);
+#define ASSERT_ARGS_pf_debug_unpack assert(interp); \
+                                    assert(self); \
+                                    assert(cursor);
+#define ASSERT_ARGS_pf_register_standard_funcs assert(interp); \
+                                               assert(pf);
+#define ASSERT_ARGS_run_sub assert(interp); \
+                            assert(sub_pmc);
+#define ASSERT_ARGS_segment_init assert(self); \
+                                 assert(pf); \
+                                 assert(name);
+#define ASSERT_ARGS_sort_segs assert(dir);
+#define ASSERT_ARGS_sub_pragma assert(interp); \
+                               assert(sub_pmc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/packfile/pf_items.c
==============================================================================
--- trunk/src/packfile/pf_items.c	(original)
+++ trunk/src/packfile/pf_items.c	Wed Dec 31 11:19:36 2008
@@ -81,6 +81,19 @@
 static opcode_t fetch_op_test(ARGIN(const unsigned char *b))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_cvt_num12_num8 assert(dest); \
+                                   assert(src);
+#define ASSERT_ARGS_cvt_num12_num8_be assert(dest); \
+                                      assert(src);
+#define ASSERT_ARGS_cvt_num12_num8_le assert(dest); \
+                                      assert(src);
+#define ASSERT_ARGS_fetch_op_be_4 assert(b);
+#define ASSERT_ARGS_fetch_op_be_8 assert(b);
+#define ASSERT_ARGS_fetch_op_le_4 assert(b);
+#define ASSERT_ARGS_fetch_op_le_8 assert(b);
+#define ASSERT_ARGS_fetch_op_mixed_be assert(b);
+#define ASSERT_ARGS_fetch_op_mixed_le assert(b);
+#define ASSERT_ARGS_fetch_op_test assert(b);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/pbc_merge.c
==============================================================================
--- trunk/src/pbc_merge.c	(original)
+++ trunk/src/pbc_merge.c	Wed Dec 31 11:19:36 2008
@@ -160,6 +160,36 @@
         __attribute__nonnull__(3)
         FUNC_MODIFIES(*pf);
 
+#define ASSERT_ARGS_help assert(interp);
+#define ASSERT_ARGS_pbc_merge_begin assert(interp); \
+                                    assert(inputs);
+#define ASSERT_ARGS_pbc_merge_bytecode assert(interp); \
+                                       assert(inputs); \
+                                       assert(pf);
+#define ASSERT_ARGS_pbc_merge_constants assert(interp); \
+                                        assert(inputs); \
+                                        assert(pf); \
+                                        assert(bc);
+#define ASSERT_ARGS_pbc_merge_ctpointers assert(interp); \
+                                         assert(inputs); \
+                                         assert(bc);
+#define ASSERT_ARGS_pbc_merge_debugs assert(interp); \
+                                     assert(inputs); \
+                                     assert(pf); \
+                                     assert(bc);
+#define ASSERT_ARGS_pbc_merge_fixups assert(interp); \
+                                     assert(inputs); \
+                                     assert(pf); \
+                                     assert(bc);
+#define ASSERT_ARGS_pbc_merge_loadpbc assert(interp); \
+                                      assert(fullname);
+#define ASSERT_ARGS_pbc_merge_pic_index assert(interp); \
+                                        assert(inputs); \
+                                        assert(pf); \
+                                        assert(bc);
+#define ASSERT_ARGS_pbc_merge_write assert(interp); \
+                                    assert(pf); \
+                                    assert(filename);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/pic.c
==============================================================================
--- trunk/src/pic.c	(original)
+++ trunk/src/pic.c	Wed Dec 31 11:19:36 2008
@@ -194,6 +194,41 @@
         __attribute__nonnull__(6)
         FUNC_MODIFIES(*dest_base);
 
+#define ASSERT_ARGS_is_pic_func assert(interp); \
+                                assert(pc); \
+                                assert(mic);
+#define ASSERT_ARGS_is_pic_param assert(interp); \
+                                 assert(pc); \
+                                 assert(mic);
+#define ASSERT_ARGS_parrot_pic_move assert(interp); \
+                                    assert(mic);
+#define ASSERT_ARGS_pass_int assert(sig); \
+                             assert(src_base); \
+                             assert(src); \
+                             assert(dest_base); \
+                             assert(dest);
+#define ASSERT_ARGS_pass_mixed assert(interp); \
+                               assert(sig); \
+                               assert(src_base); \
+                               assert(src); \
+                               assert(dest_base); \
+                               assert(dest);
+#define ASSERT_ARGS_pass_num assert(sig); \
+                             assert(src_base); \
+                             assert(src); \
+                             assert(dest_base); \
+                             assert(dest);
+#define ASSERT_ARGS_pass_pmc assert(sig); \
+                             assert(src_base); \
+                             assert(src); \
+                             assert(dest_base); \
+                             assert(dest);
+#define ASSERT_ARGS_pass_str assert(interp); \
+                             assert(sig); \
+                             assert(src_base); \
+                             assert(src); \
+                             assert(dest_base); \
+                             assert(dest);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/pic_jit.c
==============================================================================
--- trunk/src/pic_jit.c	(original)
+++ trunk/src/pic_jit.c	Wed Dec 31 11:19:36 2008
@@ -92,6 +92,24 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_args_match_params assert(sig_args); \
+                                      assert(seg); \
+                                      assert(start);
+#define ASSERT_ARGS_call_is_safe assert(sub); \
+                                 assert(set_args);
+#define ASSERT_ARGS_jit_can_compile_sub assert(interp); \
+                                        assert(sub);
+#define ASSERT_ARGS_ops_jittable assert(interp); \
+                                 assert(sub); \
+                                 assert(sig_results); \
+                                 assert(seg); \
+                                 assert(pc); \
+                                 assert(end); \
+                                 assert(flags);
+#define ASSERT_ARGS_pic_test_func assert(interp); \
+                                  assert(args);
+#define ASSERT_ARGS_returns_match_results assert(sig_ret); \
+                                          assert(sig_result);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/pmc.c
==============================================================================
--- trunk/src/pmc.c	(original)
+++ trunk/src/pmc.c	Wed Dec 31 11:19:36 2008
@@ -50,6 +50,13 @@
         FUNC_MODIFIES(*pmc)
         FUNC_MODIFIES(*pool);
 
+#define ASSERT_ARGS_create_class_pmc assert(interp);
+#define ASSERT_ARGS_get_new_pmc_header assert(interp);
+#define ASSERT_ARGS_pmc_free assert(interp); \
+                             assert(pmc);
+#define ASSERT_ARGS_pmc_free_to_pool assert(interp); \
+                                     assert(pmc); \
+                                     assert(pool);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/pmc_freeze.c
==============================================================================
--- trunk/src/pmc_freeze.c	(original)
+++ trunk/src/pmc_freeze.c	Wed Dec 31 11:19:36 2008
@@ -293,10 +293,9 @@
         __attribute__nonnull__(3);
 
 static void visit_todo_list(PARROT_INTERP,
-    ARGIN(PMC* pmc),
+    ARGIN_NULLOK(PMC* pmc),
     ARGIN(visit_info* info))
         __attribute__nonnull__(1)
-        __attribute__nonnull__(2)
         __attribute__nonnull__(3);
 
 static void visit_todo_list_thaw(PARROT_INTERP,
@@ -305,6 +304,93 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_add_pmc_next_for_GC assert(pmc); \
+                                        assert(info);
+#define ASSERT_ARGS_add_pmc_todo_list assert(interp); \
+                                      assert(info);
+#define ASSERT_ARGS_cleanup_next_for_GC assert(interp);
+#define ASSERT_ARGS_cleanup_next_for_GC_pool assert(pool);
+#define ASSERT_ARGS_create_image assert(interp); \
+                                 assert(info);
+#define ASSERT_ARGS_do_action assert(interp); \
+                              assert(info);
+#define ASSERT_ARGS_do_thaw assert(interp); \
+                            assert(info);
+#define ASSERT_ARGS_freeze_pmc assert(interp); \
+                               assert(info);
+#define ASSERT_ARGS_ft_init assert(interp); \
+                            assert(info);
+#define ASSERT_ARGS_id_from_pmc assert(interp); \
+                                assert(pmc);
+#define ASSERT_ARGS_next_for_GC_seen assert(interp); \
+                                     assert(info); \
+                                     assert(id);
+#define ASSERT_ARGS_op_append assert(interp); \
+                              assert(s);
+#define ASSERT_ARGS_op_check_size assert(interp); \
+                                  assert(s);
+#define ASSERT_ARGS_pmc_add_ext assert(interp); \
+                                assert(pmc);
+#define ASSERT_ARGS_push_ascii_integer assert(interp); \
+                                       assert(io);
+#define ASSERT_ARGS_push_ascii_number assert(interp); \
+                                      assert(io);
+#define ASSERT_ARGS_push_ascii_pmc assert(interp); \
+                                   assert(io); \
+                                   assert(v);
+#define ASSERT_ARGS_push_ascii_string assert(interp); \
+                                      assert(io); \
+                                      assert(s);
+#define ASSERT_ARGS_push_opcode_integer assert(interp); \
+                                        assert(io);
+#define ASSERT_ARGS_push_opcode_number assert(interp); \
+                                       assert(io);
+#define ASSERT_ARGS_push_opcode_pmc assert(interp); \
+                                    assert(io); \
+                                    assert(v);
+#define ASSERT_ARGS_push_opcode_string assert(interp); \
+                                       assert(io); \
+                                       assert(v);
+#define ASSERT_ARGS_run_thaw assert(interp); \
+                             assert(image);
+#define ASSERT_ARGS_shift_ascii_integer assert(io);
+#define ASSERT_ARGS_shift_ascii_number assert(io);
+#define ASSERT_ARGS_shift_ascii_pmc assert(io);
+#define ASSERT_ARGS_shift_ascii_string assert(interp); \
+                                       assert(io);
+#define ASSERT_ARGS_shift_opcode_integer assert(io);
+#define ASSERT_ARGS_shift_opcode_number assert(io);
+#define ASSERT_ARGS_shift_opcode_pmc assert(interp); \
+                                     assert(io);
+#define ASSERT_ARGS_shift_opcode_string assert(interp); \
+                                        assert(io);
+#define ASSERT_ARGS_str_append assert(interp); \
+                               assert(s); \
+                               assert(b);
+#define ASSERT_ARGS_thaw_create_pmc assert(interp); \
+                                    assert(info);
+#define ASSERT_ARGS_thaw_pmc assert(interp); \
+                             assert(info); \
+                             assert(id); \
+                             assert(type);
+#define ASSERT_ARGS_todo_list_init assert(interp); \
+                                   assert(info);
+#define ASSERT_ARGS_todo_list_seen assert(interp); \
+                                   assert(pmc); \
+                                   assert(info); \
+                                   assert(id);
+#define ASSERT_ARGS_visit_loop_next_for_GC assert(interp); \
+                                           assert(current); \
+                                           assert(info);
+#define ASSERT_ARGS_visit_loop_todo_list assert(interp); \
+                                         assert(info);
+#define ASSERT_ARGS_visit_next_for_GC assert(interp); \
+                                      assert(pmc); \
+                                      assert(info);
+#define ASSERT_ARGS_visit_todo_list assert(interp); \
+                                    assert(info);
+#define ASSERT_ARGS_visit_todo_list_thaw assert(interp); \
+                                         assert(info);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/runops_cores.c
==============================================================================
--- trunk/src/runops_cores.c	(original)
+++ trunk/src/runops_cores.c	Wed Dec 31 11:19:36 2008
@@ -39,6 +39,8 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_runops_trace_core assert(interp); \
+                                      assert(pc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/runops_cores.h
==============================================================================
--- trunk/src/runops_cores.h	(original)
+++ trunk/src/runops_cores.h	Wed Dec 31 11:19:36 2008
@@ -55,6 +55,18 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_runops_cgoto_core assert(interp); \
+                                      assert(pc);
+#define ASSERT_ARGS_runops_debugger_core assert(interp); \
+                                         assert(pc);
+#define ASSERT_ARGS_runops_fast_core assert(interp); \
+                                     assert(pc);
+#define ASSERT_ARGS_runops_gc_debug_core assert(interp); \
+                                         assert(pc);
+#define ASSERT_ARGS_runops_profile_core assert(interp); \
+                                        assert(pc);
+#define ASSERT_ARGS_runops_slow_core assert(interp); \
+                                     assert(pc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/runops_cores.c */
 

Modified: trunk/src/scheduler.c
==============================================================================
--- trunk/src/scheduler.c	(original)
+++ trunk/src/scheduler.c	Wed Dec 31 11:19:36 2008
@@ -44,6 +44,10 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*scheduler);
 
+#define ASSERT_ARGS_scheduler_process_messages assert(interp); \
+                                               assert(scheduler);
+#define ASSERT_ARGS_scheduler_process_wait_list assert(interp); \
+                                                assert(scheduler);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/spf_render.c
==============================================================================
--- trunk/src/spf_render.c	(original)
+++ trunk/src/spf_render.c	Wed Dec 31 11:19:36 2008
@@ -90,6 +90,15 @@
         FUNC_MODIFIES(*dest)
         FUNC_MODIFIES(*src);
 
+#define ASSERT_ARGS_gen_sprintf_call assert(out); \
+                                     assert(info);
+#define ASSERT_ARGS_handle_flags assert(interp); \
+                                 assert(info); \
+                                 assert(str);
+#define ASSERT_ARGS_str_append_w_flags assert(interp); \
+                                       assert(dest); \
+                                       assert(info); \
+                                       assert(src);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/spf_vtable.c
==============================================================================
--- trunk/src/spf_vtable.c	(original)
+++ trunk/src/spf_vtable.c	Wed Dec 31 11:19:36 2008
@@ -121,6 +121,29 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(3);
 
+#define ASSERT_ARGS_getchr_pmc assert(interp); \
+                               assert(obj);
+#define ASSERT_ARGS_getchr_va assert(interp); \
+                              assert(obj);
+#define ASSERT_ARGS_getfloat_pmc assert(interp); \
+                                 assert(obj);
+#define ASSERT_ARGS_getfloat_va assert(interp); \
+                                assert(obj);
+#define ASSERT_ARGS_getint_pmc assert(interp); \
+                               assert(obj);
+#define ASSERT_ARGS_getint_va assert(interp); \
+                              assert(obj);
+#define ASSERT_ARGS_getptr_pmc assert(interp); \
+                               assert(obj);
+#define ASSERT_ARGS_getptr_va assert(obj);
+#define ASSERT_ARGS_getstring_pmc assert(interp); \
+                                  assert(obj);
+#define ASSERT_ARGS_getstring_va assert(interp); \
+                                 assert(obj);
+#define ASSERT_ARGS_getuint_pmc assert(interp); \
+                                assert(obj);
+#define ASSERT_ARGS_getuint_va assert(interp); \
+                               assert(obj);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/stacks.c
==============================================================================
--- trunk/src/stacks.c	(original)
+++ trunk/src/stacks.c	Wed Dec 31 11:19:36 2008
@@ -32,6 +32,8 @@
         __attribute__nonnull__(1)
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS_run_cleanup_action assert(interp); \
+                                       assert(e);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/stm/backend.c
==============================================================================
--- trunk/src/stm/backend.c	(original)
+++ trunk/src/stm/backend.c	Wed Dec 31 11:19:36 2008
@@ -188,6 +188,44 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*log);
 
+#define ASSERT_ARGS_alloc_read assert(interp); \
+                               assert(log);
+#define ASSERT_ARGS_alloc_write assert(interp); \
+                                assert(log);
+#define ASSERT_ARGS_do_partial_abort assert(interp); \
+                                     assert(log); \
+                                     assert(inner);
+#define ASSERT_ARGS_do_real_abort assert(interp); \
+                                  assert(log); \
+                                  assert(inner);
+#define ASSERT_ARGS_do_real_commit assert(interp); \
+                                   assert(log);
+#define ASSERT_ARGS_find_write_record assert(interp);
+#define ASSERT_ARGS_force_sharing assert(interp);
+#define ASSERT_ARGS_get_read assert(log);
+#define ASSERT_ARGS_get_read_valid_depth assert(interp); \
+                                         assert(log);
+#define ASSERT_ARGS_get_sublog assert(log);
+#define ASSERT_ARGS_get_write assert(log);
+#define ASSERT_ARGS_is_aborted assert(log);
+#define ASSERT_ARGS_is_version assert(maybe_version);
+#define ASSERT_ARGS_local_pmc_copy assert(interp);
+#define ASSERT_ARGS_mark_read_record assert(interp); \
+                                     assert(read);
+#define ASSERT_ARGS_mark_write_record assert(interp); \
+                                      assert(write);
+#define ASSERT_ARGS_merge_transactions assert(interp); \
+                                       assert(log); \
+                                       assert(outer); \
+                                       assert(inner);
+#define ASSERT_ARGS_next_version assert(old_version);
+#define ASSERT_ARGS_replay_writes assert(interp); \
+                                  assert(log);
+#define ASSERT_ARGS_safe_to_clone assert(original);
+#define ASSERT_ARGS_setup_wait assert(interp); \
+                               assert(log);
+#define ASSERT_ARGS_wait_for_version assert(interp); \
+                                     assert(log);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/stm/stm_waitlist.h
==============================================================================
--- trunk/src/stm/stm_waitlist.h	(original)
+++ trunk/src/stm/stm_waitlist.h	Wed Dec 31 11:19:36 2008
@@ -86,6 +86,16 @@
 void Parrot_STM_waitlist_wait(PARROT_INTERP)
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_Parrot_STM_tx_log_get assert(interp);
+#define ASSERT_ARGS_Parrot_STM_waitlist_add_self assert(interp); \
+                                                 assert(waitlist);
+#define ASSERT_ARGS_Parrot_STM_waitlist_destroy_thread assert(interp);
+#define ASSERT_ARGS_Parrot_STM_waitlist_init assert(interp); \
+                                             assert(waitlist);
+#define ASSERT_ARGS_Parrot_STM_waitlist_remove_all assert(interp);
+#define ASSERT_ARGS_Parrot_STM_waitlist_signal assert(interp); \
+                                               assert(waitlist);
+#define ASSERT_ARGS_Parrot_STM_waitlist_wait assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/stm/waitlist.c */
 

Modified: trunk/src/stm/waitlist.c
==============================================================================
--- trunk/src/stm/waitlist.c	(original)
+++ trunk/src/stm/waitlist.c	Wed Dec 31 11:19:36 2008
@@ -81,6 +81,18 @@
         __attribute__nonnull__(1)
         FUNC_MODIFIES(*who);
 
+#define ASSERT_ARGS_add_entry assert(waitlist); \
+                              assert(entry);
+#define ASSERT_ARGS_alloc_entry assert(interp);
+#define ASSERT_ARGS_get_thread assert(interp);
+#define ASSERT_ARGS_get_thread_noalloc assert(interp);
+#define ASSERT_ARGS_Parrot_STM_tx_log_alloc assert(interp);
+#define ASSERT_ARGS_remove_first assert(waitlist); \
+                                 assert(expect_first);
+#define ASSERT_ARGS_waitlist_remove assert(what);
+#define ASSERT_ARGS_waitlist_remove_check assert(what);
+#define ASSERT_ARGS_waitlist_signal_all assert(list);
+#define ASSERT_ARGS_waitlist_signal_one assert(who);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/string.c
==============================================================================
--- trunk/src/string.c	(original)
+++ trunk/src/string.c	Wed Dec 31 11:19:36 2008
@@ -60,6 +60,8 @@
         __attribute__nonnull__(2)
         FUNC_MODIFIES(*s);
 
+#define ASSERT_ARGS_make_writable assert(interp); \
+                                  assert(s);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/thread.c
==============================================================================
--- trunk/src/thread.c	(original)
+++ trunk/src/thread.c	Wed Dec 31 11:19:36 2008
@@ -100,6 +100,30 @@
 PARROT_CAN_RETURN_NULL
 static void* thread_func(ARGIN_NULLOK(void *arg));
 
+#define ASSERT_ARGS_detach
+#define ASSERT_ARGS_get_pool assert(interp);
+#define ASSERT_ARGS_is_suspended_for_gc assert(interp);
+#define ASSERT_ARGS_make_local_args_copy assert(interp); \
+                                         assert(old_interp);
+#define ASSERT_ARGS_make_local_copy assert(interp); \
+                                    assert(from); \
+                                    assert(arg);
+#define ASSERT_ARGS_mutex_unlock assert(arg);
+#define ASSERT_ARGS_pt_check_tid assert(from);
+#define ASSERT_ARGS_pt_gc_count_threads assert(interp);
+#define ASSERT_ARGS_pt_gc_wait_for_stage assert(interp);
+#define ASSERT_ARGS_pt_gc_wakeup_check assert(interp);
+#define ASSERT_ARGS_pt_ns_clone assert(d); \
+                                assert(dest_ns); \
+                                assert(s); \
+                                assert(source_ns);
+#define ASSERT_ARGS_pt_suspend_all_for_gc assert(interp);
+#define ASSERT_ARGS_pt_suspend_one_for_gc assert(interp);
+#define ASSERT_ARGS_pt_thread_signal assert(self); \
+                                     assert(interp);
+#define ASSERT_ARGS_pt_thread_wait assert(interp);
+#define ASSERT_ARGS_remove_queued_suspend_gc assert(interp);
+#define ASSERT_ARGS_thread_func
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/trace.c
==============================================================================
--- trunk/src/trace.c	(original)
+++ trunk/src/trace.c	Wed Dec 31 11:19:36 2008
@@ -35,6 +35,7 @@
 static STRING* trace_class_name(ARGIN(const PMC* pmc))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_trace_class_name assert(pmc);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/trace.h
==============================================================================
--- trunk/src/trace.h	(original)
+++ trunk/src/trace.h	Wed Dec 31 11:19:36 2008
@@ -40,6 +40,15 @@
 void trace_pmc_dump(PARROT_INTERP, ARGIN_NULLOK(PMC *pmc))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_trace_key_dump assert(interp); \
+                                   assert(key);
+#define ASSERT_ARGS_trace_op assert(interp); \
+                             assert(code_start); \
+                             assert(code_end);
+#define ASSERT_ARGS_trace_op_dump assert(interp); \
+                                  assert(code_start); \
+                                  assert(pc);
+#define ASSERT_ARGS_trace_pmc_dump assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: src/trace.c */
 

Modified: trunk/src/utils.c
==============================================================================
--- trunk/src/utils.c	(original)
+++ trunk/src/utils.c	Wed Dec 31 11:19:36 2008
@@ -69,6 +69,20 @@
     ARGIN(parrot_prm_context* c))
         __attribute__nonnull__(2);
 
+#define ASSERT_ARGS__drand48
+#define ASSERT_ARGS__erand48
+#define ASSERT_ARGS__jrand48
+#define ASSERT_ARGS__lrand48
+#define ASSERT_ARGS__mrand48
+#define ASSERT_ARGS__nrand48
+#define ASSERT_ARGS__srand48
+#define ASSERT_ARGS_COMPARE assert(interp); \
+                            assert(a); \
+                            assert(b); \
+                            assert(cmp);
+#define ASSERT_ARGS_next_rand
+#define ASSERT_ARGS_process_cycle_without_exit assert(c);
+#define ASSERT_ARGS_rec_climb_back_and_mark assert(c);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 

Modified: trunk/src/warnings.c
==============================================================================
--- trunk/src/warnings.c	(original)
+++ trunk/src/warnings.c	Wed Dec 31 11:19:36 2008
@@ -29,6 +29,7 @@
 static INTVAL print_warning(PARROT_INTERP, ARGIN_NULLOK(STRING *msg))
         __attribute__nonnull__(1);
 
+#define ASSERT_ARGS_print_warning assert(interp);
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 /* HEADERIZER END: static */
 



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