RPA Toolkit
changed the callback parameters and added look ahead/back while parsing
authorMartin Stoilov <martin@rpasearch.com>
Tue, 25 Jan 2011 06:54:11 +0000 (22:54 -0800)
committerMartin Stoilov <martin@rpasearch.com>
Tue, 25 Jan 2011 06:54:11 +0000 (22:54 -0800)
rgrep/rpagrep.c
rpa/rpadbex.h
rpa/rpadbexpriv.c
rpa/rpastat.c
rpa/rpastat.h
tests/calc-test.c
tests/rpagen-test.c

index 1a42a1d..55ba509 100644 (file)
@@ -387,7 +387,7 @@ rpa_buffer_t *rpa_buffer_loadfile(FILE *pFile)
 }
 
 
-static int rpa_callback_output(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+static int rpa_callback_output(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rpa_grep_t *pGrep = (rpa_grep_t *)userdata;
 
@@ -409,7 +409,7 @@ static int rpa_callback_output(rpa_stat_handle stat, const char *name, void *use
 }
 
 
-static int rpa_callback_matched_output(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+static int rpa_callback_matched_output(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rpa_grep_t *pGrep = (rpa_grep_t *)userdata;
 
index edc0105..38fe91d 100644 (file)
@@ -50,13 +50,21 @@ extern "C" {
 #define RPA_REASON_ALL         (RPA_REASON_START|RPA_REASON_END|RPA_REASON_MATCHED)
 
 
+typedef struct rpa_recordpeek_s {
+       const char *name;
+       const char *input;
+       unsigned int size;
+       unsigned int reason;
+} rpa_recordpeek_t;
+
+
 typedef struct rpa_stat_s *rpa_stat_handle;
 typedef struct rpa_dbex_s *rpa_dbex_handle;
 typedef struct rpa_varlink_s *rpa_group_handle;
 typedef struct rpa_varlink_s *rpa_pattern_handle;
 typedef struct rpa_varlink_s *rpa_callback_handle;
 typedef void (*rpa_progress_callback)(void *userdata, const char *input, const char *start, const char *end);
-typedef int (*rpa_match_callback)(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end);
+typedef int (*rpa_match_callback)(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason);
 
 
 rpa_dbex_handle rpa_dbex_create(void);
@@ -110,9 +118,12 @@ int rpa_stat_match(rpa_stat_handle hStat, rpa_pattern_handle hPattern, const cha
 int rpa_stat_parse(rpa_stat_handle hStat, rpa_pattern_handle hPattern, const char *input, const char *start, const char *end);
 int rpa_stat_set_progress_callback(rpa_stat_handle hStat, rpa_progress_callback progress, void *userdata);
 int rpa_stat_abort(rpa_stat_handle hStat);
+const rpa_recordpeek_t *rpa_stat_record_lookahead(rpa_stat_handle hStat, unsigned long n);
+const rpa_recordpeek_t *rpa_stat_record_lookback(rpa_stat_handle hStat, unsigned long n);
 void *rpa_stat_get_userdata(rpa_stat_handle hStat, unsigned int index);
 int rpa_stat_set_userdata(rpa_stat_handle hStat, unsigned int index, void *ud);
-
+const char *rpa_stat_input_start(rpa_stat_handle hStat);
+const char *rpa_stat_input_end(rpa_stat_handle hStat);
 
 #ifdef __cplusplus
 }
index 3310ace..0f05e36 100644 (file)
@@ -115,7 +115,7 @@ int rpa_common_callback(rpa_mnode_t *mnode, rpa_stat_t *stat, const char *input,
                goto error;
        pCbData = pVarLinkCallback->var.v.ptr;
        if  (pCbData->func)
-               return pCbData->func(stat, mnode->match->name, pCbData->userdata, input, size, reason, stat->start, stat->end);
+               return pCbData->func(stat, mnode->match->name, pCbData->userdata, input, size, reason);
 error:
        return size;
 }
index 361fe6f..097f00a 100644 (file)
@@ -438,22 +438,62 @@ int rpa_stat_match_lite(rpa_stat_handle hStat, rpa_pattern_handle hPattern, cons
 }
 
 
+static int rpa_mnode_play_callback(rpa_mnode_t *mnode, rpa_stat_t *stat, const char *input, unsigned int size, unsigned int reason)
+{
+       int ret = size;
+       if ( ((rpa_mnode_callback_t*)mnode)->matched_callback && (reason & mnode->flags))
+               ret = ((rpa_mnode_callback_t*)mnode)->matched_callback(mnode, stat, input, size, (reason & mnode->flags));
+       return ret;
+}
+
+
 static int rpa_stat_play_cbset(rpa_stat_t *stat, const char *input, unsigned int size)
 {
        rpa_cbset_t *cbset = &stat->cbset;
-       rpa_word_t off;
        int ret;
 
-       for (off = 1; off <= cbset->off; off++) {
-               rpa_cbrecord_t *cbrec = &cbset->data[off];
-               ret = rpa_mnode_exec_callback(cbrec->mnode, stat, cbrec->input, cbrec->size, cbrec->reason);
-               if (cbrec->size && !ret)
+       for (stat->currecord = 1; stat->currecord <= cbset->off; stat->currecord++) {
+               rpa_cbrecord_t *cbrec = &cbset->data[stat->currecord];
+               ret = rpa_mnode_play_callback(cbrec->mnode, stat, cbrec->input, cbrec->size, cbrec->reason);
+               if (cbrec->size && !ret) {
+                       stat->currecord = -1;
                        return 0;
+               }
        }
+       stat->currecord = -1;
        return size;
 }
 
 
+const rpa_recordpeek_t *rpa_stat_record_lookahead(rpa_stat_handle stat, unsigned long n)
+{
+       rpa_cbrecord_t *cbrec;
+       if (stat->currecord < 0 || stat->currecord + n > stat->cbset.off)
+               return NULL;
+       cbrec = &stat->cbset.data[stat->currecord + n];
+       stat->record.input = cbrec->input;
+       stat->record.name = cbrec->mnode->match->name;
+       stat->record.size = cbrec->size;
+       stat->record.reason = cbrec->reason;
+       return &stat->record;
+}
+
+
+const rpa_recordpeek_t *rpa_stat_record_lookback(rpa_stat_handle stat, unsigned long n)
+{
+       rpa_cbrecord_t *cbrec;
+       if (stat->currecord < 0 || stat->currecord - n < 1)
+               return NULL;
+       cbrec = &stat->cbset.data[stat->currecord - n];
+       stat->record.input = cbrec->input;
+       stat->record.name = cbrec->mnode->match->name;
+       stat->record.size = cbrec->size;
+       stat->record.reason = cbrec->reason;
+       return &stat->record;
+}
+
+
+
 int rpa_stat_parse(rpa_stat_handle hStat, rpa_pattern_handle hPattern, const char *input, const char *start, const char *end)
 {
        const unsigned char smk = RPA_STACK_MARK;
@@ -589,6 +629,7 @@ rpa_dloop_t *rpa_stat_current_loop(rpa_stat_t *stat)
        return (void*)0;
 }
 
+
 void rpa_stat_cache_reset(rpa_stat_t *stat)
 {
        int i;
@@ -598,3 +639,20 @@ void rpa_stat_cache_reset(rpa_stat_t *stat)
                stat->mcache[i].match = NULL;
        }
 }
+
+
+const char *rpa_stat_input_start(rpa_stat_handle hStat)
+{
+       if (!hStat)
+               return NULL;
+       return hStat->start;
+}
+
+
+const char *rpa_stat_input_end(rpa_stat_handle hStat)
+{
+       if (!hStat)
+               return NULL;
+       return hStat->end;
+}
+
index d16a108..7edaaa6 100644 (file)
@@ -92,6 +92,8 @@ struct rpa_stat_s {
        RPA_CHECKSTACK_FUNCTION checkstack;
        rpa_progress_callback progress;
        rpa_cbset_t cbset;
+       rpa_sword_t currecord;
+       rpa_recordpeek_t record;
        void *progress_userdata;
        int (*getchar)(unsigned int *pwc, rpa_stat_t *stat, const char *input);
        const char *where;
index 1919b58..c876ffa 100644 (file)
@@ -31,7 +31,7 @@ int lc_stack_pop(lc_stack_t *stack)
 }
 
 
-int lc_print(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_print(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
 #ifdef DEBUGPRINT
        fprintf(stdout, "%s: ", name);
@@ -42,7 +42,7 @@ int lc_print(rpa_stat_handle stat, const char *name, void *userdata, const char
 }
 
 
-int lc_addop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_addop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        lc_stack_t *stack = (lc_stack_t*)userdata;
        int op1 = 0, op2 = 0;
@@ -50,11 +50,11 @@ int lc_addop_callback(rpa_stat_handle stat, const char *name, void *userdata, co
        op2 = lc_stack_pop(stack);
        op1 = lc_stack_pop(stack);      
        lc_stack_push(stack, op1 + op2);
-       lc_print(stat, name, userdata, input, size, reason, start, end);
+       lc_print(stat, name, userdata, input, size, reason);
        return size;
 }
 
-int lc_subop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_subop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        lc_stack_t *stack = (lc_stack_t*)userdata;
        int op1 = 0, op2 = 0;
@@ -62,12 +62,12 @@ int lc_subop_callback(rpa_stat_handle stat, const char *name, void *userdata, co
        op2 = lc_stack_pop(stack);
        op1 = lc_stack_pop(stack);      
        lc_stack_push(stack, op1 - op2);
-       lc_print(stat, name, userdata, input, size, reason, start, end);
+       lc_print(stat, name, userdata, input, size, reason);
        return size;
 }
 
 
-int lc_divop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_divop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        lc_stack_t *stack = (lc_stack_t*)userdata;
        int op1 = 0, op2 = 0;
@@ -75,11 +75,11 @@ int lc_divop_callback(rpa_stat_handle stat, const char *name, void *userdata, co
        op2 = lc_stack_pop(stack);
        op1 = lc_stack_pop(stack);      
        lc_stack_push(stack, op1 / op2);
-       lc_print(stat, name, userdata, input, size, reason, start, end);
+       lc_print(stat, name, userdata, input, size, reason);
        return size;
 }
 
-int lc_mulop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_mulop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        lc_stack_t *stack = (lc_stack_t*)userdata;
        int op1 = 0, op2 = 0;
@@ -87,16 +87,16 @@ int lc_mulop_callback(rpa_stat_handle stat, const char *name, void *userdata, co
        op2 = lc_stack_pop(stack);
        op1 = lc_stack_pop(stack);      
        lc_stack_push(stack, op1 * op2);
-       lc_print(stat, name, userdata, input, size, reason, start, end);
+       lc_print(stat, name, userdata, input, size, reason);
        return size;
 }
 
-int lc_integer_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int lc_integer_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        lc_stack_t *stack = (lc_stack_t*)userdata;
 
        lc_stack_push(stack, atoi(input));
-       lc_print(stat, name, userdata, input, size, reason, start, end);
+       lc_print(stat, name, userdata, input, size, reason);
        return size;
 }
 
index edc3867..6be11ef 100644 (file)
@@ -295,9 +295,11 @@ static rvm_switable_t switable_js[] = {
                {NULL, NULL},
 };
 
-inline int codegen_print_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+inline int codegen_print_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
+       const rpa_recordpeek_t *rec = rpa_stat_record_lookahead(stat, 1);
+
 
        if (parseinfo) {
                if (reason & RPA_REASON_START)
@@ -309,6 +311,8 @@ inline int codegen_print_callback(rpa_stat_handle stat, const char *name, void *
                fprintf(stdout, "%s: ", name);
                if (!(reason & RPA_REASON_START))
                                fwrite(input, sizeof(char), size, stdout);
+               if (rec)
+                       fprintf(stdout, "(next name: %s)", rec->name);
                fprintf(stdout, " (debth: %d, level: %d, binaryop: %d, dirty: %d)", rvm_costat_getdebth(co), rvm_costat_getlevel(co), rvm_costat_getbinaryop(co), rvm_costat_getdirty(co));
                fprintf(stdout, "\n");
                fflush(stdout);
@@ -325,7 +329,7 @@ void codegen_dump_code(rvm_asmins_t *code, rulong size)
 }
 
 
-int codegen_opcode_unary_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opcode_unary_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
 
@@ -346,12 +350,12 @@ int codegen_opcode_unary_callback(rpa_stat_handle stat, const char *name, void *
        else
                r_array_push(co->opcodes, RVM_ABORT, ruint);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        return size;
 }
 
 
-int codegen_opcode_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opcode_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
 
@@ -432,12 +436,12 @@ int codegen_opcode_callback(rpa_stat_handle stat, const char *name, void *userda
        else
                r_array_push(co->opcodes, RVM_ABORT, ruint);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        return size;
 }
 
 
-int codegen_binary_asmop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_binary_asmop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -463,14 +467,14 @@ int codegen_binary_asmop_callback(rpa_stat_handle stat, const char *name, void *
                rvm_costat_decbinaryop(co);
        }
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_valop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_valop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -495,26 +499,26 @@ int codegen_valop_callback(rpa_stat_handle stat, const char *name, void *userdat
 
        }
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_conditionalexp_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_conditionalexp_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_unary_asmop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_unary_asmop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -531,13 +535,13 @@ int codegen_unary_asmop_callback(rpa_stat_handle stat, const char *name, void *u
        if (reason & RPA_REASON_END) {
        }
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_costate_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_costate_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -550,69 +554,69 @@ int codegen_costate_callback(rpa_stat_handle stat, const char *name, void *userd
                rvm_costat_pop(co);
        }
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_push_r0_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_push_r0_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_integer_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_integer_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R0, DA, XX, r_strtol(input, NULL, 10)));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_printop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_printop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_codegen_addins(co->cg, rvm_asmd(RVM_PRN, R0, DA, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_double_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_double_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_codegen_addins(co->cg, rvm_asmd(RVM_MOV, R0, DA, XX, r_strtod(input, NULL)));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_string_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_string_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -621,14 +625,14 @@ int codegen_string_callback(rpa_stat_handle stat, const char *name, void *userda
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R2, DA, XX, size));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ALLOCSTR, R0, R1, R2, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_program_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_program_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        ruint off;
@@ -648,7 +652,7 @@ int codegen_program_callback(rpa_stat_handle stat, const char *name, void *userd
        }
 
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        if (reason & RPA_REASON_END) {
@@ -658,7 +662,7 @@ int codegen_program_callback(rpa_stat_handle stat, const char *name, void *userd
 }
 
 
-int codegen_opinit_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opinit_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -666,14 +670,14 @@ int codegen_opinit_callback(rpa_stat_handle stat, const char *name, void *userda
        rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_STRR, R0, R1, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_opassign_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opassign_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -686,14 +690,14 @@ int codegen_opassign_callback(rpa_stat_handle stat, const char *name, void *user
        }
        rvm_codegen_addins(co->cg, rvm_asm(RVM_STRR, R0, R1, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_oppostfix_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_oppostfix_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -705,14 +709,14 @@ int codegen_oppostfix_callback(rpa_stat_handle stat, const char *name, void *use
        rvm_codegen_addins(co->cg, rvm_asm(RVM_STRR, R2, R1, XX, 0));
 
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_opprefix_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opprefix_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -723,14 +727,14 @@ int codegen_opprefix_callback(rpa_stat_handle stat, const char *name, void *user
        rvm_codegen_addins(co->cg, rvm_asm(opcode, R0, R0, DA, 1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_STRR, R0, R1, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_ptr_deref_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_ptr_deref_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -739,14 +743,14 @@ int codegen_ptr_deref_callback(rpa_stat_handle stat, const char *name, void *use
        rvm_codegen_addins(co->cg, rvm_asm(RVM_LDRR, R0, R1, XX, 0));   // Load the value from offset
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));   // Push it on the stack
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_arrayelementvalue_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_arrayelementvalue_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -754,14 +758,14 @@ int codegen_arrayelementvalue_callback(rpa_stat_handle stat, const char *name, v
        rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));    // Array
        rvm_codegen_addins(co->cg, rvm_asm(RVM_LDOBJN, R0, R1, R0, 0)); // Load the value from array offset
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_memberexpressionbase_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_memberexpressionbase_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -769,14 +773,14 @@ int codegen_memberexpressionbase_callback(rpa_stat_handle stat, const char *name
        rvm_codegen_addins(co->cg, rvm_asm(RVM_LDRR, R0, R0, XX, 0));   // Array Address
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));   // Array -> On Stack
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_n_arrayelementaddress_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_n_arrayelementaddress_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -784,14 +788,14 @@ int codegen_n_arrayelementaddress_callback(rpa_stat_handle stat, const char *nam
        rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));    // Supposedly Array Address
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ADDROBJN, R0, R1, R0, 0));       // Get the address of the element at offset R0
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_h_arrayelementaddress_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_h_arrayelementaddress_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -799,14 +803,14 @@ int codegen_h_arrayelementaddress_callback(rpa_stat_handle stat, const char *nam
 //     rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));    // Supposedly Array Address
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ADDROBJH, R0, R1, R0, 0));       // Get the address of the element at offset R0
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_h_arraynamelookupadd_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_h_arraynamelookupadd_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -820,14 +824,14 @@ int codegen_h_arraynamelookupadd_callback(rpa_stat_handle stat, const char *name
        rvm_codegen_addins(co->cg, rvm_asmp(RVM_MOV, R2, DA, XX, (void*)input));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_OBJLKUPADD, R0, R1, R2, 0));     // Get the address of the element at offset R0
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_h_arraynamelookup_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_h_arraynamelookup_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -837,14 +841,14 @@ int codegen_h_arraynamelookup_callback(rpa_stat_handle stat, const char *name, v
        rvm_codegen_addins(co->cg, rvm_asmp(RVM_MOV, R2, DA, XX, (void*)input));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_OBJLKUP, R0, R1, R2, 0));        // Get the address of the element at offset R0
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_h_arrayelementvalue_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_h_arrayelementvalue_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -852,14 +856,14 @@ int codegen_h_arrayelementvalue_callback(rpa_stat_handle stat, const char *name,
 //     rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));    // Supposedly Array Address
        rvm_codegen_addins(co->cg, rvm_asm(RVM_LDOBJH, R0, R1, R0, 0)); // Get the address of the element at offset R0
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_swiidexist_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_swiidexist_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rint swi = rvm_cpu_getswi(co->cpu, input, size);
@@ -872,7 +876,7 @@ int codegen_swiidexist_callback(rpa_stat_handle stat, const char *name, void *us
 }
 
 
-int codegen_swiid_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_swiid_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -884,14 +888,14 @@ int codegen_swiid_callback(rpa_stat_handle stat, const char *name, void *userdat
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R0, DA, XX, swi));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SETTYPE, R0, DA, XX, RVM_DTYPE_SWIID));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_opidentifier_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opidentifier_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -903,7 +907,7 @@ int codegen_opidentifier_callback(rpa_stat_handle stat, const char *name, void *
                } else {
                        rvm_codegen_addins(co->cg, rvm_asmp(RVM_MOV, R0, DA, XX, v->data.ptr));
                }
-               codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+               codegen_print_callback(stat, name, userdata, input, size, reason);
                codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
                return size;
@@ -917,7 +921,7 @@ int codegen_opidentifier_callback(rpa_stat_handle stat, const char *name, void *
 }
 
 
-int codegen_validentifierop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_validentifierop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -929,7 +933,7 @@ int codegen_validentifierop_callback(rpa_stat_handle stat, const char *name, voi
                } else {
                        rvm_codegen_addins(co->cg, rvm_asmp(RVM_LDRR, R0, DA, XX, v->data.ptr));
                }
-               codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+               codegen_print_callback(stat, name, userdata, input, size, reason);
                codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
                return size;
@@ -943,7 +947,7 @@ int codegen_validentifierop_callback(rpa_stat_handle stat, const char *name, voi
 }
 
 
-int codegen_varalloc_to_ptr_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_varalloc_to_ptr_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -972,14 +976,14 @@ int codegen_varalloc_to_ptr_callback(rpa_stat_handle stat, const char *name, voi
        }
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_varalloc_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_varalloc_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1008,14 +1012,14 @@ int codegen_varalloc_callback(rpa_stat_handle stat, const char *name, void *user
        }
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CLRR, R1, XX, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_newarraysize_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_newarraysize_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1023,14 +1027,14 @@ int codegen_newarraysize_callback(rpa_stat_handle stat, const char *name, void *
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R1, R0, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ALLOCOBJ, R0, R1, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_newarraynosize_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_newarraynosize_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1038,49 +1042,49 @@ int codegen_newarraynosize_callback(rpa_stat_handle stat, const char *name, void
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R1, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ALLOCOBJ, R0, R1, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_scopepush_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_scopepush_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_scope_push(co->scope);
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_scopepop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_scopepop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
        rvm_scope_pop(co->scope);
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_compile_error_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_compile_error_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
-       fprintf(stdout, "COMPILE ERROR pos: %ld\n", (long) (input - start));
+       fprintf(stdout, "COMPILE ERROR pos: %ld\n", (long) (input - rpa_stat_input_start(stat)));
        rpa_dbex_abort(co->dbex);
        return 0;
 }
 
 
-int codegen_funcallparameter_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_funcallparameter_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1088,14 +1092,14 @@ int codegen_funcallparameter_callback(rpa_stat_handle stat, const char *name, vo
 
        funcall->params += 1;
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_funcallname_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_funcallname_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1117,14 +1121,14 @@ int codegen_funcallname_callback(rpa_stat_handle stat, const char *name, void *u
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(TP)|BIT(FP)|BIT(SP)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_funcallexpression_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_funcallexpression_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1138,14 +1142,14 @@ int codegen_funcallexpression_callback(rpa_stat_handle stat, const char *name, v
        rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BITS(TP,LR)));
 
        r_array_removelast(co->funcall);
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_fundeclparameter_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_fundeclparameter_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1162,21 +1166,21 @@ int codegen_fundeclparameter_callback(rpa_stat_handle stat, const char *name, vo
        fundecl->params += 1;
        r_array_inclast(co->fp, rword);
        rvm_scope_addoffset(co->scope, input, size, r_array_last(co->fp, rword));
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_fundeclname_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_fundeclname_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off;
        rvm_fundecl_t fundecl = {input, size, 0, 0};
        rint ret;
 
-       ret = codegen_varalloc_callback(stat, name, userdata, input, size, reason, start, end);
+       ret = codegen_varalloc_callback(stat, name, userdata, input, size, reason);
        if (ret == 0)
                return ret;
 
@@ -1195,28 +1199,28 @@ int codegen_fundeclname_callback(rpa_stat_handle stat, const char *name, void *u
        rvm_scope_push(co->scope);
        rvm_costat_pushroot(co);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
 
-int codegen_fundeclsignature_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_fundeclsignature_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
 
 //     rvm_codemap_add(cg->codemap, fundecl->funname, fundecl->funnamesiz, rvm_codegen_getcodesize(co->cg));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_fundecl_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_fundecl_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1253,14 +1257,14 @@ int codegen_fundecl_callback(rpa_stat_handle stat, const char *name, void *userd
 
        r_array_removelast(co->fundecl);
        rvm_costat_pop(co);
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_opreturn_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_opreturn_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1269,14 +1273,14 @@ int codegen_opreturn_callback(rpa_stat_handle stat, const char *name, void *user
                rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BITS(RVM_SAVEDREGS_FIRST, RVM_SAVEDREGS_FIRST + rvm_costat_getdirty(co) - 1)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_ifconditionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_ifconditionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1288,14 +1292,14 @@ int codegen_ifconditionop_callback(rpa_stat_handle stat, const char *name, void
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R0, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BEQ, DA, XX, XX, -1));   //This has to be redefined when we know the size of the code block
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_ifop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_ifop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1304,14 +1308,14 @@ int codegen_ifop_callback(rpa_stat_handle stat, const char *name, void *userdata
        cs.codesize = rvm_codegen_getcodesize(co->cg) - cs.codestart;
        rvm_codegen_replaceins(co->cg, cs.codestart + 1, rvm_asm(RVM_BEQ, DA, XX, XX, cs.codesize - 1));        //This has to be redefined when we know the size of the code block
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_elseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_elseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1326,14 +1330,14 @@ int codegen_elseop_callback(rpa_stat_handle stat, const char *name, void *userda
        cs.codesize = 0;
        r_array_add(co->codespan, &cs);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_ifelseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_ifelseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1342,14 +1346,14 @@ int codegen_ifelseop_callback(rpa_stat_handle stat, const char *name, void *user
        cs.codesize = rvm_codegen_getcodesize(co->cg) - cs.codestart;
        rvm_codegen_replaceins(co->cg, cs.codestart - 1, rvm_asm(RVM_B, DA, XX, XX, cs.codesize));      //Branch to the end of the else block, now we know the size
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_dokeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_dokeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1358,13 +1362,13 @@ int codegen_dokeyword_callback(rpa_stat_handle stat, const char *name, void *use
        cs.codestart = rvm_codegen_getcodesize(co->cg);
        r_array_add(co->codespan, &cs);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_iterationdo_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_iterationdo_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1383,13 +1387,13 @@ int codegen_iterationdo_callback(rpa_stat_handle stat, const char *name, void *u
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BNEQ, DA, XX, XX, -cs.codesize));
        rvm_codemap_poploopblock(co->cg->codemap);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_whileconditionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_whileconditionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1399,14 +1403,14 @@ int codegen_whileconditionop_callback(rpa_stat_handle stat, const char *name, vo
        cs->l1 = rvm_codegen_getcodesize(co->cg);
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BEQ, DA, XX, XX, -1));   //This has to be redefined when we know the size of the code block
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_iterationwhileop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_iterationwhileop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1429,14 +1433,14 @@ int codegen_iterationwhileop_callback(rpa_stat_handle stat, const char *name, vo
                cs.codesize = rvm_codegen_getcodesize(co->cg) - cs.codestart;
        }
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_questionmarkop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_questionmarkop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1448,14 +1452,14 @@ int codegen_questionmarkop_callback(rpa_stat_handle stat, const char *name, void
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BEQ, DA, XX, XX, 0)); // This will be re-written
        r_array_add(co->codespan, &cs);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_iftrueop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_iftrueop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1465,14 +1469,14 @@ int codegen_iftrueop_callback(rpa_stat_handle stat, const char *name, void *user
        rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0)); // This will be re-written
        rvm_codegen_replaceins(co->cg, cs->l1, rvm_asm(RVM_BEQ, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - cs->l1)); // Re-writing the instruction
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_iffalseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_iffalseop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1480,14 +1484,14 @@ int codegen_iffalseop_callback(rpa_stat_handle stat, const char *name, void *use
 
        rvm_codegen_replaceins(co->cg, cs.l2, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - cs.l2));     // Re-writing the instruction
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
 
        return size;
 }
 
 
-int codegen_breakkeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_breakkeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1500,13 +1504,13 @@ int codegen_breakkeyword_callback(rpa_stat_handle stat, const char *name, void *
        rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, -(rvm_codegen_getcodesize(co->cg) - cs->l2)));
 
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_continuekeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_continuekeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1519,13 +1523,13 @@ int codegen_continuekeyword_callback(rpa_stat_handle stat, const char *name, voi
        rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, -(rvm_codegen_getcodesize(co->cg) - cs->l3)));
 
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_forkeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_forkeyword_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1536,13 +1540,13 @@ int codegen_forkeyword_callback(rpa_stat_handle stat, const char *name, void *us
        rvm_scope_push(co->scope);
        r_array_push(co->loops, r_array_lastslot(co->codespan), rvm_codespan_t*);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_forinitop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_forinitop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1555,7 +1559,7 @@ int codegen_forinitop_callback(rpa_stat_handle stat, const char *name, void *use
        rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 1)); // Break point, This will be re-written.
        cs->l3 = rvm_codegen_getcodesize(co->cg);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
@@ -1565,7 +1569,7 @@ int codegen_forinitop_callback(rpa_stat_handle stat, const char *name, void *use
  * due to the trick we did in the BNF schema. That will make the implementation of the for ( ; ; ) loops
  * a lot more easier and the generated code having less branch instructions
  */
-int codegen_forincrementop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_forincrementop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1573,13 +1577,13 @@ int codegen_forincrementop_callback(rpa_stat_handle stat, const char *name, void
 
        rvm_codegen_replaceins(co->cg, cs->l1, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - cs->l1));   // Re-writing the instruction
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_forcompareop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_forcompareop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1592,13 +1596,13 @@ int codegen_forcompareop_callback(rpa_stat_handle stat, const char *name, void *
         * The beginning loop starts here, right after the RVM_BEQ instruction.
         */
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_iterationforop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_iterationforop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1612,13 +1616,13 @@ int codegen_iterationforop_callback(rpa_stat_handle stat, const char *name, void
        rvm_scope_pop(co->scope);
        r_array_removelast(co->loops);
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }
 
 
-int codegen_newexpressionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason, const char *start, const char *end)
+int codegen_newexpressionop_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
@@ -1633,7 +1637,7 @@ int codegen_newexpressionop_callback(rpa_stat_handle stat, const char *name, voi
        rvm_codegen_addins(co->cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
 
 
-       codegen_print_callback(stat, name, userdata, input, size, reason, start, end);
+       codegen_print_callback(stat, name, userdata, input, size, reason);
        codegen_dump_code(rvm_codegen_getcode(co->cg, off), rvm_codegen_getcodesize(co->cg) - off);
        return size;
 }