From 009deb74e036c25053246ce9b8a21069f8440834 Mon Sep 17 00:00:00 2001 From: Adrian Thurston Date: Fri, 22 May 2015 09:37:59 -0400 Subject: large scale symbol renaming in C code using _ conventions for C, camelCase of C++ --- src/bytecode.c | 1232 ++++++++++++++++++++--------------------- src/bytecode.h | 94 ++-- src/codevect.c | 66 +-- src/compiler.cc | 14 +- src/ctinput.cc | 86 +-- src/debug.c | 6 +- src/fsmcodegen.cc | 6 +- src/fsmcodegen.h | 4 +- src/fsmexec.cc | 70 +-- src/input.c | 378 ++++++------- src/input.h | 64 +-- src/iter.c | 326 +++++------ src/list.c | 64 +-- src/map.c | 266 ++++----- src/map.h | 64 +-- src/pdabuild.cc | 420 +++++++------- src/pdacodegen.cc | 330 +++++------ src/pdarun.c | 1572 ++++++++++++++++++++++++++--------------------------- src/pdarun.h | 272 ++++----- src/pool.c | 106 ++-- src/pool.h | 4 +- src/program.c | 120 ++-- src/program.h | 126 ++--- src/redfsm.cc | 76 +-- src/string.c | 66 +-- src/struct.c | 40 +- src/struct.h | 26 +- src/tree.c | 930 +++++++++++++++---------------- src/tree.h | 234 ++++---- test/ext1.lm | 4 +- 30 files changed, 3533 insertions(+), 3533 deletions(-) diff --git a/src/bytecode.c b/src/bytecode.c index d3d7782b..c956e477 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -122,21 +122,21 @@ static void rcode_downref( program_t *prg, tree_t **sp, code_t *instr ); void colm_parser_set_context( program_t *prg, tree_t **sp, parser_t *parser, struct_t *val ) { - parser->pdaRun->context = val; + parser->pda_run->context = val; } static head_t *tree_to_str( program_t *prg, tree_t **sp, tree_t *tree, int trim ) { /* Collect the tree data. */ StrCollect collect; - initStrCollect( &collect ); + init_str_collect( &collect ); - printTreeCollect( prg, sp, &collect, tree, trim ); + print_tree_collect( prg, sp, &collect, tree, trim ); /* Set up the input stream. */ - head_t *ret = stringAllocFull( prg, collect.data, collect.length ); + head_t *ret = string_alloc_full( prg, collect.data, collect.length ); - strCollectDestroy( &collect ); + str_collect_destroy( &collect ); return ret; } @@ -144,26 +144,26 @@ static head_t *tree_to_str( program_t *prg, tree_t **sp, tree_t *tree, int trim static word_t stream_append_tree( program_t *prg, tree_t **sp, stream_t *dest, tree_t *input ) { long length = 0; - struct stream_impl *impl = streamToImpl( dest ); + struct stream_impl *impl = stream_to_impl( dest ); if ( input->id == LEL_ID_STR ) { /* Collect the tree data. */ StrCollect collect; - initStrCollect( &collect ); - printTreeCollect( prg, sp, &collect, input, false ); + init_str_collect( &collect ); + print_tree_collect( prg, sp, &collect, input, false ); /* Load it into the input. */ - impl->funcs->appendData( impl, collect.data, collect.length ); + impl->funcs->append_data( impl, collect.data, collect.length ); length = collect.length; - strCollectDestroy( &collect ); + str_collect_destroy( &collect ); } else if ( input->id == LEL_ID_PTR ) { colm_tree_upref( input ); - impl->funcs->appendStream( impl, input ); + impl->funcs->append_stream( impl, input ); } else { colm_tree_upref( input ); - impl->funcs->appendTree( impl, input ); + impl->funcs->append_tree( impl, input ); } return length; @@ -173,8 +173,8 @@ static word_t stream_append_stream( program_t *prg, tree_t **sp, stream_t *dest, { long length = 0; - struct stream_impl *impl = streamToImpl( dest ); - impl->funcs->appendStream( impl, stream ); + struct stream_impl *impl = stream_to_impl( dest ); + impl->funcs->append_stream( impl, stream ); return length; } @@ -183,11 +183,11 @@ static void stream_undo_append( program_t *prg, tree_t **sp, struct stream_impl *is, tree_t *input, long length ) { if ( input->id == LEL_ID_STR ) - is->funcs->undoAppendData( is, length ); + is->funcs->undo_append_data( is, length ); else if ( input->id == LEL_ID_PTR ) - is->funcs->undoAppendStream( is ); + is->funcs->undo_append_stream( is ); else { - tree_t *tree = is->funcs->undoAppendTree( is ); + tree_t *tree = is->funcs->undo_append_tree( is ); colm_tree_downref( prg, sp, tree ); } } @@ -195,24 +195,24 @@ static void stream_undo_append( program_t *prg, tree_t **sp, static void stream_undo_append_stream( program_t *prg, tree_t **sp, struct stream_impl *is, tree_t *input, long length ) { - is->funcs->undoAppendStream( is ); + is->funcs->undo_append_stream( is ); } -static tree_t *stream_pull_bc( program_t *prg, tree_t **sp, struct pda_run *pdaRun, +static tree_t *stream_pull_bc( program_t *prg, tree_t **sp, struct pda_run *pda_run, stream_t *stream, tree_t *length ) { long len = ((long)length); - struct stream_impl *impl = streamToImpl( stream ); - head_t *tokdata = colm_stream_pull( prg, sp, pdaRun, impl, len ); - return constructString( prg, tokdata ); + struct stream_impl *impl = stream_to_impl( stream ); + head_t *tokdata = colm_stream_pull( prg, sp, pda_run, impl, len ); + return construct_string( prg, tokdata ); } static void undo_pull( program_t *prg, stream_t *stream, tree_t *str ) { - struct stream_impl *impl = streamToImpl( stream ); - const char *data = stringData( ( (str_t*)str )->value ); - long length = stringLength( ( (str_t*)str )->value ); - undoStreamPull( impl, data, length ); + struct stream_impl *impl = stream_to_impl( stream ); + const char *data = string_data( ( (str_t*)str )->value ); + long length = string_length( ( (str_t*)str )->value ); + undo_stream_pull( impl, data, length ); } static long stream_push( program_t *prg, tree_t **sp, struct stream_impl *in, tree_t *tree, int ignore ) @@ -224,12 +224,12 @@ static long stream_push( program_t *prg, tree_t **sp, struct stream_impl *in, tr /* Collect the tree data. */ StrCollect collect; - initStrCollect( &collect ); - printTreeCollect( prg, sp, &collect, tree, false ); + init_str_collect( &collect ); + print_tree_collect( prg, sp, &collect, tree, false ); colm_stream_push_text( in, collect.data, collect.length ); long length = collect.length; - strCollectDestroy( &collect ); + str_collect_destroy( &collect ); return length; } @@ -262,16 +262,16 @@ static void set_local( Execution *exec, long field, tree_t *tree ) static tree_t *get_local_split( program_t *prg, Execution *exec, long field ) { tree_t *val = vm_get_local( exec, field ); - tree_t *split = splitTree( prg, val ); + tree_t *split = split_tree( prg, val ); vm_set_local( exec, field, split ); return split; } static void downref_local_trees( program_t *prg, tree_t **sp, - Execution *exec, struct local_info *locals, long localsLen ) + Execution *exec, struct local_info *locals, long locals_len ) { long i; - for ( i = localsLen-1; i >= 0; i-- ) { + for ( i = locals_len-1; i >= 0; i-- ) { if ( locals[i].type == LI_Tree ) { debug( prg, REALM_BYTECODE, "local tree downref: %ld\n", (long)locals[i].offset ); @@ -283,10 +283,10 @@ static void downref_local_trees( program_t *prg, tree_t **sp, } static void downref_locals( program_t *prg, tree_t ***psp, - Execution *exec, struct local_info *locals, long localsLen ) + Execution *exec, struct local_info *locals, long locals_len ) { long i; - for ( i = localsLen-1; i >= 0; i-- ) { + for ( i = locals_len-1; i >= 0; i-- ) { switch ( locals[i].type ) { case LI_Tree: { debug( prg, REALM_BYTECODE, "local tree downref: %ld\n", @@ -326,7 +326,7 @@ static tree_t *construct_arg0( program_t *prg, int argc, const char **argv ) tree_t *arg0 = 0; if ( argc > 0 ) { head_t *head = colm_string_alloc_pointer( prg, argv[0], strlen(argv[0]) ); - arg0 = constructString( prg, head ); + arg0 = construct_string( prg, head ); colm_tree_upref( arg0 ); } return arg0; @@ -334,18 +334,18 @@ static tree_t *construct_arg0( program_t *prg, int argc, const char **argv ) static list_t *construct_argv( program_t *prg, int argc, const char **argv ) { - list_t *list = (list_t*)colm_construct_generic( prg, prg->rtd->argvGenericId ); + list_t *list = (list_t*)colm_construct_generic( prg, prg->rtd->argv_generic_id ); int i; for ( i = 1; i < argc; i++ ) { head_t *head = colm_string_alloc_pointer( prg, argv[i], strlen(argv[i]) ); - tree_t *arg = constructString( prg, head ); + tree_t *arg = construct_string( prg, head ); colm_tree_upref( arg ); struct_t *strct = colm_struct_new_size( prg, 16 ); - strct->id = prg->rtd->argvElId; + strct->id = prg->rtd->argv_el_id; colm_struct_set_field( strct, tree_t*, 0, arg ); - list_el_t *listEl = colm_struct_get_addr( strct, list_el_t*, 1 ); - colm_list_append( list, listEl ); + list_el_t *list_el = colm_struct_get_addr( strct, list_el_t*, 1 ); + colm_list_append( list, list_el ); } return list; @@ -357,34 +357,34 @@ static list_t *construct_argv( program_t *prg, int argc, const char **argv ) void colm_rcode_downref_all( program_t *prg, tree_t **sp, struct rt_code_vect *rev ) { - while ( rev->tabLen > 0 ) { + while ( rev->tab_len > 0 ) { /* Read the length */ - code_t *prcode = rev->data + rev->tabLen - SIZEOF_WORD; + code_t *prcode = rev->data + rev->tab_len - SIZEOF_WORD; word_t len; read_word_p( len, prcode ); /* Find the start of block. */ - long start = rev->tabLen - len - SIZEOF_WORD; + long start = rev->tab_len - len - SIZEOF_WORD; prcode = rev->data + start; /* Execute it. */ rcode_downref( prg, sp, prcode ); /* Backup over it. */ - rev->tabLen -= len + SIZEOF_WORD; + rev->tab_len -= len + SIZEOF_WORD; } } void colm_execute( program_t *prg, Execution *exec, code_t *code ) { - tree_t **sp = prg->stackRoot; + tree_t **sp = prg->stack_root; - struct frame_info *fi = &prg->rtd->frameInfo[prg->rtd->rootFrameId]; + struct frame_info *fi = &prg->rtd->frame_info[prg->rtd->root_frame_id]; /* Set up the stack as if we have * called. We allow a return value. */ - long stretch = FR_AA + fi->frameSize; + long stretch = FR_AA + fi->frame_size; vm_contiguous( stretch ); vm_push_tree( 0 ); @@ -393,27 +393,27 @@ void colm_execute( program_t *prg, Execution *exec, code_t *code ) vm_push_tree( 0 ); vm_push_tree( 0 ); - exec->framePtr = vm_ptop(); - vm_pushn( fi->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frameSize ); + exec->frame_ptr = vm_ptop(); + vm_pushn( fi->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); /* Execution loop. */ sp = colm_execute_code( prg, exec, sp, code ); - downref_locals( prg, &sp, exec, fi->locals, fi->localsLen ); - vm_popn( fi->frameSize ); + downref_locals( prg, &sp, exec, fi->locals, fi->locals_len ); + vm_popn( fi->frame_size ); vm_pop_ignore(); vm_pop_ignore(); - colm_tree_downref( prg, sp, prg->returnVal ); - prg->returnVal = vm_pop_tree(); + colm_tree_downref( prg, sp, prg->return_val ); + prg->return_val = vm_pop_tree(); vm_pop_ignore(); - prg->stackRoot = sp; + prg->stack_root = sp; } -tree_t *colm_run_func( struct colm_program *prg, int frameId, - const char **params, int paramCount ) +tree_t *colm_run_func( struct colm_program *prg, int frame_id, + const char **params, int param_count ) { /* Make the arguments available to the program. */ prg->argc = 0; @@ -422,155 +422,155 @@ tree_t *colm_run_func( struct colm_program *prg, int frameId, Execution execution; memset( &execution, 0, sizeof(execution) ); - tree_t **sp = prg->stackRoot; + tree_t **sp = prg->stack_root; - struct frame_info *fi = &prg->rtd->frameInfo[frameId]; + struct frame_info *fi = &prg->rtd->frame_info[frame_id]; code_t *code = fi->codeWC; - vm_pushn( paramCount ); - execution.callArgs = vm_ptop(); - memset( vm_ptop(), 0, sizeof(word_t) * paramCount ); + vm_pushn( param_count ); + execution.call_args = vm_ptop(); + memset( vm_ptop(), 0, sizeof(word_t) * param_count ); int p; - for ( p = 0; p < paramCount; p++ ) { + for ( p = 0; p < param_count; p++ ) { if ( params[p] == 0 ) { - ((value_t*)execution.callArgs)[p] = 0; + ((value_t*)execution.call_args)[p] = 0; } else { head_t *head = colm_string_alloc_pointer( prg, params[p], strlen(params[p]) ); - tree_t *tree = constructString( prg, head ); + tree_t *tree = construct_string( prg, head ); colm_tree_upref( tree ); - ((tree_t**)execution.callArgs)[p] = tree; + ((tree_t**)execution.call_args)[p] = tree; } } - long stretch = FR_AA + fi->frameSize; + long stretch = FR_AA + fi->frame_size; vm_contiguous( stretch ); /* Set up the stack as if we have called. We allow a return value. */ - vm_push_tree( (tree_t*)execution.callArgs ); + vm_push_tree( (tree_t*)execution.call_args ); vm_push_tree( 0 ); vm_push_tree( 0 ); vm_push_tree( 0 ); vm_push_tree( 0 ); - execution.frameId = frameId; + execution.frame_id = frame_id; - execution.framePtr = vm_ptop(); - vm_pushn( fi->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frameSize ); + execution.frame_ptr = vm_ptop(); + vm_pushn( fi->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); /* Execution loop. */ sp = colm_execute_code( prg, &execution, sp, code ); - colm_tree_downref( prg, sp, prg->returnVal ); - prg->returnVal = execution.retVal; + colm_tree_downref( prg, sp, prg->return_val ); + prg->return_val = execution.ret_val; - vm_popn( paramCount ); + vm_popn( param_count ); - assert( sp == prg->stackRoot ); + assert( sp == prg->stack_root ); - return prg->returnVal; + return prg->return_val; }; -int colm_make_reverse_code( struct pda_run *pdaRun ) +int colm_make_reverse_code( struct pda_run *pda_run ) { - struct rt_code_vect *reverseCode = &pdaRun->reverseCode; - struct rt_code_vect *rcodeCollect = &pdaRun->rcodeCollect; + struct rt_code_vect *reverse_code = &pda_run->reverse_code; + struct rt_code_vect *rcode_collect = &pda_run->rcode_collect; /* Do we need to revert the left hand side? */ /* Check if there was anything generated. */ - if ( rcodeCollect->tabLen == 0 ) + if ( rcode_collect->tab_len == 0 ) return false; - if ( pdaRun->rcBlockCount == 0 ) { + if ( pda_run->rc_block_count == 0 ) { /* One reverse code run for the DECK terminator. */ - append_code_val( reverseCode, IN_PCR_END_DECK ); - append_code_val( reverseCode, IN_PCR_RET ); - append_word( reverseCode, 2 ); - pdaRun->rcBlockCount += 1; - colm_increment_steps( pdaRun ); + append_code_val( reverse_code, IN_PCR_END_DECK ); + append_code_val( reverse_code, IN_PCR_RET ); + append_word( reverse_code, 2 ); + pda_run->rc_block_count += 1; + colm_increment_steps( pda_run ); } - long startLength = reverseCode->tabLen; + long start_length = reverse_code->tab_len; /* Go backwards, group by group, through the reverse code. Push each group * to the global reverse code stack. */ - code_t *p = rcodeCollect->data + rcodeCollect->tabLen; - while ( p != rcodeCollect->data ) { + code_t *p = rcode_collect->data + rcode_collect->tab_len; + while ( p != rcode_collect->data ) { p--; long len = *p; p = p - len; - append_code_vect( reverseCode, p, len ); + append_code_vect( reverse_code, p, len ); } /* Stop, then place a total length in the global stack. */ - append_code_val( reverseCode, IN_PCR_RET ); - long length = reverseCode->tabLen - startLength; - append_word( reverseCode, length ); + append_code_val( reverse_code, IN_PCR_RET ); + long length = reverse_code->tab_len - start_length; + append_word( reverse_code, length ); /* Clear the revere code buffer. */ - rcodeCollect->tabLen = 0; + rcode_collect->tab_len = 0; - pdaRun->rcBlockCount += 1; - colm_increment_steps( pdaRun ); + pda_run->rc_block_count += 1; + colm_increment_steps( pda_run ); return true; } -void colm_transfer_reverse_code( struct pda_run *pdaRun, parse_tree_t *parseTree ) +void colm_transfer_reverse_code( struct pda_run *pda_run, parse_tree_t *parse_tree ) { - if ( pdaRun->rcBlockCount > 0 ) { + if ( pda_run->rc_block_count > 0 ) { //debug( REALM_PARSE, "attaching reverse code to token\n" ); - parseTree->flags |= PF_HAS_RCODE; - pdaRun->rcBlockCount = 0; + parse_tree->flags |= PF_HAS_RCODE; + pda_run->rc_block_count = 0; } } static void rcode_unit_term( Execution *exec ) { - append_code_val( &exec->parser->pdaRun->rcodeCollect, exec->rcodeUnitLen ); - exec->rcodeUnitLen = 0; + append_code_val( &exec->parser->pda_run->rcode_collect, exec->rcode_unit_len ); + exec->rcode_unit_len = 0; } static void rcode_unit_start( Execution *exec ) { - exec->rcodeUnitLen = 0; + exec->rcode_unit_len = 0; } static void rcode_code( Execution *exec, const code_t code ) { - append_code_val( &exec->parser->pdaRun->rcodeCollect, code ); - exec->rcodeUnitLen += SIZEOF_CODE; + append_code_val( &exec->parser->pda_run->rcode_collect, code ); + exec->rcode_unit_len += SIZEOF_CODE; } -static void rcodeHalf( Execution *exec, const half_t half ) +static void rcode_half( Execution *exec, const half_t half ) { - append_half( &exec->parser->pdaRun->rcodeCollect, half ); - exec->rcodeUnitLen += SIZEOF_HALF; + append_half( &exec->parser->pda_run->rcode_collect, half ); + exec->rcode_unit_len += SIZEOF_HALF; } static void rcode_word( Execution *exec, const word_t word ) { - append_word( &exec->parser->pdaRun->rcodeCollect, word ); - exec->rcodeUnitLen += SIZEOF_WORD; + append_word( &exec->parser->pda_run->rcode_collect, word ); + exec->rcode_unit_len += SIZEOF_WORD; } -code_t *colm_pop_reverse_code( struct rt_code_vect *allRev ) +code_t *colm_pop_reverse_code( struct rt_code_vect *all_rev ) { /* Read the length */ - code_t *prcode = allRev->data + allRev->tabLen - SIZEOF_WORD; + code_t *prcode = all_rev->data + all_rev->tab_len - SIZEOF_WORD; word_t len; read_word_p( len, prcode ); /* Find the start of block. */ - long start = allRev->tabLen - len - SIZEOF_WORD; - prcode = allRev->data + start; + long start = all_rev->tab_len - len - SIZEOF_WORD; + prcode = all_rev->data + start; /* Backup over it. */ - allRev->tabLen -= len + SIZEOF_WORD; + all_rev->tab_len -= len + SIZEOF_WORD; return prcode; } @@ -591,8 +591,8 @@ again: read_tree( restore ); debug( prg, REALM_BYTECODE, "IN_RESTORE_LHS\n" ); - colm_tree_downref( prg, sp, exec->parser->pdaRun->parseInput->shadow->tree ); - exec->parser->pdaRun->parseInput->shadow->tree = restore; + colm_tree_downref( prg, sp, exec->parser->pda_run->parse_input->shadow->tree ); + exec->parser->pda_run->parse_input->shadow->tree = restore; break; } case IN_LOAD_NIL: { @@ -618,13 +618,13 @@ again: case IN_LOAD_TRUE: { debug( prg, REALM_BYTECODE, "IN_LOAD_TRUE\n" ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_LOAD_FALSE: { debug( prg, REALM_BYTECODE, "IN_LOAD_FALSE\n" ); //colm_tree_upref( prg->falseVal ); - vm_push_tree( prg->falseVal ); + vm_push_tree( prg->false_val ); break; } case IN_LOAD_INT: { @@ -643,8 +643,8 @@ again: debug( prg, REALM_BYTECODE, "IN_LOAD_STR %d\n", offset ); - head_t *lit = makeLiteral( prg, offset ); - tree_t *tree = constructString( prg, lit ); + head_t *lit = make_literal( prg, offset ); + tree_t *tree = construct_string( prg, lit ); colm_tree_upref( tree ); vm_push_tree( tree ); break; @@ -659,7 +659,7 @@ again: arg[i] = vm_pop_tree(); for ( i = 0; i < n; i++ ) - printTreeFile( prg, sp, stdout, arg[i], false ); + print_tree_file( prg, sp, stdout, arg[i], false ); for ( i = 0; i < n; i++ ) colm_tree_downref( prg, sp, arg[i] ); @@ -674,13 +674,13 @@ again: for ( i = n-1; i >= 0; i-- ) arg[i] = vm_pop_tree(); stream_t *stream = vm_pop_stream(); - struct stream_impl *si = streamToImpl( stream ); + struct stream_impl *si = stream_to_impl( stream ); for ( i = 0; i < n; i++ ) { if ( si->file != 0 ) - printTreeFile( prg, sp, si->file, arg[i], false ); + print_tree_file( prg, sp, si->file, arg[i], false ); else - printTreeFd( prg, sp, si->fd, arg[i], false ); + print_tree_fd( prg, sp, si->fd, arg[i], false ); } for ( i = 0; i < n; i++ ) @@ -698,7 +698,7 @@ again: arg[i] = vm_pop_tree(); for ( i = 0; i < n; i++ ) - printXmlStdout( prg, sp, arg[i], true, true ); + print_xml_stdout( prg, sp, arg[i], true, true ); for ( i = 0; i < n; i++ ) colm_tree_downref( prg, sp, arg[i] ); @@ -714,7 +714,7 @@ again: arg[i] = vm_pop_tree(); for ( i = 0; i < n; i++ ) - printXmlStdout( prg, sp, arg[i], false, true ); + print_xml_stdout( prg, sp, arg[i], false, true ); for ( i = 0; i < n; i++ ) colm_tree_downref( prg, sp, arg[i] ); @@ -782,26 +782,26 @@ again: break; } case IN_LOAD_INPUT_BKT: { - tree_t *accumStream; - read_tree( accumStream ); + tree_t *accum_stream; + read_tree( accum_stream ); debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_BKT\n" ); - colm_tree_upref( accumStream ); - vm_push_tree( accumStream ); + colm_tree_upref( accum_stream ); + vm_push_tree( accum_stream ); break; } case IN_LOAD_CONTEXT_R: { debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_R\n" ); - vm_push_type( struct_t*, exec->parser->pdaRun->context ); + vm_push_type( struct_t*, exec->parser->pda_run->context ); break; } case IN_LOAD_CONTEXT_WV: { debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_WV\n" ); - vm_push_type( struct_t *, exec->parser->pdaRun->context ); + vm_push_type( struct_t *, exec->parser->pda_run->context ); /* Set up the reverse instruction. */ rcode_unit_start( exec ); @@ -813,13 +813,13 @@ again: /* This is identical to the _R version, but using it for writing * would be confusing. */ - vm_push_type( struct_t *, exec->parser->pdaRun->context ); + vm_push_type( struct_t *, exec->parser->pda_run->context ); break; } case IN_LOAD_CONTEXT_BKT: { debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_BKT\n" ); - vm_push_type( struct_t *, exec->parser->pdaRun->context ); + vm_push_type( struct_t *, exec->parser->pda_run->context ); break; } @@ -842,16 +842,16 @@ again: /* If there are captures (this is a translate block) then copy them into * the local frame now. */ - struct lang_el_info *lelInfo = prg->rtd->lelInfo; - char **mark = exec->parser->pdaRun->mark; + struct lang_el_info *lel_info = prg->rtd->lel_info; + char **mark = exec->parser->pda_run->mark; int i; - for ( i = 0; i < lelInfo[exec->parser->pdaRun->tokenId].numCaptureAttr; i++ ) { - struct lang_el_info *lei = &lelInfo[exec->parser->pdaRun->tokenId]; - CaptureAttr *ca = &prg->rtd->captureAttr[lei->captureAttr + i]; - head_t *data = stringAllocFull( prg, mark[ca->mark_enter], + for ( i = 0; i < lel_info[exec->parser->pda_run->token_id].num_capture_attr; i++ ) { + struct lang_el_info *lei = &lel_info[exec->parser->pda_run->token_id]; + CaptureAttr *ca = &prg->rtd->capture_attr[lei->capture_attr + i]; + head_t *data = string_alloc_full( prg, mark[ca->mark_enter], mark[ca->mark_leave] - mark[ca->mark_enter] ); - tree_t *string = constructString( prg, data ); + tree_t *string = construct_string( prg, data ); colm_tree_upref( string ); set_local( exec, -1 - i, string ); } @@ -865,7 +865,7 @@ again: debug( prg, REALM_BYTECODE, "IN_INIT_RHS_EL %hd\n", field ); - tree_t *val = getRhsEl( prg, exec->parser->pdaRun->redLel->shadow->tree, position ); + tree_t *val = get_rhs_el( prg, exec->parser->pda_run->red_lel->shadow->tree, position ); colm_tree_upref( val ); vm_set_local(exec, field, val); break; @@ -878,13 +878,13 @@ again: debug( prg, REALM_BYTECODE, "IN_INIT_LHS_EL %hd\n", field ); /* We transfer it to to the local field. Possibly take a copy. */ - tree_t *val = exec->parser->pdaRun->redLel->shadow->tree; + tree_t *val = exec->parser->pda_run->red_lel->shadow->tree; /* Save it. */ colm_tree_upref( val ); - exec->parser->pdaRun->parsed = val; + exec->parser->pda_run->parsed = val; - exec->parser->pdaRun->redLel->shadow->tree = 0; + exec->parser->pda_run->red_lel->shadow->tree = 0; vm_set_local(exec, field, val); break; } @@ -896,7 +896,7 @@ again: tree_t *val = vm_get_local(exec, field); vm_set_local(exec, field, 0); - exec->parser->pdaRun->redLel->shadow->tree = val; + exec->parser->pda_run->red_lel->shadow->tree = val; break; } case IN_UITER_ADVANCE: { @@ -908,15 +908,15 @@ again: /* Get the iterator. */ user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - long yieldSize = vm_ssize() - uiter->rootSize; - assert( uiter->yieldSize == yieldSize ); + long yield_size = vm_ssize() - uiter->root_size; + assert( uiter->yield_size == yield_size ); /* Fix the return instruction pointer. */ - uiter->stackRoot[-IFR_AA + IFR_RIN] = (SW)instr; + uiter->stack_root[-IFR_AA + IFR_RIN] = (SW)instr; instr = uiter->resume; - exec->framePtr = uiter->frame; - exec->iframePtr = &uiter->stackRoot[-IFR_AA]; + exec->frame_ptr = uiter->frame; + exec->iframe_ptr = &uiter->stack_root[-IFR_AA]; break; } case IN_UITER_GET_CUR_R: { @@ -938,7 +938,7 @@ again: debug( prg, REALM_BYTECODE, "IN_UITER_GET_CUR_WC\n" ); user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - splitRef( prg, &sp, &uiter->ref ); + split_ref( prg, &sp, &uiter->ref ); tree_t *split = uiter->ref.kid->tree; colm_tree_upref( split ); vm_push_tree( split ); @@ -952,9 +952,9 @@ again: tree_t *t = vm_pop_tree(); user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - splitRef( prg, &sp, &uiter->ref ); + split_ref( prg, &sp, &uiter->ref ); tree_t *old = uiter->ref.kid->tree; - setUiterCur( prg, uiter, t ); + set_uiter_cur( prg, uiter, t ); colm_tree_downref( prg, sp, old ); break; } @@ -1035,7 +1035,7 @@ again: debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_REF_WC\n" ); ref_t *ref = (ref_t*) vm_get_plocal(exec, field); - splitRef( prg, &sp, ref ); + split_ref( prg, &sp, ref ); tree_t *val = ref->kid->tree; colm_tree_upref( val ); vm_push_tree( val ); @@ -1049,8 +1049,8 @@ again: tree_t *val = vm_pop_tree(); ref_t *ref = (ref_t*) vm_get_plocal(exec, field); - splitRef( prg, &sp, ref ); - refSetValue( prg, sp, ref, val ); + split_ref( prg, &sp, ref ); + ref_set_value( prg, sp, ref, val ); break; } case IN_GET_FIELD_TREE_R: { @@ -1076,7 +1076,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *split = getFieldSplit( prg, obj, field ); + tree_t *split = get_field_split( prg, obj, field ); colm_tree_upref( split ); vm_push_tree( split ); break; @@ -1090,13 +1090,13 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *split = getFieldSplit( prg, obj, field ); + tree_t *split = get_field_split( prg, obj, field ); colm_tree_upref( split ); vm_push_tree( split ); /* Set up the reverse instruction. */ rcode_code( exec, IN_GET_FIELD_TREE_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); break; } case IN_GET_FIELD_TREE_BKT: { @@ -1108,7 +1108,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *split = getFieldSplit( prg, obj, field ); + tree_t *split = get_field_split( prg, obj, field ); colm_tree_upref( split ); vm_push_tree( split ); break; @@ -1146,7 +1146,7 @@ again: /* Set up the reverse instruction. */ rcode_code( exec, IN_SET_FIELD_TREE_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); rcode_word( exec, (word_t)prev ); rcode_unit_term( exec ); break; @@ -1275,7 +1275,7 @@ again: /* Set up the reverse instruction. */ rcode_code( exec, IN_GET_STRUCT_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); break; } case IN_GET_STRUCT_BKT: { @@ -1287,7 +1287,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *split = getFieldSplit( prg, obj, field ); + tree_t *split = get_field_split( prg, obj, field ); colm_tree_upref( split ); vm_push_tree( split ); break; @@ -1322,7 +1322,7 @@ again: /* Set up the reverse instruction. */ rcode_code( exec, IN_SET_STRUCT_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); rcode_word( exec, (word_t)prev ); rcode_unit_term( exec ); break; @@ -1380,7 +1380,7 @@ again: colm_struct_set_field( strct, tree_t*, field, val ); rcode_code( exec, IN_SET_STRUCT_VAL_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); rcode_word( exec, (word_t)prev ); rcode_unit_term( exec ); break; @@ -1408,11 +1408,11 @@ again: read_byte( len ); for ( i = 0; i < len; i++ ) { - uchar prodNum, childNum; - read_byte( prodNum ); - read_byte( childNum ); - if ( !done && obj->prod_num == prodNum ) { - val = getRhsEl( prg, obj, childNum ); + uchar prod_num, child_num; + read_byte( prod_num ); + read_byte( child_num ); + if ( !done && obj->prod_num == prod_num ) { + val = get_rhs_el( prg, obj, child_num ); done = 1; } } @@ -1449,8 +1449,8 @@ again: vm_pop_tree(); value_t integer = vm_pop_value(); str_t *format = vm_pop_string(); - head_t *res = stringSprintf( prg, format, (long)integer ); - str_t *str = (str_t*)constructString( prg, res ); + head_t *res = string_sprintf( prg, format, (long)integer ); + str_t *str = (str_t*)construct_string( prg, res ); colm_tree_upref( (tree_t*)str ); vm_push_string( str ); colm_tree_downref( prg, sp, (tree_t*)format ); @@ -1460,8 +1460,8 @@ again: debug( prg, REALM_BYTECODE, "IN_INT_TO_STR\n" ); value_t i = vm_pop_value(); - head_t *res = intToStr( prg, (long)i ); - tree_t *str = constructString( prg, res ); + head_t *res = int_to_str( prg, (long)i ); + tree_t *str = construct_string( prg, res ); colm_tree_upref( str ); vm_push_tree( str ); break; @@ -1471,7 +1471,7 @@ again: tree_t *tree = vm_pop_tree(); head_t *res = tree_to_str( prg, sp, tree, false ); - tree_t *str = constructString( prg, res ); + tree_t *str = construct_string( prg, res ); colm_tree_upref( str ); vm_push_tree( str ); colm_tree_downref( prg, sp, tree ); @@ -1482,7 +1482,7 @@ again: tree_t *tree = vm_pop_tree(); head_t *res = tree_to_str( prg, sp, tree, true ); - tree_t *str = constructString( prg, res ); + tree_t *str = construct_string( prg, res ); colm_tree_upref( str ); vm_push_tree( str ); colm_tree_downref( prg, sp, tree ); @@ -1492,7 +1492,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TREE_TRIM\n" ); tree_t *tree = vm_pop_tree(); - tree_t *trimmed = treeTrim( prg, sp, tree ); + tree_t *trimmed = tree_trim( prg, sp, tree ); vm_push_tree( trimmed ); break; } @@ -1501,8 +1501,8 @@ again: str_t *s2 = vm_pop_string(); str_t *s1 = vm_pop_string(); - head_t *res = concatStr( s1->value, s2->value ); - tree_t *str = constructString( prg, res ); + head_t *res = concat_str( s1->value, s2->value ); + tree_t *str = construct_string( prg, res ); colm_tree_upref( str ); colm_tree_downref( prg, sp, (tree_t*)s1 ); colm_tree_downref( prg, sp, (tree_t*)s2 ); @@ -1514,7 +1514,7 @@ again: debug( prg, REALM_BYTECODE, "IN_STR_LENGTH\n" ); str_t *str = vm_pop_string(); - long len = stringLength( str->value ); + long len = string_length( str->value ); value_t res = len; vm_push_value( res ); colm_tree_downref( prg, sp, (tree_t*)str ); @@ -1527,7 +1527,7 @@ again: debug( prg, REALM_BYTECODE, "IN_JMP_FALSE_TREE %d\n", dist ); tree_t *tree = vm_pop_tree(); - if ( testFalse( prg, tree ) ) + if ( test_false( prg, tree ) ) instr += dist; colm_tree_downref( prg, sp, tree ); break; @@ -1539,7 +1539,7 @@ again: debug( prg, REALM_BYTECODE, "IN_JMP_TRUE_TREE %d\n", dist ); tree_t *tree = vm_pop_tree(); - if ( !testFalse( prg, tree ) ) + if ( !test_false( prg, tree ) ) instr += dist; colm_tree_downref( prg, sp, tree ); break; @@ -1577,7 +1577,7 @@ again: } case IN_REJECT: { debug( prg, REALM_BYTECODE, "IN_REJECT\n" ); - exec->parser->pdaRun->reject = true; + exec->parser->pda_run->reject = true; break; } @@ -1734,7 +1734,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TST_NZ_TREE\n" ); tree_t *tree = vm_pop_tree(); - long r = !testFalse( prg, tree ); + long r = !test_false( prg, tree ); colm_tree_downref( prg, sp, tree ); vm_push_value( r ); break; @@ -1753,7 +1753,7 @@ again: debug( prg, REALM_BYTECODE, "IN_NOT_TREE\n" ); tree_t *tree = vm_pop_tree(); - long r = testFalse( prg, tree ); + long r = test_false( prg, tree ); value_t val = r ? TRUE_VAL : FALSE_VAL; vm_push_value( val ); colm_tree_downref( prg, sp, tree ); @@ -1817,25 +1817,25 @@ again: } case IN_TRITER_FROM_REF: { short field; - half_t argSize; - half_t searchTypeId; + half_t arg_size; + half_t search_type_id; read_half( field ); - read_half( argSize ); - read_half( searchTypeId ); + read_half( arg_size ); + read_half( search_type_id ); debug( prg, REALM_BYTECODE, "IN_TRITER_FROM_REF " - "%hd %hd %hd\n", field, argSize, searchTypeId ); + "%hd %hd %hd\n", field, arg_size, search_type_id ); - ref_t rootRef; - rootRef.kid = vm_pop_kid(); - rootRef.next = vm_pop_ref(); + ref_t root_ref; + root_ref.kid = vm_pop_kid(); + root_ref.next = vm_pop_ref(); void *mem = vm_get_plocal(exec, field); - tree_t **stackRoot = vm_ptop(); - long rootSize = vm_ssize(); + tree_t **stack_root = vm_ptop(); + long root_size = vm_ssize(); - colm_init_tree_iter( (tree_iter_t*)mem, stackRoot, - argSize, rootSize, &rootRef, searchTypeId ); + colm_init_tree_iter( (tree_iter_t*)mem, stack_root, + arg_size, root_size, &root_ref, search_type_id ); break; } case IN_TRITER_UNWIND: @@ -1845,30 +1845,30 @@ again: tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); debug( prg, REALM_BYTECODE, "IN_TRITER_DESTROY %hd %d\n", - field, iter->yieldSize ); + field, iter->yield_size ); colm_tree_iter_destroy( prg, &sp, iter ); break; } case IN_REV_TRITER_FROM_REF: { short field; - half_t argSize; - half_t searchTypeId; + half_t arg_size; + half_t search_type_id; read_half( field ); - read_half( argSize ); - read_half( searchTypeId ); + read_half( arg_size ); + read_half( search_type_id ); debug( prg, REALM_BYTECODE, "IN_REV_TRITER_FROM_REF " - "%hd %hd %hd\n", field, argSize, searchTypeId ); + "%hd %hd %hd\n", field, arg_size, search_type_id ); - ref_t rootRef; - rootRef.kid = vm_pop_kid(); - rootRef.next = vm_pop_ref(); + ref_t root_ref; + root_ref.kid = vm_pop_kid(); + root_ref.next = vm_pop_ref(); - tree_t **stackRoot = vm_ptop(); - long rootSize = vm_ssize(); + tree_t **stack_root = vm_ptop(); + long root_size = vm_ssize(); int children = 0; - kid_t *kid = treeChild( prg, rootRef.kid->tree ); + kid_t *kid = tree_child( prg, root_ref.kid->tree ); while ( kid != 0 ) { vm_push_kid( kid ); kid = kid->next; @@ -1876,8 +1876,8 @@ again: } void *mem = vm_get_plocal(exec, field); - colm_init_rev_tree_iter( (rev_tree_iter_t*)mem, stackRoot, - argSize, rootSize, &rootRef, searchTypeId, children ); + colm_init_rev_tree_iter( (rev_tree_iter_t*)mem, stack_root, + arg_size, root_size, &root_ref, search_type_id, children ); break; } case IN_REV_TRITER_UNWIND: @@ -1898,7 +1898,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TREE_SEARCH\n" ); tree_t *tree = vm_pop_tree(); - tree_t *res = treeSearch( prg, tree, id ); + tree_t *res = tree_search( prg, tree, id ); colm_tree_upref( res ); vm_push_tree( res ); colm_tree_downref( prg, sp, tree ); @@ -1911,7 +1911,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_ADVANCE\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = treeIterAdvance( prg, &sp, iter ); + tree_t *res = tree_iter_advance( prg, &sp, iter ); //colm_tree_upref( res ); vm_push_tree( res ); break; @@ -1923,7 +1923,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_NEXT_CHILD\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = treeIterNextChild( prg, &sp, iter ); + tree_t *res = tree_iter_next_child( prg, &sp, iter ); //colm_tree_upref( res ); vm_push_tree( res ); break; @@ -1935,7 +1935,7 @@ again: debug( prg, REALM_BYTECODE, "IN_REV_TRITER_PREV_CHILD\n" ); rev_tree_iter_t *iter = (rev_tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = treeRevIterPrevChild( prg, &sp, iter ); + tree_t *res = tree_rev_iter_prev_child( prg, &sp, iter ); //colm_tree_upref( res ); vm_push_tree( res ); break; @@ -1947,7 +1947,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_NEXT_REPEAT\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = treeIterNextRepeat( prg, &sp, iter ); + tree_t *res = tree_iter_next_repeat( prg, &sp, iter ); //colm_tree_upref( res ); vm_push_tree( res ); break; @@ -1959,7 +1959,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_PREV_REPEAT\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = treeIterPrevRepeat( prg, &sp, iter ); + tree_t *res = tree_iter_prev_repeat( prg, &sp, iter ); //colm_tree_upref( res ); vm_push_tree( res ); break; @@ -1971,7 +1971,7 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_GET_CUR_R\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *tree = treeIterDerefCur( iter ); + tree_t *tree = tree_iter_deref_cur( iter ); colm_tree_upref( tree ); vm_push_tree( tree ); break; @@ -1983,8 +1983,8 @@ again: debug( prg, REALM_BYTECODE, "IN_TRITER_GET_CUR_WC\n" ); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - splitIterCur( prg, &sp, iter ); - tree_t *tree = treeIterDerefCur( iter ); + split_iter_cur( prg, &sp, iter ); + tree_t *tree = tree_iter_deref_cur( iter ); colm_tree_upref( tree ); vm_push_tree( tree ); break; @@ -1997,33 +1997,33 @@ again: tree_t *tree = vm_pop_tree(); tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - splitIterCur( prg, &sp, iter ); - tree_t *old = treeIterDerefCur( iter ); - setTriterCur( prg, iter, tree ); + split_iter_cur( prg, &sp, iter ); + tree_t *old = tree_iter_deref_cur( iter ); + set_triter_cur( prg, iter, tree ); colm_tree_downref( prg, sp, old ); break; } case IN_GEN_ITER_FROM_REF: { short field; - half_t argSize; - half_t genericId; + half_t arg_size; + half_t generic_id; read_half( field ); - read_half( argSize ); - read_half( genericId ); + read_half( arg_size ); + read_half( generic_id ); debug( prg, REALM_BYTECODE, "IN_LIST_ITER_FROM_REF " - "%hd %hd %hd\n", field, argSize, genericId ); + "%hd %hd %hd\n", field, arg_size, generic_id ); - ref_t rootRef; - rootRef.kid = vm_pop_kid(); - rootRef.next = vm_pop_ref(); + ref_t root_ref; + root_ref.kid = vm_pop_kid(); + root_ref.next = vm_pop_ref(); void *mem = vm_get_plocal(exec, field); - tree_t **stackRoot = vm_ptop(); - long rootSize = vm_ssize(); + tree_t **stack_root = vm_ptop(); + long root_size = vm_ssize(); - colm_init_list_iter( (generic_iter_t*)mem, stackRoot, argSize, - rootSize, &rootRef, genericId ); + colm_init_list_iter( (generic_iter_t*)mem, stack_root, arg_size, + root_size, &root_ref, generic_id ); break; } case IN_GEN_ITER_UNWIND: @@ -2033,7 +2033,7 @@ again: generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - debug( prg, REALM_BYTECODE, "IN_LIST_ITER_DESTROY %d\n", iter->yieldSize ); + debug( prg, REALM_BYTECODE, "IN_LIST_ITER_DESTROY %d\n", iter->yield_size ); colm_list_iter_destroy( prg, &sp, iter ); break; @@ -2086,33 +2086,33 @@ again: break; } case IN_MATCH: { - half_t patternId; - read_half( patternId ); + half_t pattern_id; + read_half( pattern_id ); debug( prg, REALM_BYTECODE, "IN_MATCH\n" ); tree_t *tree = vm_pop_tree(); /* Run the match, push the result. */ - int rootNode = prg->rtd->patReplInfo[patternId].offset; + int root_node = prg->rtd->pat_repl_info[pattern_id].offset; /* Bindings are indexed starting at 1. Zero bindId to represent no * binding. We make a space for it here rather than do math at * access them. */ - long numBindings = prg->rtd->patReplInfo[patternId].numBindings; - tree_t *bindings[1+numBindings]; - memset( bindings, 0, sizeof(tree_t*)*(1+numBindings) ); + long num_bindings = prg->rtd->pat_repl_info[pattern_id].num_bindings; + tree_t *bindings[1+num_bindings]; + memset( bindings, 0, sizeof(tree_t*)*(1+num_bindings) ); kid_t kid; kid.tree = tree; kid.next = 0; - int matched = matchPattern( bindings, prg, rootNode, &kid, false ); + int matched = match_pattern( bindings, prg, root_node, &kid, false ); if ( !matched ) - memset( bindings, 0, sizeof(tree_t*)*(1+numBindings) ); + memset( bindings, 0, sizeof(tree_t*)*(1+num_bindings) ); else { int b; - for ( b = 1; b <= numBindings; b++ ) + for ( b = 1; b <= num_bindings; b++ ) assert( bindings[b] != 0 ); } @@ -2120,7 +2120,7 @@ again: colm_tree_upref( result ); vm_push_tree( result ? tree : 0 ); int b; - for ( b = 1; b <= numBindings; b++ ) { + for ( b = 1; b <= num_bindings; b++ ) { colm_tree_upref( bindings[b] ); vm_push_tree( bindings[b] ); } @@ -2171,7 +2171,7 @@ again: debug( prg, REALM_BYTECODE, "IN_PARSE_APPEND_BKT\n" ); - struct stream_impl *si = streamToImpl( ((parser_t*)pptr)->input ); + struct stream_impl *si = stream_to_impl( ((parser_t*)pptr)->input ); stream_undo_append( prg, sp, si, input, len ); colm_tree_downref( prg, sp, input ); @@ -2218,7 +2218,7 @@ again: debug( prg, REALM_BYTECODE, "IN_PARSE_APPEND_STREAM_BKT\n" ); - struct stream_impl *si = streamToImpl( ((parser_t*)pptr)->input ); + struct stream_impl *si = stream_to_impl( ((parser_t*)pptr)->input ); stream_undo_append_stream( prg, sp, si, input, len ); colm_tree_downref( prg, sp, input ); @@ -2266,8 +2266,8 @@ again: debug( prg, REALM_BYTECODE, "IN_PARSE_LOAD\n" ); parser_t *parser = vm_pop_parser(); - struct pda_run *pdaRun = parser->pdaRun; - long steps = pdaRun->steps; + struct pda_run *pda_run = parser->pda_run; + long steps = pda_run->steps; vm_push_parser( exec->parser ); vm_push_type( long, exec->pcr ); @@ -2303,62 +2303,62 @@ again: case IN_PCR_CALL: { debug( prg, REALM_BYTECODE, "IN_PCR_CALL\n" ); - int frameSize = 0; - if ( exec->parser->pdaRun->frameId >= 0 ) { - struct frame_info *fi = &prg->rtd->frameInfo[exec->parser->pdaRun->frameId]; - frameSize = fi->frameSize; + int frame_size = 0; + if ( exec->parser->pda_run->frame_id >= 0 ) { + struct frame_info *fi = &prg->rtd->frame_info[exec->parser->pda_run->frame_id]; + frame_size = fi->frame_size; } - vm_contiguous( 4 + frameSize ); + vm_contiguous( 4 + frame_size ); - vm_push_type( tree_t**, exec->framePtr ); - vm_push_type( tree_t**, exec->iframePtr ); - vm_push_type( long, exec->frameId ); + vm_push_type( tree_t**, exec->frame_ptr ); + vm_push_type( tree_t**, exec->iframe_ptr ); + vm_push_type( long, exec->frame_id ); /* Return location one instruction back. Depends on the size of of * the frag/finish. */ - code_t *returnTo = instr - ( SIZEOF_CODE + SIZEOF_CODE + SIZEOF_HALF ); - vm_push_type( code_t*, returnTo ); + code_t *return_to = instr - ( SIZEOF_CODE + SIZEOF_CODE + SIZEOF_HALF ); + vm_push_type( code_t*, return_to ); - exec->framePtr = 0; - exec->iframePtr = 0; - exec->frameId = 0; + exec->frame_ptr = 0; + exec->iframe_ptr = 0; + exec->frame_id = 0; - instr = exec->parser->pdaRun->code; + instr = exec->parser->pda_run->code; - exec->frameId = exec->parser->pdaRun->frameId; + exec->frame_id = exec->parser->pda_run->frame_id; - if ( exec->parser->pdaRun->frameId >= 0 ) { - struct frame_info *fi = &prg->rtd->frameInfo[exec->parser->pdaRun->frameId]; + if ( exec->parser->pda_run->frame_id >= 0 ) { + struct frame_info *fi = &prg->rtd->frame_info[exec->parser->pda_run->frame_id]; - exec->framePtr = vm_ptop(); - vm_pushn( fi->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frameSize ); + exec->frame_ptr = vm_ptop(); + vm_pushn( fi->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); } break; } case IN_LOAD_RETVAL: { debug( prg, REALM_BYTECODE, "IN_LOAD_RETVAL\n" ); - vm_push_tree( exec->retVal ); + vm_push_tree( exec->ret_val ); break; } case IN_PCR_RET: { debug( prg, REALM_BYTECODE, "IN_PCR_RET\n" ); - if ( exec->frameId >= 0 ) { - struct frame_info *fi = &prg->rtd->frameInfo[exec->frameId]; - downref_local_trees( prg, sp, exec, fi->locals, fi->localsLen ); - debug( prg, REALM_BYTECODE, "RET: %d\n", fi->frameSize ); + if ( exec->frame_id >= 0 ) { + struct frame_info *fi = &prg->rtd->frame_info[exec->frame_id]; + downref_local_trees( prg, sp, exec, fi->locals, fi->locals_len ); + debug( prg, REALM_BYTECODE, "RET: %d\n", fi->frame_size ); - vm_popn( fi->frameSize ); + vm_popn( fi->frame_size ); } instr = vm_pop_type(code_t*); - exec->frameId = vm_pop_type(long); - exec->iframePtr = vm_pop_type(tree_t**); - exec->framePtr = vm_pop_type(tree_t**); + exec->frame_id = vm_pop_type(long); + exec->iframe_ptr = vm_pop_type(tree_t**); + exec->frame_ptr = vm_pop_type(tree_t**); if ( instr == 0 ) { fflush( stdout ); @@ -2369,18 +2369,18 @@ again: case IN_PCR_END_DECK: { debug( prg, REALM_BYTECODE, "IN_PCR_END_DECK\n" ); - exec->parser->pdaRun->onDeck = false; + exec->parser->pda_run->on_deck = false; break; } case IN_PARSE_FRAG_WC: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_WC %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_WC %hd\n", stop_id ); - exec->pcr = colm_parse_frag( prg, sp, exec->parser->pdaRun, - exec->parser->input, stopId, exec->pcr ); + exec->pcr = colm_parse_frag( prg, sp, exec->parser->pda_run, + exec->parser->input, stop_id, exec->pcr ); /* If done, jump to the terminating instruction, otherwise fall * through to call some code, then jump back here. */ @@ -2400,20 +2400,20 @@ again: vm_push_parser( parser ); - if ( prg->induceExit ) + if ( prg->induce_exit ) goto out; break; } case IN_PARSE_FRAG_WV: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_WV %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_WV %hd\n", stop_id ); - exec->pcr = colm_parse_frag( prg, sp, exec->parser->pdaRun, - exec->parser->input, stopId, exec->pcr ); + exec->pcr = colm_parse_frag( prg, sp, exec->parser->pda_run, + exec->parser->input, stop_id, exec->pcr ); /* If done, jump to the terminating instruction, otherwise fall * through to call some code, then jump back here. */ @@ -2440,23 +2440,23 @@ again: rcode_word( exec, (word_t) PCR_START ); rcode_word( exec, steps ); rcode_code( exec, IN_PARSE_FRAG_BKT ); - rcodeHalf( exec, 0 ); + rcode_half( exec, 0 ); rcode_code( exec, IN_PCR_CALL ); rcode_code( exec, IN_PARSE_FRAG_EXIT_BKT ); rcode_unit_term( exec ); - if ( prg->induceExit ) + if ( prg->induce_exit ) goto out; break; } case IN_PARSE_FRAG_BKT: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_BKT %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_BKT %hd\n", stop_id ); - exec->pcr = colm_parse_undo_frag( prg, sp, exec->parser->pdaRun, + exec->pcr = colm_parse_undo_frag( prg, sp, exec->parser->pda_run, exec->parser->input, exec->steps, exec->pcr ); if ( exec->pcr == PCR_DONE ) @@ -2475,14 +2475,14 @@ again: } case IN_PARSE_FINISH_WC: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_WC %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_WC %hd\n", stop_id ); tree_t *result = 0; exec->pcr = colm_parse_finish( &result, prg, sp, - exec->parser->pdaRun, exec->parser->input, false, exec->pcr ); + exec->parser->pda_run, exec->parser->input, false, exec->pcr ); exec->parser->result = result; @@ -2504,20 +2504,20 @@ again: vm_push_parser( parser ); - if ( prg->induceExit ) + if ( prg->induce_exit ) goto out; break; } case IN_PARSE_FINISH_WV: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_WV %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_WV %hd\n", stop_id ); tree_t *result = 0; - exec->pcr = colm_parse_finish( &result, prg, sp, exec->parser->pdaRun, + exec->pcr = colm_parse_finish( &result, prg, sp, exec->parser->pda_run, exec->parser->input, true, exec->pcr ); exec->parser->result = result; @@ -2545,24 +2545,24 @@ again: rcode_word( exec, (word_t)PCR_START ); rcode_word( exec, steps ); rcode_code( exec, IN_PARSE_FINISH_BKT ); - rcodeHalf( exec, 0 ); + rcode_half( exec, 0 ); rcode_code( exec, IN_PCR_CALL ); rcode_code( exec, IN_PARSE_FINISH_EXIT_BKT ); rcode_unit_term( exec ); - if ( prg->induceExit ) + if ( prg->induce_exit ) goto out; break; } case IN_PARSE_FINISH_BKT: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); - debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_BKT %hd\n", stopId ); + debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_BKT %hd\n", stop_id ); - exec->pcr = colm_parse_undo_frag( prg, sp, exec->parser->pdaRun, + exec->pcr = colm_parse_undo_frag( prg, sp, exec->parser->pda_run, exec->parser->input, exec->steps, exec->pcr ); if ( exec->pcr == PCR_DONE ) @@ -2579,8 +2579,8 @@ again: exec->pcr = vm_pop_type(long); exec->parser = vm_pop_parser(); - struct stream_impl *si = streamToImpl( parser->input ); - si->funcs->unsetEof( si ); + struct stream_impl *si = stream_to_impl( parser->input ); + si->funcs->unset_eof( si ); break; } @@ -2589,8 +2589,8 @@ again: stream_t *stream = vm_pop_stream(); tree_t *len = vm_pop_tree(); - struct pda_run *pdaRun = exec->parser != 0 ? exec->parser->pdaRun : 0; - tree_t *string = stream_pull_bc( prg, sp, pdaRun, stream, len ); + struct pda_run *pda_run = exec->parser != 0 ? exec->parser->pda_run : 0; + tree_t *string = stream_pull_bc( prg, sp, pda_run, stream, len ); colm_tree_upref( string ); vm_push_tree( string ); @@ -2609,8 +2609,8 @@ again: stream_t *stream = vm_pop_stream(); tree_t *len = vm_pop_tree(); - struct pda_run *pdaRun = exec->parser != 0 ? exec->parser->pdaRun : 0; - tree_t *string = stream_pull_bc( prg, sp, pdaRun, stream, len ); + struct pda_run *pda_run = exec->parser != 0 ? exec->parser->pda_run : 0; + tree_t *string = stream_pull_bc( prg, sp, pda_run, stream, len ); colm_tree_upref( string ); vm_push_tree( string ); @@ -2634,7 +2634,7 @@ again: stream_t *input = vm_pop_stream(); tree_t *tree = vm_pop_tree(); - long len = stream_push( prg, sp, streamToImpl( input ), tree, false ); + long len = stream_push( prg, sp, stream_to_impl( input ), tree, false ); vm_push_tree( 0 ); /* Single unit. */ @@ -2650,7 +2650,7 @@ again: stream_t *input = vm_pop_stream(); tree_t *tree = vm_pop_tree(); - long len = stream_push( prg, sp, streamToImpl( input ), tree, true ); + long len = stream_push( prg, sp, stream_to_impl( input ), tree, true ); vm_push_tree( 0 ); /* Single unit. */ @@ -2668,15 +2668,15 @@ again: debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_BKT %d\n", len ); stream_t *input = vm_pop_stream(); - colm_undo_stream_push( prg, sp, streamToImpl( input ), len ); + colm_undo_stream_push( prg, sp, stream_to_impl( input ), len ); break; } case IN_INPUT_PUSH_STREAM_WV: { debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_STREAM_WV\n" ); stream_t *input = vm_pop_stream(); - stream_t *toPush = vm_pop_stream(); - long len = stream_push_stream( prg, sp, streamToImpl( input ), toPush ); + stream_t *to_push = vm_pop_stream(); + long len = stream_push_stream( prg, sp, stream_to_impl( input ), to_push ); vm_push_tree( 0 ); /* Single unit. */ @@ -2692,63 +2692,63 @@ again: debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_STREAM_BKT %d\n", len ); stream_t *input = vm_pop_stream(); - colm_undo_stream_push( prg, sp, streamToImpl( input ), len ); + colm_undo_stream_push( prg, sp, stream_to_impl( input ), len ); break; } case IN_CONS_GENERIC: { - half_t genericId; - read_half( genericId ); + half_t generic_id; + read_half( generic_id ); - debug( prg, REALM_BYTECODE, "IN_CONS_GENERIC %hd\n", genericId ); + debug( prg, REALM_BYTECODE, "IN_CONS_GENERIC %hd\n", generic_id ); - struct_t *gen = colm_construct_generic( prg, genericId ); + struct_t *gen = colm_construct_generic( prg, generic_id ); vm_push_struct( gen ); break; } case IN_CONS_OBJECT: { - half_t langElId; - read_half( langElId ); + half_t lang_el_id; + read_half( lang_el_id ); - debug( prg, REALM_BYTECODE, "IN_CONS_OBJECT %hd\n", langElId ); + debug( prg, REALM_BYTECODE, "IN_CONS_OBJECT %hd\n", lang_el_id ); - tree_t *replTree = colm_construct_object( prg, 0, 0, langElId ); - vm_push_tree( replTree ); + tree_t *repl_tree = colm_construct_object( prg, 0, 0, lang_el_id ); + vm_push_tree( repl_tree ); break; } case IN_CONSTRUCT: { - half_t patternId; - read_half( patternId ); + half_t pattern_id; + read_half( pattern_id ); debug( prg, REALM_BYTECODE, "IN_CONSTRUCT\n" ); //struct lang_el_info *lelInfo = prg->rtd->lelInfo; //struct pat_cons_node *nodes = prg->rtd->patReplNodes; - int rootNode = prg->rtd->patReplInfo[patternId].offset; + int root_node = prg->rtd->pat_repl_info[pattern_id].offset; /* Note that bindIds are indexed at one. Add one spot for them. */ - int numBindings = prg->rtd->patReplInfo[patternId].numBindings; - tree_t *bindings[1+numBindings]; + int num_bindings = prg->rtd->pat_repl_info[pattern_id].num_bindings; + tree_t *bindings[1+num_bindings]; int b; - for ( b = 1; b <= numBindings; b++ ) { + for ( b = 1; b <= num_bindings; b++ ) { bindings[b] = vm_pop_tree(); assert( bindings[b] != 0 ); } - tree_t *replTree = colm_construct_tree( prg, 0, bindings, rootNode ); + tree_t *repl_tree = colm_construct_tree( prg, 0, bindings, root_node ); - vm_push_tree( replTree ); + vm_push_tree( repl_tree ); break; } case IN_CONSTRUCT_TERM: { - half_t tokenId; - read_half( tokenId ); + half_t token_id; + read_half( token_id ); debug( prg, REALM_BYTECODE, "IN_CONSTRUCT_TERM\n" ); /* Pop the string we are constructing the token from. */ str_t *str = vm_pop_string(); - tree_t *res = colm_construct_term( prg, tokenId, str->value ); + tree_t *res = colm_construct_term( prg, token_id, str->value ); colm_tree_upref( res ); vm_push_tree( res ); break; @@ -2781,7 +2781,7 @@ again: for ( i = nargs-1; i >= 0; i-- ) arg[i] = vm_pop_tree(); - tree_t *result = makeTree( prg, arg, nargs ); + tree_t *result = make_tree( prg, arg, nargs ); for ( i = 1; i < nargs; i++ ) colm_tree_downref( prg, sp, arg[i] ); @@ -2789,13 +2789,13 @@ again: break; } case IN_TREE_CAST: { - half_t langElId; - read_half( langElId ); + half_t lang_el_id; + read_half( lang_el_id ); - debug( prg, REALM_BYTECODE, "IN_TREE_CAST %hd\n", langElId ); + debug( prg, REALM_BYTECODE, "IN_TREE_CAST %hd\n", lang_el_id ); tree_t *tree = vm_pop_tree(); - tree_t *res = castTree( prg, langElId, tree ); + tree_t *res = cast_tree( prg, lang_el_id, tree ); colm_tree_upref( res ); colm_tree_downref( prg, sp, tree ); vm_push_tree( res ); @@ -2859,7 +2859,7 @@ again: ref_t *ref = (ref_t*)(sp + back); tree_t *obj = ref->kid->tree; - kid_t *attr_kid = getFieldKid( obj, field ); + kid_t *attr_kid = get_field_kid( obj, field ); vm_contiguous( 2 ); vm_push_ref( ref ); @@ -2878,22 +2878,22 @@ again: ref_t *ref = (ref_t*)(sp + back); tree_t *obj = ref->kid->tree; - kid_t *attrKid = 0; + kid_t *attr_kid = 0; read_byte( len ); for ( i = 0; i < len; i++ ) { - uchar prodNum, childNum; - read_byte( prodNum ); - read_byte( childNum ); - if ( !done && obj->prod_num == prodNum ) { - attrKid = getRhsElKid( prg, obj, childNum ); + uchar prod_num, child_num; + read_byte( prod_num ); + read_byte( child_num ); + if ( !done && obj->prod_num == prod_num ) { + attr_kid = get_rhs_el_kid( prg, obj, child_num ); done = 1; } } vm_contiguous( 2 ); vm_push_ref( ref ); - vm_push_kid( attrKid ); + vm_push_kid( attr_kid ); break; } case IN_REF_FROM_BACK: { @@ -2940,8 +2940,8 @@ again: debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_DATA_R\n" ); tree_t *tree = vm_pop_tree(); - head_t *data = stringCopy( prg, tree->tokdata ); - tree_t *str = constructString( prg, data ); + head_t *data = string_copy( prg, tree->tokdata ); + tree_t *str = construct_string( prg, data ); colm_tree_upref( str ); vm_push_tree( str ); colm_tree_downref( prg, sp, tree ); @@ -2952,8 +2952,8 @@ again: tree_t *tree = vm_pop_tree(); tree_t *val = vm_pop_tree(); - head_t *head = stringCopy( prg, ((str_t*)val)->value ); - stringFree( prg, tree->tokdata ); + head_t *head = string_copy( prg, ((str_t*)val)->value ); + string_free( prg, tree->tokdata ); tree->tokdata = head; colm_tree_downref( prg, sp, tree ); @@ -2967,7 +2967,7 @@ again: tree_t *val = vm_pop_tree(); head_t *oldval = tree->tokdata; - head_t *head = stringCopy( prg, ((str_t*)val)->value ); + head_t *head = string_copy( prg, ((str_t*)val)->value ); tree->tokdata = head; /* Set up reverse code. Needs no args. */ @@ -2987,7 +2987,7 @@ again: tree_t *tree = vm_pop_tree(); head_t *head = (head_t*)oldval; - stringFree( prg, tree->tokdata ); + string_free( prg, tree->tokdata ); tree->tokdata = head; colm_tree_downref( prg, sp, tree ); break; @@ -3018,15 +3018,15 @@ again: case IN_GET_MATCH_LENGTH_R: { debug( prg, REALM_BYTECODE, "IN_GET_MATCH_LENGTH_R\n" ); - value_t integer = stringLength(exec->parser->pdaRun->tokdata); + value_t integer = string_length(exec->parser->pda_run->tokdata); vm_push_value( integer ); break; } case IN_GET_MATCH_TEXT_R: { debug( prg, REALM_BYTECODE, "IN_GET_MATCH_TEXT_R\n" ); - head_t *s = stringCopy( prg, exec->parser->pdaRun->tokdata ); - tree_t *tree = constructString( prg, s ); + head_t *s = string_copy( prg, exec->parser->pda_run->tokdata ); + tree_t *tree = construct_string( prg, s ); colm_tree_upref( tree ); vm_push_tree( tree ); break; @@ -3042,29 +3042,29 @@ again: break; } case IN_GET_LIST_EL_MEM_R: { - short genId, field; - read_half( genId ); + short gen_id, field; + read_half( gen_id ); read_half( field ); debug( prg, REALM_BYTECODE, "IN_GET_LIST_EL_MEM_R\n" ); struct_t *s = vm_pop_struct(); - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); - struct_t *val = colm_list_el_get( prg, listEl, genId, field ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); + struct_t *val = colm_list_el_get( prg, list_el, gen_id, field ); vm_push_struct( val ); break; } case IN_GET_LIST_MEM_R: { - short genId, field; - read_half( genId ); + short gen_id, field; + read_half( gen_id ); read_half( field ); debug( prg, REALM_BYTECODE, - "IN_GET_LIST_MEM_R %hd %hd\n", genId, field ); + "IN_GET_LIST_MEM_R %hd %hd\n", gen_id, field ); list_t *list = vm_pop_list(); - struct_t *val = colm_list_get( prg, list, genId, field ); + struct_t *val = colm_list_get( prg, list, gen_id, field ); vm_push_struct( val ); break; } @@ -3077,7 +3077,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); break; @@ -3091,13 +3091,13 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); /* Set up the reverse instruction. */ rcode_code( exec, IN_GET_LIST_MEM_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); break; } case IN_GET_LIST_MEM_BKT: { @@ -3109,21 +3109,21 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *res = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( res ); vm_push_tree( res ); break; } case IN_GET_VLIST_MEM_R: { - short genId, field; - read_half( genId ); + short gen_id, field; + read_half( gen_id ); read_half( field ); debug( prg, REALM_BYTECODE, - "IN_GET_VLIST_MEM_R %hd %hd\n", genId, field ); + "IN_GET_VLIST_MEM_R %hd %hd\n", gen_id, field ); list_t *list = vm_pop_list(); - struct_t *el = colm_list_get( prg, list, genId, field ); + struct_t *el = colm_list_get( prg, list, gen_id, field ); value_t val = colm_struct_get_field( el, value_t, 0 ); vm_push_value( val ); @@ -3138,7 +3138,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); break; @@ -3152,13 +3152,13 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); /* Set up the reverse instruction. */ rcode_code( exec, IN_GET_LIST_MEM_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); break; } case IN_GET_VLIST_MEM_BKT: { @@ -3170,7 +3170,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *res = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( res ); vm_push_tree( res ); break; @@ -3182,7 +3182,7 @@ again: debug( prg, REALM_BYTECODE, "IN_GET_PARSER_MEM_R %hd\n", field ); tree_t *obj = vm_pop_tree(); - tree_t *val = getParserMem( (parser_t*)obj, field ); + tree_t *val = get_parser_mem( (parser_t*)obj, field ); colm_tree_upref( val ); /* In at least one case we extract the result on a parser with ref @@ -3193,16 +3193,16 @@ again: } case IN_GET_MAP_EL_MEM_R: { - short genId, field; - read_half( genId ); + short gen_id, field; + read_half( gen_id ); read_half( field ); debug( prg, REALM_BYTECODE, "IN_GET_MAP_EL_MEM_R\n" ); struct_t *strct = vm_pop_struct(); - map_el_t *mapEl = colm_struct_to_map_el( prg, strct, genId ); - struct_t *val = colm_map_el_get( prg, mapEl, genId, field ); + map_el_t *map_el = colm_struct_to_map_el( prg, strct, gen_id ); + struct_t *val = colm_map_el_get( prg, map_el, gen_id, field ); vm_push_struct( val ); break; } @@ -3210,7 +3210,7 @@ again: debug( prg, REALM_BYTECODE, "IN_MAP_LENGTH\n" ); tree_t *obj = vm_pop_tree(); - long len = mapLength( (map_t*)obj ); + long len = map_length( (map_t*)obj ); value_t res = len; vm_push_value( res ); @@ -3218,15 +3218,15 @@ again: break; } case IN_GET_MAP_MEM_R: { - short genId, field; - read_half( genId ); + short gen_id, field; + read_half( gen_id ); read_half( field ); debug( prg, REALM_BYTECODE, - "IN_GET_MAP_MEM_R %hd %hd\n", genId, field ); + "IN_GET_MAP_MEM_R %hd %hd\n", gen_id, field ); map_t *map = vm_pop_map(); - struct_t *val = colm_map_get( prg, map, genId, field ); + struct_t *val = colm_map_get( prg, map, gen_id, field ); vm_push_struct( val ); break; } @@ -3239,7 +3239,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); break; @@ -3253,13 +3253,13 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *val = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( val ); vm_push_tree( val ); /* Set up the reverse instruction. */ rcode_code( exec, IN_GET_MAP_MEM_BKT ); - rcodeHalf( exec, field ); + rcode_half( exec, field ); break; } case IN_GET_MAP_MEM_BKT: { @@ -3271,7 +3271,7 @@ again: tree_t *obj = vm_pop_tree(); colm_tree_downref( prg, sp, obj ); - tree_t *res = getListMemSplit( prg, (list_t*)obj, field ); + tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); colm_tree_upref( res ); vm_push_tree( res ); break; @@ -3287,7 +3287,7 @@ again: while ( size > 0 ) { value_t v = vm_pop_value(); - ((value_t*)exec->callArgs)[pos] = v; + ((value_t*)exec->call_args)[pos] = v; size -= 1; pos += 1; } @@ -3301,9 +3301,9 @@ again: debug( prg, REALM_BYTECODE, "IN_PREP_ARGS %hd\n", size ); - vm_push_type( tree_t**, exec->callArgs ); + vm_push_type( tree_t**, exec->call_args ); vm_pushn( size ); - exec->callArgs = vm_ptop(); + exec->call_args = vm_ptop(); memset( vm_ptop(), 0, sizeof(word_t) * size ); break; } @@ -3315,67 +3315,67 @@ again: debug( prg, REALM_BYTECODE, "IN_CLEAR_ARGS %hd\n", size ); vm_popn( size ); - exec->callArgs = vm_pop_type( tree_t** ); + exec->call_args = vm_pop_type( tree_t** ); break; } case IN_HOST: { - half_t funcId; - read_half( funcId ); + half_t func_id; + read_half( func_id ); - debug( prg, REALM_BYTECODE, "IN_HOST %hd\n", funcId ); + debug( prg, REALM_BYTECODE, "IN_HOST %hd\n", func_id ); - sp = host_call( prg, funcId, sp ); + sp = host_call( prg, func_id, sp ); break; } case IN_CALL_WV: { - half_t funcId; - read_half( funcId ); + half_t func_id; + read_half( func_id ); - struct function_info *fi = &prg->rtd->functionInfo[funcId]; - struct frame_info *fr = &prg->rtd->frameInfo[fi->frameId]; + struct function_info *fi = &prg->rtd->function_info[func_id]; + struct frame_info *fr = &prg->rtd->frame_info[fi->frame_id]; debug( prg, REALM_BYTECODE, "IN_CALL_WV %s\n", fr->name ); - vm_contiguous( FR_AA + fi->frameSize ); + vm_contiguous( FR_AA + fi->frame_size ); - vm_push_type( tree_t**, exec->callArgs ); + vm_push_type( tree_t**, exec->call_args ); vm_push_value( 0 ); /* Return value. */ vm_push_type( code_t*, instr ); - vm_push_type( tree_t**, exec->framePtr ); - vm_push_type( long, exec->frameId ); + vm_push_type( tree_t**, exec->frame_ptr ); + vm_push_type( long, exec->frame_id ); instr = fr->codeWV; - exec->frameId = fi->frameId; + exec->frame_id = fi->frame_id; - exec->framePtr = vm_ptop(); - vm_pushn( fr->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fr->frameSize ); + exec->frame_ptr = vm_ptop(); + vm_pushn( fr->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fr->frame_size ); break; } case IN_CALL_WC: { - half_t funcId; - read_half( funcId ); + half_t func_id; + read_half( func_id ); - struct function_info *fi = &prg->rtd->functionInfo[funcId]; - struct frame_info *fr = &prg->rtd->frameInfo[fi->frameId]; + struct function_info *fi = &prg->rtd->function_info[func_id]; + struct frame_info *fr = &prg->rtd->frame_info[fi->frame_id]; - debug( prg, REALM_BYTECODE, "IN_CALL_WC %s %d\n", fr->name, fr->frameSize ); + debug( prg, REALM_BYTECODE, "IN_CALL_WC %s %d\n", fr->name, fr->frame_size ); - vm_contiguous( FR_AA + fi->frameSize ); + vm_contiguous( FR_AA + fi->frame_size ); - vm_push_type( tree_t**, exec->callArgs ); + vm_push_type( tree_t**, exec->call_args ); vm_push_value( 0 ); /* Return value. */ vm_push_type( code_t*, instr ); - vm_push_type( tree_t**, exec->framePtr ); - vm_push_type( long, exec->frameId ); + vm_push_type( tree_t**, exec->frame_ptr ); + vm_push_type( long, exec->frame_id ); instr = fr->codeWC; - exec->frameId = fi->frameId; + exec->frame_id = fi->frame_id; - exec->framePtr = vm_ptop(); - vm_pushn( fr->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fr->frameSize ); + exec->frame_ptr = vm_ptop(); + vm_pushn( fr->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fr->frame_size ); break; } case IN_YIELD: { @@ -3386,23 +3386,23 @@ again: user_iter_t *uiter = (user_iter_t*) vm_plocal_iframe( IFR_AA ); if ( kid == 0 || kid->tree == 0 || - kid->tree->id == uiter->searchId || - uiter->searchId == prg->rtd->anyId ) + kid->tree->id == uiter->search_id || + uiter->search_id == prg->rtd->any_id ) { /* Store the yeilded value. */ uiter->ref.kid = kid; uiter->ref.next = next; - uiter->yieldSize = vm_ssize() - uiter->rootSize; + uiter->yield_size = vm_ssize() - uiter->root_size; uiter->resume = instr; - uiter->frame = exec->framePtr; + uiter->frame = exec->frame_ptr; /* Restore the instruction and frame pointer. */ instr = (code_t*) vm_local_iframe(IFR_RIN); - exec->framePtr = (tree_t**) vm_local_iframe(IFR_RFR); - exec->iframePtr = (tree_t**) vm_local_iframe(IFR_RIF); + exec->frame_ptr = (tree_t**) vm_local_iframe(IFR_RFR); + exec->iframe_ptr = (tree_t**) vm_local_iframe(IFR_RIF); /* Return the yield result on the top of the stack. */ - tree_t *result = uiter->ref.kid != 0 ? prg->trueVal : prg->falseVal; + tree_t *result = uiter->ref.kid != 0 ? prg->true_val : prg->false_val; //colm_tree_upref( result ); vm_push_tree( result ); } @@ -3410,18 +3410,18 @@ again: } case IN_UITER_CREATE_WV: { short field; - half_t funcId, searchId; + half_t func_id, search_id; read_half( field ); - read_half( funcId ); - read_half( searchId ); + read_half( func_id ); + read_half( search_id ); debug( prg, REALM_BYTECODE, "IN_UITER_CREATE_WV\n" ); - struct function_info *fi = prg->rtd->functionInfo + funcId; + struct function_info *fi = prg->rtd->function_info + func_id; - vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frameSize ); + vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frame_size ); - user_iter_t *uiter = colm_uiter_create( prg, &sp, fi, searchId ); + user_iter_t *uiter = colm_uiter_create( prg, &sp, fi, search_id ); vm_set_local(exec, field, (SW) uiter); /* This is a setup similar to as a call, only the frame structure @@ -3429,34 +3429,34 @@ again: * the call. We don't need to set up the return ip because the * uiter advance will set it. The frame we need to do because it * is set once for the lifetime of the iterator. */ - vm_push_type( tree_t**, exec->callArgs ); + vm_push_type( tree_t**, exec->call_args ); vm_push_value( 0 ); vm_push_type( code_t*, 0 ); /* Return instruction pointer, */ - vm_push_type( tree_t**, exec->iframePtr ); /* Return iframe. */ - vm_push_type( tree_t**, exec->framePtr ); /* Return frame. */ + vm_push_type( tree_t**, exec->iframe_ptr ); /* Return iframe. */ + vm_push_type( tree_t**, exec->frame_ptr ); /* Return frame. */ uiter->frame = vm_ptop(); - vm_pushn( fi->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frameSize ); + vm_pushn( fi->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); - uiterInit( prg, sp, uiter, fi, true ); + uiter_init( prg, sp, uiter, fi, true ); break; } case IN_UITER_CREATE_WC: { short field; - half_t funcId, searchId; + half_t func_id, search_id; read_half( field ); - read_half( funcId ); - read_half( searchId ); + read_half( func_id ); + read_half( search_id ); debug( prg, REALM_BYTECODE, "IN_UITER_CREATE_WC\n" ); - struct function_info *fi = prg->rtd->functionInfo + funcId; + struct function_info *fi = prg->rtd->function_info + func_id; - vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frameSize ); + vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frame_size ); - user_iter_t *uiter = colm_uiter_create( prg, &sp, fi, searchId ); + user_iter_t *uiter = colm_uiter_create( prg, &sp, fi, search_id ); vm_set_local(exec, field, (SW) uiter); /* This is a setup similar to as a call, only the frame structure @@ -3464,18 +3464,18 @@ again: * the call. We don't need to set up the return ip because the * uiter advance will set it. The frame we need to do because it * is set once for the lifetime of the iterator. */ - vm_push_type( tree_t**, exec->callArgs ); + vm_push_type( tree_t**, exec->call_args ); vm_push_value( 0 ); vm_push_type( code_t*, 0 ); /* Return instruction pointer, */ - vm_push_type( tree_t**, exec->iframePtr ); /* Return iframe. */ - vm_push_type( tree_t**, exec->framePtr ); /* Return frame. */ + vm_push_type( tree_t**, exec->iframe_ptr ); /* Return iframe. */ + vm_push_type( tree_t**, exec->frame_ptr ); /* Return frame. */ uiter->frame = vm_ptop(); - vm_pushn( fi->frameSize ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frameSize ); + vm_pushn( fi->frame_size ); + memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); - uiterInit( prg, sp, uiter, fi, false ); + uiter_init( prg, sp, uiter, fi, false ); break; } case IN_UITER_DESTROY: { @@ -3501,18 +3501,18 @@ again: } case IN_RET: { - struct frame_info *fi = &prg->rtd->frameInfo[exec->frameId]; - downref_local_trees( prg, sp, exec, fi->locals, fi->localsLen ); - vm_popn( fi->frameSize ); + struct frame_info *fi = &prg->rtd->frame_info[exec->frame_id]; + downref_local_trees( prg, sp, exec, fi->locals, fi->locals_len ); + vm_popn( fi->frame_size ); - exec->frameId = vm_pop_type(long); - exec->framePtr = vm_pop_type(tree_t**); + exec->frame_id = vm_pop_type(long); + exec->frame_ptr = vm_pop_type(tree_t**); instr = vm_pop_type(code_t*); - exec->retVal = vm_pop_tree(); + exec->ret_val = vm_pop_tree(); vm_pop_value(); //vm_popn( fi->argSize ); - fi = &prg->rtd->frameInfo[exec->frameId]; + fi = &prg->rtd->frame_info[exec->frame_id]; debug( prg, REALM_BYTECODE, "IN_RET %s\n", fi->name ); /* This if for direct calls of functions. */ @@ -3538,8 +3538,8 @@ again: debug( prg, REALM_BYTECODE, "IN_TO_UPPER\n" ); tree_t *in = vm_pop_tree(); - head_t *head = stringToUpper( in->tokdata ); - tree_t *upper = constructString( prg, head ); + head_t *head = string_to_upper( in->tokdata ); + tree_t *upper = construct_string( prg, head ); colm_tree_upref( upper ); vm_push_tree( upper ); colm_tree_downref( prg, sp, in ); @@ -3549,8 +3549,8 @@ again: debug( prg, REALM_BYTECODE, "IN_TO_LOWER\n" ); tree_t *in = vm_pop_tree(); - head_t *head = stringToLower( in->tokdata ); - tree_t *lower = constructString( prg, head ); + head_t *head = string_to_lower( in->tokdata ); + tree_t *lower = construct_string( prg, head ); colm_tree_upref( lower ); vm_push_tree( lower ); colm_tree_downref( prg, sp, in ); @@ -3572,10 +3572,10 @@ again: /* Pop the root object. */ vm_pop_tree(); - if ( prg->stdinVal == 0 ) - prg->stdinVal = colm_stream_open_fd( prg, "", 0 ); + if ( prg->stdin_val == 0 ) + prg->stdin_val = colm_stream_open_fd( prg, "", 0 ); - vm_push_stream( prg->stdinVal ); + vm_push_stream( prg->stdin_val ); break; } case IN_GET_STDOUT: { @@ -3583,10 +3583,10 @@ again: /* Pop the root object. */ vm_pop_tree(); - if ( prg->stdoutVal == 0 ) - prg->stdoutVal = colm_stream_open_fd( prg, "", 1 ); + if ( prg->stdout_val == 0 ) + prg->stdout_val = colm_stream_open_fd( prg, "", 1 ); - vm_push_stream( prg->stdoutVal ); + vm_push_stream( prg->stdout_val ); break; } case IN_GET_STDERR: { @@ -3594,10 +3594,10 @@ again: /* Pop the root object. */ vm_pop_tree(); - if ( prg->stderrVal == 0 ) - prg->stderrVal = colm_stream_open_fd( prg, "", 2 ); + if ( prg->stderr_val == 0 ) + prg->stderr_val = colm_stream_open_fd( prg, "", 2 ); - vm_push_stream( prg->stderrVal ); + vm_push_stream( prg->stderr_val ); break; } case IN_SYSTEM: { @@ -3633,7 +3633,7 @@ again: debug( prg, REALM_BYTECODE, "IN_STR_ATOI\n" ); str_t *str = vm_pop_string(); - word_t res = strAtoi( str->value ); + word_t res = str_atoi( str->value ); value_t integer = res; vm_push_value( integer ); colm_tree_downref( prg, sp, (tree_t*)str ); @@ -3643,7 +3643,7 @@ again: debug( prg, REALM_BYTECODE, "IN_STR_ATOO\n" ); str_t *str = vm_pop_string(); - word_t res = strAtoo( str->value ); + word_t res = str_atoo( str->value ); value_t integer = res; vm_push_value( integer ); colm_tree_downref( prg, sp, (tree_t*)str ); @@ -3653,7 +3653,7 @@ again: debug( prg, REALM_BYTECODE, "IN_STR_UORD8\n" ); str_t *str = vm_pop_string(); - word_t res = strUord8( str->value ); + word_t res = str_uord8( str->value ); value_t integer = res; vm_push_value( integer ); colm_tree_downref( prg, sp, (tree_t*)str ); @@ -3663,7 +3663,7 @@ again: debug( prg, REALM_BYTECODE, "IN_STR_UORD16\n" ); str_t *str = vm_pop_string(); - word_t res = strUord16( str->value ); + word_t res = str_uord16( str->value ); value_t integer = res; vm_push_value( integer ); colm_tree_downref( prg, sp, (tree_t*)str ); @@ -3746,35 +3746,35 @@ again: } case IN_LIST_PUSH_HEAD_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_PUSH_HEAD_WC\n" ); list_t *list = vm_pop_list(); struct_t *s = vm_pop_struct(); - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); - colm_list_prepend( list, listEl ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); + colm_list_prepend( list, list_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_LIST_PUSH_HEAD_WV: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_PUSH_HEAD_WV\n" ); list_t *list = vm_pop_list(); struct_t *s = vm_pop_struct(); - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); - colm_list_prepend( list, listEl ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); + colm_list_prepend( list, list_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); /* Set up reverse code. Needs no args. */ rcode_code( exec, IN_FN ); @@ -3790,35 +3790,35 @@ again: break; } case IN_LIST_PUSH_TAIL_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_PUSH_TAIL_WC\n" ); list_t *list = vm_pop_list(); struct_t *s = vm_pop_struct(); - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); - colm_list_append( list, listEl ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); + colm_list_append( list, list_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_LIST_PUSH_TAIL_WV: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_PUSH_TAIL_WV\n" ); list_t *list = vm_pop_list(); struct_t *s = vm_pop_struct(); - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); - colm_list_append( list, listEl ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); + colm_list_append( list, list_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); /* Set up reverse code. Needs no args. */ rcode_code( exec, IN_FN ); @@ -3834,8 +3834,8 @@ again: break; } case IN_LIST_POP_TAIL_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_TAIL_WC\n" ); @@ -3843,14 +3843,14 @@ again: list_el_t *tail = list->tail; colm_list_detach_tail( list ); - struct_t *s = colm_generic_el_container( prg, tail, genId ); + struct_t *s = colm_generic_el_container( prg, tail, gen_id ); vm_push_struct( s ); break; } case IN_LIST_POP_TAIL_WV: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_TAIL_WV\n" ); @@ -3858,7 +3858,7 @@ again: list_el_t *tail = list->tail; colm_list_detach_tail( list ); - struct_t *s = colm_generic_el_container( prg, tail, genId ); + struct_t *s = colm_generic_el_container( prg, tail, gen_id ); vm_push_struct( s ); @@ -3866,15 +3866,15 @@ again: * Need it up referenced for the reverse code too. */ rcode_code( exec, IN_FN ); rcode_code( exec, IN_LIST_POP_TAIL_BKT ); - rcodeHalf( exec, genId ); + rcode_half( exec, gen_id ); rcode_word( exec, (word_t)s ); rcode_unit_term( exec ); break; } case IN_LIST_POP_TAIL_BKT: { - short genId; + short gen_id; tree_t *val; - read_half( genId ); + read_half( gen_id ); read_tree( val ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_TAIL_BKT\n" ); @@ -3882,14 +3882,14 @@ again: list_t *list = vm_pop_list(); struct_t *s = (struct_t*) val; - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_append( list, listEl ); + colm_list_append( list, list_el ); break; } case IN_LIST_POP_HEAD_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_HEAD_WC\n" ); @@ -3897,14 +3897,14 @@ again: list_el_t *head = list->head; colm_list_detach_head( list ); - struct_t *s = colm_generic_el_container( prg, head, genId ); + struct_t *s = colm_generic_el_container( prg, head, gen_id ); vm_push_struct( s ); break; } case IN_LIST_POP_HEAD_WV: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_HEAD_WV\n" ); @@ -3912,7 +3912,7 @@ again: list_el_t *head = list->head; colm_list_detach_head( list ); - struct_t *s = colm_generic_el_container( prg, head, genId ); + struct_t *s = colm_generic_el_container( prg, head, gen_id ); vm_push_struct( s ); @@ -3920,15 +3920,15 @@ again: * Need it up referenced for the reverse code too. */ rcode_code( exec, IN_FN ); rcode_code( exec, IN_LIST_POP_HEAD_BKT ); - rcodeHalf( exec, genId ); + rcode_half( exec, gen_id ); rcode_word( exec, (word_t)s ); rcode_unit_term( exec ); break; } case IN_LIST_POP_HEAD_BKT: { - short genId; + short gen_id; tree_t *val; - read_half( genId ); + read_half( gen_id ); read_tree( val ); debug( prg, REALM_BYTECODE, "IN_LIST_POP_HEAD_BKT\n" ); @@ -3936,83 +3936,83 @@ again: list_t *list = vm_pop_list(); struct_t *s = (struct_t*) val; - list_el_t *listEl = colm_struct_to_list_el( prg, s, genId ); + list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_prepend( list, listEl ); + colm_list_prepend( list, list_el ); break; } case IN_MAP_FIND: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_MAP_FIND %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_MAP_FIND %hd\n", gen_id ); map_t *map = vm_pop_map(); tree_t *key = vm_pop_tree(); - map_el_t *mapEl = colm_map_find( prg, map, key ); + map_el_t *map_el = colm_map_find( prg, map, key ); - struct colm_struct *strct = mapEl != 0 ? - colm_generic_el_container( prg, mapEl, genId ) : 0; + struct colm_struct *strct = map_el != 0 ? + colm_generic_el_container( prg, map_el, gen_id ) : 0; vm_push_struct( strct ); - if ( map->genericInfo->keyType == TYPE_TREE ) + if ( map->generic_info->key_type == TYPE_TREE ) colm_tree_downref( prg, sp, key ); break; } case IN_MAP_INSERT_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_MAP_INSERT_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_MAP_INSERT_WC %hd\n", gen_id ); map_t *map = vm_pop_map(); struct_t *s = vm_pop_struct(); - map_el_t *mapEl = colm_struct_to_map_el( prg, s, genId ); + map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - colm_map_insert( prg, map, mapEl ); + colm_map_insert( prg, map, map_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_MAP_INSERT_WV: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_MAP_INSERT_WV %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_MAP_INSERT_WV %hd\n", gen_id ); map_t *map = vm_pop_map(); struct_t *s = vm_pop_struct(); - map_el_t *mapEl = colm_struct_to_map_el( prg, s, genId ); + map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - map_el_t *inserted = colm_map_insert( prg, map, mapEl ); + map_el_t *inserted = colm_map_insert( prg, map, map_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); rcode_code( exec, IN_FN ); rcode_code( exec, IN_MAP_INSERT_BKT ); - rcodeHalf( exec, genId ); + rcode_half( exec, gen_id ); rcode_code( exec, inserted != 0 ? 1 : 0 ); - rcode_word( exec, (word_t)mapEl ); + rcode_word( exec, (word_t)map_el ); rcode_unit_term( exec ); break; } case IN_MAP_INSERT_BKT: { - short genId; + short gen_id; uchar inserted; - word_t wmapEl; + word_t wmap_el; - read_half( genId ); + read_half( gen_id ); read_byte( inserted ); - read_word( wmapEl ); + read_word( wmap_el ); - map_el_t *mapEl = (map_el_t*)wmapEl; + map_el_t *map_el = (map_el_t*)wmap_el; debug( prg, REALM_BYTECODE, "IN_MAP_INSERT_BKT %d\n", (int)inserted ); @@ -4020,24 +4020,24 @@ again: map_t *map = vm_pop_map(); if ( inserted ) - colm_map_detach( prg, map, mapEl ); + colm_map_detach( prg, map, map_el ); break; } case IN_MAP_DETACH_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_MAP_DETACH_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_MAP_DETACH_WC %hd\n", gen_id ); map_t *map = vm_pop_map(); struct_t *s = vm_pop_struct(); - map_el_t *mapEl = colm_struct_to_map_el( prg, s, genId ); + map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - colm_map_detach( prg, map, mapEl ); + colm_map_detach( prg, map, map_el ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_MAP_DETACH_WV: { @@ -4045,7 +4045,7 @@ again: tree_t *obj = vm_pop_tree(); tree_t *key = vm_pop_tree(); - struct tree_pair pair = mapRemove( prg, (map_t*)obj, key ); + struct tree_pair pair = map_remove( prg, (map_t*)obj, key ); colm_tree_upref( pair.val ); vm_push_tree( pair.val ); @@ -4074,17 +4074,17 @@ again: tree_t *obj = vm_pop_tree(); #if 0 if ( key != 0 ) - mapUnremove( prg, (map_t*)obj, key, val ); + map_unremove( prg, (map_t*)obj, key, val ); #endif colm_tree_downref( prg, sp, obj ); break; } case IN_VMAP_INSERT_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VMAP_INSERT_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VMAP_INSERT_WC %hd\n", gen_id ); map_t *map = vm_pop_map(); struct_t *value = vm_pop_struct(); @@ -4093,14 +4093,14 @@ again: colm_vmap_insert( prg, map, key, value ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_VMAP_REMOVE_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VMAP_REMOVE_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VMAP_REMOVE_WC %hd\n", gen_id ); map_t *map = vm_pop_map(); tree_t *key = vm_pop_tree(); @@ -4108,14 +4108,14 @@ again: colm_vmap_remove( prg, map, key ); //colm_tree_upref( prg->trueVal ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_VMAP_FIND: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VMAP_FIND %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VMAP_FIND %hd\n", gen_id ); map_t *map = vm_pop_map(); tree_t *key = vm_pop_tree(); @@ -4124,43 +4124,43 @@ again: vm_push_tree( result ); - if ( map->genericInfo->keyType == TYPE_TREE ) + if ( map->generic_info->key_type == TYPE_TREE ) colm_tree_downref( prg, sp, key ); break; } case IN_VLIST_PUSH_TAIL_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VLIST_PUSH_TAIL_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VLIST_PUSH_TAIL_WC %hd\n", gen_id ); list_t *list = vm_pop_list(); value_t value = vm_pop_value(); colm_vlist_append( prg, list, value ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_VLIST_PUSH_HEAD_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VLIST_PUSH_HEAD_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VLIST_PUSH_HEAD_WC %hd\n", gen_id ); list_t *list = vm_pop_list(); value_t value = vm_pop_value(); colm_vlist_prepend( prg, list, value ); - vm_push_tree( prg->trueVal ); + vm_push_tree( prg->true_val ); break; } case IN_VLIST_POP_HEAD_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VLIST_POP_HEAD_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VLIST_POP_HEAD_WC %hd\n", gen_id ); list_t *list = vm_pop_list(); @@ -4169,10 +4169,10 @@ again: break; } case IN_VLIST_POP_TAIL_WC: { - short genId; - read_half( genId ); + short gen_id; + read_half( gen_id ); - debug( prg, REALM_BYTECODE, "IN_VLIST_POP_TAIL_WC %hd\n", genId ); + debug( prg, REALM_BYTECODE, "IN_VLIST_POP_TAIL_WC %hd\n", gen_id ); list_t *list = vm_pop_list(); @@ -4185,9 +4185,9 @@ again: debug( prg, REALM_BYTECODE, "IN_EXIT\n" ); vm_pop_tree(); - prg->exitStatus = vm_pop_type(long); - prg->induceExit = 1; - exit( prg->exitStatus ); + prg->exit_status = vm_pop_type(long); + prg->induce_exit = 1; + exit( prg->exit_status ); } case IN_EXIT: { /* The unwind code follows the exit call (exception, see @@ -4198,43 +4198,43 @@ again: debug( prg, REALM_BYTECODE, "IN_EXIT, unwind len: %hd\n", unwind_len ); vm_pop_tree(); - prg->exitStatus = vm_pop_type(long); - prg->induceExit = 1; + prg->exit_status = vm_pop_type(long); + prg->induce_exit = 1; while ( true ) { /* We stop on the root, leaving the psuedo-call setup on the * stack. Note we exclude the local data. */ - if ( exec->frameId == prg->rtd->rootFrameId ) + if ( exec->frame_id == prg->rtd->root_frame_id ) break; - struct frame_info *fi = &prg->rtd->frameInfo[exec->frameId]; + struct frame_info *fi = &prg->rtd->frame_info[exec->frame_id]; debug( prg, REALM_BYTECODE, "IN_EXIT, popping frame %s, " "unwind-len %hd, arg-size %ld\n", ( fi->name != 0 ? fi->name : "" ), - unwind_len, fi->argSize ); + unwind_len, fi->arg_size ); if ( unwind_len > 0 ) sp = colm_execute_code( prg, exec, sp, instr ); - downref_locals( prg, &sp, exec, fi->locals, fi->localsLen ); - vm_popn( fi->frameSize ); + downref_locals( prg, &sp, exec, fi->locals, fi->locals_len ); + vm_popn( fi->frame_size ); /* Call layout. */ - exec->frameId = vm_pop_type(long); - exec->framePtr = vm_pop_type(tree_t**); + exec->frame_id = vm_pop_type(long); + exec->frame_ptr = vm_pop_type(tree_t**); instr = vm_pop_type(code_t*); - tree_t *retVal = vm_pop_tree(); + tree_t *ret_val = vm_pop_tree(); vm_pop_value(); /* The IN_PREP_ARGS stack data. */ - vm_popn( fi->argSize ); + vm_popn( fi->arg_size ); vm_pop_value(); - if ( fi->retTree ) { + if ( fi->ret_tree ) { /* Problem here. */ - colm_tree_downref( prg, sp, retVal ); + colm_tree_downref( prg, sp, ret_val ); } read_half( unwind_len ); @@ -4269,7 +4269,7 @@ again: goto again; out: - if ( ! prg->induceExit ) + if ( ! prg->induce_exit ) assert( sp == root ); return sp; } @@ -4316,8 +4316,8 @@ again: } case IN_PARSE_FRAG_BKT: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_BKT\n" ); break; } @@ -4326,8 +4326,8 @@ again: break; } case IN_PARSE_FINISH_BKT: { - half_t stopId; - read_half( stopId ); + half_t stop_id; + read_half( stop_id ); debug( prg, REALM_BYTECODE, "IN_PARSE_FINISH_BKT\n" ); break; } @@ -4446,7 +4446,7 @@ again: debug( prg, REALM_BYTECODE, "IN_SET_TOKEN_DATA_BKT\n" ); head_t *head = (head_t*)oldval; - stringFree( prg, head ); + string_free( prg, head ); break; } case IN_GET_LIST_MEM_BKT: { diff --git a/src/bytecode.h b/src/bytecode.h index c92e6cb6..af03db77 100644 --- a/src/bytecode.h +++ b/src/bytecode.h @@ -557,8 +557,8 @@ enum LEL_ID { #define vm_ssize() ( prg->sb_total + (prg->sb_end - sp) ) -#define vm_local_iframe(o) (exec->iframePtr[o]) -#define vm_plocal_iframe(o) (&exec->iframePtr[o]) +#define vm_local_iframe(o) (exec->iframe_ptr[o]) +#define vm_plocal_iframe(o) (&exec->iframe_ptr[o]) void vm_init( struct colm_program * ); tree_t** vm_bs_add( struct colm_program *, tree_t **, int ); @@ -576,17 +576,17 @@ typedef tree_t **StackPtr; typedef struct colm_execution { - tree_t **framePtr; - tree_t **iframePtr; - long frameId; - tree_t **callArgs; + tree_t **frame_ptr; + tree_t **iframe_ptr; + long frame_id; + tree_t **call_args; - long rcodeUnitLen; + long rcode_unit_len; parser_t *parser; long steps; long pcr; - tree_t *retVal; + tree_t *ret_val; } Execution; struct colm_execution; @@ -594,77 +594,77 @@ struct colm_execution; static inline tree_t **vm_get_plocal( struct colm_execution *exec, int o ) { if ( o >= FR_AA ) { - tree_t **callArgs = (tree_t**)exec->framePtr[FR_CA]; - return &callArgs[o - FR_AA]; + tree_t **call_args = (tree_t**)exec->frame_ptr[FR_CA]; + return &call_args[o - FR_AA]; } else { - return &exec->framePtr[o]; + return &exec->frame_ptr[o]; } } static inline tree_t *vm_get_local( struct colm_execution *exec, int o ) { if ( o >= FR_AA ) { - tree_t **callArgs = (tree_t**)exec->framePtr[FR_CA]; - return callArgs[o - FR_AA]; + tree_t **call_args = (tree_t**)exec->frame_ptr[FR_CA]; + return call_args[o - FR_AA]; } else { - return exec->framePtr[o]; + return exec->frame_ptr[o]; } } static inline void vm_set_local( struct colm_execution *exec, int o, tree_t* v ) { if ( o >= FR_AA ) { - tree_t **callArgs = (tree_t**)exec->framePtr[FR_CA]; - callArgs[o - FR_AA] = v; + tree_t **call_args = (tree_t**)exec->frame_ptr[FR_CA]; + call_args[o - FR_AA] = v; } else { - exec->framePtr[o] = v; + exec->frame_ptr[o] = v; } } -long stringLength( head_t *str ); -const char *stringData( head_t *str ); -head_t *initStrSpace( long length ); -head_t *stringCopy( struct colm_program *prg, head_t *head ); -void stringFree( struct colm_program *prg, head_t *head ); -void stringShorten( head_t *tokdata, long newlen ); -head_t *concatStr( head_t *s1, head_t *s2 ); -word_t strAtoi( head_t *str ); -word_t strAtoo( head_t *str ); -word_t strUord16( head_t *head ); -word_t strUord8( head_t *head ); -word_t cmpString( head_t *s1, head_t *s2 ); -head_t *stringToUpper( head_t *s ); -head_t *stringToLower( head_t *s ); -head_t *stringSprintf( program_t *prg, str_t *format, long integer ); - -head_t *makeLiteral( struct colm_program *prg, long litoffset ); -head_t *intToStr( struct colm_program *prg, word_t i ); +long string_length( head_t *str ); +const char *string_data( head_t *str ); +head_t *init_str_space( long length ); +head_t *string_copy( struct colm_program *prg, head_t *head ); +void string_free( struct colm_program *prg, head_t *head ); +void string_shorten( head_t *tokdata, long newlen ); +head_t *concat_str( head_t *s1, head_t *s2 ); +word_t str_atoi( head_t *str ); +word_t str_atoo( head_t *str ); +word_t str_uord16( head_t *head ); +word_t str_uord8( head_t *head ); +word_t cmp_string( head_t *s1, head_t *s2 ); +head_t *string_to_upper( head_t *s ); +head_t *string_to_lower( head_t *s ); +head_t *string_sprintf( program_t *prg, str_t *format, long integer ); + +head_t *make_literal( struct colm_program *prg, long litoffset ); +head_t *int_to_str( struct colm_program *prg, word_t i ); void colm_execute( struct colm_program *prg, Execution *exec, code_t *code ); -void reductionExecution( Execution *exec, tree_t **sp ); -void generationExecution( Execution *exec, tree_t **sp ); -void reverseExecution( Execution *exec, tree_t **sp, struct rt_code_vect *allRev ); +void reduction_execution( Execution *exec, tree_t **sp ); +void generation_execution( Execution *exec, tree_t **sp ); +void reverse_execution( Execution *exec, tree_t **sp, struct rt_code_vect *all_rev ); -kid_t *allocAttrs( struct colm_program *prg, long length ); -void freeAttrs( struct colm_program *prg, kid_t *attrs ); -kid_t *getAttrKid( tree_t *tree, long pos ); +kid_t *alloc_attrs( struct colm_program *prg, long length ); +void free_attrs( struct colm_program *prg, kid_t *attrs ); +kid_t *get_attr_kid( tree_t *tree, long pos ); -tree_t *splitTree( struct colm_program *prg, tree_t *t ); +tree_t *split_tree( struct colm_program *prg, tree_t *t ); void colm_rcode_downref_all( struct colm_program *prg, tree_t **sp, struct rt_code_vect *cv ); -int colm_make_reverse_code( struct pda_run *pdaRun ); -void colm_transfer_reverse_code( struct pda_run *pdaRun, parse_tree_t *tree ); +int colm_make_reverse_code( struct pda_run *pda_run ); +void colm_transfer_reverse_code( struct pda_run *pda_run, parse_tree_t *tree ); -void splitRef( struct colm_program *prg, tree_t ***sp, ref_t *fromRef ); +void split_ref( struct colm_program *prg, tree_t ***sp, ref_t *from_ref ); -void allocGlobal( struct colm_program *prg ); +void alloc_global( struct colm_program *prg ); tree_t **colm_execute_code( struct colm_program *prg, Execution *exec, tree_t **sp, code_t *instr ); -code_t *colm_pop_reverse_code( struct rt_code_vect *allRev ); +code_t *colm_pop_reverse_code( struct rt_code_vect *all_rev ); #ifdef __cplusplus } diff --git a/src/codevect.c b/src/codevect.c index 1b037977..9f968f73 100644 --- a/src/codevect.c +++ b/src/codevect.c @@ -27,42 +27,42 @@ #include -void initRtCodeVect( struct rt_code_vect *vect ) +void init_rt_code_vect( struct rt_code_vect *vect ) { vect->data = 0; - vect->tabLen = 0; - vect->allocLen = 0; + vect->tab_len = 0; + vect->alloc_len = 0; } -static long newSizeUp( long existing, long needed ) +static long new_size_up( long existing, long needed ) { return needed > existing ? (needed<<1) : existing; } -static long newSizeDown( long existing, long needed ) +static long new_size_down( long existing, long needed ) { return needed < (existing>>2) ? (needed<<1) : existing; } /* Up resize the data for len elements using Resize::upResize to tell us the * new tabLen. Reads and writes allocLen. Does not read or write tabLen. */ -static void upResize( struct rt_code_vect *vect, long len ) +static void up_resize( struct rt_code_vect *vect, long len ) { /* Ask the resizer what the new tabLen will be. */ - long newLen = newSizeUp(vect->allocLen, len); + long new_len = new_size_up(vect->alloc_len, len); /* Did the data grow? */ - if ( newLen > vect->allocLen ) { - vect->allocLen = newLen; + if ( new_len > vect->alloc_len ) { + vect->alloc_len = new_len; if ( vect->data != 0 ) { /* Table exists already, resize it up. */ - vect->data = (code_t*) realloc( vect->data, sizeof(code_t) * newLen ); + vect->data = (code_t*) realloc( vect->data, sizeof(code_t) * new_len ); //if ( vect->data == 0 ) // throw std::bad_alloc(); } else { /* Create the data. */ - vect->data = (code_t*) malloc( sizeof(code_t) * newLen ); + vect->data = (code_t*) malloc( sizeof(code_t) * new_len ); //if ( vect->data == 0 ) // throw std::bad_alloc(); } @@ -71,22 +71,22 @@ static void upResize( struct rt_code_vect *vect, long len ) /* Down resize the data for len elements using Resize::downResize to determine * the new tabLen. Reads and writes allocLen. Does not read or write tabLen. */ -static void downResize( struct rt_code_vect *vect, long len) +static void down_resize( struct rt_code_vect *vect, long len) { /* Ask the resizer what the new tabLen will be. */ - long newLen = newSizeDown( vect->allocLen, len ); + long new_len = new_size_down( vect->alloc_len, len ); /* Did the data shrink? */ - if ( newLen < vect->allocLen ) { - vect->allocLen = newLen; - if ( newLen == 0 ) { + if ( new_len < vect->alloc_len ) { + vect->alloc_len = new_len; + if ( new_len == 0 ) { /* Simply free the data. */ free( vect->data ); vect->data = 0; } else { /* Not shrinking to size zero, realloc it to the smaller size. */ - vect->data = (code_t*) realloc( vect->data, sizeof(code_t) * newLen ); + vect->data = (code_t*) realloc( vect->data, sizeof(code_t) * new_len ); //if ( vect->data == 0 ) // throw std::bad_alloc(); } @@ -100,28 +100,28 @@ void colm_rt_code_vect_empty( struct rt_code_vect *vect ) /* Free the data space. */ free( vect->data ); vect->data = 0; - vect->tabLen = vect->allocLen = 0; + vect->tab_len = vect->alloc_len = 0; } } void colm_rt_code_vect_replace( struct rt_code_vect *vect, long pos, const code_t *val, long len ) { - long endPos, i; + long end_pos, i; //code_t *item; /* If we are given a negative position to replace at then * treat it as a position relative to the length. */ if ( pos < 0 ) - pos = vect->tabLen + pos; + pos = vect->tab_len + pos; /* The end is the one past the last item that we want * to write to. */ - endPos = pos + len; + end_pos = pos + len; /* Make sure we have enough space. */ - if ( endPos > vect->tabLen ) { - upResize( vect, endPos ); + if ( end_pos > vect->tab_len ) { + up_resize( vect, end_pos ); /* Delete any objects we need to delete. */ //item = vect->data + pos; @@ -129,7 +129,7 @@ void colm_rt_code_vect_replace( struct rt_code_vect *vect, long pos, // item->~code_t(); /* We are extending the vector, set the new data length. */ - vect->tabLen = endPos; + vect->tab_len = end_pos; } else { /* Delete any objects we need to delete. */ @@ -147,19 +147,19 @@ void colm_rt_code_vect_replace( struct rt_code_vect *vect, long pos, void colm_rt_code_vect_remove( struct rt_code_vect *vect, long pos, long len ) { - long newLen, lenToSlideOver, endPos; + long new_len, len_to_slide_over, end_pos; code_t *dst;//, *item; /* If we are given a negative position to remove at then * treat it as a position relative to the length. */ if ( pos < 0 ) - pos = vect->tabLen + pos; + pos = vect->tab_len + pos; /* The first position after the last item deleted. */ - endPos = pos + len; + end_pos = pos + len; /* The new data length. */ - newLen = vect->tabLen - len; + new_len = vect->tab_len - len; /* The place in the data we are deleting at. */ dst = vect->data + pos; @@ -170,15 +170,15 @@ void colm_rt_code_vect_remove( struct rt_code_vect *vect, long pos, long len ) // item->~code_t(); /* Shift data over if necessary. */ - lenToSlideOver = vect->tabLen - endPos; - if ( len > 0 && lenToSlideOver > 0 ) - memmove(dst, dst + len, sizeof(code_t)*lenToSlideOver); + len_to_slide_over = vect->tab_len - end_pos; + if ( len > 0 && len_to_slide_over > 0 ) + memmove(dst, dst + len, sizeof(code_t)*len_to_slide_over); /* Shrink the data if necessary. */ - downResize( vect, newLen ); + down_resize( vect, new_len ); /* Set the new data length. */ - vect->tabLen = newLen; + vect->tab_len = new_len; } diff --git a/src/compiler.cc b/src/compiler.cc index 085bcf07..4fac52ff 100644 --- a/src/compiler.cc +++ b/src/compiler.cc @@ -989,18 +989,18 @@ pda_run *Compiler::parsePattern( program_t *prg, tree_t **sp, const InputLoc &lo stream_t *stream = colm_stream_new_struct( prg ); stream->impl = sourceStream; - in->funcs->appendStream( in, (tree_t*)stream ); - in->funcs->setEof( in ); + in->funcs->append_stream( in, (tree_t*)stream ); + in->funcs->set_eof( in ); long pcr = colm_parse_loop( prg, sp, pdaRun, in, PCR_START ); assert( pcr == PCR_DONE ); - if ( pdaRun->parseError ) { + if ( pdaRun->parse_error ) { cerr << ( loc.fileName != 0 ? loc.fileName : "" ) << ":" << loc.line << ":" << loc.col; - if ( pdaRun->parseErrorText != 0 ) { + if ( pdaRun->parse_error_text != 0 ) { cerr << ": relative error: " << - pdaRun->parseErrorText->tokdata->data; + pdaRun->parse_error_text->tokdata->data; } else { cerr << ": parse error"; @@ -1018,9 +1018,9 @@ void Compiler::parsePatterns() program_t *prg = colm_new_program( runtimeData ); /* Turn off context-dependent parsing. */ - prg->ctxDepParsing = 0; + prg->ctx_dep_parsing = 0; - tree_t **sp = prg->stackRoot; + tree_t **sp = prg->stack_root; for ( ConsList::Iter cons = replList; cons.lte(); cons++ ) { if ( cons->langEl != 0 ) { diff --git a/src/ctinput.cc b/src/ctinput.cc index d16d69cb..5ae81153 100644 --- a/src/ctinput.cc +++ b/src/ctinput.cc @@ -43,7 +43,7 @@ struct stream_impl *colm_impl_new_pat( const char *name, Pattern *pattern ) struct stream_impl *ss = (struct stream_impl*)malloc(sizeof(struct stream_impl)); memset( ss, 0, sizeof(struct stream_impl) ); ss->pattern = pattern; - ss->patItem = pattern->list->head; + ss->pat_item = pattern->list->head; ss->funcs = &patternFuncs; return ss; } @@ -51,12 +51,12 @@ struct stream_impl *colm_impl_new_pat( const char *name, Pattern *pattern ) LangEl *inputStreamPatternGetLangEl( struct stream_impl *ss, long *bindId, char **data, long *length ) { - LangEl *klangEl = ss->patItem->prodEl->langEl; - *bindId = ss->patItem->bindId; + LangEl *klangEl = ss->pat_item->prodEl->langEl; + *bindId = ss->pat_item->bindId; *data = 0; *length = 0; - ss->patItem = ss->patItem->next; + ss->pat_item = ss->pat_item->next; ss->offset = 0; return klangEl; } @@ -66,7 +66,7 @@ int inputStreamPatternGetParseBlock( struct stream_impl *ss, int skip, { *copied = 0; - PatternItem *buf = ss->patItem; + PatternItem *buf = ss->pat_item; int offset = ss->offset; while ( true ) { @@ -113,7 +113,7 @@ int inputStreamPatternGetData( struct stream_impl *ss, char *dest, int length ) { int copied = 0; - PatternItem *buf = ss->patItem; + PatternItem *buf = ss->pat_item; int offset = ss->offset; while ( true ) { @@ -148,10 +148,10 @@ int inputStreamPatternGetData( struct stream_impl *ss, char *dest, int length ) void inputStreamPatternBackup( struct stream_impl *ss ) { - if ( ss->patItem == 0 ) - ss->patItem = ss->pattern->list->tail; + if ( ss->pat_item == 0 ) + ss->pat_item = ss->pattern->list->tail; else - ss->patItem = ss->patItem->prev; + ss->pat_item = ss->pat_item->prev; } void inputStreamPatternPushBackBuf( struct stream_impl *ss, RunBuf *runBuf ) @@ -166,19 +166,19 @@ void inputStreamPatternPushBackBuf( struct stream_impl *ss, RunBuf *runBuf ) while ( length > ss->offset ) { length -= ss->offset; if ( ss->offset > 0 ) - assert( memcmp( ss->patItem->data, data-length, ss->offset ) == 0 ); + assert( memcmp( ss->pat_item->data, data-length, ss->offset ) == 0 ); inputStreamPatternBackup( ss ); - ss->offset = ss->patItem->data.length(); + ss->offset = ss->pat_item->data.length(); } ss->offset -= length; - assert( memcmp( &ss->patItem->data[ss->offset], data, length ) == 0 ); + assert( memcmp( &ss->pat_item->data[ss->offset], data, length ) == 0 ); } void inputStreamPatternUndoConsumeLangEl( struct stream_impl *ss ) { inputStreamPatternBackup( ss ); - ss->offset = ss->patItem->data.length(); + ss->offset = ss->pat_item->data.length(); } int inputStreamPatternConsumeData( program_t *prg, tree_t **sp, struct stream_impl *ss, int length, location_t *loc ) @@ -188,15 +188,15 @@ int inputStreamPatternConsumeData( program_t *prg, tree_t **sp, struct stream_im int consumed = 0; while ( true ) { - if ( ss->patItem == 0 ) + if ( ss->pat_item == 0 ) break; - int avail = ss->patItem->data.length() - ss->offset; + int avail = ss->pat_item->data.length() - ss->offset; if ( length >= avail ) { /* Read up to the end of the data. Advance the * pattern item. */ - ss->patItem = ss->patItem->next; + ss->pat_item = ss->pat_item->next; ss->offset = 0; length -= avail; @@ -243,33 +243,33 @@ struct stream_impl *colm_impl_new_cons( const char *name, Constructor *construct struct stream_impl *ss = (struct stream_impl*)malloc(sizeof(struct stream_impl)); memset( ss, 0, sizeof(struct stream_impl) ); ss->constructor = constructor; - ss->consItem = constructor->list->head; + ss->cons_item = constructor->list->head; ss->funcs = &replFuncs; return ss; } LangEl *inputStreamConsGetLangEl( struct stream_impl *ss, long *bindId, char **data, long *length ) { - LangEl *klangEl = ss->consItem->type == ConsItem::ExprType ? - ss->consItem->langEl : ss->consItem->prodEl->langEl; - *bindId = ss->consItem->bindId; + LangEl *klangEl = ss->cons_item->type == ConsItem::ExprType ? + ss->cons_item->langEl : ss->cons_item->prodEl->langEl; + *bindId = ss->cons_item->bindId; *data = 0; *length = 0; - if ( ss->consItem->type == ConsItem::LiteralType ) { - if ( ss->consItem->prodEl->typeRef->pdaLiteral != 0 ) { + if ( ss->cons_item->type == ConsItem::LiteralType ) { + if ( ss->cons_item->prodEl->typeRef->pdaLiteral != 0 ) { bool unusedCI; - prepareLitString( ss->consItem->data, unusedCI, - ss->consItem->prodEl->typeRef->pdaLiteral->data, - ss->consItem->prodEl->typeRef->pdaLiteral->loc ); + prepareLitString( ss->cons_item->data, unusedCI, + ss->cons_item->prodEl->typeRef->pdaLiteral->data, + ss->cons_item->prodEl->typeRef->pdaLiteral->loc ); - *data = ss->consItem->data; - *length = ss->consItem->data.length(); + *data = ss->cons_item->data; + *length = ss->cons_item->data.length(); } } - ss->consItem = ss->consItem->next; + ss->cons_item = ss->cons_item->next; ss->offset = 0; return klangEl; } @@ -279,7 +279,7 @@ int inputStreamConsGetParseBlock( struct stream_impl *ss, { *copied = 0; - ConsItem *buf = ss->consItem; + ConsItem *buf = ss->cons_item; int offset = ss->offset; while ( true ) { @@ -326,7 +326,7 @@ int inputStreamConsGetData( struct stream_impl *ss, char *dest, int length ) { int copied = 0; - ConsItem *buf = ss->consItem; + ConsItem *buf = ss->cons_item; int offset = ss->offset; while ( true ) { @@ -361,10 +361,10 @@ int inputStreamConsGetData( struct stream_impl *ss, char *dest, int length ) void inputStreamConsBackup( struct stream_impl *ss ) { - if ( ss->consItem == 0 ) - ss->consItem = ss->constructor->list->tail; + if ( ss->cons_item == 0 ) + ss->cons_item = ss->constructor->list->tail; else - ss->consItem = ss->consItem->prev; + ss->cons_item = ss->cons_item->prev; } void inputStreamConsPushBackBuf( struct stream_impl *ss, RunBuf *runBuf ) @@ -383,19 +383,19 @@ void inputStreamConsPushBackBuf( struct stream_impl *ss, RunBuf *runBuf ) while ( length > ss->offset ) { length -= ss->offset; if ( ss->offset > 0 ) - assert( memcmp( ss->consItem->data, data-length, ss->offset ) == 0 ); + assert( memcmp( ss->cons_item->data, data-length, ss->offset ) == 0 ); inputStreamConsBackup( ss ); - ss->offset = ss->consItem->data.length(); + ss->offset = ss->cons_item->data.length(); } ss->offset -= length; - assert( memcmp( &ss->consItem->data[ss->offset], data, length ) == 0 ); + assert( memcmp( &ss->cons_item->data[ss->offset], data, length ) == 0 ); } void inputStreamConsUndoConsumeLangEl( struct stream_impl *ss ) { inputStreamConsBackup( ss ); - ss->offset = ss->consItem->data.length(); + ss->offset = ss->cons_item->data.length(); } int inputStreamConsConsumeData( program_t *prg, tree_t **sp, @@ -404,15 +404,15 @@ int inputStreamConsConsumeData( program_t *prg, tree_t **sp, int consumed = 0; while ( true ) { - if ( ss->consItem == 0 ) + if ( ss->cons_item == 0 ) break; - int avail = ss->consItem->data.length() - ss->offset; + int avail = ss->cons_item->data.length() - ss->offset; if ( length >= avail ) { /* Read up to the end of the data. Advance the * pattern item. */ - ss->consItem = ss->consItem->next; + ss->cons_item = ss->cons_item->next; ss->offset = 0; length -= avail; @@ -463,14 +463,14 @@ extern "C" void internalSendNamedLangEl( program_t *prg, tree_t **sp, char *data; long length; - LangEl *klangEl = is->funcs->consumeLangEl( is, &bindId, &data, &length ); + LangEl *klangEl = is->funcs->consume_lang_el( is, &bindId, &data, &length ); //cerr << "named langEl: " << prg->rtd->lelInfo[klangEl->id].name << endl; /* Copy the token data. */ head_t *tokdata = 0; if ( data != 0 ) - tokdata = stringAllocFull( prg, data, length ); + tokdata = string_alloc_full( prg, data, length ); kid_t *input = make_token_with_data( prg, pdaRun, is, klangEl->id, tokdata ); @@ -484,7 +484,7 @@ extern "C" void internalSendNamedLangEl( program_t *prg, tree_t **sp, if ( bindId > 0 ) pushBinding( pdaRun, parseTree ); - pdaRun->parseInput = parseTree; + pdaRun->parse_input = parseTree; } extern "C" void internalInitBindings( pda_run *pdaRun ) diff --git a/src/debug.c b/src/debug.c index c43f5a68..21b7501c 100644 --- a/src/debug.c +++ b/src/debug.c @@ -25,7 +25,7 @@ #include #include -const char *const colmRealmNames[REALMS] = +const char *const colm_realm_names[REALMS] = { "BYTECODE", "PARSE", @@ -40,7 +40,7 @@ const char *const colmRealmNames[REALMS] = int _debug( struct colm_program *prg, long realm, const char *fmt, ... ) { int result = 0; - if ( prg->activeRealm & realm ) { + if ( prg->active_realm & realm ) { /* Compute the index by shifting. */ int ind = 0; while ( (realm & 0x1) != 0x1 ) { @@ -48,7 +48,7 @@ int _debug( struct colm_program *prg, long realm, const char *fmt, ... ) ind += 1; } - fprintf( stderr, "%s: ", colmRealmNames[ind] ); + fprintf( stderr, "%s: ", colm_realm_names[ind] ); va_list args; va_start( args, fmt ); result = vfprintf( stderr, fmt, args ); diff --git a/src/fsmcodegen.cc b/src/fsmcodegen.cc index 6fe34cec..75311bc5 100644 --- a/src/fsmcodegen.cc +++ b/src/fsmcodegen.cc @@ -777,10 +777,10 @@ void FsmCodeGen::writeData() out << "\n"; out << "static long " << ENTRY_BY_REGION() << "[] = {\n\t"; - for ( int i = 0; i < fsmTables->numRegions; i++ ) { - out << fsmTables->entryByRegion[i]; + for ( int i = 0; i < fsmTables->num_regions; i++ ) { + out << fsmTables->entry_by_region[i]; - if ( i < fsmTables->numRegions-1 ) { + if ( i < fsmTables->num_regions-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; diff --git a/src/fsmcodegen.h b/src/fsmcodegen.h index 6f0811c4..f2672166 100644 --- a/src/fsmcodegen.h +++ b/src/fsmcodegen.h @@ -107,7 +107,7 @@ protected: string BLOCK_START() { return ACCESS() + "start"; } string TOKLEN() { return ACCESS() + "toklen"; } string ACT() { return ACCESS() + "act"; } - string MATCHED_TOKEN() { return ACCESS() + "matchedToken"; } + string MATCHED_TOKEN() { return ACCESS() + "matched_token"; } string DATA_PREFIX(); @@ -115,7 +115,7 @@ protected: string ERROR() { return DATA_PREFIX() + "error"; } string FIRST_FINAL() { return DATA_PREFIX() + "first_final"; } - string ENTRY_BY_REGION() { return DATA_PREFIX() + "entryByRegion"; } + string ENTRY_BY_REGION() { return DATA_PREFIX() + "entry_by_region"; } void INLINE_LIST( ostream &ret, InlineList *inlineList, diff --git a/src/fsmexec.cc b/src/fsmexec.cc index 6d06eba7..3b3d08f3 100644 --- a/src/fsmexec.cc +++ b/src/fsmexec.cc @@ -57,33 +57,33 @@ void execAction( struct pda_run *pdaRun, GenAction *genAction ) * will exist. */ pdaRun->toklen = pdaRun->tokend; if ( item->tokenRegion->lmSwitchHandlesError && pdaRun->act == 0 ) { - pdaRun->fsm_cs = pdaRun->fsm_tables->errorState; + pdaRun->fsm_cs = pdaRun->fsm_tables->error_state; } else { for ( TokenInstanceListReg::Iter lmi = item->tokenRegion->tokenInstanceList; lmi.lte(); lmi++ ) { if ( lmi->inLmSelect && pdaRun->act == lmi->longestMatchId ) - pdaRun->matchedToken = lmi->tokenDef->tdLangEl->id; + pdaRun->matched_token = lmi->tokenDef->tdLangEl->id; } } - pdaRun->returnResult = true; - pdaRun->skipToklen = true; + pdaRun->return_result = true; + pdaRun->skip_toklen = true; break; case InlineItem::LmOnLast: pdaRun->p += 1; - pdaRun->matchedToken = item->longestMatchPart->tokenDef->tdLangEl->id; - pdaRun->returnResult = true; + pdaRun->matched_token = item->longestMatchPart->tokenDef->tdLangEl->id; + pdaRun->return_result = true; break; case InlineItem::LmOnNext: - pdaRun->matchedToken = item->longestMatchPart->tokenDef->tdLangEl->id; - pdaRun->returnResult = true; + pdaRun->matched_token = item->longestMatchPart->tokenDef->tdLangEl->id; + pdaRun->return_result = true; break; case InlineItem::LmOnLagBehind: pdaRun->toklen = pdaRun->tokend; - pdaRun->matchedToken = item->longestMatchPart->tokenDef->tdLangEl->id; - pdaRun->returnResult = true; - pdaRun->skipToklen = true; + pdaRun->matched_token = item->longestMatchPart->tokenDef->tdLangEl->id; + pdaRun->return_result = true; + pdaRun->skip_toklen = true; break; } } @@ -103,25 +103,25 @@ extern "C" void internalFsmExecute( struct pda_run *pdaRun, struct stream_impl * pdaRun->start = pdaRun->p; /* Init the token match to nothing (the sentinal). */ - pdaRun->matchedToken = 0; + pdaRun->matched_token = 0; /*_resume:*/ - if ( pdaRun->fsm_cs == pdaRun->fsm_tables->errorState ) + if ( pdaRun->fsm_cs == pdaRun->fsm_tables->error_state ) goto out; if ( pdaRun->p == pdaRun->pe ) goto out; _loop_head: - _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->fromStateActions[pdaRun->fsm_cs]; + _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->from_state_actions[pdaRun->fsm_cs]; _nacts = (unsigned int) *_acts++; while ( _nacts-- > 0 ) - execAction( pdaRun, pdaRun->fsm_tables->actionSwitch[*_acts++] ); + execAction( pdaRun, pdaRun->fsm_tables->action_switch[*_acts++] ); - _keys = pdaRun->fsm_tables->transKeys + pdaRun->fsm_tables->keyOffsets[pdaRun->fsm_cs]; - _trans = pdaRun->fsm_tables->indexOffsets[pdaRun->fsm_cs]; + _keys = pdaRun->fsm_tables->trans_keys + pdaRun->fsm_tables->key_offsets[pdaRun->fsm_cs]; + _trans = pdaRun->fsm_tables->index_offsets[pdaRun->fsm_cs]; - _klen = pdaRun->fsm_tables->singleLengths[pdaRun->fsm_cs]; + _klen = pdaRun->fsm_tables->single_lengths[pdaRun->fsm_cs]; if ( _klen > 0 ) { const char *_lower = _keys; const char *_mid; @@ -144,7 +144,7 @@ _loop_head: _trans += _klen; } - _klen = pdaRun->fsm_tables->rangeLengths[pdaRun->fsm_cs]; + _klen = pdaRun->fsm_tables->range_lengths[pdaRun->fsm_cs]; if ( _klen > 0 ) { const char *_lower = _keys; const char *_mid; @@ -172,43 +172,43 @@ _match: if ( pdaRun->fsm_tables->transActionsWI[_trans] == 0 ) goto _again; - pdaRun->returnResult = false; - pdaRun->skipToklen = false; + pdaRun->return_result = false; + pdaRun->skip_toklen = false; _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->transActionsWI[_trans]; _nacts = (unsigned int) *_acts++; while ( _nacts-- > 0 ) - execAction( pdaRun, pdaRun->fsm_tables->actionSwitch[*_acts++] ); - if ( pdaRun->returnResult ) { - if ( pdaRun->skipToklen ) + execAction( pdaRun, pdaRun->fsm_tables->action_switch[*_acts++] ); + if ( pdaRun->return_result ) { + if ( pdaRun->skip_toklen ) goto skip_toklen; goto final; } _again: - _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->toStateActions[pdaRun->fsm_cs]; + _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->to_state_actions[pdaRun->fsm_cs]; _nacts = (unsigned int) *_acts++; while ( _nacts-- > 0 ) - execAction( pdaRun, pdaRun->fsm_tables->actionSwitch[*_acts++] ); + execAction( pdaRun, pdaRun->fsm_tables->action_switch[*_acts++] ); - if ( pdaRun->fsm_cs == pdaRun->fsm_tables->errorState ) + if ( pdaRun->fsm_cs == pdaRun->fsm_tables->error_state ) goto out; if ( ++pdaRun->p != pdaRun->pe ) goto _loop_head; out: if ( pdaRun->eof ) { - pdaRun->returnResult = false; - pdaRun->skipToklen = false; - _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->eofActions[pdaRun->fsm_cs]; + pdaRun->return_result = false; + pdaRun->skip_toklen = false; + _acts = pdaRun->fsm_tables->actions + pdaRun->fsm_tables->eof_actions[pdaRun->fsm_cs]; _nacts = (unsigned int) *_acts++; - if ( pdaRun->fsm_tables->eofTargs[pdaRun->fsm_cs] >= 0 ) - pdaRun->fsm_cs = pdaRun->fsm_tables->eofTargs[pdaRun->fsm_cs]; + if ( pdaRun->fsm_tables->eof_targs[pdaRun->fsm_cs] >= 0 ) + pdaRun->fsm_cs = pdaRun->fsm_tables->eof_targs[pdaRun->fsm_cs]; while ( _nacts-- > 0 ) - execAction( pdaRun, pdaRun->fsm_tables->actionSwitch[*_acts++] ); - if ( pdaRun->returnResult ) { - if ( pdaRun->skipToklen ) + execAction( pdaRun, pdaRun->fsm_tables->action_switch[*_acts++] ); + if ( pdaRun->return_result ) { + if ( pdaRun->skip_toklen ) goto skip_toklen; goto final; } diff --git a/src/input.c b/src/input.c index fa797f90..df6120c3 100644 --- a/src/input.c +++ b/src/input.c @@ -37,26 +37,26 @@ #define true 1 #define false 0 -RunBuf *newRunBuf() +RunBuf *new_run_buf() { RunBuf *rb = (RunBuf*)malloc(sizeof(RunBuf)); memset( rb, 0, sizeof(RunBuf) ); return rb; } -void initFdFuncs(); -void initFileFuncs(); -void initPatFuncs(); -void initConsFuncs(); +void init_fd_funcs(); +void init_file_funcs(); +void init_pat_funcs(); +void init_cons_funcs(); -extern struct StreamFuncs fileFuncs; -extern struct StreamFuncs fdFuncs; -extern struct StreamFuncs streamFuncs; +extern struct StreamFuncs file_funcs; +extern struct StreamFuncs fd_funcs; +extern struct StreamFuncs stream_funcs; void colm_clear_source_stream( struct colm_program *prg, - tree_t **sp, struct stream_impl *sourceStream ) + tree_t **sp, struct stream_impl *source_stream ) { - RunBuf *buf = sourceStream->queue; + RunBuf *buf = source_stream->queue; while ( buf != 0 ) { switch ( buf->type ) { case RunBufDataType: @@ -75,7 +75,7 @@ void colm_clear_source_stream( struct colm_program *prg, buf = next; } - sourceStream->queue = 0; + source_stream->queue = 0; } void colm_stream_destroy( program_t *prg, tree_t **sp, struct_t *s ) @@ -93,7 +93,7 @@ void colm_stream_destroy( program_t *prg, tree_t **sp, struct_t *s ) /* Keep the position up to date after consuming text. */ -void updatePosition( struct stream_impl *is, const char *data, long length ) +void update_position( struct stream_impl *is, const char *data, long length ) { int i; for ( i = 0; i < length; i++ ) { @@ -109,7 +109,7 @@ void updatePosition( struct stream_impl *is, const char *data, long length ) } /* Keep the position up to date after sending back text. */ -void undoPosition( struct stream_impl *is, const char *data, long length ) +void undo_position( struct stream_impl *is, const char *data, long length ) { /* FIXME: this needs to fetch the position information from the parsed * token and restore based on that.. */ @@ -123,42 +123,42 @@ void undoPosition( struct stream_impl *is, const char *data, long length ) } -static RunBuf *sourceStreamPopHead( struct stream_impl *ss ) +static RunBuf *source_stream_pop_head( struct stream_impl *ss ) { RunBuf *ret = ss->queue; ss->queue = ss->queue->next; if ( ss->queue == 0 ) - ss->queueTail = 0; + ss->queue_tail = 0; else ss->queue->prev = 0; return ret; } -static void sourceStreamAppend( struct stream_impl *ss, RunBuf *runBuf ) +static void source_stream_append( struct stream_impl *ss, RunBuf *run_buf ) { if ( ss->queue == 0 ) { - runBuf->prev = runBuf->next = 0; - ss->queue = ss->queueTail = runBuf; + run_buf->prev = run_buf->next = 0; + ss->queue = ss->queue_tail = run_buf; } else { - ss->queueTail->next = runBuf; - runBuf->prev = ss->queueTail; - runBuf->next = 0; - ss->queueTail = runBuf; + ss->queue_tail->next = run_buf; + run_buf->prev = ss->queue_tail; + run_buf->next = 0; + ss->queue_tail = run_buf; } } -static void sourceStreamPrepend( struct stream_impl *ss, RunBuf *runBuf ) +static void source_stream_prepend( struct stream_impl *ss, RunBuf *run_buf ) { if ( ss->queue == 0 ) { - runBuf->prev = runBuf->next = 0; - ss->queue = ss->queueTail = runBuf; + run_buf->prev = run_buf->next = 0; + ss->queue = ss->queue_tail = run_buf; } else { - ss->queue->prev = runBuf; - runBuf->prev = 0; - runBuf->next = ss->queue; - ss->queue = runBuf; + ss->queue->prev = run_buf; + run_buf->prev = 0; + run_buf->next = ss->queue; + ss->queue = run_buf; } } @@ -166,7 +166,7 @@ static void sourceStreamPrepend( struct stream_impl *ss, RunBuf *runBuf ) * Base run-time input streams. */ -int fdGetParseBlock( struct stream_impl *ss, int skip, char **pdp, int *copied ) +int fd_get_parse_block( struct stream_impl *ss, int skip, char **pdp, int *copied ) { int ret = 0; *copied = 0; @@ -176,17 +176,17 @@ int fdGetParseBlock( struct stream_impl *ss, int skip, char **pdp, int *copied ) while ( true ) { if ( buf == 0 ) { /* Got through the in-mem buffers without copying anything. */ - RunBuf *runBuf = newRunBuf(); - sourceStreamAppend( ss, runBuf ); - int received = ss->funcs->getDataSource( ss, runBuf->data, FSM_BUFSIZE ); + RunBuf *run_buf = new_run_buf(); + source_stream_append( ss, run_buf ); + int received = ss->funcs->get_data_source( ss, run_buf->data, FSM_BUFSIZE ); if ( received == 0 ) { ret = INPUT_EOD; break; } - runBuf->length = received; + run_buf->length = received; int slen = received; - *pdp = runBuf->data; + *pdp = run_buf->data; *copied = slen; ret = INPUT_DATA; break; @@ -225,7 +225,7 @@ int fdGetParseBlock( struct stream_impl *ss, int skip, char **pdp, int *copied ) return ret; } -int fdGetData( struct stream_impl *ss, char *dest, int length ) +int fd_get_data( struct stream_impl *ss, char *dest, int length ) { int copied = 0; @@ -234,14 +234,14 @@ int fdGetData( struct stream_impl *ss, char *dest, int length ) while ( true ) { if ( buf == 0 ) { /* Got through the in-mem buffers without copying anything. */ - RunBuf *runBuf = newRunBuf(); - sourceStreamAppend( ss, runBuf ); - int received = ss->funcs->getDataSource( ss, runBuf->data, FSM_BUFSIZE ); - runBuf->length = received; + RunBuf *run_buf = new_run_buf(); + source_stream_append( ss, run_buf ); + int received = ss->funcs->get_data_source( ss, run_buf->data, FSM_BUFSIZE ); + run_buf->length = received; if ( received == 0 ) break; - buf = runBuf; + buf = run_buf; } int avail = buf->length - buf->offset; @@ -268,7 +268,7 @@ int fdGetData( struct stream_impl *ss, char *dest, int length ) return copied; } -int fdConsumeData( program_t *prg, tree_t **sp, struct stream_impl *ss, int length, location_t *loc ) +int fd_consume_data( program_t *prg, tree_t **sp, struct stream_impl *ss, int length, location_t *loc ) { int consumed = 0; @@ -298,7 +298,7 @@ int fdConsumeData( program_t *prg, tree_t **sp, struct stream_impl *ss, int leng int slen = avail <= length ? avail : length; consumed += slen; length -= slen; - updatePosition( ss, buf->data + buf->offset, slen ); + update_position( ss, buf->data + buf->offset, slen ); buf->offset += slen; ss->consumed += slen; } @@ -307,20 +307,20 @@ int fdConsumeData( program_t *prg, tree_t **sp, struct stream_impl *ss, int leng if ( length == 0 ) break; - RunBuf *runBuf = sourceStreamPopHead( ss ); - free( runBuf ); + RunBuf *run_buf = source_stream_pop_head( ss ); + free( run_buf ); } return consumed; } -int fdUndoConsumeData( struct stream_impl *ss, const char *data, int length ) +int fd_undo_consume_data( struct stream_impl *ss, const char *data, int length ) { - RunBuf *newBuf = newRunBuf(); - newBuf->length = length; - memcpy( newBuf->data, data, length ); - sourceStreamPrepend( ss, newBuf ); - undoPosition( ss, data, length ); + RunBuf *new_buf = new_run_buf(); + new_buf->length = length; + memcpy( new_buf->data, data, length ); + source_stream_prepend( ss, new_buf ); + undo_position( ss, data, length ); ss->consumed -= length; return length; @@ -330,23 +330,23 @@ int fdUndoConsumeData( struct stream_impl *ss, const char *data, int length ) * File */ -int fileGetDataSource( struct stream_impl *ss, char *dest, int length ) +int file_get_data_source( struct stream_impl *ss, char *dest, int length ) { //debug( REALM_INPUT, "inputStreamFileGetDataSource length = %ld\n", length ); size_t res = fread( dest, 1, length, ss->file ); return res; } -void initFileFuncs() +void init_file_funcs() { - memset( &fileFuncs, 0, sizeof(struct StreamFuncs) ); + memset( &file_funcs, 0, sizeof(struct StreamFuncs) ); } /* * FD */ -int fdGetDataSource( struct stream_impl *ss, char *dest, int length ) +int fd_get_data_source( struct stream_impl *ss, char *dest, int length ) { if ( ss->eof ) return 0; @@ -362,7 +362,7 @@ int fdGetDataSource( struct stream_impl *ss, char *dest, int length ) * StreamImpl struct, this wraps the list of input streams. */ -void initStreamImpl( struct stream_impl *is, const char *name ) +void init_stream_impl( struct stream_impl *is, const char *name ) { memset( is, 0, sizeof(struct stream_impl) ); @@ -372,9 +372,9 @@ void initStreamImpl( struct stream_impl *is, const char *name ) is->byte = 0; } -void colm_clear_stream_impl( struct colm_program *prg, tree_t **sp, struct stream_impl *inputStream ) +void colm_clear_stream_impl( struct colm_program *prg, tree_t **sp, struct stream_impl *input_stream ) { - RunBuf *buf = inputStream->queue; + RunBuf *buf = input_stream->queue; while ( buf != 0 ) { switch ( buf->type ) { case RunBufDataType: @@ -394,60 +394,60 @@ void colm_clear_stream_impl( struct colm_program *prg, tree_t **sp, struct strea buf = next; } - inputStream->queue = 0; + input_stream->queue = 0; } -static void inputStreamPrepend( struct stream_impl *is, RunBuf *runBuf ) +static void input_stream_prepend( struct stream_impl *is, RunBuf *run_buf ) { if ( is->queue == 0 ) { - runBuf->prev = runBuf->next = 0; - is->queue = is->queueTail = runBuf; + run_buf->prev = run_buf->next = 0; + is->queue = is->queue_tail = run_buf; } else { - is->queue->prev = runBuf; - runBuf->prev = 0; - runBuf->next = is->queue; - is->queue = runBuf; + is->queue->prev = run_buf; + run_buf->prev = 0; + run_buf->next = is->queue; + is->queue = run_buf; } } -static RunBuf *inputStreamPopHead( struct stream_impl *is ) +static RunBuf *input_stream_pop_head( struct stream_impl *is ) { RunBuf *ret = is->queue; is->queue = is->queue->next; if ( is->queue == 0 ) - is->queueTail = 0; + is->queue_tail = 0; else is->queue->prev = 0; return ret; } -static void inputStreamAppend( struct stream_impl *is, RunBuf *runBuf ) +static void input_stream_append( struct stream_impl *is, RunBuf *run_buf ) { if ( is->queue == 0 ) { - runBuf->prev = runBuf->next = 0; - is->queue = is->queueTail = runBuf; + run_buf->prev = run_buf->next = 0; + is->queue = is->queue_tail = run_buf; } else { - is->queueTail->next = runBuf; - runBuf->prev = is->queueTail; - runBuf->next = 0; - is->queueTail = runBuf; + is->queue_tail->next = run_buf; + run_buf->prev = is->queue_tail; + run_buf->next = 0; + is->queue_tail = run_buf; } } -static RunBuf *inputStreamPopTail( struct stream_impl *is ) +static RunBuf *input_stream_pop_tail( struct stream_impl *is ) { - RunBuf *ret = is->queueTail; - is->queueTail = is->queueTail->prev; - if ( is->queueTail == 0 ) + RunBuf *ret = is->queue_tail; + is->queue_tail = is->queue_tail->prev; + if ( is->queue_tail == 0 ) is->queue = 0; else - is->queueTail->next = 0; + is->queue_tail->next = 0; return ret; } -static int isSourceStream( struct stream_impl *is ) +static int is_source_stream( struct stream_impl *is ) { if ( is->queue != 0 && is->queue->type == RunBufSourceType ) return true; @@ -462,8 +462,8 @@ static void _setEof( struct stream_impl *is ) static void _unsetEof( struct stream_impl *is ) { - if ( isSourceStream( is ) ) { - struct stream_impl *si = streamToImpl( (stream_t*)is->queue->tree ); + if ( is_source_stream( is ) ) { + struct stream_impl *si = stream_to_impl( (stream_t*)is->queue->tree ); si->eof = false; } else { @@ -486,8 +486,8 @@ static int _getParseBlock( struct stream_impl *is, int skip, char **pdp, int *co } if ( buf->type == RunBufSourceType ) { - struct stream_impl *si = streamToImpl( (stream_t*)buf->tree ); - int type = si->funcs->getParseBlock( si, skip, pdp, copied ); + struct stream_impl *si = stream_to_impl( (stream_t*)buf->tree ); + int type = si->funcs->get_parse_block( si, skip, pdp, copied ); // if ( type == INPUT_EOD && !si->eosSent ) { // si->eosSent = 1; @@ -583,8 +583,8 @@ static int _getData( struct stream_impl *is, char *dest, int length ) } if ( buf->type == RunBufSourceType ) { - struct stream_impl *si = streamToImpl( (stream_t*)buf->tree ); - int glen = si->funcs->getData( si, dest+copied, length ); + struct stream_impl *si = stream_to_impl( (stream_t*)buf->tree ); + int glen = si->funcs->get_data( si, dest+copied, length ); if ( glen == 0 ) { //debug( REALM_INPUT, "skipping over input\n" ); @@ -641,8 +641,8 @@ static int _consumeData( program_t *prg, tree_t **sp, struct stream_impl *is, break; if ( buf->type == RunBufSourceType ) { - struct stream_impl *si = streamToImpl( (stream_t*)buf->tree ); - int slen = si->funcs->consumeData( prg, sp, si, length, loc ); + struct stream_impl *si = stream_to_impl( (stream_t*)buf->tree ); + int slen = si->funcs->consume_data( prg, sp, si, length, loc ); //debug( REALM_INPUT, " got %d bytes from source\n", slen ); consumed += slen; @@ -670,12 +670,12 @@ static int _consumeData( program_t *prg, tree_t **sp, struct stream_impl *is, break; } - RunBuf *runBuf = inputStreamPopHead( is ); + RunBuf *run_buf = input_stream_pop_head( is ); //if ( runBuf->type == RunBufSourceType ) { // stream_t *stream = (stream_t*)runBuf->tree; // colm_tree_downref( prg, sp, (tree_t*) stream ); //} - free( runBuf ); + free( run_buf ); } return consumed; @@ -685,16 +685,16 @@ static int _undoConsumeData( struct stream_impl *is, const char *data, int lengt { //debug( REALM_INPUT, "undoing consume of %ld bytes\n", length ); - if ( is->consumed == 0 && isSourceStream( is ) ) { - struct stream_impl *si = streamToImpl( (stream_t*)is->queue->tree ); - int len = si->funcs->undoConsumeData( si, data, length ); + if ( is->consumed == 0 && is_source_stream( is ) ) { + struct stream_impl *si = stream_to_impl( (stream_t*)is->queue->tree ); + int len = si->funcs->undo_consume_data( si, data, length ); return len; } else { - RunBuf *newBuf = newRunBuf(); - newBuf->length = length; - memcpy( newBuf->data, data, length ); - inputStreamPrepend( is, newBuf ); + RunBuf *new_buf = new_run_buf(); + new_buf->length = length; + memcpy( new_buf->data, data, length ); + input_stream_prepend( is, new_buf ); is->consumed -= length; return length; @@ -706,18 +706,18 @@ static tree_t *_consumeTree( struct stream_impl *is ) while ( is->queue != 0 && is->queue->type == RunBufDataType && is->queue->offset == is->queue->length ) { - RunBuf *runBuf = inputStreamPopHead( is ); - free( runBuf ); + RunBuf *run_buf = input_stream_pop_head( is ); + free( run_buf ); } if ( is->queue != 0 && (is->queue->type == RunBufTokenType || is->queue->type == RunBufIgnoreType) ) { - RunBuf *runBuf = inputStreamPopHead( is ); + RunBuf *run_buf = input_stream_pop_head( is ); /* FIXME: using runbufs here for this is a poor use of memory. */ - tree_t *tree = runBuf->tree; - free(runBuf); + tree_t *tree = run_buf->tree; + free(run_buf); return tree; } @@ -729,18 +729,18 @@ static void _undoConsumeTree( struct stream_impl *is, tree_t *tree, int ignore ) /* Create a new buffer for the data. This is the easy implementation. * Something better is needed here. It puts a max on the amount of * data that can be pushed back to the inputStream. */ - RunBuf *newBuf = newRunBuf(); - newBuf->type = ignore ? RunBufIgnoreType : RunBufTokenType; - newBuf->tree = tree; - inputStreamPrepend( is, newBuf ); + RunBuf *new_buf = new_run_buf(); + new_buf->type = ignore ? RunBufIgnoreType : RunBufTokenType; + new_buf->tree = tree; + input_stream_prepend( is, new_buf ); } -static struct LangEl *_consumeLangEl( struct stream_impl *is, long *bindId, +static struct LangEl *_consumeLangEl( struct stream_impl *is, long *bind_id, char **data, long *length ) { - if ( isSourceStream( is ) ) { - struct stream_impl *si = streamToImpl( (stream_t*)is->queue->tree ); - return si->funcs->consumeLangEl( si, bindId, data, length ); + if ( is_source_stream( is ) ) { + struct stream_impl *si = stream_to_impl( (stream_t*)is->queue->tree ); + return si->funcs->consume_lang_el( si, bind_id, data, length ); } else { assert( false ); @@ -749,9 +749,9 @@ static struct LangEl *_consumeLangEl( struct stream_impl *is, long *bindId, static void _undoConsumeLangEl( struct stream_impl *is ) { - if ( isSourceStream( is ) ) { - struct stream_impl *si = streamToImpl( (stream_t*)is->queue->tree ); - return si->funcs->undoConsumeLangEl( si ); + if ( is_source_stream( is ) ) { + struct stream_impl *si = stream_to_impl( (stream_t*)is->queue->tree ); + return si->funcs->undo_consume_lang_el( si ); } else { assert( false ); @@ -760,10 +760,10 @@ static void _undoConsumeLangEl( struct stream_impl *is ) static void _prependData( struct stream_impl *is, const char *data, long length ) { - if ( isSourceStream( is ) && - streamToImpl((stream_t*)is->queue->tree)->funcs == &streamFuncs ) + if ( is_source_stream( is ) && + stream_to_impl((stream_t*)is->queue->tree)->funcs == &stream_funcs ) { - _prependData( streamToImpl( (stream_t*)is->queue->tree ), data, length ); + _prependData( stream_to_impl( (stream_t*)is->queue->tree ), data, length ); } else { /* Create a new buffer for the data. This is the easy implementation. @@ -771,11 +771,11 @@ static void _prependData( struct stream_impl *is, const char *data, long length * data that can be pushed back to the inputStream. */ assert( length < FSM_BUFSIZE ); - RunBuf *newBuf = newRunBuf(); - newBuf->length = length; - memcpy( newBuf->data, data, length ); + RunBuf *new_buf = new_run_buf(); + new_buf->length = length; + memcpy( new_buf->data, data, length ); - inputStreamPrepend( is, newBuf ); + input_stream_prepend( is, new_buf ); } } @@ -784,10 +784,10 @@ static void _prependTree( struct stream_impl *is, tree_t *tree, int ignore ) /* Create a new buffer for the data. This is the easy implementation. * Something better is needed here. It puts a max on the amount of * data that can be pushed back to the inputStream. */ - RunBuf *newBuf = newRunBuf(); - newBuf->type = ignore ? RunBufIgnoreType : RunBufTokenType; - newBuf->tree = tree; - inputStreamPrepend( is, newBuf ); + RunBuf *new_buf = new_run_buf(); + new_buf->type = ignore ? RunBufIgnoreType : RunBufTokenType; + new_buf->tree = tree; + input_stream_prepend( is, new_buf ); } static void _prependStream( struct stream_impl *in, struct colm_tree *tree ) @@ -795,10 +795,10 @@ static void _prependStream( struct stream_impl *in, struct colm_tree *tree ) /* Create a new buffer for the data. This is the easy implementation. * Something better is needed here. It puts a max on the amount of * data that can be pushed back to the inputStream. */ - RunBuf *newBuf = newRunBuf(); - newBuf->type = RunBufSourceType; - newBuf->tree = tree; - inputStreamPrepend( in, newBuf ); + RunBuf *new_buf = new_run_buf(); + new_buf->type = RunBufSourceType; + new_buf->tree = tree; + input_stream_prepend( in, new_buf ); } static int _undoPrependData( struct stream_impl *is, int length ) @@ -815,8 +815,8 @@ static int _undoPrependData( struct stream_impl *is, int length ) break; if ( buf->type == RunBufSourceType ) { - struct stream_impl *si = streamToImpl( (stream_t*)buf->tree ); - int slen = si->funcs->undoPrependData( si, length ); + struct stream_impl *si = stream_to_impl( (stream_t*)buf->tree ); + int slen = si->funcs->undo_prepend_data( si, length ); consumed += slen; length -= slen; @@ -840,8 +840,8 @@ static int _undoPrependData( struct stream_impl *is, int length ) if ( length == 0 ) break; - RunBuf *runBuf = inputStreamPopHead( is ); - free( runBuf ); + RunBuf *run_buf = input_stream_pop_head( is ); + free( run_buf ); } return consumed; @@ -852,18 +852,18 @@ static tree_t *_undoPrependTree( struct stream_impl *is ) while ( is->queue != 0 && is->queue->type == RunBufDataType && is->queue->offset == is->queue->length ) { - RunBuf *runBuf = inputStreamPopHead( is ); - free( runBuf ); + RunBuf *run_buf = input_stream_pop_head( is ); + free( run_buf ); } if ( is->queue != 0 && (is->queue->type == RunBufTokenType || is->queue->type == RunBufIgnoreType) ) { - RunBuf *runBuf = inputStreamPopHead( is ); + RunBuf *run_buf = input_stream_pop_head( is ); /* FIXME: using runbufs here for this is a poor use of memory. */ - tree_t *tree = runBuf->tree; - free(runBuf); + tree_t *tree = run_buf->tree; + free(run_buf); return tree; } @@ -873,8 +873,8 @@ static tree_t *_undoPrependTree( struct stream_impl *is ) static void _appendData( struct stream_impl *is, const char *data, long len ) { while ( len > 0 ) { - RunBuf *ad = newRunBuf(); - inputStreamAppend( is, ad ); + RunBuf *ad = new_run_buf(); + input_stream_append( is, ad ); long consume = len <= (long)sizeof(ad->data) ? @@ -894,7 +894,7 @@ static tree_t *_undoAppendData( struct stream_impl *is, int length ) /* Move over skip bytes. */ while ( true ) { - RunBuf *buf = is->queueTail; + RunBuf *buf = is->queue_tail; if ( buf == 0 ) break; @@ -918,8 +918,8 @@ static tree_t *_undoAppendData( struct stream_impl *is, int length ) if ( length == 0 ) break; - RunBuf *runBuf = inputStreamPopTail( is ); - free( runBuf ); + RunBuf *run_buf = input_stream_pop_tail( is ); + free( run_buf ); } return 0; @@ -927,9 +927,9 @@ static tree_t *_undoAppendData( struct stream_impl *is, int length ) static void _appendTree( struct stream_impl *is, tree_t *tree ) { - RunBuf *ad = newRunBuf(); + RunBuf *ad = new_run_buf(); - inputStreamAppend( is, ad ); + input_stream_append( is, ad ); ad->type = RunBufTokenType; ad->tree = tree; @@ -938,9 +938,9 @@ static void _appendTree( struct stream_impl *is, tree_t *tree ) static void _appendStream( struct stream_impl *in, struct colm_tree *tree ) { - RunBuf *ad = newRunBuf(); + RunBuf *ad = new_run_buf(); - inputStreamAppend( in, ad ); + input_stream_append( in, ad ); ad->type = RunBufSourceType; ad->tree = tree; @@ -949,21 +949,21 @@ static void _appendStream( struct stream_impl *in, struct colm_tree *tree ) static tree_t *_undoAppendTree( struct stream_impl *is ) { - RunBuf *runBuf = inputStreamPopTail( is ); - tree_t *tree = runBuf->tree; - free( runBuf ); + RunBuf *run_buf = input_stream_pop_tail( is ); + tree_t *tree = run_buf->tree; + free( run_buf ); return tree; } static tree_t *_undoAppendStream( struct stream_impl *is ) { - RunBuf *runBuf = inputStreamPopTail( is ); - tree_t *tree = runBuf->tree; - free( runBuf ); + RunBuf *run_buf = input_stream_pop_tail( is ); + tree_t *tree = run_buf->tree; + free( run_buf ); return tree; } -struct StreamFuncs streamFuncs = +struct StreamFuncs stream_funcs = { &_getParseBlock, &_getData, @@ -990,30 +990,30 @@ struct StreamFuncs streamFuncs = &_undoAppendStream, }; -struct StreamFuncs fdFuncs = +struct StreamFuncs fd_funcs = { - .getData = &fdGetData, - .getParseBlock = &fdGetParseBlock, - .consumeData = &fdConsumeData, - .undoConsumeData = &fdUndoConsumeData, - .getDataSource = &fdGetDataSource, + .get_data = &fd_get_data, + .get_parse_block = &fd_get_parse_block, + .consume_data = &fd_consume_data, + .undo_consume_data = &fd_undo_consume_data, + .get_data_source = &fd_get_data_source, }; -struct StreamFuncs fileFuncs = +struct StreamFuncs file_funcs = { - .getData = &fdGetData, - .getParseBlock = &fdGetParseBlock, - .consumeData = &fdConsumeData, - .undoConsumeData = &fdUndoConsumeData, - .getDataSource = &fileGetDataSource, + .get_data = &fd_get_data, + .get_parse_block = &fd_get_parse_block, + .consume_data = &fd_consume_data, + .undo_consume_data = &fd_undo_consume_data, + .get_data_source = &file_get_data_source, }; struct stream_impl *colm_impl_new_file( const char *name, FILE *file ) { struct stream_impl *ss = (struct stream_impl*)malloc(sizeof(struct stream_impl)); - initStreamImpl( ss, name ); - ss->funcs = &fileFuncs; + init_stream_impl( ss, name ); + ss->funcs = &file_funcs; ss->file = file; @@ -1023,8 +1023,8 @@ struct stream_impl *colm_impl_new_file( const char *name, FILE *file ) struct stream_impl *colm_impl_new_fd( const char *name, long fd ) { struct stream_impl *ss = (struct stream_impl*)malloc(sizeof(struct stream_impl)); - initStreamImpl( ss, name ); - ss->funcs = &fdFuncs; + init_stream_impl( ss, name ); + ss->funcs = &fd_funcs; ss->fd = fd; @@ -1034,8 +1034,8 @@ struct stream_impl *colm_impl_new_fd( const char *name, long fd ) struct stream_impl *colm_impl_new_generic( const char *name ) { struct stream_impl *ss = (struct stream_impl*)malloc(sizeof(struct stream_impl)); - initStreamImpl( ss, name ); - ss->funcs = &streamFuncs; + init_stream_impl( ss, name ); + ss->funcs = &stream_funcs; return ss; } @@ -1062,30 +1062,30 @@ stream_t *colm_stream_open_fd( program_t *prg, char *name, long fd ) stream_t *colm_stream_open_file( program_t *prg, tree_t *name, tree_t *mode ) { - head_t *headName = ((str_t*)name)->value; - head_t *headMode = ((str_t*)mode)->value; + head_t *head_name = ((str_t*)name)->value; + head_t *head_mode = ((str_t*)mode)->value; stream_t *stream = 0; - const char *givenMode = stringData(headMode); - const char *fopenMode = 0; - if ( memcmp( givenMode, "r", stringLength(headMode) ) == 0 ) - fopenMode = "rb"; - else if ( memcmp( givenMode, "w", stringLength(headMode) ) == 0 ) - fopenMode = "wb"; - else if ( memcmp( givenMode, "a", stringLength(headMode) ) == 0 ) - fopenMode = "ab"; + const char *given_mode = string_data(head_mode); + const char *fopen_mode = 0; + if ( memcmp( given_mode, "r", string_length(head_mode) ) == 0 ) + fopen_mode = "rb"; + else if ( memcmp( given_mode, "w", string_length(head_mode) ) == 0 ) + fopen_mode = "wb"; + else if ( memcmp( given_mode, "a", string_length(head_mode) ) == 0 ) + fopen_mode = "ab"; else { - fatal( "unknown file open mode: %s\n", givenMode ); + fatal( "unknown file open mode: %s\n", given_mode ); } /* Need to make a C-string (null terminated). */ - char *fileName = (char*)malloc(stringLength(headName)+1); - memcpy( fileName, stringData(headName), stringLength(headName) ); - fileName[stringLength(headName)] = 0; - FILE *file = fopen( fileName, fopenMode ); + char *file_name = (char*)malloc(string_length(head_name)+1); + memcpy( file_name, string_data(head_name), string_length(head_name) ); + file_name[string_length(head_name)] = 0; + FILE *file = fopen( file_name, fopen_mode ); if ( file != 0 ) { stream = colm_stream_new_struct( prg ); - stream->impl = colm_impl_new_file( fileName, file ); + stream->impl = colm_impl_new_file( file_name, file ); } return stream; @@ -1105,7 +1105,7 @@ struct stream_impl *colm_stream_impl( struct colm_struct *s ) return ((stream_t*)s)->impl; } -struct stream_impl *streamToImpl( stream_t *ptr ) +struct stream_impl *stream_to_impl( stream_t *ptr ) { return ptr->impl; } diff --git a/src/input.h b/src/input.h index be1b1bf5..f6f35891 100644 --- a/src/input.h +++ b/src/input.h @@ -70,48 +70,48 @@ typedef struct _RunBuf struct _RunBuf *next, *prev; } RunBuf; -RunBuf *newRunBuf(); +RunBuf *new_run_buf(); struct StreamFuncs { - int (*getParseBlock)( struct stream_impl *ss, int skip, char **pdp, int *copied ); + int (*get_parse_block)( struct stream_impl *ss, int skip, char **pdp, int *copied ); - int (*getData)( struct stream_impl *ss, char *dest, int length ); + int (*get_data)( struct stream_impl *ss, char *dest, int length ); - int (*consumeData)( struct colm_program *prg, struct colm_tree **sp, + int (*consume_data)( struct colm_program *prg, struct colm_tree **sp, struct stream_impl *ss, int length, struct colm_location *loc ); - int (*undoConsumeData)( struct stream_impl *ss, const char *data, int length ); + int (*undo_consume_data)( struct stream_impl *ss, const char *data, int length ); - struct colm_tree *(*consumeTree)( struct stream_impl *ss ); - void (*undoConsumeTree)( struct stream_impl *ss, + struct colm_tree *(*consume_tree)( struct stream_impl *ss ); + void (*undo_consume_tree)( struct stream_impl *ss, struct colm_tree *tree, int ignore ); /* Language elments (compile-time). */ - struct LangEl *(*consumeLangEl)( struct stream_impl *ss, - long *bindId, char **data, long *length ); - void (*undoConsumeLangEl)( struct stream_impl *ss ); + struct LangEl *(*consume_lang_el)( struct stream_impl *ss, + long *bind_id, char **data, long *length ); + void (*undo_consume_lang_el)( struct stream_impl *ss ); /* Private implmentation for some shared get data functions. */ - int (*getDataSource)( struct stream_impl *ss, char *dest, int length ); + int (*get_data_source)( struct stream_impl *ss, char *dest, int length ); - void (*setEof)( struct stream_impl *is ); - void (*unsetEof)( struct stream_impl *is ); + void (*set_eof)( struct stream_impl *is ); + void (*unset_eof)( struct stream_impl *is ); /* Prepending to a stream. */ - void (*prependData)( struct stream_impl *in, const char *data, long len ); - void (*prependTree)( struct stream_impl *is, struct colm_tree *tree, int ignore ); - void (*prependStream)( struct stream_impl *in, struct colm_tree *tree ); - int (*undoPrependData)( struct stream_impl *is, int length ); - struct colm_tree *(*undoPrependTree)( struct stream_impl *is ); - struct colm_tree *(*undoPrependStream)( struct stream_impl *in ); + void (*prepend_data)( struct stream_impl *in, const char *data, long len ); + void (*prepend_tree)( struct stream_impl *is, struct colm_tree *tree, int ignore ); + void (*prepend_stream)( struct stream_impl *in, struct colm_tree *tree ); + int (*undo_prepend_data)( struct stream_impl *is, int length ); + struct colm_tree *(*undo_prepend_tree)( struct stream_impl *is ); + struct colm_tree *(*undo_prepend_stream)( struct stream_impl *in ); /* Appending to a stream. */ - void (*appendData)( struct stream_impl *in, const char *data, long len ); - void (*appendTree)( struct stream_impl *in, struct colm_tree *tree ); - void (*appendStream)( struct stream_impl *in, struct colm_tree *tree ); - struct colm_tree *(*undoAppendData)( struct stream_impl *in, int length ); - struct colm_tree *(*undoAppendTree)( struct stream_impl *in ); - struct colm_tree *(*undoAppendStream)( struct stream_impl *in ); + void (*append_data)( struct stream_impl *in, const char *data, long len ); + void (*append_tree)( struct stream_impl *in, struct colm_tree *tree ); + void (*append_stream)( struct stream_impl *in, struct colm_tree *tree ); + struct colm_tree *(*undo_append_data)( struct stream_impl *in, int length ); + struct colm_tree *(*undo_append_tree)( struct stream_impl *in ); + struct colm_tree *(*undo_append_stream)( struct stream_impl *in ); }; /* List of source streams. Enables streams to be pushed/popped. */ @@ -119,12 +119,12 @@ struct stream_impl { struct StreamFuncs *funcs; - char eofSent; + char eof_sent; char eof; - char eosSent; + char eos_sent; RunBuf *queue; - RunBuf *queueTail; + RunBuf *queue_tail; const char *data; long dlen; @@ -139,9 +139,9 @@ struct stream_impl long fd; struct Pattern *pattern; - struct PatternItem *patItem; + struct PatternItem *pat_item; struct Constructor *constructor; - struct ConsItem *consItem; + struct ConsItem *cons_item; int consumed; }; @@ -152,8 +152,8 @@ struct stream_impl *colm_impl_new_file( const char *name, FILE *file ); struct stream_impl *colm_impl_new_fd( const char *name, long fd ); struct stream_impl *colm_impl_new_generic( const char *name ); -void updatePosition( struct stream_impl *inputStream, const char *data, long length ); -void undoPosition( struct stream_impl *inputStream, const char *data, long length ); +void update_position( struct stream_impl *input_stream, const char *data, long length ); +void undo_position( struct stream_impl *input_stream, const char *data, long length ); struct stream_impl *colm_stream_impl( struct colm_struct *s ); diff --git a/src/iter.c b/src/iter.c index 92cd0669..ef7490ff 100644 --- a/src/iter.c +++ b/src/iter.c @@ -28,18 +28,18 @@ #define true 1 #define false 0 -void colm_init_list_iter( generic_iter_t *listIter, tree_t **stackRoot, - long argSize, long rootSize, const ref_t *rootRef, int genericId ) +void colm_init_list_iter( generic_iter_t *list_iter, tree_t **stack_root, + long arg_size, long root_size, const ref_t *root_ref, int generic_id ) { - listIter->type = IT_Tree; - listIter->rootRef = *rootRef; - listIter->stackRoot = stackRoot; - listIter->yieldSize = 0; - listIter->rootSize = rootSize; - listIter->ref.kid = 0; - listIter->ref.next = 0; - listIter->argSize = argSize; - listIter->genericId = genericId; + list_iter->type = IT_Tree; + list_iter->root_ref = *root_ref; + list_iter->stack_root = stack_root; + list_iter->yield_size = 0; + list_iter->root_size = root_size; + list_iter->ref.kid = 0; + list_iter->ref.next = 0; + list_iter->arg_size = arg_size; + list_iter->generic_id = generic_id; } void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter ) @@ -47,10 +47,10 @@ void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter if ( (int)iter->type != 0 ) { int i; tree_t **sp = *psp; - long curStackSize = vm_ssize() - iter->rootSize; - assert( iter->yieldSize == curStackSize ); - vm_popn( iter->yieldSize ); - for ( i = 0; i < iter->argSize; i++ ) + long cur_stack_size = vm_ssize() - iter->root_size; + assert( iter->yield_size == cur_stack_size ); + vm_popn( iter->yield_size ); + for ( i = 0; i < iter->arg_size; i++ ) colm_tree_downref( prg, sp, vm_pop_tree() ); iter->type = 0; *psp = sp; @@ -60,11 +60,11 @@ void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter tree_t *colm_list_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == (vm_ssize() - iter->rootSize) ); + assert( iter->yield_size == (vm_ssize() - iter->root_size) ); if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the root. */ - list_t *list = *((list_t**)iter->rootRef.kid); + list_t *list = *((list_t**)iter->root_ref.kid); iter->ref.kid = (kid_t*)list->head; iter->ref.next = 0; @@ -76,26 +76,26 @@ tree_t *colm_list_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *i /* Have a previous item, continue searching from there. */ //iterFind( prg, psp, iter, false ); - list_el_t *listEl = (list_el_t*)iter->ref.kid; - listEl = listEl->list_next; - iter->ref.kid = (kid_t*)listEl; + list_el_t *list_el = (list_el_t*)iter->ref.kid; + list_el = list_el->list_next; + iter->ref.kid = (kid_t*)list_el; iter->ref.next = 0; } sp = *psp; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } tree_t *colm_map_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == (vm_ssize() - iter->rootSize) ); + assert( iter->yield_size == (vm_ssize() - iter->root_size) ); if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the root. */ - map_t *map = *((map_t**)iter->rootRef.kid); + map_t *map = *((map_t**)iter->root_ref.kid); iter->ref.kid = (kid_t*)map->head; iter->ref.next = 0; @@ -107,91 +107,91 @@ tree_t *colm_map_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *it /* Have a previous item, continue searching from there. */ //iterFind( prg, psp, iter, false ); - map_el_t *mapEl = (map_el_t*)iter->ref.kid; - mapEl = mapEl->next; - iter->ref.kid = (kid_t*)mapEl; + map_el_t *map_el = (map_el_t*)iter->ref.kid; + map_el = map_el->next; + iter->ref.kid = (kid_t*)map_el; iter->ref.next = 0; } sp = *psp; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } tree_t *colm_list_iter_deref_cur( program_t *prg, generic_iter_t *iter ) { - struct generic_info *gi = &prg->rtd->genericInfo[iter->genericId]; + struct generic_info *gi = &prg->rtd->generic_info[iter->generic_id]; list_el_t *el = (list_el_t*)iter->ref.kid; struct colm_struct *s = el != 0 ? - colm_struct_container( el, gi->elOffset ) : 0; + colm_struct_container( el, gi->el_offset ) : 0; return (tree_t*)s; } value_t colm_viter_deref_cur( program_t *prg, generic_iter_t *iter ) { - struct generic_info *gi = &prg->rtd->genericInfo[iter->genericId]; + struct generic_info *gi = &prg->rtd->generic_info[iter->generic_id]; list_el_t *el = (list_el_t*)iter->ref.kid; struct colm_struct *s = el != 0 ? - colm_struct_container( el, gi->elOffset ) : 0; + colm_struct_container( el, gi->el_offset ) : 0; value_t value = colm_struct_get_field( s, value_t, 0 ); - if ( gi->valueType == TYPE_TREE ) + if ( gi->value_type == TYPE_TREE ) colm_tree_upref( (tree_t*)value ); return value; } -void colm_init_tree_iter( tree_iter_t *treeIter, tree_t **stackRoot, - long argSize, long rootSize, - const ref_t *rootRef, int searchId ) +void colm_init_tree_iter( tree_iter_t *tree_iter, tree_t **stack_root, + long arg_size, long root_size, + const ref_t *root_ref, int search_id ) { - treeIter->type = IT_Tree; - treeIter->rootRef = *rootRef; - treeIter->searchId = searchId; - treeIter->stackRoot = stackRoot; - treeIter->yieldSize = 0; - treeIter->rootSize = rootSize; - treeIter->ref.kid = 0; - treeIter->ref.next = 0; - treeIter->argSize = argSize; + tree_iter->type = IT_Tree; + tree_iter->root_ref = *root_ref; + tree_iter->search_id = search_id; + tree_iter->stack_root = stack_root; + tree_iter->yield_size = 0; + tree_iter->root_size = root_size; + tree_iter->ref.kid = 0; + tree_iter->ref.next = 0; + tree_iter->arg_size = arg_size; } -void colm_init_rev_tree_iter( rev_tree_iter_t *revTriter, tree_t **stackRoot, - long argSize, long rootSize, - const ref_t *rootRef, int searchId, int children ) +void colm_init_rev_tree_iter( rev_tree_iter_t *rev_triter, tree_t **stack_root, + long arg_size, long root_size, + const ref_t *root_ref, int search_id, int children ) { - revTriter->type = IT_RevTree; - revTriter->rootRef = *rootRef; - revTriter->searchId = searchId; - revTriter->stackRoot = stackRoot; - revTriter->yieldSize = children; - revTriter->rootSize = rootSize; - revTriter->kidAtYield = 0; - revTriter->children = children; - revTriter->ref.kid = 0; - revTriter->ref.next = 0; - revTriter->argSize = argSize; + rev_triter->type = IT_RevTree; + rev_triter->root_ref = *root_ref; + rev_triter->search_id = search_id; + rev_triter->stack_root = stack_root; + rev_triter->yield_size = children; + rev_triter->root_size = root_size; + rev_triter->kid_at_yield = 0; + rev_triter->children = children; + rev_triter->ref.kid = 0; + rev_triter->ref.next = 0; + rev_triter->arg_size = arg_size; } -void initUserIter( user_iter_t *userIter, tree_t **stackRoot, long rootSize, - long argSize, long searchId ) +void init_user_iter( user_iter_t *user_iter, tree_t **stack_root, long root_size, + long arg_size, long search_id ) { - userIter->type = IT_User; - userIter->stackRoot = stackRoot; - userIter->argSize = argSize; - userIter->yieldSize = 0; - userIter->rootSize = rootSize; - userIter->resume = 0; - userIter->frame = 0; - userIter->searchId = searchId; - - userIter->ref.kid = 0; - userIter->ref.next = 0; + user_iter->type = IT_User; + user_iter->stack_root = stack_root; + user_iter->arg_size = arg_size; + user_iter->yield_size = 0; + user_iter->root_size = root_size; + user_iter->resume = 0; + user_iter->frame = 0; + user_iter->search_id = search_id; + + user_iter->ref.kid = 0; + user_iter->ref.next = 0; } -user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_info *fi, long searchId ) +user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_info *fi, long search_id ) { tree_t **sp = *psp; @@ -199,27 +199,27 @@ user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_i void *mem = vm_ptop(); user_iter_t *uiter = mem; - tree_t **stackRoot = vm_ptop(); - long rootSize = vm_ssize(); + tree_t **stack_root = vm_ptop(); + long root_size = vm_ssize(); - initUserIter( uiter, stackRoot, rootSize, fi->argSize, searchId ); + init_user_iter( uiter, stack_root, root_size, fi->arg_size, search_id ); *psp = sp; return uiter; } -void uiterInit( program_t *prg, tree_t **sp, user_iter_t *uiter, - struct function_info *fi, int revertOn ) +void uiter_init( program_t *prg, tree_t **sp, user_iter_t *uiter, + struct function_info *fi, int revert_on ) { /* Set up the first yeild so when we resume it starts at the beginning. */ uiter->ref.kid = 0; - uiter->yieldSize = vm_ssize() - uiter->rootSize; + uiter->yield_size = vm_ssize() - uiter->root_size; // uiter->frame = &uiter->stackRoot[-IFR_AA]; - if ( revertOn ) - uiter->resume = prg->rtd->frameInfo[fi->frameId].codeWV; + if ( revert_on ) + uiter->resume = prg->rtd->frame_info[fi->frame_id].codeWV; else - uiter->resume = prg->rtd->frameInfo[fi->frameId].codeWC; + uiter->resume = prg->rtd->frame_info[fi->frame_id].codeWC; } @@ -228,10 +228,10 @@ void colm_tree_iter_destroy( program_t *prg, tree_t ***psp, tree_iter_t *iter ) if ( (int)iter->type != 0 ) { int i; tree_t **sp = *psp; - long curStackSize = vm_ssize() - iter->rootSize; - assert( iter->yieldSize == curStackSize ); - vm_popn( iter->yieldSize ); - for ( i = 0; i < iter->argSize; i++ ) + long cur_stack_size = vm_ssize() - iter->root_size; + assert( iter->yield_size == cur_stack_size ); + vm_popn( iter->yield_size ); + for ( i = 0; i < iter->arg_size; i++ ) colm_tree_downref( prg, sp, vm_pop_tree() ); iter->type = 0; *psp = sp; @@ -243,10 +243,10 @@ void colm_rev_tree_iter_destroy( struct colm_program *prg, tree_t ***psp, rev_tr if ( (int)riter->type != 0 ) { int i; tree_t **sp = *psp; - long curStackSize = vm_ssize() - riter->rootSize; - assert( riter->yieldSize == curStackSize ); - vm_popn( riter->yieldSize ); - for ( i = 0; i < riter->argSize; i++ ) + long cur_stack_size = vm_ssize() - riter->root_size; + assert( riter->yield_size == cur_stack_size ); + vm_popn( riter->yield_size ); + for ( i = 0; i < riter->arg_size; i++ ) colm_tree_downref( prg, sp, vm_pop_tree() ); riter->type = 0; *psp = sp; @@ -260,10 +260,10 @@ void colm_uiter_destroy( program_t *prg, tree_t ***psp, user_iter_t *uiter ) /* We should always be coming from a yield. The current stack size will be * nonzero and the stack size in the iterator will be correct. */ - long curStackSize = vm_ssize() - uiter->rootSize; - assert( uiter->yieldSize == curStackSize ); + long cur_stack_size = vm_ssize() - uiter->root_size; + assert( uiter->yield_size == cur_stack_size ); - vm_popn( uiter->yieldSize ); + vm_popn( uiter->yield_size ); vm_popn( sizeof(user_iter_t) / sizeof(word_t) ); uiter->type = 0; @@ -279,16 +279,16 @@ void colm_uiter_unwind( program_t *prg, tree_t ***psp, user_iter_t *uiter ) /* We should always be coming from a yield. The current stack size will be * nonzero and the stack size in the iterator will be correct. */ - long curStackSize = vm_ssize() - uiter->rootSize; - assert( uiter->yieldSize == curStackSize ); + long cur_stack_size = vm_ssize() - uiter->root_size; + assert( uiter->yield_size == cur_stack_size ); - long argSize = uiter->argSize; + long arg_size = uiter->arg_size; - vm_popn( uiter->yieldSize ); + vm_popn( uiter->yield_size ); vm_popn( sizeof(user_iter_t) / sizeof(word_t) ); /* The IN_PREP_ARGS stack data. */ - vm_popn( argSize ); + vm_popn( arg_size ); vm_pop_value(); uiter->type = 0; @@ -297,43 +297,43 @@ void colm_uiter_unwind( program_t *prg, tree_t ***psp, user_iter_t *uiter ) } } -tree_t *treeIterDerefCur( tree_iter_t *iter ) +tree_t *tree_iter_deref_cur( tree_iter_t *iter ) { return iter->ref.kid == 0 ? 0 : iter->ref.kid->tree; } -void setTriterCur( program_t *prg, tree_iter_t *iter, tree_t *tree ) +void set_triter_cur( program_t *prg, tree_iter_t *iter, tree_t *tree ) { iter->ref.kid->tree = tree; } -void setUiterCur( program_t *prg, user_iter_t *uiter, tree_t *tree ) +void set_uiter_cur( program_t *prg, user_iter_t *uiter, tree_t *tree ) { uiter->ref.kid->tree = tree; } -void splitIterCur( program_t *prg, tree_t ***psp, tree_iter_t *iter ) +void split_iter_cur( program_t *prg, tree_t ***psp, tree_iter_t *iter ) { if ( iter->ref.kid == 0 ) return; - splitRef( prg, psp, &iter->ref ); + split_ref( prg, psp, &iter->ref ); } -void iterFind( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst ) +void iter_find( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first ) { - int anyTree = iter->searchId == prg->rtd->anyId; - tree_t **top = iter->stackRoot; + int any_tree = iter->search_id == prg->rtd->any_id; + tree_t **top = iter->stack_root; kid_t *child; tree_t **sp = *psp; rec_call: - if ( tryFirst && ( iter->ref.kid->tree->id == iter->searchId || anyTree ) ) { + if ( try_first && ( iter->ref.kid->tree->id == iter->search_id || any_tree ) ) { *psp = sp; return; } else { - child = treeChild( prg, iter->ref.kid->tree ); + child = tree_child( prg, iter->ref.kid->tree ); if ( child != 0 ) { vm_contiguous( 2 ); vm_push_ref( iter->ref.next ); @@ -341,7 +341,7 @@ rec_call: iter->ref.kid = child; iter->ref.next = (ref_t*)vm_ptop(); while ( iter->ref.kid != 0 ) { - tryFirst = true; + try_first = true; goto rec_call; rec_return: iter->ref.kid = iter->ref.kid->next; @@ -358,44 +358,44 @@ rec_call: *psp = sp; } -tree_t *treeIterAdvance( program_t *prg, tree_t ***psp, tree_iter_t *iter ) +tree_t *tree_iter_advance( program_t *prg, tree_t ***psp, tree_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == (vm_ssize() - iter->rootSize) ); + assert( iter->yield_size == (vm_ssize() - iter->root_size) ); if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the root. */ - iter->ref = iter->rootRef; - iterFind( prg, psp, iter, true ); + iter->ref = iter->root_ref; + iter_find( prg, psp, iter, true ); } else { /* Have a previous item, continue searching from there. */ - iterFind( prg, psp, iter, false ); + iter_find( prg, psp, iter, false ); } sp = *psp; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } -tree_t *treeIterNextChild( program_t *prg, tree_t ***psp, tree_iter_t *iter ) +tree_t *tree_iter_next_child( program_t *prg, tree_t ***psp, tree_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == (vm_ssize() - iter->rootSize) ); + assert( iter->yield_size == (vm_ssize() - iter->root_size) ); kid_t *kid = 0; if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the first child. */ - kid_t *child = treeChild( prg, iter->rootRef.kid->tree ); + kid_t *child = tree_child( prg, iter->root_ref.kid->tree ); if ( child == 0 ) iter->ref.next = 0; else { /* Make a reference to the root. */ vm_contiguous( 2 ); - vm_push_ref( iter->rootRef.next ); - vm_push_kid( iter->rootRef.kid ); + vm_push_ref( iter->root_ref.next ); + vm_push_kid( iter->root_ref.kid ); iter->ref.next = (ref_t*)vm_ptop(); kid = child; @@ -406,29 +406,29 @@ tree_t *treeIterNextChild( program_t *prg, tree_t ***psp, tree_iter_t *iter ) kid = iter->ref.kid->next; } - if ( iter->searchId != prg->rtd->anyId ) { + if ( iter->search_id != prg->rtd->any_id ) { /* Have a previous item, go to the next sibling. */ - while ( kid != 0 && kid->tree->id != iter->searchId ) + while ( kid != 0 && kid->tree->id != iter->search_id ) kid = kid->next; } iter->ref.kid = kid; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; *psp = sp; - return ( iter->ref.kid ? prg->trueVal : prg->falseVal ); + return ( iter->ref.kid ? prg->true_val : prg->false_val ); } -tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *iter ) +tree_t *tree_rev_iter_prev_child( program_t *prg, tree_t ***psp, rev_tree_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == ( vm_ssize() - iter->rootSize ) ); + assert( iter->yield_size == ( vm_ssize() - iter->root_size ) ); - if ( iter->kidAtYield != iter->ref.kid ) { + if ( iter->kid_at_yield != iter->ref.kid ) { /* Need to reload the kids. */ vm_popn( iter->children ); int c; - kid_t *kid = treeChild( prg, iter->rootRef.kid->tree ); + kid_t *kid = tree_child( prg, iter->root_ref.kid->tree ); for ( c = 0; c < iter->children; c++ ) { vm_push_kid( kid ); kid = kid->next; @@ -440,9 +440,9 @@ tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *it iter->children -= 1; } - if ( iter->searchId != prg->rtd->anyId ) { + if ( iter->search_id != prg->rtd->any_id ) { /* Have a previous item, go to the next sibling. */ - while ( iter->children > 0 && ((kid_t*)(vm_top()))->tree->id != iter->searchId ) { + while ( iter->children > 0 && ((kid_t*)(vm_top()))->tree->id != iter->search_id ) { iter->children -= 1; vm_pop_ignore(); } @@ -453,29 +453,29 @@ tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *it iter->ref.kid = 0; } else { - iter->ref.next = &iter->rootRef; + iter->ref.next = &iter->root_ref; iter->ref.kid = (kid_t*)vm_top(); } /* We will use this to detect a split above the iterated tree. */ - iter->kidAtYield = iter->ref.kid; + iter->kid_at_yield = iter->ref.kid; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; *psp = sp; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } -void iterFindRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst ) +void iter_find_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first ) { tree_t **sp = *psp; - int anyTree = iter->searchId == prg->rtd->anyId; - tree_t **top = iter->stackRoot; + int any_tree = iter->search_id == prg->rtd->any_id; + tree_t **top = iter->stack_root; kid_t *child; rec_call: - if ( tryFirst && ( iter->ref.kid->tree->id == iter->searchId || anyTree ) ) { + if ( try_first && ( iter->ref.kid->tree->id == iter->search_id || any_tree ) ) { *psp = sp; return; } @@ -485,7 +485,7 @@ rec_call: * root of the iteration, or if does not have any neighbours to the * right. */ if ( top == vm_ptop() || iter->ref.kid->next == 0 ) { - child = treeChild( prg, iter->ref.kid->tree ); + child = tree_child( prg, iter->ref.kid->tree ); if ( child != 0 ) { vm_contiguous( 2 ); vm_push_ref( iter->ref.next ); @@ -493,7 +493,7 @@ rec_call: iter->ref.kid = child; iter->ref.next = (ref_t*)vm_ptop(); while ( iter->ref.kid != 0 ) { - tryFirst = true; + try_first = true; goto rec_call; rec_return: iter->ref.kid = iter->ref.kid->next; @@ -511,38 +511,38 @@ rec_call: *psp = sp; } -tree_t *treeIterNextRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter ) +tree_t *tree_iter_next_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == ( vm_ssize() - iter->rootSize ) ); + assert( iter->yield_size == ( vm_ssize() - iter->root_size ) ); if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the root. */ - iter->ref = iter->rootRef; - iterFindRepeat( prg, psp, iter, true ); + iter->ref = iter->root_ref; + iter_find_repeat( prg, psp, iter, true ); } else { /* Have a previous item, continue searching from there. */ - iterFindRepeat( prg, psp, iter, false ); + iter_find_repeat( prg, psp, iter, false ); } sp = *psp; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } -void iterFindRevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst ) +void iter_find_rev_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first ) { tree_t **sp = *psp; - int anyTree = iter->searchId == prg->rtd->anyId; - tree_t **top = iter->stackRoot; + int any_tree = iter->search_id == prg->rtd->any_id; + tree_t **top = iter->stack_root; kid_t *child; - if ( tryFirst ) { + if ( try_first ) { while ( true ) { if ( top == vm_ptop() || iter->ref.kid->next == 0 ) { - child = treeChild( prg, iter->ref.kid->tree ); + child = tree_child( prg, iter->ref.kid->tree ); if ( child == 0 ) break; @@ -572,14 +572,14 @@ void iterFindRevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tr * because the chain may have been split, setting it null (to * prevent repeated walks up). */ ref_t *ref = (ref_t*)vm_ptop(); - iter->ref.kid = treeChild( prg, ref->kid->tree ); + iter->ref.kid = tree_child( prg, ref->kid->tree ); } else { iter->ref.kid = vm_pop_kid(); iter->ref.next = vm_pop_ref(); } first: - if ( iter->ref.kid->tree->id == iter->searchId || anyTree ) { + if ( iter->ref.kid->tree->id == iter->search_id || any_tree ) { *psp = sp; return; } @@ -589,25 +589,25 @@ first: } -tree_t *treeIterPrevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter ) +tree_t *tree_iter_prev_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter ) { tree_t **sp = *psp; - assert( iter->yieldSize == (vm_ssize() - iter->rootSize) ); + assert( iter->yield_size == (vm_ssize() - iter->root_size) ); if ( iter->ref.kid == 0 ) { /* kid_t is zero, start from the root. */ - iter->ref = iter->rootRef; - iterFindRevRepeat( prg, psp, iter, true ); + iter->ref = iter->root_ref; + iter_find_rev_repeat( prg, psp, iter, true ); } else { /* Have a previous item, continue searching from there. */ - iterFindRevRepeat( prg, psp, iter, false ); + iter_find_rev_repeat( prg, psp, iter, false ); } sp = *psp; - iter->yieldSize = vm_ssize() - iter->rootSize; + iter->yield_size = vm_ssize() - iter->root_size; - return (iter->ref.kid ? prg->trueVal : prg->falseVal ); + return (iter->ref.kid ? prg->true_val : prg->false_val ); } diff --git a/src/list.c b/src/list.c index 732c2d40..55a0ce0e 100644 --- a/src/list.c +++ b/src/list.c @@ -31,14 +31,14 @@ static void colm_list_add_after( list_t *list, list_el_t *prev_el, list_el_t *ne static void colm_list_add_before( list_t *list, list_el_t *next_el, list_el_t *new_el); list_el_t *colm_list_detach( list_t *list, list_el_t *el ); -void colm_list_prepend( list_t *list, list_el_t *newEl ) +void colm_list_prepend( list_t *list, list_el_t *new_el ) { - colm_list_add_before( list, list->head, newEl ); + colm_list_add_before( list, list->head, new_el ); } -void colm_list_append( list_t *list, list_el_t *newEl ) +void colm_list_append( list_t *list, list_el_t *new_el ) { - colm_list_add_after( list, list->tail, newEl ); + colm_list_add_after( list, list->tail, new_el ); } list_el_t *colm_list_detach_head( list_t *list ) @@ -53,42 +53,42 @@ list_el_t *colm_list_detach_tail( list_t *list ) long colm_list_length( list_t *list ) { - return list->listLen; + return list->list_len; } void colm_vlist_append( struct colm_program *prg, list_t *list, value_t value ) { - struct colm_struct *s = colm_struct_new( prg, list->genericInfo->elStructId ); + struct colm_struct *s = colm_struct_new( prg, list->generic_info->el_struct_id ); colm_struct_set_field( s, value_t, 0, value ); - list_el_t *listEl = colm_struct_get_addr( s, list_el_t*, list->genericInfo->elOffset ); + list_el_t *list_el = colm_struct_get_addr( s, list_el_t*, list->generic_info->el_offset ); - colm_list_append( list, listEl ); + colm_list_append( list, list_el ); } void colm_vlist_prepend( struct colm_program *prg, list_t *list, value_t value ) { - struct colm_struct *s = colm_struct_new( prg, list->genericInfo->elStructId ); + struct colm_struct *s = colm_struct_new( prg, list->generic_info->el_struct_id ); colm_struct_set_field( s, value_t, 0, value ); - list_el_t *listEl = colm_struct_get_addr( s, list_el_t*, list->genericInfo->elOffset ); + list_el_t *list_el = colm_struct_get_addr( s, list_el_t*, list->generic_info->el_offset ); - colm_list_prepend( list, listEl ); + colm_list_prepend( list, list_el ); } value_t colm_vlist_detach_tail( struct colm_program *prg, list_t *list ) { - list_el_t *listEl = list->tail; - colm_list_detach( list, listEl ); + list_el_t *list_el = list->tail; + colm_list_detach( list, list_el ); - struct colm_struct *s = colm_generic_el_container( prg, listEl, - (list->genericInfo - prg->rtd->genericInfo) ); + struct colm_struct *s = colm_generic_el_container( prg, list_el, + (list->generic_info - prg->rtd->generic_info) ); value_t val = colm_struct_get_field( s, value_t, 0 ); - if ( list->genericInfo->valueType == TYPE_TREE ) + if ( list->generic_info->value_type == TYPE_TREE ) colm_tree_upref( (tree_t*)val ); return val; @@ -96,15 +96,15 @@ value_t colm_vlist_detach_tail( struct colm_program *prg, list_t *list ) value_t colm_vlist_detach_head( struct colm_program *prg, list_t *list ) { - list_el_t *listEl = list->head; - colm_list_detach( list, listEl ); + list_el_t *list_el = list->head; + colm_list_detach( list, list_el ); - struct colm_struct *s = colm_generic_el_container( prg, listEl, - (list->genericInfo - prg->rtd->genericInfo) ); + struct colm_struct *s = colm_generic_el_container( prg, list_el, + (list->generic_info - prg->rtd->generic_info) ); value_t val = colm_struct_get_field( s, value_t, 0 ); - if ( list->genericInfo->valueType == TYPE_TREE ) + if ( list->generic_info->value_type == TYPE_TREE ) colm_tree_upref( (tree_t*) val ); return val; @@ -140,7 +140,7 @@ static void colm_list_add_after( list_t *list, list_el_t *prev_el, list_el_t *ne } /* Update list length. */ - list->listLen++; + list->list_len++; } static void colm_list_add_before( list_t *list, list_el_t *next_el, list_el_t *new_el) @@ -171,7 +171,7 @@ static void colm_list_add_before( list_t *list, list_el_t *next_el, list_el_t *n new_el->list_prev->list_next = new_el; } - list->listLen++; + list->list_len++; } list_el_t *colm_list_detach( list_t *list, list_el_t *el ) @@ -189,7 +189,7 @@ list_el_t *colm_list_detach( list_t *list, list_el_t *el ) el->list_next->list_prev = el->list_prev; /* Update List length and return element we detached. */ - list->listLen--; + list->list_len--; return el; } @@ -209,9 +209,9 @@ list_t *colm_list_new( struct colm_program *prg ) } struct colm_struct *colm_list_get( struct colm_program *prg, - list_t *list, word_t genId, word_t field ) + list_t *list, word_t gen_id, word_t field ) { - struct generic_info *gi = &prg->rtd->genericInfo[genId]; + struct generic_info *gi = &prg->rtd->generic_info[gen_id]; list_el_t *result = 0; switch ( field ) { case 0: @@ -226,21 +226,21 @@ struct colm_struct *colm_list_get( struct colm_program *prg, } struct colm_struct *s = result != 0 ? - colm_struct_container( result, gi->elOffset ) : 0; + colm_struct_container( result, gi->el_offset ) : 0; return s; } struct colm_struct *colm_list_el_get( struct colm_program *prg, - list_el_t *listEl, word_t genId, word_t field ) + list_el_t *list_el, word_t gen_id, word_t field ) { - struct generic_info *gi = &prg->rtd->genericInfo[genId]; + struct generic_info *gi = &prg->rtd->generic_info[gen_id]; list_el_t *result = 0; switch ( field ) { case 0: - result = listEl->list_prev; + result = list_el->list_prev; break; case 1: - result = listEl->list_next; + result = list_el->list_next; break; default: assert( 0 ); @@ -248,6 +248,6 @@ struct colm_struct *colm_list_el_get( struct colm_program *prg, } struct colm_struct *s = result != 0 ? - colm_struct_container( result, gi->elOffset ) : 0; + colm_struct_container( result, gi->el_offset ) : 0; return s; } diff --git a/src/map.c b/src/map.c index e1ef8bf6..cdf45ee8 100644 --- a/src/map.c +++ b/src/map.c @@ -29,16 +29,16 @@ #define false 0 struct colm_struct *colm_map_el_get( struct colm_program *prg, - map_el_t *mapEl, word_t genId, word_t field ) + map_el_t *map_el, word_t gen_id, word_t field ) { - struct generic_info *gi = &prg->rtd->genericInfo[genId]; + struct generic_info *gi = &prg->rtd->generic_info[gen_id]; map_el_t *result = 0; switch ( field ) { case 0: - result = mapEl->prev; + result = map_el->prev; break; case 1: - result = mapEl->next; + result = map_el->next; break; default: assert( 0 ); @@ -46,14 +46,14 @@ struct colm_struct *colm_map_el_get( struct colm_program *prg, } struct colm_struct *s = result != 0 ? - colm_struct_container( result, gi->elOffset ) : 0; + colm_struct_container( result, gi->el_offset ) : 0; return s; } struct colm_struct *colm_map_get( struct colm_program *prg, - map_t *map, word_t genId, word_t field ) + map_t *map, word_t gen_id, word_t field ) { - struct generic_info *gi = &prg->rtd->genericInfo[genId]; + struct generic_info *gi = &prg->rtd->generic_info[gen_id]; map_el_t *result = 0; switch ( field ) { case 0: @@ -68,16 +68,16 @@ struct colm_struct *colm_map_get( struct colm_program *prg, } struct colm_struct *s = result != 0 ? - colm_struct_container( result, gi->elOffset ) : 0; + colm_struct_container( result, gi->el_offset ) : 0; return s; } -void mapListAbandon( map_t *map ) +void map_list_abandon( map_t *map ) { map->head = map->tail = 0; } -void mapListAddBefore( map_t *map, map_el_t *next_el, map_el_t *new_el ) +void map_list_add_before( map_t *map, map_el_t *next_el, map_el_t *new_el ) { /* Set the next pointer of the new element to next_el. We do * this regardless of the state of the list. */ @@ -106,7 +106,7 @@ void mapListAddBefore( map_t *map, map_el_t *next_el, map_el_t *new_el ) } } -void mapListAddAfter( map_t *map, map_el_t *prev_el, map_el_t *new_el ) +void map_list_add_after( map_t *map, map_el_t *prev_el, map_el_t *new_el ) { /* Set the previous pointer of new_el to prev_el. We do * this regardless of the state of the list. */ @@ -136,7 +136,7 @@ void mapListAddAfter( map_t *map, map_el_t *prev_el, map_el_t *new_el ) } -map_el_t *mapListDetach( map_t *map, map_el_t *el ) +map_el_t *map_list_detach( map_t *map, map_el_t *el ) { /* Set forward pointers to skip over el. */ if ( el->prev == 0 ) @@ -156,13 +156,13 @@ map_el_t *mapListDetach( map_t *map, map_el_t *el ) /* Once an insertion position is found, attach a element to the tree. */ -void mapAttachRebal( map_t *map, map_el_t *element, map_el_t *parentEl, map_el_t *lastLess ) +void map_attach_rebal( map_t *map, map_el_t *element, map_el_t *parent_el, map_el_t *last_less ) { /* Increment the number of element in the tree. */ - map->treeSize += 1; + map->tree_size += 1; /* Set element's parent. */ - element->parent = parentEl; + element->parent = parent_el; /* New element always starts as a leaf with height 1. */ element->left = 0; @@ -170,30 +170,30 @@ void mapAttachRebal( map_t *map, map_el_t *element, map_el_t *parentEl, map_el_t element->height = 1; /* Are we inserting in the tree somewhere? */ - if ( parentEl != 0 ) { + if ( parent_el != 0 ) { /* We have a parent so we are somewhere in the tree. If the parent * equals lastLess, then the last traversal in the insertion went * left, otherwise it went right. */ - if ( lastLess == parentEl ) { - parentEl->left = element; + if ( last_less == parent_el ) { + parent_el->left = element; - mapListAddBefore( map, parentEl, element ); + map_list_add_before( map, parent_el, element ); } else { - parentEl->right = element; + parent_el->right = element; - mapListAddAfter( map, parentEl, element ); + map_list_add_after( map, parent_el, element ); } } else { /* No parent element so we are inserting the root. */ map->root = element; - mapListAddAfter( map, map->tail, element ); + map_list_add_after( map, map->tail, element ); } /* Recalculate the heights. */ - mapRecalcHeights( map, parentEl ); + map_recalc_heights( map, parent_el ); /* Find the first unbalance. */ map_el_t *ub = mapFindFirstUnbalGP( map, element ); @@ -203,17 +203,17 @@ void mapAttachRebal( map_t *map, map_el_t *element, map_el_t *parentEl, map_el_t { /* We assert that after this single rotation the * tree is now properly balanced. */ - mapRebalance( map, ub ); + map_rebalance( map, ub ); } } #if 0 /* Recursively delete all the children of a element. */ -void mapDeleteChildrenOf( map_t *map, map_el_t *element ) +void map_delete_children_of( map_t *map, map_el_t *element ) { /* Recurse left. */ if ( element->left ) { - mapDeleteChildrenOf( map, element->left ); + map_delete_children_of( map, element->left ); /* Delete left element. */ delete element->left; @@ -222,7 +222,7 @@ void mapDeleteChildrenOf( map_t *map, map_el_t *element ) /* Recurse right. */ if ( element->right ) { - mapDeleteChildrenOf( map, element->right ); + map_delete_children_of( map, element->right ); /* Delete right element. */ delete element->right; @@ -230,23 +230,23 @@ void mapDeleteChildrenOf( map_t *map, map_el_t *element ) } } -void mapEmpty( map_t *map ) +void map_empty( map_t *map ) { if ( map->root ) { /* Recursively delete from the tree structure. */ - mapDeleteChildrenOf( map, map->root ); + map_delete_children_of( map, map->root ); delete map->root; map->root = 0; - map->treeSize = 0; + map->tree_size = 0; - mapListAbandon( map ); + map_list_abandon( map ); } } #endif /* rebalance from a element whose gradparent is unbalanced. Only * call on a element that has a grandparent. */ -map_el_t *mapRebalance( map_t *map, map_el_t *n ) +map_el_t *map_rebalance( map_t *map, map_el_t *n ) { long lheight, rheight; map_el_t *a, *b, *c; @@ -395,12 +395,12 @@ map_el_t *mapRebalance( map_t *map, map_el_t *n ) b->height = (lheight > rheight ? lheight : rheight) + 1; /* Fix height of b's parents. */ - mapRecalcHeights( map, ggp ); + map_recalc_heights( map, ggp ); return ggp; } /* Recalculates the heights of all the ancestors of element. */ -void mapRecalcHeights( map_t *map, map_el_t *element ) +void map_recalc_heights( map_t *map, map_el_t *element ) { while ( element != 0 ) { @@ -424,7 +424,7 @@ void mapRecalcHeights( map_t *map, map_el_t *element ) /* Finds the first element whose grandparent is unbalanced. */ map_el_t *mapFindFirstUnbalGP( map_t *map, map_el_t *element ) { - long lheight, rheight, balanceProp; + long lheight, rheight, balance_prop; map_el_t *gp; if ( element == 0 || element->parent == 0 || @@ -437,9 +437,9 @@ map_el_t *mapFindFirstUnbalGP( map_t *map, map_el_t *element ) { lheight = gp->left ? gp->left->height : 0; rheight = gp->right ? gp->right->height : 0; - balanceProp = lheight - rheight; + balance_prop = lheight - rheight; - if ( balanceProp < -1 || balanceProp > 1 ) + if ( balance_prop < -1 || balance_prop > 1 ) return element; element = element->parent; @@ -451,7 +451,7 @@ map_el_t *mapFindFirstUnbalGP( map_t *map, map_el_t *element ) /* Finds the first element that is unbalanced. */ -map_el_t *mapFindFirstUnbalEl( map_t *map, map_el_t *element ) +map_el_t *map_find_first_unbal_el( map_t *map, map_el_t *element ) { if ( element == 0 ) return 0; @@ -462,9 +462,9 @@ map_el_t *mapFindFirstUnbalEl( map_t *map, map_el_t *element ) element->left->height : 0; long rheight = element->right ? element->right->height : 0; - long balanceProp = lheight - rheight; + long balance_prop = lheight - rheight; - if ( balanceProp < -1 || balanceProp > 1 ) + if ( balance_prop < -1 || balance_prop > 1 ) return element; element = element->parent; @@ -473,7 +473,7 @@ map_el_t *mapFindFirstUnbalEl( map_t *map, map_el_t *element ) } /* Replace a element in the tree with another element not in the tree. */ -void mapReplaceEl( map_t *map, map_el_t *element, map_el_t *replacement ) +void map_replace_el( map_t *map, map_el_t *element, map_el_t *replacement ) { map_el_t *parent = element->parent, *left = element->left, @@ -504,7 +504,7 @@ void mapReplaceEl( map_t *map, map_el_t *element, map_el_t *replacement ) /* Removes a element from a tree and puts filler in it's place. * Filler should be null or a child of element. */ -void mapRemoveEl( map_t *map, map_el_t *element, map_el_t *filler ) +void map_remove_el( map_t *map, map_el_t *element, map_el_t *filler ) { map_el_t *parent = element->parent; @@ -527,37 +527,37 @@ void mapRemoveEl( map_t *map, map_el_t *element, map_el_t *filler ) #if 0 /* Recursive worker for tree copying. */ -map_el_t *mapCopyBranch( program_t *prg, map_t *map, map_el_t *el, kid_t *oldNextDown, kid_t **newNextDown ) +map_el_t *map_copy_branch( program_t *prg, map_t *map, map_el_t *el, kid_t *old_next_down, kid_t **new_next_down ) { /* Duplicate element. Either the base element's copy constructor or defaul * constructor will get called. Both will suffice for initting the * pointers to null when they need to be. */ - map_el_t *newEl = mapElAllocate( prg ); + map_el_t *new_el = map_el_allocate( prg ); - if ( (kid_t*)el == oldNextDown ) - *newNextDown = (kid_t*)newEl; + if ( (kid_t*)el == old_next_down ) + *new_next_down = (kid_t*)new_el; /* If the left tree is there, copy it. */ - if ( newEl->left ) { - newEl->left = mapCopyBranch( prg, map, newEl->left, oldNextDown, newNextDown ); - newEl->left->parent = newEl; + if ( new_el->left ) { + new_el->left = map_copy_branch( prg, map, new_el->left, old_next_down, new_next_down ); + new_el->left->parent = new_el; } - mapListAddAfter( map, map->tail, newEl ); + map_list_add_after( map, map->tail, new_el ); /* If the right tree is there, copy it. */ - if ( newEl->right ) { - newEl->right = mapCopyBranch( prg, map, newEl->right, oldNextDown, newNextDown ); - newEl->right->parent = newEl; + if ( new_el->right ) { + new_el->right = map_copy_branch( prg, map, new_el->right, old_next_down, new_next_down ); + new_el->right->parent = new_el; } - return newEl; + return new_el; } #endif static long map_cmp( program_t *prg, map_t *map, const tree_t *tree1, const tree_t *tree2 ) { - if ( map->genericInfo->keyType == TYPE_TREE ) { + if ( map->generic_info->key_type == TYPE_TREE ) { return colm_cmp_tree( prg, tree1, tree2 ); } else { @@ -569,123 +569,123 @@ static long map_cmp( program_t *prg, map_t *map, const tree_t *tree1, const tree } } -map_el_t *mapInsertEl( program_t *prg, map_t *map, map_el_t *element, map_el_t **lastFound ) +map_el_t *map_insert_el( program_t *prg, map_t *map, map_el_t *element, map_el_t **last_found ) { - long keyRelation; - map_el_t *curEl = map->root, *parentEl = 0; - map_el_t *lastLess = 0; + long key_relation; + map_el_t *cur_el = map->root, *parent_el = 0; + map_el_t *last_less = 0; while ( true ) { - if ( curEl == 0 ) { + if ( cur_el == 0 ) { /* We are at an external element and did not find the key we were * looking for. Attach underneath the leaf and rebalance. */ - mapAttachRebal( map, element, parentEl, lastLess ); + map_attach_rebal( map, element, parent_el, last_less ); - if ( lastFound != 0 ) - *lastFound = element; + if ( last_found != 0 ) + *last_found = element; return element; } - keyRelation = map_cmp( prg, map, - element->key, curEl->key ); + key_relation = map_cmp( prg, map, + element->key, cur_el->key ); /* Do we go left? */ - if ( keyRelation < 0 ) { - parentEl = lastLess = curEl; - curEl = curEl->left; + if ( key_relation < 0 ) { + parent_el = last_less = cur_el; + cur_el = cur_el->left; } /* Do we go right? */ - else if ( keyRelation > 0 ) { - parentEl = curEl; - curEl = curEl->right; + else if ( key_relation > 0 ) { + parent_el = cur_el; + cur_el = cur_el->right; } /* We have hit the target. */ else { - if ( lastFound != 0 ) - *lastFound = curEl; + if ( last_found != 0 ) + *last_found = cur_el; return 0; } } } #if 0 -map_el_t *mapInsertKey( program_t *prg, map_t *map, tree_t *key, map_el_t **lastFound ) +map_el_t *map_insert_key( program_t *prg, map_t *map, tree_t *key, map_el_t **last_found ) { - long keyRelation; - map_el_t *curEl = map->root, *parentEl = 0; - map_el_t *lastLess = 0; + long key_relation; + map_el_t *cur_el = map->root, *parent_el = 0; + map_el_t *last_less = 0; while ( true ) { - if ( curEl == 0 ) { + if ( cur_el == 0 ) { /* We are at an external element and did not find the key we were * looking for. Create the new element, attach it underneath the leaf * and rebalance. */ - map_el_t *element = mapElAllocate( prg ); + map_el_t *element = map_el_allocate( prg ); element->key = key; - mapAttachRebal( map, element, parentEl, lastLess ); + map_attach_rebal( map, element, parent_el, last_less ); - if ( lastFound != 0 ) - *lastFound = element; + if ( last_found != 0 ) + *last_found = element; return element; } - keyRelation = map_cmp( prg, map, key, curEl->key ); + key_relation = map_cmp( prg, map, key, cur_el->key ); /* Do we go left? */ - if ( keyRelation < 0 ) { - parentEl = lastLess = curEl; - curEl = curEl->left; + if ( key_relation < 0 ) { + parent_el = last_less = cur_el; + cur_el = cur_el->left; } /* Do we go right? */ - else if ( keyRelation > 0 ) { - parentEl = curEl; - curEl = curEl->right; + else if ( key_relation > 0 ) { + parent_el = cur_el; + cur_el = cur_el->right; } /* We have hit the target. */ else { - if ( lastFound != 0 ) - *lastFound = curEl; + if ( last_found != 0 ) + *last_found = cur_el; return 0; } } } #endif -map_el_t *colm_map_insert( program_t *prg, map_t *map, map_el_t *mapEl ) +map_el_t *colm_map_insert( program_t *prg, map_t *map, map_el_t *map_el ) { - return mapInsertEl( prg, map, mapEl, 0 ); + return map_insert_el( prg, map, map_el, 0 ); } map_el_t *colm_vmap_insert( program_t *prg, map_t *map, struct_t *key, struct_t *value ) { - struct colm_struct *s = colm_struct_new( prg, map->genericInfo->elStructId ); + struct colm_struct *s = colm_struct_new( prg, map->generic_info->el_struct_id ); - colm_struct_set_field( s, struct_t*, map->genericInfo->elOffset, key ); + colm_struct_set_field( s, struct_t*, map->generic_info->el_offset, key ); colm_struct_set_field( s, struct_t*, 0, value ); - map_el_t *mapEl = colm_struct_get_addr( s, map_el_t*, map->genericInfo->elOffset ); + map_el_t *map_el = colm_struct_get_addr( s, map_el_t*, map->generic_info->el_offset ); - colm_map_insert( prg, map, mapEl ); + colm_map_insert( prg, map, map_el ); return 0; } map_el_t *colm_vmap_remove( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *mapEl = colm_map_find( prg, map, key ); - if ( mapEl != 0 ) - colm_map_detach( prg, map, mapEl ); + map_el_t *map_el = colm_map_find( prg, map, key ); + if ( map_el != 0 ) + colm_map_detach( prg, map, map_el ); return 0; } tree_t *colm_vmap_find( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *mapEl = colm_map_find( prg, map, key ); - if ( mapEl != 0 ) { - struct_t *s = colm_generic_el_container( prg, mapEl, - map->genericInfo - prg->rtd->genericInfo ); + map_el_t *map_el = colm_map_find( prg, map, key ); + if ( map_el != 0 ) { + struct_t *s = colm_generic_el_container( prg, map_el, + map->generic_info - prg->rtd->generic_info ); tree_t *val = colm_struct_get_field( s, tree_t*, 0 ); - if ( map->genericInfo->valueType == TYPE_TREE ) + if ( map->generic_info->value_type == TYPE_TREE ) colm_tree_upref( val ); return val; @@ -693,14 +693,14 @@ tree_t *colm_vmap_find( program_t *prg, map_t *map, tree_t *key ) return 0; } -void colm_map_detach( program_t *prg, map_t *map, map_el_t *mapEl ) +void colm_map_detach( program_t *prg, map_t *map, map_el_t *map_el ) { - mapDetach( prg, map, mapEl ); + map_detach( prg, map, map_el ); } map_el_t *colm_map_find( program_t *prg, map_t *map, tree_t *key ) { - return mapImplFind( prg, map, key ); + return map_impl_find( prg, map, key ); } /** @@ -708,23 +708,23 @@ map_el_t *colm_map_find( program_t *prg, map_t *map, tree_t *key ) * * \returns The element if key exists, null if the key does not exist. */ -map_el_t *mapImplFind( program_t *prg, map_t *map, tree_t *key ) +map_el_t *map_impl_find( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *curEl = map->root; - long keyRelation; + map_el_t *cur_el = map->root; + long key_relation; - while ( curEl != 0 ) { - keyRelation = map_cmp( prg, map, key, curEl->key ); + while ( cur_el != 0 ) { + key_relation = map_cmp( prg, map, key, cur_el->key ); /* Do we go left? */ - if ( keyRelation < 0 ) - curEl = curEl->left; + if ( key_relation < 0 ) + cur_el = cur_el->left; /* Do we go right? */ - else if ( keyRelation > 0 ) - curEl = curEl->right; + else if ( key_relation > 0 ) + cur_el = cur_el->right; /* We have hit the target. */ else { - return curEl; + return cur_el; } } return 0; @@ -738,11 +738,11 @@ map_el_t *mapImplFind( program_t *prg, map_t *map, tree_t *key ) * * \returns The element detached if the key is found, othewise returns null. */ -map_el_t *mapDetachByKey( program_t *prg, map_t *map, tree_t *key ) +map_el_t *map_detach_by_key( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *element = mapImplFind( prg, map, key ); + map_el_t *element = map_impl_find( prg, map, key ); if ( element ) - mapDetach( prg, map, element ); + map_detach( prg, map, element ); return element; } @@ -754,16 +754,16 @@ map_el_t *mapDetachByKey( program_t *prg, map_t *map, tree_t *key ) * * \returns The element given. */ -map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) +map_el_t *map_detach( program_t *prg, map_t *map, map_el_t *element ) { map_el_t *replacement, *fixfrom; long lheight, rheight; /* Remove the element from the ordered list. */ - mapListDetach( map, element ); + map_list_detach( map, element ); /* Update treeSize. */ - map->treeSize--; + map->tree_size--; /* Find a replacement element. */ if (element->right) @@ -781,8 +781,8 @@ map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) else fixfrom = replacement->parent; - mapRemoveEl( map, replacement, replacement->right ); - mapReplaceEl( map, element, replacement ); + map_remove_el( map, replacement, replacement->right ); + map_replace_el( map, element, replacement ); } else if (element->left) { @@ -799,8 +799,8 @@ map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) else fixfrom = replacement->parent; - mapRemoveEl( map, replacement, replacement->left ); - mapReplaceEl( map, element, replacement ); + map_remove_el( map, replacement, replacement->left ); + map_replace_el( map, element, replacement ); } else { @@ -808,7 +808,7 @@ map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) fixfrom = element->parent; /* The element we are deleting is a leaf element. */ - mapRemoveEl( map, element, 0 ); + map_remove_el( map, element, 0 ); } /* If fixfrom is null it means we just deleted @@ -817,10 +817,10 @@ map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) return element; /* Fix the heights after the deletion. */ - mapRecalcHeights( map, fixfrom ); + map_recalc_heights( map, fixfrom ); /* Fix every unbalanced element going up in the tree. */ - map_el_t *ub = mapFindFirstUnbalEl( map, fixfrom ); + map_el_t *ub = map_find_first_unbal_el( map, fixfrom ); while ( ub ) { /* Find the element to rebalance by moving down from the first unbalanced @@ -863,10 +863,10 @@ map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ) /* rebalance returns the grandparant of the subtree formed * by the element that were rebalanced. * We must continue upward from there rebalancing. */ - fixfrom = mapRebalance( map, ub ); + fixfrom = map_rebalance( map, ub ); /* Find the next unbalaced element. */ - ub = mapFindFirstUnbalEl( map, fixfrom ); + ub = map_find_first_unbal_el( map, fixfrom ); } return element; diff --git a/src/map.h b/src/map.h index b3a23671..737a4de7 100644 --- a/src/map.h +++ b/src/map.h @@ -30,45 +30,45 @@ extern "C" { #include #include "internal.h" -void mapListAbandon( map_t *map ); +void map_list_abandon( map_t *map ); -void mapListAddBefore( map_t *map, map_el_t *next_el, map_el_t *new_el ); -void mapListAddAfter( map_t *map, map_el_t *prev_el, map_el_t *new_el ); -map_el_t *mapListDetach( map_t *map, map_el_t *el ); -void mapAttachRebal( map_t *map, map_el_t *element, map_el_t *parentEl, map_el_t *lastLess ); -void mapDeleteChildrenOf( map_t *map, map_el_t *element ); -void mapEmpty( map_t *map ); -map_el_t *mapRebalance( map_t *map, map_el_t *n ); -void mapRecalcHeights( map_t *map, map_el_t *element ); +void map_list_add_before( map_t *map, map_el_t *next_el, map_el_t *new_el ); +void map_list_add_after( map_t *map, map_el_t *prev_el, map_el_t *new_el ); +map_el_t *map_list_detach( map_t *map, map_el_t *el ); +void map_attach_rebal( map_t *map, map_el_t *element, map_el_t *parent_el, map_el_t *last_less ); +void map_delete_children_of( map_t *map, map_el_t *element ); +void map_empty( map_t *map ); +map_el_t *map_rebalance( map_t *map, map_el_t *n ); +void map_recalc_heights( map_t *map, map_el_t *element ); map_el_t *mapFindFirstUnbalGP( map_t *map, map_el_t *element ); -map_el_t *mapFindFirstUnbalEl( map_t *map, map_el_t *element ); -void mapRemoveEl( map_t *map, map_el_t *element, map_el_t *filler ); -void mapReplaceEl( map_t *map, map_el_t *element, map_el_t *replacement ); -map_el_t *mapInsertEl( program_t *prg, map_t *map, map_el_t *element, map_el_t **lastFound ); -map_el_t *mapInsertKey( program_t *prg, map_t *map, tree_t *key, map_el_t **lastFound ); -map_el_t *mapImplFind( program_t *prg, map_t *map, tree_t *key ); -map_el_t *mapDetachByKey( program_t *prg, map_t *map, tree_t *key ); -map_el_t *mapDetach( program_t *prg, map_t *map, map_el_t *element ); -map_el_t *mapCopyBranch( program_t *prg, map_t *map, map_el_t *el, - kid_t *oldNextDown, kid_t **newNextDown ); +map_el_t *map_find_first_unbal_el( map_t *map, map_el_t *element ); +void map_remove_el( map_t *map, map_el_t *element, map_el_t *filler ); +void map_replace_el( map_t *map, map_el_t *element, map_el_t *replacement ); +map_el_t *map_insert_el( program_t *prg, map_t *map, map_el_t *element, map_el_t **last_found ); +map_el_t *map_insert_key( program_t *prg, map_t *map, tree_t *key, map_el_t **last_found ); +map_el_t *map_impl_find( program_t *prg, map_t *map, tree_t *key ); +map_el_t *map_detach_by_key( program_t *prg, map_t *map, tree_t *key ); +map_el_t *map_detach( program_t *prg, map_t *map, map_el_t *element ); +map_el_t *map_copy_branch( program_t *prg, map_t *map, map_el_t *el, + kid_t *old_next_down, kid_t **new_next_down ); -struct tree_pair mapRemove( program_t *prg, map_t *map, tree_t *key ); +struct tree_pair map_remove( program_t *prg, map_t *map, tree_t *key ); -long cmpTree( program_t *prg, const tree_t *tree1, const tree_t *tree2 ); +long cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 ); -void mapImplRemoveEl( program_t *prg, map_t *map, map_el_t *element ); -int mapImplRemoveKey( program_t *prg, map_t *map, tree_t *key ); +void map_impl_remove_el( program_t *prg, map_t *map, map_el_t *element ); +int map_impl_remove_key( program_t *prg, map_t *map, tree_t *key ); -tree_t *mapFind( program_t *prg, map_t *map, tree_t *key ); -long mapLength( map_t *map ); -tree_t *mapUnstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing ); -int mapInsert( program_t *prg, map_t *map, tree_t *key, tree_t *element ); -void mapUnremove( program_t *prg, map_t *map, tree_t *key, tree_t *element ); -tree_t *mapUninsert( program_t *prg, map_t *map, tree_t *key ); -tree_t *mapStore( program_t *prg, map_t *map, tree_t *key, tree_t *element ); +tree_t *map_find( program_t *prg, map_t *map, tree_t *key ); +long map_length( map_t *map ); +tree_t *map_unstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing ); +int map_insert( program_t *prg, map_t *map, tree_t *key, tree_t *element ); +void map_unremove( program_t *prg, map_t *map, tree_t *key, tree_t *element ); +tree_t *map_uninsert( program_t *prg, map_t *map, tree_t *key ); +tree_t *map_store( program_t *prg, map_t *map, tree_t *key, tree_t *element ); -map_el_t *colm_map_insert( program_t *prg, map_t *map, map_el_t *mapEl ); -void colm_map_detach( program_t *prg, map_t *map, map_el_t *mapEl ); +map_el_t *colm_map_insert( program_t *prg, map_t *map, map_el_t *map_el ); +void colm_map_detach( program_t *prg, map_t *map, map_el_t *map_el ); map_el_t *colm_map_find( program_t *prg, map_t *map, tree_t *key ); map_el_t *colm_vmap_insert( program_t *prg, map_t *map, struct_t *key, struct_t *value ); diff --git a/src/pdabuild.cc b/src/pdabuild.cc index 6362542c..f360c3b2 100644 --- a/src/pdabuild.cc +++ b/src/pdabuild.cc @@ -1332,102 +1332,102 @@ void Compiler::makeRuntimeData() * ProdCodeBlockLens */ - runtimeData->frameInfo = new frame_info[nextFrameId]; - runtimeData->numFrames = nextFrameId; - memset( runtimeData->frameInfo, 0, sizeof(struct frame_info) * nextFrameId ); + runtimeData->frame_info = new frame_info[nextFrameId]; + runtimeData->num_frames = nextFrameId; + memset( runtimeData->frame_info, 0, sizeof(struct frame_info) * nextFrameId ); /* * Init code block. */ if ( rootCodeBlock == 0 ) { - runtimeData->rootCode = 0; - runtimeData->rootCodeLen = 0; - runtimeData->rootFrameId = 0; + runtimeData->root_code = 0; + runtimeData->root_code_len = 0; + runtimeData->root_frame_id = 0; } else { - runtimeData->rootCode = rootCodeBlock->codeWC.data; - runtimeData->rootCodeLen = rootCodeBlock->codeWC.length(); - runtimeData->rootFrameId = rootCodeBlock->frameId; + runtimeData->root_code = rootCodeBlock->codeWC.data; + runtimeData->root_code_len = rootCodeBlock->codeWC.length(); + runtimeData->root_frame_id = rootCodeBlock->frameId; } - runtimeData->frameInfo[rootCodeBlock->frameId].codeWV = 0; - runtimeData->frameInfo[rootCodeBlock->frameId].codeLenWV = 0; + runtimeData->frame_info[rootCodeBlock->frameId].codeWV = 0; + runtimeData->frame_info[rootCodeBlock->frameId].codeLenWV = 0; - runtimeData->frameInfo[rootCodeBlock->frameId].locals = makeLocalInfo( rootCodeBlock->locals ); - runtimeData->frameInfo[rootCodeBlock->frameId].localsLen = rootCodeBlock->locals.locals.length(); + runtimeData->frame_info[rootCodeBlock->frameId].locals = makeLocalInfo( rootCodeBlock->locals ); + runtimeData->frame_info[rootCodeBlock->frameId].locals_len = rootCodeBlock->locals.locals.length(); - runtimeData->frameInfo[rootCodeBlock->frameId].frameSize = rootLocalFrame->size(); - runtimeData->frameInfo[rootCodeBlock->frameId].argSize = 0; - runtimeData->frameInfo[rootCodeBlock->frameId].retTree = false; + runtimeData->frame_info[rootCodeBlock->frameId].frame_size = rootLocalFrame->size(); + runtimeData->frame_info[rootCodeBlock->frameId].arg_size = 0; + runtimeData->frame_info[rootCodeBlock->frameId].ret_tree = false; /* * prodInfo */ count = prodList.length(); - runtimeData->prodInfo = new prod_info[count]; - runtimeData->numProds = count; + runtimeData->prod_info = new prod_info[count]; + runtimeData->num_prods = count; count = 0; for ( DefList::Iter prod = prodList; prod.lte(); prod++ ) { - runtimeData->prodInfo[count].lhsId = prod->prodName->id; - runtimeData->prodInfo[count].prodNum = prod->prodNum; - runtimeData->prodInfo[count].length = prod->fsmLength; - runtimeData->prodInfo[count].name = prod->data; - runtimeData->prodInfo[count].frameId = -1; + runtimeData->prod_info[count].lhs_id = prod->prodName->id; + runtimeData->prod_info[count].prod_num = prod->prodNum; + runtimeData->prod_info[count].length = prod->fsmLength; + runtimeData->prod_info[count].name = prod->data; + runtimeData->prod_info[count].frame_id = -1; CodeBlock *block = prod->redBlock; if ( block != 0 ) { - runtimeData->prodInfo[count].frameId = block->frameId; - runtimeData->frameInfo[block->frameId].codeWV = block->codeWV.data; - runtimeData->frameInfo[block->frameId].codeLenWV = block->codeWV.length(); + runtimeData->prod_info[count].frame_id = block->frameId; + runtimeData->frame_info[block->frameId].codeWV = block->codeWV.data; + runtimeData->frame_info[block->frameId].codeLenWV = block->codeWV.length(); - runtimeData->frameInfo[block->frameId].locals = makeLocalInfo( block->locals ); - runtimeData->frameInfo[block->frameId].localsLen = block->locals.locals.length(); + runtimeData->frame_info[block->frameId].locals = makeLocalInfo( block->locals ); + runtimeData->frame_info[block->frameId].locals_len = block->locals.locals.length(); - runtimeData->frameInfo[block->frameId].frameSize = block->localFrame->size(); - runtimeData->frameInfo[block->frameId].argSize = 0; - runtimeData->frameInfo[block->frameId].retTree = false; + runtimeData->frame_info[block->frameId].frame_size = block->localFrame->size(); + runtimeData->frame_info[block->frameId].arg_size = 0; + runtimeData->frame_info[block->frameId].ret_tree = false; } - runtimeData->prodInfo[count].lhsUpref = true; - runtimeData->prodInfo[count].copy = prod->copy.data; - runtimeData->prodInfo[count].copyLen = prod->copy.length() / 2; + runtimeData->prod_info[count].lhs_upref = true; + runtimeData->prod_info[count].copy = prod->copy.data; + runtimeData->prod_info[count].copy_len = prod->copy.length() / 2; count += 1; } /* * regionInfo */ - runtimeData->numRegions = regionList.length()+1; - runtimeData->regionInfo = new region_info[runtimeData->numRegions]; - memset( runtimeData->regionInfo, 0, - sizeof(struct region_info) * runtimeData->numRegions ); + runtimeData->num_regions = regionList.length()+1; + runtimeData->region_info = new region_info[runtimeData->num_regions]; + memset( runtimeData->region_info, 0, + sizeof(struct region_info) * runtimeData->num_regions ); - runtimeData->regionInfo[0].defaultToken = -1; - runtimeData->regionInfo[0].eofFrameId = -1; - runtimeData->regionInfo[0].ciLelId = 0; + runtimeData->region_info[0].default_token = -1; + runtimeData->region_info[0].eof_frame_id = -1; + runtimeData->region_info[0].ci_lel_id = 0; for ( RegionList::Iter reg = regionList; reg.lte(); reg++ ) { long regId = reg->id+1; - runtimeData->regionInfo[regId].defaultToken = + runtimeData->region_info[regId].default_token = reg->impl->defaultTokenInstance == 0 ? -1 : reg->impl->defaultTokenInstance->tokenDef->tdLangEl->id; - runtimeData->regionInfo[regId].eofFrameId = -1; - runtimeData->regionInfo[regId].ciLelId = reg->zeroLel != 0 ? reg->zeroLel->id : 0; + runtimeData->region_info[regId].eof_frame_id = -1; + runtimeData->region_info[regId].ci_lel_id = reg->zeroLel != 0 ? reg->zeroLel->id : 0; CodeBlock *block = reg->preEofBlock; if ( block != 0 ) { - runtimeData->regionInfo[regId].eofFrameId = block->frameId; - runtimeData->frameInfo[block->frameId].codeWV = block->codeWV.data; - runtimeData->frameInfo[block->frameId].codeLenWV = block->codeWV.length(); + runtimeData->region_info[regId].eof_frame_id = block->frameId; + runtimeData->frame_info[block->frameId].codeWV = block->codeWV.data; + runtimeData->frame_info[block->frameId].codeLenWV = block->codeWV.length(); - runtimeData->frameInfo[block->frameId].locals = makeLocalInfo( block->locals ); - runtimeData->frameInfo[block->frameId].localsLen = block->locals.locals.length(); + runtimeData->frame_info[block->frameId].locals = makeLocalInfo( block->locals ); + runtimeData->frame_info[block->frameId].locals_len = block->locals.locals.length(); - runtimeData->frameInfo[block->frameId].frameSize = block->localFrame->size(); - runtimeData->frameInfo[block->frameId].argSize = 0; - runtimeData->frameInfo[block->frameId].retTree = false; + runtimeData->frame_info[block->frameId].frame_size = block->localFrame->size(); + runtimeData->frame_info[block->frameId].arg_size = 0; + runtimeData->frame_info[block->frameId].ret_tree = false; } } @@ -1436,39 +1436,39 @@ void Compiler::makeRuntimeData() */ count = nextSymbolId; - runtimeData->lelInfo = new lang_el_info[count]; - runtimeData->numLangEls = count; - memset( runtimeData->lelInfo, 0, sizeof(struct lang_el_info)*count ); + runtimeData->lel_info = new lang_el_info[count]; + runtimeData->num_lang_els = count; + memset( runtimeData->lel_info, 0, sizeof(struct lang_el_info)*count ); for ( int i = 0; i < nextSymbolId; i++ ) { LangEl *lel = langElIndex[i]; if ( lel != 0 ) { - runtimeData->lelInfo[i].name = lel->fullLit; - runtimeData->lelInfo[i].xmlTag = lel->xmlTag; - runtimeData->lelInfo[i].repeat = lel->isRepeat; - runtimeData->lelInfo[i].list = lel->isList; - runtimeData->lelInfo[i].literal = lel->isLiteral; - runtimeData->lelInfo[i].ignore = lel->isIgnore; - runtimeData->lelInfo[i].frameId = -1; + runtimeData->lel_info[i].name = lel->fullLit; + runtimeData->lel_info[i].xml_tag = lel->xmlTag; + runtimeData->lel_info[i].repeat = lel->isRepeat; + runtimeData->lel_info[i].list = lel->isList; + runtimeData->lel_info[i].literal = lel->isLiteral; + runtimeData->lel_info[i].ignore = lel->isIgnore; + runtimeData->lel_info[i].frame_id = -1; CodeBlock *block = lel->transBlock; if ( block != 0 ) { - runtimeData->lelInfo[i].frameId = block->frameId; - runtimeData->frameInfo[block->frameId].codeWV = block->codeWV.data; - runtimeData->frameInfo[block->frameId].codeLenWV = block->codeWV.length(); + runtimeData->lel_info[i].frame_id = block->frameId; + runtimeData->frame_info[block->frameId].codeWV = block->codeWV.data; + runtimeData->frame_info[block->frameId].codeLenWV = block->codeWV.length(); - runtimeData->frameInfo[block->frameId].locals = makeLocalInfo( block->locals ); - runtimeData->frameInfo[block->frameId].localsLen = block->locals.locals.length(); + runtimeData->frame_info[block->frameId].locals = makeLocalInfo( block->locals ); + runtimeData->frame_info[block->frameId].locals_len = block->locals.locals.length(); - runtimeData->frameInfo[block->frameId].frameSize = block->localFrame->size(); - runtimeData->frameInfo[block->frameId].argSize = 0; - runtimeData->frameInfo[block->frameId].retTree = false; + runtimeData->frame_info[block->frameId].frame_size = block->localFrame->size(); + runtimeData->frame_info[block->frameId].arg_size = 0; + runtimeData->frame_info[block->frameId].ret_tree = false; } - runtimeData->lelInfo[i].objectTypeId = + runtimeData->lel_info[i].object_type_id = lel->objectDef == 0 ? 0 : lel->objectDef->id; - runtimeData->lelInfo[i].ofiOffset = lel->ofiOffset; - runtimeData->lelInfo[i].objectLength = + runtimeData->lel_info[i].ofi_offset = lel->ofiOffset; + runtimeData->lel_info[i].object_length = lel->objectDef != 0 ? lel->objectDef->size() : 0; // runtimeData->lelInfo[i].contextTypeId = 0; @@ -1480,21 +1480,21 @@ void Compiler::makeRuntimeData() // runtimeData->lelInfo[i].contextLength << endl; // } - runtimeData->lelInfo[i].termDupId = lel->termDup == 0 ? 0 : lel->termDup->id; + runtimeData->lel_info[i].term_dup_id = lel->termDup == 0 ? 0 : lel->termDup->id; if ( lel->tokenDef != 0 && lel->tokenDef->join != 0 && lel->tokenDef->join->context != 0 ) - runtimeData->lelInfo[i].markId = lel->tokenDef->join->mark->markId; + runtimeData->lel_info[i].mark_id = lel->tokenDef->join->mark->markId; else - runtimeData->lelInfo[i].markId = -1; + runtimeData->lel_info[i].mark_id = -1; - runtimeData->lelInfo[i].numCaptureAttr = 0; + runtimeData->lel_info[i].num_capture_attr = 0; } else { - memset(&runtimeData->lelInfo[i], 0, sizeof(struct lang_el_info) ); - runtimeData->lelInfo[i].name = "__UNUSED"; - runtimeData->lelInfo[i].xmlTag = "__UNUSED"; - runtimeData->lelInfo[i].frameId = -1; + memset(&runtimeData->lel_info[i], 0, sizeof(struct lang_el_info) ); + runtimeData->lel_info[i].name = "__UNUSED"; + runtimeData->lel_info[i].xml_tag = "__UNUSED"; + runtimeData->lel_info[i].frame_id = -1; } } @@ -1503,15 +1503,15 @@ void Compiler::makeRuntimeData() */ count = structEls.length(); - runtimeData->selInfo = new struct_el_info[count]; - runtimeData->numStructEls = count; - memset( runtimeData->selInfo, 0, sizeof(struct struct_el_info)*count ); + runtimeData->sel_info = new struct_el_info[count]; + runtimeData->num_struct_els = count; + memset( runtimeData->sel_info, 0, sizeof(struct struct_el_info)*count ); StructElList::Iter sel = structEls; for ( int i = 0; i < count; i++, sel++ ) { int treesLen; - runtimeData->selInfo[i].size = sel->structDef->objectDef->size(); - runtimeData->selInfo[i].trees = makeTrees( sel->structDef->objectDef, treesLen ); - runtimeData->selInfo[i].treesLen = treesLen; + runtimeData->sel_info[i].size = sel->structDef->objectDef->size(); + runtimeData->sel_info[i].trees = makeTrees( sel->structDef->objectDef, treesLen ); + runtimeData->sel_info[i].trees_len = treesLen; } /* @@ -1519,44 +1519,44 @@ void Compiler::makeRuntimeData() */ count = functionList.length(); - runtimeData->functionInfo = new function_info[count]; - runtimeData->numFunctions = count; - memset( runtimeData->functionInfo, 0, sizeof(struct function_info)*count ); + runtimeData->function_info = new function_info[count]; + runtimeData->num_functions = count; + memset( runtimeData->function_info, 0, sizeof(struct function_info)*count ); for ( FunctionList::Iter func = functionList; func.lte(); func++ ) { - runtimeData->functionInfo[func->funcId].frameId = -1; + runtimeData->function_info[func->funcId].frame_id = -1; CodeBlock *block = func->codeBlock; if ( block != 0 ) { - runtimeData->functionInfo[func->funcId].frameId = block->frameId; + runtimeData->function_info[func->funcId].frame_id = block->frameId; /* Name. */ - runtimeData->frameInfo[block->frameId].name = func->name; + runtimeData->frame_info[block->frameId].name = func->name; /* Code. */ - runtimeData->frameInfo[block->frameId].codeWV = block->codeWV.data; - runtimeData->frameInfo[block->frameId].codeLenWV = block->codeWV.length(); - runtimeData->frameInfo[block->frameId].codeWC = block->codeWC.data; - runtimeData->frameInfo[block->frameId].codeLenWC = block->codeWC.length(); + runtimeData->frame_info[block->frameId].codeWV = block->codeWV.data; + runtimeData->frame_info[block->frameId].codeLenWV = block->codeWV.length(); + runtimeData->frame_info[block->frameId].codeWC = block->codeWC.data; + runtimeData->frame_info[block->frameId].codeLenWC = block->codeWC.length(); /* Locals. */ - runtimeData->frameInfo[block->frameId].locals = makeLocalInfo( block->locals ); - runtimeData->frameInfo[block->frameId].localsLen = block->locals.locals.length(); + runtimeData->frame_info[block->frameId].locals = makeLocalInfo( block->locals ); + runtimeData->frame_info[block->frameId].locals_len = block->locals.locals.length(); /* Meta. */ - runtimeData->frameInfo[block->frameId].frameSize = func->localFrame->size(); - runtimeData->frameInfo[block->frameId].argSize = func->paramListSize; + runtimeData->frame_info[block->frameId].frame_size = func->localFrame->size(); + runtimeData->frame_info[block->frameId].arg_size = func->paramListSize; bool retTree = false; if ( func->typeRef ) { UniqueType *ut = func->typeRef->resolveType( this ); retTree = ut->tree(); } - runtimeData->frameInfo[block->frameId].retTree = retTree; + runtimeData->frame_info[block->frameId].ret_tree = retTree; } - runtimeData->functionInfo[func->funcId].frameSize = func->localFrame->size(); - runtimeData->functionInfo[func->funcId].argSize = func->paramListSize; + runtimeData->function_info[func->funcId].frame_size = func->localFrame->size(); + runtimeData->function_info[func->funcId].arg_size = func->paramListSize; } /* @@ -1564,11 +1564,11 @@ void Compiler::makeRuntimeData() */ /* Filled in later after patterns are parsed. */ - runtimeData->patReplInfo = new pat_cons_info[nextPatConsId]; - memset( runtimeData->patReplInfo, 0, sizeof(struct pat_cons_info) * nextPatConsId ); - runtimeData->numPatterns = nextPatConsId; - runtimeData->patReplNodes = 0; - runtimeData->numPatternNodes = 0; + runtimeData->pat_repl_info = new pat_cons_info[nextPatConsId]; + memset( runtimeData->pat_repl_info, 0, sizeof(struct pat_cons_info) * nextPatConsId ); + runtimeData->num_patterns = nextPatConsId; + runtimeData->pat_repl_nodes = 0; + runtimeData->num_pattern_nodes = 0; /* @@ -1579,40 +1579,40 @@ void Compiler::makeRuntimeData() count += nspace->genericList.length(); assert( count == nextGenericId ); - runtimeData->genericInfo = new generic_info[count]; - runtimeData->numGenerics = count; - memset( &runtimeData->genericInfo[0], 0, sizeof(struct generic_info) ); + runtimeData->generic_info = new generic_info[count]; + runtimeData->num_generics = count; + memset( &runtimeData->generic_info[0], 0, sizeof(struct generic_info) ); for ( NamespaceList::Iter nspace = namespaceList; nspace.lte(); nspace++ ) { for ( GenericList::Iter gen = nspace->genericList; gen.lte(); gen++ ) { - runtimeData->genericInfo[gen->id].type = gen->typeId; + runtimeData->generic_info[gen->id].type = gen->typeId; - runtimeData->genericInfo[gen->id].elType = + runtimeData->generic_info[gen->id].el_type = gen->elUt->typeId; - runtimeData->genericInfo[gen->id].elStructId = + runtimeData->generic_info[gen->id].el_struct_id = ( gen->typeId == GEN_VMAP || gen->typeId == GEN_VLIST ) ? gen->elUt->structEl->id : -1; - runtimeData->genericInfo[gen->id].elOffset = + runtimeData->generic_info[gen->id].el_offset = gen->el != 0 ? gen->el->offset : -1; - runtimeData->genericInfo[gen->id].keyType = + runtimeData->generic_info[gen->id].key_type = gen->keyUt != 0 ? gen->keyUt->typeId : TYPE_NOTYPE; - runtimeData->genericInfo[gen->id].keyOffset = 0; + runtimeData->generic_info[gen->id].key_offset = 0; - runtimeData->genericInfo[gen->id].valueType = + runtimeData->generic_info[gen->id].value_type = gen->valueUt != 0 ? gen->valueUt->typeId : TYPE_NOTYPE; - runtimeData->genericInfo[gen->id].valueOffset = 0; + runtimeData->generic_info[gen->id].value_offset = 0; - runtimeData->genericInfo[gen->id].parserId = + runtimeData->generic_info[gen->id].parser_id = gen->typeId == GEN_PARSER ? gen->elUt->langEl->parserId : -1; } } - runtimeData->argvGenericId = argvTypeRef->generic->id; + runtimeData->argv_generic_id = argvTypeRef->generic->id; /* * Literals */ - runtimeData->numLiterals = literalStrings.length(); + runtimeData->num_literals = literalStrings.length(); runtimeData->litdata = new const char *[literalStrings.length()]; runtimeData->litlen = new long [literalStrings.length()]; runtimeData->literals = 0; @@ -1633,9 +1633,9 @@ void Compiler::makeRuntimeData() // for ( TokenInstanceListReg::Iter td = reg->tokenInstanceList; td.lte(); td++ ) // numCapturedAttr += td->reCaptureVect.length(); // } - runtimeData->captureAttr = new CaptureAttr[numCapturedAttr]; - runtimeData->numCapturedAttr = numCapturedAttr; - memset( runtimeData->captureAttr, 0, sizeof( CaptureAttr ) * numCapturedAttr ); + runtimeData->capture_attr = new CaptureAttr[numCapturedAttr]; + runtimeData->num_captured_attr = numCapturedAttr; + memset( runtimeData->capture_attr, 0, sizeof( CaptureAttr ) * numCapturedAttr ); count = 0; // for ( RegionList::Iter reg = regionList; reg.lte(); reg++ ) { @@ -1652,42 +1652,42 @@ void Compiler::makeRuntimeData() // } // } - runtimeData->fsmTables = fsmTables; - runtimeData->pdaTables = pdaTables; + runtimeData->fsm_tables = fsmTables; + runtimeData->pda_tables = pdaTables; /* FIXME: need a parser descriptor. */ - runtimeData->startStates = new int[nextParserId]; - runtimeData->eofLelIds = new int[nextParserId]; - runtimeData->parserLelIds = new int[nextParserId]; - runtimeData->numParsers = nextParserId; + runtimeData->start_states = new int[nextParserId]; + runtimeData->eof_lel_ids = new int[nextParserId]; + runtimeData->parser_lel_ids = new int[nextParserId]; + runtimeData->num_parsers = nextParserId; for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) { if ( lel->parserId >= 0 ) { - runtimeData->startStates[lel->parserId] = lel->startState->stateNum; - runtimeData->eofLelIds[lel->parserId] = lel->eofLel->id; - runtimeData->parserLelIds[lel->parserId] = lel->id; + runtimeData->start_states[lel->parserId] = lel->startState->stateNum; + runtimeData->eof_lel_ids[lel->parserId] = lel->eofLel->id; + runtimeData->parser_lel_ids[lel->parserId] = lel->id; } } - runtimeData->globalSize = globalObjectDef->size(); + runtimeData->global_size = globalObjectDef->size(); /* * firstNonTermId */ - runtimeData->firstNonTermId = firstNonTermId; + runtimeData->first_non_term_id = firstNonTermId; /* Special trees. */ - runtimeData->integerId = -1; //intLangEl->id; - runtimeData->stringId = strLangEl->id; - runtimeData->anyId = anyLangEl->id; - runtimeData->eofId = 0; //eofLangEl->id; - runtimeData->noTokenId = noTokenLangEl->id; - runtimeData->globalId = globalSel->id; - runtimeData->argvElId = argvElSel->id; + runtimeData->integer_id = -1; //intLangEl->id; + runtimeData->string_id = strLangEl->id; + runtimeData->any_id = anyLangEl->id; + runtimeData->eof_id = 0; //eofLangEl->id; + runtimeData->no_token_id = noTokenLangEl->id; + runtimeData->global_id = globalSel->id; + runtimeData->argv_el_id = argvElSel->id; runtimeData->fsm_execute = &internalFsmExecute; - runtimeData->sendNamedLangEl = &internalSendNamedLangEl; - runtimeData->initBindings = &internalInitBindings; - runtimeData->popBinding = &internalPopBinding; + runtimeData->send_named_lang_el = &internalSendNamedLangEl; + runtimeData->init_bindings = &internalInitBindings; + runtimeData->pop_binding = &internalPopBinding; } @@ -1698,7 +1698,7 @@ void countNodes( program_t *prg, int &count, parse_tree_t *parseTree, kid_t *kid count += 1; /* Should't have to recurse here. */ - tree_t *ignoreList = treeLeftIgnore( prg, kid->tree ); + tree_t *ignoreList = tree_left_ignore( prg, kid->tree ); if ( ignoreList != 0 ) { kid_t *ignore = ignoreList->child; while ( ignore != 0 ) { @@ -1707,7 +1707,7 @@ void countNodes( program_t *prg, int &count, parse_tree_t *parseTree, kid_t *kid } } - ignoreList = treeRightIgnore( prg, kid->tree ); + ignoreList = tree_right_ignore( prg, kid->tree ); if ( ignoreList != 0 ) { kid_t *ignore = ignoreList->child; while ( ignore != 0 ) { @@ -1720,9 +1720,9 @@ void countNodes( program_t *prg, int &count, parse_tree_t *parseTree, kid_t *kid if ( !( parseTree->flags & PF_NAMED ) && !( parseTree->flags & PF_ARTIFICIAL ) && - treeChild( prg, kid->tree ) != 0 ) + tree_child( prg, kid->tree ) != 0 ) { - countNodes( prg, count, parseTree->child, treeChild( prg, kid->tree ) ); + countNodes( prg, count, parseTree->child, tree_child( prg, kid->tree ) ); } countNodes( prg, count, parseTree->next, kid->next ); } @@ -1737,57 +1737,57 @@ void fillNodes( program_t *prg, int &nextAvail, struct bindings *bindings, long kid_t *child = !( parseTree->flags & PF_NAMED ) && !( parseTree->flags & PF_ARTIFICIAL ) && - treeChild( prg, kid->tree ) != 0 + tree_child( prg, kid->tree ) != 0 ? - treeChild( prg, kid->tree ) : 0; + tree_child( prg, kid->tree ) : 0; parse_tree_t *ptChild = !( parseTree->flags & PF_NAMED ) && !( parseTree->flags & PF_ARTIFICIAL ) && - treeChild( prg, kid->tree ) != 0 + tree_child( prg, kid->tree ) != 0 ? parseTree->child : 0; /* Set up the fields. */ node.id = kid->tree->id; - node.prodNum = kid->tree->prod_num; - node.length = stringLength( kid->tree->tokdata ); - node.data = stringData( kid->tree->tokdata ); + node.prod_num = kid->tree->prod_num; + node.length = string_length( kid->tree->tokdata ); + node.data = string_data( kid->tree->tokdata ); /* Ignore items. */ - tree_t *ignoreList = treeLeftIgnore( prg, kid->tree ); + tree_t *ignoreList = tree_left_ignore( prg, kid->tree ); kid_t *ignore = ignoreList == 0 ? 0 : ignoreList->child; - node.leftIgnore = ignore == 0 ? -1 : nextAvail; + node.left_ignore = ignore == 0 ? -1 : nextAvail; while ( ignore != 0 ) { struct pat_cons_node &node = nodes[nextAvail++]; memset( &node, 0, sizeof(struct pat_cons_node) ); node.id = ignore->tree->id; - node.prodNum = ignore->tree->prod_num; + node.prod_num = ignore->tree->prod_num; node.next = ignore->next == 0 ? -1 : nextAvail; - node.length = stringLength( ignore->tree->tokdata ); - node.data = stringData( ignore->tree->tokdata ); + node.length = string_length( ignore->tree->tokdata ); + node.data = string_data( ignore->tree->tokdata ); ignore = ignore->next; } /* Ignore items. */ - ignoreList = treeRightIgnore( prg, kid->tree ); + ignoreList = tree_right_ignore( prg, kid->tree ); ignore = ignoreList == 0 ? 0 : ignoreList->child; - node.rightIgnore = ignore == 0 ? -1 : nextAvail; + node.right_ignore = ignore == 0 ? -1 : nextAvail; while ( ignore != 0 ) { struct pat_cons_node &node = nodes[nextAvail++]; memset( &node, 0, sizeof(struct pat_cons_node) ); node.id = ignore->tree->id; - node.prodNum = ignore->tree->prod_num; + node.prod_num = ignore->tree->prod_num; node.next = ignore->next == 0 ? -1 : nextAvail; - node.length = stringLength( ignore->tree->tokdata ); - node.data = stringData( ignore->tree->tokdata ); + node.length = string_length( ignore->tree->tokdata ); + node.data = string_data( ignore->tree->tokdata ); ignore = ignore->next; } @@ -1817,10 +1817,10 @@ void fillNodes( program_t *prg, int &nextAvail, struct bindings *bindings, long /* Since the parser is bottom up the bindings are in a bottom up * traversal order. Check after recursing. */ - node.bindId = 0; + node.bind_id = 0; if ( bindId < bindings->length() && bindings->data[bindId] == parseTree ) { /* Remember that binding ids are indexed from one. */ - node.bindId = bindId++; + node.bind_id = bindId++; //cout << "binding match in " << __PRETTY_FUNCTION__ << endl; //cout << "bindId: " << node.bindId << endl; @@ -1843,51 +1843,51 @@ void Compiler::fillInPatterns( program_t *prg ) int count = 0; for ( PatList::Iter pat = patternList; pat.lte(); pat++ ) { countNodes( prg, count, - pat->pdaRun->stackTop->next, - pat->pdaRun->stackTop->next->shadow ); + pat->pdaRun->stack_top->next, + pat->pdaRun->stack_top->next->shadow ); } for ( ConsList::Iter repl = replList; repl.lte(); repl++ ) { countNodes( prg, count, - repl->pdaRun->stackTop->next, - repl->pdaRun->stackTop->next->shadow ); + repl->pdaRun->stack_top->next, + repl->pdaRun->stack_top->next->shadow ); } - runtimeData->patReplNodes = new pat_cons_node[count]; - runtimeData->numPatternNodes = count; + runtimeData->pat_repl_nodes = new pat_cons_node[count]; + runtimeData->num_pattern_nodes = count; int nextAvail = 0; for ( PatList::Iter pat = patternList; pat.lte(); pat++ ) { int ind = nextAvail++; - runtimeData->patReplInfo[pat->patRepId].offset = ind; + runtimeData->pat_repl_info[pat->patRepId].offset = ind; /* BindIds are indexed base one. */ - runtimeData->patReplInfo[pat->patRepId].numBindings = + runtimeData->pat_repl_info[pat->patRepId].num_bindings = pat->pdaRun->bindings->length() - 1; /* Init the bind */ long bindId = 1; fillNodes( prg, nextAvail, pat->pdaRun->bindings, bindId, - runtimeData->patReplNodes, - pat->pdaRun->stackTop->next, - pat->pdaRun->stackTop->next->shadow, + runtimeData->pat_repl_nodes, + pat->pdaRun->stack_top->next, + pat->pdaRun->stack_top->next->shadow, ind ); } for ( ConsList::Iter repl = replList; repl.lte(); repl++ ) { int ind = nextAvail++; - runtimeData->patReplInfo[repl->patRepId].offset = ind; + runtimeData->pat_repl_info[repl->patRepId].offset = ind; /* BindIds are indexed base one. */ - runtimeData->patReplInfo[repl->patRepId].numBindings = + runtimeData->pat_repl_info[repl->patRepId].num_bindings = repl->pdaRun->bindings->length() - 1; long bindId = 1; fillNodes( prg, nextAvail, repl->pdaRun->bindings, bindId, - runtimeData->patReplNodes, - repl->pdaRun->stackTop->next, - repl->pdaRun->stackTop->next->shadow, + runtimeData->pat_repl_nodes, + repl->pdaRun->stack_top->next, + repl->pdaRun->stack_top->next->shadow, ind ); } @@ -1982,7 +1982,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) /* Allocate indicies and owners. */ - pdaTables->numIndicies = count; + pdaTables->num_indicies = count; pdaTables->indicies = new int[count]; pdaTables->owners = new int[count]; for ( long i = 0; i < count; i++ ) { @@ -1993,7 +1993,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) /* Allocate offsets. */ int numStates = pdaGraph->stateList.length(); pdaTables->offsets = new unsigned int[numStates]; - pdaTables->numStates = numStates; + pdaTables->num_states = numStates; /* Place transitions into indicies/owners */ PdaState **states = new PdaState*[numStates]; @@ -2029,7 +2029,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) } /* We allocated the max, but cmpression gives us less. */ - pdaTables->numIndicies = indLen; + pdaTables->num_indicies = indLen; delete[] states; @@ -2038,7 +2038,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) */ count = pdaGraph->stateList.length() * 2;; pdaTables->keys = new int[count]; - pdaTables->numKeys = count; + pdaTables->num_keys = count; count = 0; for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) { @@ -2060,7 +2060,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) */ count = pdaGraph->actionSet.length(); pdaTables->targs = new unsigned int[count]; - pdaTables->numTargs = count; + pdaTables->num_targs = count; count = 0; for ( PdaActionSet::Iter asi = pdaGraph->actionSet; asi.lte(); asi++ ) @@ -2070,12 +2070,12 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) * ActInds */ count = pdaGraph->actionSet.length(); - pdaTables->actInds = new unsigned int[count]; - pdaTables->numActInds = count; + pdaTables->act_inds = new unsigned int[count]; + pdaTables->num_act_inds = count; count = pos = 0; for ( PdaActionSet::Iter asi = pdaGraph->actionSet; asi.lte(); asi++ ) { - pdaTables->actInds[count++] = pos; + pdaTables->act_inds[count++] = pos; pos += asi->key.actions.length() + 1; } @@ -2087,7 +2087,7 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) count += asi->key.actions.length() + 1; pdaTables->actions = new unsigned int[count]; - pdaTables->numActions = count; + pdaTables->num_actions = count; count = 0; for ( PdaActionSet::Iter asi = pdaGraph->actionSet; asi.lte(); asi++ ) { @@ -2101,21 +2101,21 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) * CommitLen */ count = pdaGraph->actionSet.length(); - pdaTables->commitLen = new int[count]; - pdaTables->numCommitLen = count; + pdaTables->commit_len = new int[count]; + pdaTables->num_commit_len = count; count = 0; for ( PdaActionSet::Iter asi = pdaGraph->actionSet; asi.lte(); asi++ ) - pdaTables->commitLen[count++] = asi->key.commitLen; + pdaTables->commit_len[count++] = asi->key.commitLen; /* * tokenRegionInds. Start at one so region index 0 is null (unset). */ count = 0; pos = 1; - pdaTables->tokenRegionInds = new int[pdaTables->numStates]; + pdaTables->token_region_inds = new int[pdaTables->num_states]; for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) { - pdaTables->tokenRegionInds[count++] = pos; + pdaTables->token_region_inds[count++] = pos; pos += state->regions.length() + 1; } @@ -2128,18 +2128,18 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) count += state->regions.length() + 1; - pdaTables->numRegionItems = count; - pdaTables->tokenRegions = new int[pdaTables->numRegionItems]; + pdaTables->num_region_items = count; + pdaTables->token_regions = new int[pdaTables->num_region_items]; count = 0; - pdaTables->tokenRegions[count++] = 0; + pdaTables->token_regions[count++] = 0; for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) { for ( RegionVect::Iter reg = state->regions; reg.lte(); reg++ ) { int id = ( *reg == EOF_REGION ) ? 0 : (*reg)->id + 1; - pdaTables->tokenRegions[count++] = id; + pdaTables->token_regions[count++] = id; } - pdaTables->tokenRegions[count++] = 0; + pdaTables->token_regions[count++] = 0; } /* @@ -2150,21 +2150,21 @@ struct pda_tables *Compiler::makePdaTables( PdaGraph *pdaGraph ) for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) count += state->regions.length() + 1; - pdaTables->numPreRegionItems = count; - pdaTables->tokenPreRegions = new int[pdaTables->numPreRegionItems]; + pdaTables->num_pre_region_items = count; + pdaTables->token_pre_regions = new int[pdaTables->num_pre_region_items]; count = 0; - pdaTables->tokenPreRegions[count++] = 0; + pdaTables->token_pre_regions[count++] = 0; for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) { for ( RegionVect::Iter reg = state->regions; reg.lte(); reg++ ) { assert( state->preRegions.length() <= 1 ); if ( state->preRegions.length() == 0 || state->preRegions[0]->impl->wasEmpty ) - pdaTables->tokenPreRegions[count++] = -1; + pdaTables->token_pre_regions[count++] = -1; else - pdaTables->tokenPreRegions[count++] = state->preRegions[0]->id + 1; + pdaTables->token_pre_regions[count++] = state->preRegions[0]->id + 1; } - pdaTables->tokenPreRegions[count++] = 0; + pdaTables->token_pre_regions[count++] = 0; } diff --git a/src/pdacodegen.cc b/src/pdacodegen.cc index 8d032db8..2361c347 100644 --- a/src/pdacodegen.cc +++ b/src/pdacodegen.cc @@ -75,16 +75,16 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables /* * Blocks of code in frames. */ - for ( int i = 0; i < runtimeData->numFrames; i++ ) { + for ( int i = 0; i < runtimeData->num_frames; i++ ) { /* FIXME: horrible code cloning going on here. */ - if ( runtimeData->frameInfo[i].codeLenWV > 0 ) { + if ( runtimeData->frame_info[i].codeLenWV > 0 ) { out << "static code_t code_" << i << "_wv[] = {\n\t"; - code_t *block = runtimeData->frameInfo[i].codeWV; - for ( int j = 0; j < runtimeData->frameInfo[i].codeLenWV; j++ ) { + code_t *block = runtimeData->frame_info[i].codeWV; + for ( int j = 0; j < runtimeData->frame_info[i].codeLenWV; j++ ) { out << (unsigned long) block[j]; - if ( j < runtimeData->frameInfo[i].codeLenWV-1 ) { + if ( j < runtimeData->frame_info[i].codeLenWV-1 ) { out << ", "; if ( (j+1) % 8 == 0 ) out << "\n\t"; @@ -93,14 +93,14 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables out << "\n};\n\n"; } - if ( runtimeData->frameInfo[i].codeLenWC > 0 ) { + if ( runtimeData->frame_info[i].codeLenWC > 0 ) { out << "static code_t code_" << i << "_wc[] = {\n\t"; - code_t *block = runtimeData->frameInfo[i].codeWC; - for ( int j = 0; j < runtimeData->frameInfo[i].codeLenWC; j++ ) { + code_t *block = runtimeData->frame_info[i].codeWC; + for ( int j = 0; j < runtimeData->frame_info[i].codeLenWC; j++ ) { out << (unsigned long) block[j]; - if ( j < runtimeData->frameInfo[i].codeLenWC-1 ) { + if ( j < runtimeData->frame_info[i].codeLenWC-1 ) { out << ", "; if ( (j+1) % 8 == 0 ) out << "\n\t"; @@ -109,14 +109,14 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables out << "\n};\n\n"; } - if ( runtimeData->frameInfo[i].localsLen > 0 ) { + if ( runtimeData->frame_info[i].locals_len > 0 ) { out << "static struct local_info locals_" << i << "[] = {\n\t"; - struct local_info *li = runtimeData->frameInfo[i].locals; - for ( int j = 0; j < runtimeData->frameInfo[i].localsLen; j++ ) { + struct local_info *li = runtimeData->frame_info[i].locals; + for ( int j = 0; j < runtimeData->frame_info[i].locals_len; j++ ) { out << "{ " << (int)li[j].type << ", " << li[j].offset << " }"; - if ( j < runtimeData->frameInfo[i].localsLen-1 ) { + if ( j < runtimeData->frame_info[i].locals_len-1 ) { out << ", "; if ( (j+1) % 8 == 0 ) out << "\n\t"; @@ -129,15 +129,15 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables /* * Blocks in production info. */ - for ( int i = 0; i < runtimeData->numProds; i++ ) { - if ( runtimeData->prodInfo[i].copyLen > 0 ) { + for ( int i = 0; i < runtimeData->num_prods; i++ ) { + if ( runtimeData->prod_info[i].copy_len > 0 ) { out << "static unsigned char copy_" << i << "[] = {\n\t"; - unsigned char *block = runtimeData->prodInfo[i].copy; - for ( int j = 0; j < runtimeData->prodInfo[i].copyLen; j++ ) { + unsigned char *block = runtimeData->prod_info[i].copy; + for ( int j = 0; j < runtimeData->prod_info[i].copy_len; j++ ) { out << (long) block[j*2] << ", " << (long) block[j*2+1]; - if ( j < runtimeData->prodInfo[i].copyLen-1 ) { + if ( j < runtimeData->prod_info[i].copy_len-1 ) { out << ", "; if ( (j+1) % 8 == 0 ) out << "\n\t"; @@ -151,11 +151,11 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * Init code. */ out << "static code_t " << rootCode() << "[] = {\n\t"; - code_t *block = runtimeData->rootCode ; - for ( int j = 0; j < runtimeData->rootCodeLen; j++ ) { + code_t *block = runtimeData->root_code ; + for ( int j = 0; j < runtimeData->root_code_len; j++ ) { out << (unsigned int) block[j]; - if ( j < runtimeData->rootCodeLen-1 ) { + if ( j < runtimeData->root_code_len-1 ) { out << ", "; if ( (j+1) % 8 == 0 ) out << "\n\t"; @@ -167,8 +167,8 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * lelInfo */ out << "static struct lang_el_info " << lelInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numLangEls; i++ ) { - struct lang_el_info *el = &runtimeData->lelInfo[i]; + for ( int i = 0; i < runtimeData->num_lang_els; i++ ) { + struct lang_el_info *el = &runtimeData->lel_info[i]; out << "\t{"; /* Name. */ @@ -178,7 +178,7 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables /* Name. */ out << " \""; - escapeLiteralString( out, el->xmlTag ); + escapeLiteralString( out, el->xml_tag ); out << "\", "; /* Repeat, literal, ignore flags. */ @@ -186,30 +186,30 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables out << (int)el->list << ", "; out << (int)el->literal << ", "; out << (int)el->ignore << ", "; - out << el->frameId << ", "; - out << el->objectTypeId << ", "; - out << el->ofiOffset << ", "; - out << el->objectLength << ", "; - out << el->termDupId << ", "; - out << el->markId << ", "; - out << el->captureAttr << ", "; - out << el->numCaptureAttr; + out << el->frame_id << ", "; + out << el->object_type_id << ", "; + out << el->ofi_offset << ", "; + out << el->object_length << ", "; + out << el->term_dup_id << ", "; + out << el->mark_id << ", "; + out << el->capture_attr << ", "; + out << el->num_capture_attr; out << " }"; - if ( i < runtimeData->numLangEls-1 ) + if ( i < runtimeData->num_lang_els-1 ) out << ",\n"; } out << "\n};\n\n"; - for ( int i = 0; i < runtimeData->numStructEls; i++ ) { - struct struct_el_info *el = &runtimeData->selInfo[i]; - if ( el->treesLen > 0 ) { + for ( int i = 0; i < runtimeData->num_struct_els; i++ ) { + struct struct_el_info *el = &runtimeData->sel_info[i]; + if ( el->trees_len > 0 ) { out << "static short struct_trees_" << i << "[] = {\n\t"; short *ti = el->trees; - for ( int j = 0; j < el->treesLen; j++ ) + for ( int j = 0; j < el->trees_len; j++ ) out << ti[j] << ", "; out << "\n};\n\n"; } @@ -219,17 +219,17 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * selInfo */ out << "static struct struct_el_info " << selInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numStructEls; i++ ) { - struct struct_el_info *el = &runtimeData->selInfo[i]; + for ( int i = 0; i < runtimeData->num_struct_els; i++ ) { + struct struct_el_info *el = &runtimeData->sel_info[i]; out << "\t{ "; out << el->size << ", "; /* trees. */ - if ( el->treesLen > 0 ) + if ( el->trees_len > 0 ) out << "struct_trees_" << i << ", "; else out << "0, "; - out << el->treesLen << ", "; + out << el->trees_len << ", "; out << " },\n"; } @@ -239,42 +239,42 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * frameInfo */ out << "static struct frame_info " << frameInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numFrames; i++ ) { + for ( int i = 0; i < runtimeData->num_frames; i++ ) { out << "\t{ "; /* The Name. */ - if ( runtimeData->frameInfo[i].name ) - out << "\"" << runtimeData->frameInfo[i].name << "\", "; + if ( runtimeData->frame_info[i].name ) + out << "\"" << runtimeData->frame_info[i].name << "\", "; else out << "\"\", "; - if ( runtimeData->frameInfo[i].codeLenWV > 0 ) + if ( runtimeData->frame_info[i].codeLenWV > 0 ) out << "code_" << i << "_wv, "; else out << "0, "; - out << runtimeData->frameInfo[i].codeLenWV << ", "; + out << runtimeData->frame_info[i].codeLenWV << ", "; - if ( runtimeData->frameInfo[i].codeLenWC > 0 ) + if ( runtimeData->frame_info[i].codeLenWC > 0 ) out << "code_" << i << "_wc, "; else out << "0, "; - out << runtimeData->frameInfo[i].codeLenWC << ", "; + out << runtimeData->frame_info[i].codeLenWC << ", "; /* locals. */ - if ( runtimeData->frameInfo[i].localsLen > 0 ) + if ( runtimeData->frame_info[i].locals_len > 0 ) out << "locals_" << i << ", "; else out << "0, "; - out << runtimeData->frameInfo[i].localsLen << ", "; + out << runtimeData->frame_info[i].locals_len << ", "; out << - runtimeData->frameInfo[i].argSize << ", " << - runtimeData->frameInfo[i].frameSize; + runtimeData->frame_info[i].arg_size << ", " << + runtimeData->frame_info[i].frame_size; out << " }"; - if ( i < runtimeData->numFrames-1 ) + if ( i < runtimeData->num_frames-1 ) out << ",\n"; } out << "\n};\n\n"; @@ -284,29 +284,29 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * prodInfo */ out << "static struct prod_info " << prodInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numProds; i++ ) { + for ( int i = 0; i < runtimeData->num_prods; i++ ) { out << "\t{ "; - out << runtimeData->prodInfo[i].lhsId << ", "; - out << runtimeData->prodInfo[i].prodNum << ", "; - out << runtimeData->prodInfo[i].length << ", "; + out << runtimeData->prod_info[i].lhs_id << ", "; + out << runtimeData->prod_info[i].prod_num << ", "; + out << runtimeData->prod_info[i].length << ", "; out << - '"' << runtimeData->prodInfo[i].name << "\", " << - runtimeData->prodInfo[i].frameId << ", " << - (int)runtimeData->prodInfo[i].lhsUpref << ", "; + '"' << runtimeData->prod_info[i].name << "\", " << + runtimeData->prod_info[i].frame_id << ", " << + (int)runtimeData->prod_info[i].lhs_upref << ", "; - if ( runtimeData->prodInfo[i].copyLen > 0 ) + if ( runtimeData->prod_info[i].copy_len > 0 ) out << "copy_" << i << ", "; else out << "0, "; - out << runtimeData->prodInfo[i].copyLen << ", "; + out << runtimeData->prod_info[i].copy_len << ", "; out << " }"; - if ( i < runtimeData->numProds-1 ) + if ( i < runtimeData->num_prods-1 ) out << ",\n"; } out << "\n};\n\n"; @@ -315,9 +315,9 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * patReplInfo */ out << "static struct pat_cons_info " << patReplInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numPatterns; i++ ) { - out << " { " << runtimeData->patReplInfo[i].offset << ", " << - runtimeData->patReplInfo[i].numBindings << " },\n"; + for ( int i = 0; i < runtimeData->num_patterns; i++ ) { + out << " { " << runtimeData->pat_repl_info[i].offset << ", " << + runtimeData->pat_repl_info[i].num_bindings << " },\n"; } out << "};\n\n"; @@ -325,11 +325,11 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * patReplNodes */ out << "static struct pat_cons_node " << patReplNodes() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numPatternNodes; i++ ) { - struct pat_cons_node &node = runtimeData->patReplNodes[i]; + for ( int i = 0; i < runtimeData->num_pattern_nodes; i++ ) { + struct pat_cons_node &node = runtimeData->pat_repl_nodes[i]; out << " { " << node.id << ", " << - node.prodNum << ", " << node.next << ", " << - node.child << ", " << node.bindId << ", "; + node.prod_num << ", " << node.next << ", " << + node.child << ", " << node.bind_id << ", "; if ( node.data == 0 ) out << "0"; else { @@ -339,8 +339,8 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables } out << ", " << node.length << ", "; - out << node.leftIgnore << ", "; - out << node.rightIgnore << ", "; + out << node.left_ignore << ", "; + out << node.right_ignore << ", "; out << (int)node.stop << " },\n"; } @@ -350,14 +350,14 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * functionInfo */ out << "static struct function_info " << functionInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numFunctions; i++ ) { + for ( int i = 0; i < runtimeData->num_functions; i++ ) { out << "\t{ " << - runtimeData->functionInfo[i].frameId << ", " << - runtimeData->functionInfo[i].argSize << ", " << - runtimeData->functionInfo[i].frameSize; + runtimeData->function_info[i].frame_id << ", " << + runtimeData->function_info[i].arg_size << ", " << + runtimeData->function_info[i].frame_size; out << " }"; - if ( i < runtimeData->numFunctions-1 ) + if ( i < runtimeData->num_functions-1 ) out << ",\n"; } out << "\n};\n\n"; @@ -366,13 +366,13 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * regionInfo */ out << "static struct region_info " << regionInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numRegions; i++ ) { - out << "\t{ " << runtimeData->regionInfo[i].defaultToken << - ", " << runtimeData->regionInfo[i].eofFrameId << - ", " << runtimeData->regionInfo[i].ciLelId << + for ( int i = 0; i < runtimeData->num_regions; i++ ) { + out << "\t{ " << runtimeData->region_info[i].default_token << + ", " << runtimeData->region_info[i].eof_frame_id << + ", " << runtimeData->region_info[i].ci_lel_id << " }"; - if ( i < runtimeData->numRegions-1 ) + if ( i < runtimeData->num_regions-1 ) out << ",\n"; } out << "\n};\n\n"; @@ -381,17 +381,17 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * genericInfo */ out << "static struct generic_info " << genericInfo() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numGenerics; i++ ) { + for ( int i = 0; i < runtimeData->num_generics; i++ ) { out << "\t{ " << - runtimeData->genericInfo[i].type << ", " << - runtimeData->genericInfo[i].elType << ", " << - runtimeData->genericInfo[i].elStructId << ", " << - runtimeData->genericInfo[i].elOffset << ", " << - runtimeData->genericInfo[i].keyType << ", " << - runtimeData->genericInfo[i].keyOffset << ", " << - runtimeData->genericInfo[i].valueType << ", " << - runtimeData->genericInfo[i].valueOffset << ", " << - runtimeData->genericInfo[i].parserId; + runtimeData->generic_info[i].type << ", " << + runtimeData->generic_info[i].el_type << ", " << + runtimeData->generic_info[i].el_struct_id << ", " << + runtimeData->generic_info[i].el_offset << ", " << + runtimeData->generic_info[i].key_type << ", " << + runtimeData->generic_info[i].key_offset << ", " << + runtimeData->generic_info[i].value_type << ", " << + runtimeData->generic_info[i].value_offset << ", " << + runtimeData->generic_info[i].parser_id; out << " },\n"; } out << "};\n\n"; @@ -400,7 +400,7 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables * literals */ out << "static const char *" << litdata() << "[] = {\n"; - for ( int i = 0; i < runtimeData->numLiterals; i++ ) { + for ( int i = 0; i < runtimeData->num_literals; i++ ) { out << "\t\""; escapeLiteralString( out, runtimeData->litdata[i] ); out << "\",\n"; @@ -408,39 +408,39 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables out << "};\n\n"; out << "static long " << litlen() << "[] = {\n\t"; - for ( int i = 0; i < runtimeData->numLiterals; i++ ) + for ( int i = 0; i < runtimeData->num_literals; i++ ) out << runtimeData->litlen[i] << ", "; out << "};\n\n"; out << "static head_t *" << literals() << "[] = {\n\t"; - for ( int i = 0; i < runtimeData->numLiterals; i++ ) + for ( int i = 0; i < runtimeData->num_literals; i++ ) out << "0, "; out << "};\n\n"; out << "static int startStates[] = {\n\t"; - for ( long i = 0; i < runtimeData->numParsers; i++ ) { - out << runtimeData->startStates[i] << ", "; + for ( long i = 0; i < runtimeData->num_parsers; i++ ) { + out << runtimeData->start_states[i] << ", "; } out << "};\n\n"; out << "static int eofLelIds[] = {\n\t"; - for ( long i = 0; i < runtimeData->numParsers; i++ ) { - out << runtimeData->eofLelIds[i] << ", "; + for ( long i = 0; i < runtimeData->num_parsers; i++ ) { + out << runtimeData->eof_lel_ids[i] << ", "; } out << "};\n\n"; out << "static int parserLelIds[] = {\n\t"; - for ( long i = 0; i < runtimeData->numParsers; i++ ) { - out << runtimeData->parserLelIds[i] << ", "; + for ( long i = 0; i < runtimeData->num_parsers; i++ ) { + out << runtimeData->parser_lel_ids[i] << ", "; } out << "};\n\n"; out << "static CaptureAttr captureAttr[] = {\n"; - for ( long i = 0; i < runtimeData->numCapturedAttr; i++ ) { + for ( long i = 0; i < runtimeData->num_captured_attr; i++ ) { out << "\t{ " << - runtimeData->captureAttr[i].mark_enter << ", " << - runtimeData->captureAttr[i].mark_leave << ", " << - runtimeData->captureAttr[i].offset << " },\n"; + runtimeData->capture_attr[i].mark_enter << ", " << + runtimeData->capture_attr[i].mark_leave << ", " << + runtimeData->capture_attr[i].offset << " },\n"; } out << "};\n\n"; @@ -449,59 +449,59 @@ void PdaCodeGen::writeRuntimeData( colm_sections *runtimeData, struct pda_tables "struct colm_sections colm_object = \n" "{\n" " " << lelInfo() << ",\n" - " " << runtimeData->numLangEls << ",\n" + " " << runtimeData->num_lang_els << ",\n" "\n" " " << selInfo() << ",\n" - " " << runtimeData->numStructEls << ",\n" + " " << runtimeData->num_struct_els << ",\n" "\n" " " << prodInfo() << ",\n" - " " << runtimeData->numProds << ",\n" + " " << runtimeData->num_prods << ",\n" "\n" " " << regionInfo() << ",\n" - " " << runtimeData->numRegions << ",\n" + " " << runtimeData->num_regions << ",\n" "\n" " " << rootCode() << ",\n" - " " << runtimeData->rootCodeLen << ",\n" - " " << runtimeData->rootFrameId << ",\n" + " " << runtimeData->root_code_len << ",\n" + " " << runtimeData->root_frame_id << ",\n" "\n" " " << frameInfo() << ",\n" - " " << runtimeData->numFrames << ",\n" + " " << runtimeData->num_frames << ",\n" "\n" " " << functionInfo() << ",\n" - " " << runtimeData->numFunctions << ",\n" + " " << runtimeData->num_functions << ",\n" "\n" " " << patReplInfo() << ",\n" - " " << runtimeData->numPatterns << ",\n" + " " << runtimeData->num_patterns << ",\n" "\n" " " << patReplNodes() << ",\n" - " " << runtimeData->numPatternNodes << ",\n" + " " << runtimeData->num_pattern_nodes << ",\n" "\n" " " << genericInfo() << ",\n" - " " << runtimeData->numGenerics << ",\n" - " " << runtimeData->argvGenericId << ",\n" + " " << runtimeData->num_generics << ",\n" + " " << runtimeData->argv_generic_id << ",\n" "\n" " " << litdata() << ",\n" " " << litlen() << ",\n" " " << literals() << ",\n" - " " << runtimeData->numLiterals << ",\n" + " " << runtimeData->num_literals << ",\n" "\n" " captureAttr,\n" - " " << runtimeData->numCapturedAttr << ",\n" + " " << runtimeData->num_captured_attr << ",\n" "\n" " &fsmTables_start,\n" " &pid_0_pdaTables,\n" - " startStates, eofLelIds, parserLelIds, " << runtimeData->numParsers << ",\n" + " startStates, eofLelIds, parserLelIds, " << runtimeData->num_parsers << ",\n" "\n" - " " << runtimeData->globalSize << ",\n" + " " << runtimeData->global_size << ",\n" "\n" - " " << runtimeData->firstNonTermId << ",\n" - " " << runtimeData->integerId << ",\n" - " " << runtimeData->stringId << ",\n" - " " << runtimeData->anyId << ",\n" - " " << runtimeData->eofId << ",\n" - " " << runtimeData->noTokenId << ",\n" - " " << runtimeData->globalId << ",\n" - " " << runtimeData->argvElId << ",\n" + " " << runtimeData->first_non_term_id << ",\n" + " " << runtimeData->integer_id << ",\n" + " " << runtimeData->string_id << ",\n" + " " << runtimeData->any_id << ",\n" + " " << runtimeData->eof_id << ",\n" + " " << runtimeData->no_token_id << ",\n" + " " << runtimeData->global_id << ",\n" + " " << runtimeData->argv_el_id << ",\n" " &fsm_execute,\n" " &sendNamedLangEl,\n" " &initBindings,\n" @@ -515,10 +515,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) String prefix = "pid_" + String(0, "%ld", id) + "_"; out << "static int " << prefix << indicies() << "[] = {\n\t"; - for ( int i = 0; i < tables->numIndicies; i++ ) { + for ( int i = 0; i < tables->num_indicies; i++ ) { out << tables->indicies[i]; - if ( i < tables->numIndicies-1 ) { + if ( i < tables->num_indicies-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -527,10 +527,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << owners() << "[] = {\n\t"; - for ( int i = 0; i < tables->numIndicies; i++ ) { + for ( int i = 0; i < tables->num_indicies; i++ ) { out << tables->owners[i]; - if ( i < tables->numIndicies-1 ) { + if ( i < tables->num_indicies-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -539,10 +539,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << keys() << "[] = {\n\t"; - for ( int i = 0; i < tables->numKeys; i++ ) { + for ( int i = 0; i < tables->num_keys; i++ ) { out << tables->keys[i]; - if ( i < tables->numKeys-1 ) { + if ( i < tables->num_keys-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -551,10 +551,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static unsigned int " << prefix << offsets() << "[] = {\n\t"; - for ( int i = 0; i < tables->numStates; i++ ) { + for ( int i = 0; i < tables->num_states; i++ ) { out << tables->offsets[i]; - if ( i < tables->numStates-1 ) { + if ( i < tables->num_states-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -563,10 +563,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static unsigned int " << prefix << targs() << "[] = {\n\t"; - for ( int i = 0; i < tables->numTargs; i++ ) { + for ( int i = 0; i < tables->num_targs; i++ ) { out << tables->targs[i]; - if ( i < tables->numTargs-1 ) { + if ( i < tables->num_targs-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -575,10 +575,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static unsigned int " << prefix << actInds() << "[] = {\n\t"; - for ( int i = 0; i < tables->numActInds; i++ ) { - out << tables->actInds[i]; + for ( int i = 0; i < tables->num_act_inds; i++ ) { + out << tables->act_inds[i]; - if ( i < tables->numActInds-1 ) { + if ( i < tables->num_act_inds-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -587,10 +587,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static unsigned int " << prefix << actions() << "[] = {\n\t"; - for ( int i = 0; i < tables->numActions; i++ ) { + for ( int i = 0; i < tables->num_actions; i++ ) { out << tables->actions[i]; - if ( i < tables->numActions-1 ) { + if ( i < tables->num_actions-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -599,10 +599,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << commitLen() << "[] = {\n\t"; - for ( int i = 0; i < tables->numCommitLen; i++ ) { - out << tables->commitLen[i]; + for ( int i = 0; i < tables->num_commit_len; i++ ) { + out << tables->commit_len[i]; - if ( i < tables->numCommitLen-1 ) { + if ( i < tables->num_commit_len-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -611,10 +611,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << tokenRegionInds() << "[] = {\n\t"; - for ( int i = 0; i < tables->numStates; i++ ) { - out << tables->tokenRegionInds[i]; + for ( int i = 0; i < tables->num_states; i++ ) { + out << tables->token_region_inds[i]; - if ( i < tables->numStates-1 ) { + if ( i < tables->num_states-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -623,10 +623,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << tokenRegions() << "[] = {\n\t"; - for ( int i = 0; i < tables->numRegionItems; i++ ) { - out << tables->tokenRegions[i]; + for ( int i = 0; i < tables->num_region_items; i++ ) { + out << tables->token_regions[i]; - if ( i < tables->numRegionItems-1 ) { + if ( i < tables->num_region_items-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -635,10 +635,10 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) out << "\n};\n\n"; out << "static int " << prefix << tokenPreRegions() << "[] = {\n\t"; - for ( int i = 0; i < tables->numPreRegionItems; i++ ) { - out << tables->tokenPreRegions[i]; + for ( int i = 0; i < tables->num_pre_region_items; i++ ) { + out << tables->token_pre_regions[i]; - if ( i < tables->numPreRegionItems-1 ) { + if ( i < tables->num_pre_region_items-1 ) { out << ", "; if ( (i+1) % 8 == 0 ) out << "\n\t"; @@ -662,15 +662,15 @@ void PdaCodeGen::writeParserData( long id, struct pda_tables *tables ) " " << prefix << tokenRegions() << ",\n" " " << prefix << tokenPreRegions() << ",\n" "\n" - " " << tables->numIndicies << ",\n" - " " << tables->numKeys << ",\n" - " " << tables->numStates << ",\n" - " " << tables->numTargs << ",\n" - " " << tables->numActInds << ",\n" - " " << tables->numActions << ",\n" - " " << tables->numCommitLen << ",\n" - " " << tables->numRegionItems << ",\n" - " " << tables->numPreRegionItems << "\n" + " " << tables->num_indicies << ",\n" + " " << tables->num_keys << ",\n" + " " << tables->num_states << ",\n" + " " << tables->num_targs << ",\n" + " " << tables->num_act_inds << ",\n" + " " << tables->num_actions << ",\n" + " " << tables->num_commit_len << ",\n" + " " << tables->num_region_items << ",\n" + " " << tables->num_pre_region_items << "\n" "};\n" "\n"; } diff --git a/src/pdarun.c b/src/pdarun.c index 5a0e180e..eeb5ddcb 100644 --- a/src/pdarun.c +++ b/src/pdarun.c @@ -56,65 +56,65 @@ i = (tree_t*)w; \ } while(0) -static void init_fsm_run( program_t *prg, struct pda_run *pdaRun ) +static void init_fsm_run( program_t *prg, struct pda_run *pda_run ) { - pdaRun->fsm_tables = prg->rtd->fsmTables; + pda_run->fsm_tables = prg->rtd->fsm_tables; - pdaRun->consumeBuf = 0; + pda_run->consume_buf = 0; - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; - pdaRun->eof = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; + pda_run->eof = 0; - pdaRun->preRegion = -1; + pda_run->pre_region = -1; } -static void clear_fsm_run( program_t *prg, struct pda_run *pdaRun ) +static void clear_fsm_run( program_t *prg, struct pda_run *pda_run ) { - if ( pdaRun->consumeBuf != 0 ) { + if ( pda_run->consume_buf != 0 ) { /* Transfer the run buf list to the program */ - RunBuf *head = pdaRun->consumeBuf; + RunBuf *head = pda_run->consume_buf; RunBuf *tail = head; while ( tail->next != 0 ) tail = tail->next; - tail->next = prg->allocRunBuf; - prg->allocRunBuf = head; + tail->next = prg->alloc_run_buf; + prg->alloc_run_buf = head; } } -void colm_increment_steps( struct pda_run *pdaRun ) +void colm_increment_steps( struct pda_run *pda_run ) { - pdaRun->steps += 1; + pda_run->steps += 1; //debug( prg, REALM_PARSE, "steps up to %ld\n", pdaRun->steps ); } -void colm_decrement_steps( struct pda_run *pdaRun ) +void colm_decrement_steps( struct pda_run *pda_run ) { - pdaRun->steps -= 1; + pda_run->steps -= 1; //debug( prg, REALM_PARSE, "steps down to %ld\n", pdaRun->steps ); } -head_t *colm_stream_pull( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struct stream_impl *is, long length ) +head_t *colm_stream_pull( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is, long length ) { - if ( pdaRun != 0 ) { - RunBuf *runBuf = pdaRun->consumeBuf; - if ( length > ( FSM_BUFSIZE - runBuf->length ) ) { - runBuf = newRunBuf(); - runBuf->next = pdaRun->consumeBuf; - pdaRun->consumeBuf = runBuf; + if ( pda_run != 0 ) { + RunBuf *run_buf = pda_run->consume_buf; + if ( length > ( FSM_BUFSIZE - run_buf->length ) ) { + run_buf = new_run_buf(); + run_buf->next = pda_run->consume_buf; + pda_run->consume_buf = run_buf; } - char *dest = runBuf->data + runBuf->length; + char *dest = run_buf->data + run_buf->length; - is->funcs->getData( is, dest, length ); + is->funcs->get_data( is, dest, length ); location_t *loc = location_allocate( prg ); - is->funcs->consumeData( prg, sp, is, length, loc ); + is->funcs->consume_data( prg, sp, is, length, loc ); - runBuf->length += length; + run_buf->length += length; - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; head_t *tokdata = colm_string_alloc_pointer( prg, dest, length ); tokdata->location = loc; @@ -122,48 +122,48 @@ head_t *colm_stream_pull( program_t *prg, tree_t **sp, struct pda_run *pdaRun, s return tokdata; } else { - head_t *head = initStrSpace( length ); + head_t *head = init_str_space( length ); char *dest = (char*)head->data; - is->funcs->getData( is, dest, length ); + is->funcs->get_data( is, dest, length ); location_t *loc = location_allocate( prg ); - is->funcs->consumeData( prg, sp, is, length, loc ); + is->funcs->consume_data( prg, sp, is, length, loc ); head->location = loc; return head; } } -void undoStreamPull( struct stream_impl *is, const char *data, long length ) +void undo_stream_pull( struct stream_impl *is, const char *data, long length ) { //debug( REALM_PARSE, "undoing stream pull\n" ); - is->funcs->prependData( is, data, length ); + is->funcs->prepend_data( is, data, length ); } void colm_stream_push_text( struct stream_impl *is, const char *data, long length ) { - is->funcs->prependData( is, data, length ); + is->funcs->prepend_data( is, data, length ); } void colm_stream_push_tree( struct stream_impl *is, tree_t *tree, int ignore ) { - is->funcs->prependTree( is, tree, ignore ); + is->funcs->prepend_tree( is, tree, ignore ); } void colm_stream_push_stream( struct stream_impl *is, tree_t *tree ) { - is->funcs->prependStream( is, tree ); + is->funcs->prepend_stream( is, tree ); } void colm_undo_stream_push( program_t *prg, tree_t **sp, struct stream_impl *is, long length ) { if ( length < 0 ) { - tree_t *tree = is->funcs->undoPrependTree( is ); + tree_t *tree = is->funcs->undo_prepend_tree( is ); colm_tree_downref( prg, sp, tree ); } else { - is->funcs->undoPrependData( is, length ); + is->funcs->undo_prepend_data( is, length ); } } @@ -180,12 +180,12 @@ static void send_back_text( struct stream_impl *is, const char *data, long lengt //debug( REALM_PARSE, "sending back text: %.*s\n", // (int)length, data ); - is->funcs->undoConsumeData( is, data, length ); + is->funcs->undo_consume_data( is, data, length ); } static void send_back_tree( struct stream_impl *is, tree_t *tree ) { - is->funcs->undoConsumeTree( is, tree, false ); + is->funcs->undo_consume_tree( is, tree, false ); } /* @@ -193,44 +193,44 @@ static void send_back_tree( struct stream_impl *is, tree_t *tree ) * PCR_REVERSE */ static void send_back_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, struct stream_impl *is, parse_tree_t *parseTree ) + struct pda_run *pda_run, struct stream_impl *is, parse_tree_t *parse_tree ) { #ifdef DEBUG - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; debug( prg, REALM_PARSE, "sending back: %s%s\n", - lelInfo[parseTree->shadow->tree->id].name, - parseTree->flags & PF_ARTIFICIAL ? " (artificial)" : "" ); + lel_info[parse_tree->shadow->tree->id].name, + parse_tree->flags & PF_ARTIFICIAL ? " (artificial)" : "" ); #endif - head_t *head = parseTree->shadow->tree->tokdata; - int artificial = parseTree->flags & PF_ARTIFICIAL; + head_t *head = parse_tree->shadow->tree->tokdata; + int artificial = parse_tree->flags & PF_ARTIFICIAL; if ( head != 0 && !artificial ) - send_back_text( is, stringData( head ), head->length ); + send_back_text( is, string_data( head ), head->length ); - colm_decrement_steps( pdaRun ); + colm_decrement_steps( pda_run ); /* Check for reverse code. */ - if ( parseTree->flags & PF_HAS_RCODE ) { - pdaRun->onDeck = true; - parseTree->flags &= ~PF_HAS_RCODE; + if ( parse_tree->flags & PF_HAS_RCODE ) { + pda_run->on_deck = true; + parse_tree->flags &= ~PF_HAS_RCODE; } - if ( pdaRun->steps == pdaRun->targetSteps ) { + if ( pda_run->steps == pda_run->target_steps ) { debug( prg, REALM_PARSE, "trigger parse stop, steps = " - "target = %d\n", pdaRun->targetSteps ); - pdaRun->stop = true; + "target = %d\n", pda_run->target_steps ); + pda_run->stop = true; } } -static void reset_token( struct pda_run *pdaRun ) +static void reset_token( struct pda_run *pda_run ) { /* If there is a token started, but never finished for a lack of data, we * must first backup over it. */ - if ( pdaRun->tokstart != 0 ) { - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; - pdaRun->eof = 0; + if ( pda_run->tokstart != 0 ) { + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; + pda_run->eof = 0; } } @@ -238,121 +238,121 @@ static void reset_token( struct pda_run *pdaRun ) * PCR_REVERSE */ -static void send_back( program_t *prg, tree_t **sp, struct pda_run *pdaRun, - struct stream_impl *is, parse_tree_t *parseTree ) +static void send_back( program_t *prg, tree_t **sp, struct pda_run *pda_run, + struct stream_impl *is, parse_tree_t *parse_tree ) { debug( prg, REALM_PARSE, "sending back: %s\n", - prg->rtd->lelInfo[parseTree->id].name ); + prg->rtd->lel_info[parse_tree->id].name ); - if ( parseTree->flags & PF_NAMED ) { + if ( parse_tree->flags & PF_NAMED ) { /* Send the named lang el back first, then send back any leading * whitespace. */ - is->funcs->undoConsumeLangEl( is ); + is->funcs->undo_consume_lang_el( is ); } - colm_decrement_steps( pdaRun ); + colm_decrement_steps( pda_run ); /* Artifical were not parsed, instead sent in as items. */ - if ( parseTree->flags & PF_ARTIFICIAL ) { + if ( parse_tree->flags & PF_ARTIFICIAL ) { /* Check for reverse code. */ - if ( parseTree->flags & PF_HAS_RCODE ) { + if ( parse_tree->flags & PF_HAS_RCODE ) { debug( prg, REALM_PARSE, "tree has rcode, setting on deck\n" ); - pdaRun->onDeck = true; - parseTree->flags &= ~PF_HAS_RCODE; + pda_run->on_deck = true; + parse_tree->flags &= ~PF_HAS_RCODE; } - colm_tree_upref( parseTree->shadow->tree ); + colm_tree_upref( parse_tree->shadow->tree ); - send_back_tree( is, parseTree->shadow->tree ); + send_back_tree( is, parse_tree->shadow->tree ); } else { /* Check for reverse code. */ - if ( parseTree->flags & PF_HAS_RCODE ) { + if ( parse_tree->flags & PF_HAS_RCODE ) { debug( prg, REALM_PARSE, "tree has rcode, setting on deck\n" ); - pdaRun->onDeck = true; - parseTree->flags &= ~PF_HAS_RCODE; + pda_run->on_deck = true; + parse_tree->flags &= ~PF_HAS_RCODE; } /* Push back the token data. */ - send_back_text( is, stringData( parseTree->shadow->tree->tokdata ), - stringLength( parseTree->shadow->tree->tokdata ) ); + send_back_text( is, string_data( parse_tree->shadow->tree->tokdata ), + string_length( parse_tree->shadow->tree->tokdata ) ); /* If eof was just sent back remember that it needs to be sent again. */ - if ( parseTree->id == prg->rtd->eofLelIds[pdaRun->parserId] ) - is->eofSent = false; + if ( parse_tree->id == prg->rtd->eof_lel_ids[pda_run->parser_id] ) + is->eof_sent = false; /* If the item is bound then store remove it from the bindings array. */ - prg->rtd->popBinding( pdaRun, parseTree ); + prg->rtd->pop_binding( pda_run, parse_tree ); } - if ( pdaRun->steps == pdaRun->targetSteps ) { + if ( pda_run->steps == pda_run->target_steps ) { debug( prg, REALM_PARSE, "trigger parse stop, " - "steps = target = %d\n", pdaRun->targetSteps ); - pdaRun->stop = true; + "steps = target = %d\n", pda_run->target_steps ); + pda_run->stop = true; } /* Downref the tree that was sent back and free the kid. */ - colm_tree_downref( prg, sp, parseTree->shadow->tree ); - kid_free( prg, parseTree->shadow ); - parse_tree_free( prg, parseTree ); + colm_tree_downref( prg, sp, parse_tree->shadow->tree ); + kid_free( prg, parse_tree->shadow ); + parse_tree_free( prg, parse_tree ); } -static void set_region( struct pda_run *pdaRun, int emptyIgnore, parse_tree_t *tree ) +static void set_region( struct pda_run *pda_run, int empty_ignore, parse_tree_t *tree ) { - if ( emptyIgnore ) { + if ( empty_ignore ) { /* Recording the next region. */ - tree->retryRegion = pdaRun->nextRegionInd; - if ( pdaRun->pda_tables->tokenRegions[tree->retryRegion+1] != 0 ) - pdaRun->numRetry += 1; + tree->retry_region = pda_run->next_region_ind; + if ( pda_run->pda_tables->token_regions[tree->retry_region+1] != 0 ) + pda_run->num_retry += 1; } } -static void ignore_tree( program_t *prg, struct pda_run *pdaRun, tree_t *tree ) +static void ignore_tree( program_t *prg, struct pda_run *pda_run, tree_t *tree ) { - int emptyIgnore = pdaRun->accumIgnore == 0; + int empty_ignore = pda_run->accum_ignore == 0; - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->shadow = kid_allocate( prg ); - parseTree->shadow->tree = tree; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->shadow = kid_allocate( prg ); + parse_tree->shadow->tree = tree; - parseTree->next = pdaRun->accumIgnore; - pdaRun->accumIgnore = parseTree; + parse_tree->next = pda_run->accum_ignore; + pda_run->accum_ignore = parse_tree; - colm_transfer_reverse_code( pdaRun, parseTree ); + colm_transfer_reverse_code( pda_run, parse_tree ); - if ( pdaRun->preRegion >= 0 ) - parseTree->flags |= PF_RIGHT_IGNORE; + if ( pda_run->pre_region >= 0 ) + parse_tree->flags |= PF_RIGHT_IGNORE; - set_region( pdaRun, emptyIgnore, pdaRun->accumIgnore ); + set_region( pda_run, empty_ignore, pda_run->accum_ignore ); } -static void ignore_tree_art( program_t *prg, struct pda_run *pdaRun, tree_t *tree ) +static void ignore_tree_art( program_t *prg, struct pda_run *pda_run, tree_t *tree ) { - int emptyIgnore = pdaRun->accumIgnore == 0; + int empty_ignore = pda_run->accum_ignore == 0; - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->flags |= PF_ARTIFICIAL; - parseTree->shadow = kid_allocate( prg ); - parseTree->shadow->tree = tree; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->flags |= PF_ARTIFICIAL; + parse_tree->shadow = kid_allocate( prg ); + parse_tree->shadow->tree = tree; - parseTree->next = pdaRun->accumIgnore; - pdaRun->accumIgnore = parseTree; + parse_tree->next = pda_run->accum_ignore; + pda_run->accum_ignore = parse_tree; - colm_transfer_reverse_code( pdaRun, parseTree ); + colm_transfer_reverse_code( pda_run, parse_tree ); - set_region( pdaRun, emptyIgnore, pdaRun->accumIgnore ); + set_region( pda_run, empty_ignore, pda_run->accum_ignore ); } -kid_t *make_token_with_data( program_t *prg, struct pda_run *pdaRun, +kid_t *make_token_with_data( program_t *prg, struct pda_run *pda_run, struct stream_impl *is, int id, head_t *tokdata ) { /* Make the token object. */ - long objectLength = prg->rtd->lelInfo[id].objectLength; - kid_t *attrs = allocAttrs( prg, objectLength ); + long object_length = prg->rtd->lel_info[id].object_length; + kid_t *attrs = alloc_attrs( prg, object_length ); kid_t *input = 0; input = kid_allocate( prg ); @@ -367,16 +367,16 @@ kid_t *make_token_with_data( program_t *prg, struct pda_run *pdaRun, /* No children and ignores get added later. */ input->tree->child = attrs; - struct lang_el_info *lelInfo = prg->rtd->lelInfo; - if ( lelInfo[id].numCaptureAttr > 0 ) { + struct lang_el_info *lel_info = prg->rtd->lel_info; + if ( lel_info[id].num_capture_attr > 0 ) { int i; - for ( i = 0; i < lelInfo[id].numCaptureAttr; i++ ) { - CaptureAttr *ca = &prg->rtd->captureAttr[lelInfo[id].captureAttr + i]; - head_t *data = stringAllocFull( prg, - pdaRun->mark[ca->mark_enter], - pdaRun->mark[ca->mark_leave] - - pdaRun->mark[ca->mark_enter] ); - tree_t *string = constructString( prg, data ); + for ( i = 0; i < lel_info[id].num_capture_attr; i++ ) { + CaptureAttr *ca = &prg->rtd->capture_attr[lel_info[id].capture_attr + i]; + head_t *data = string_alloc_full( prg, + pda_run->mark[ca->mark_enter], + pda_run->mark[ca->mark_leave] - + pda_run->mark[ca->mark_enter] ); + tree_t *string = construct_string( prg, data ); colm_tree_upref( string ); colm_tree_set_field( prg, input->tree, ca->offset, string ); } @@ -385,9 +385,9 @@ kid_t *make_token_with_data( program_t *prg, struct pda_run *pdaRun, return input; } -static void report_parse_error( program_t *prg, tree_t **sp, struct pda_run *pdaRun ) +static void report_parse_error( program_t *prg, tree_t **sp, struct pda_run *pda_run ) { - kid_t *kid = pdaRun->btPoint; + kid_t *kid = pda_run->bt_point; head_t *deepest = 0; while ( kid != 0 ) { head_t *head = kid->tree->tokdata; @@ -398,15 +398,15 @@ static void report_parse_error( program_t *prg, tree_t **sp, struct pda_run *pda kid = kid->next; } - head_t *errorHead = 0; + head_t *error_head = 0; /* If there are no error points on record assume the error occurred at the * beginning of the stream. */ if ( deepest == 0 ) { - errorHead = stringAllocFull( prg, ":1:1: parse error", 32 ); - errorHead->location = location_allocate( prg ); - errorHead->location->line = 1; - errorHead->location->column = 1; + error_head = string_alloc_full( prg, ":1:1: parse error", 32 ); + error_head->location = location_allocate( prg ); + error_head->location->line = 1; + error_head->location->column = 1; } else { debug( prg, REALM_PARSE, "deepest location byte: %d\n", @@ -431,317 +431,317 @@ static void report_parse_error( program_t *prg, tree_t **sp, struct pda_run *pda name = ""; char *formatted = malloc( strlen( name ) + 128 ); sprintf( formatted, "%s:%ld:%ld: parse error", name, line, column ); - errorHead = stringAllocFull( prg, formatted, strlen(formatted) ); + error_head = string_alloc_full( prg, formatted, strlen(formatted) ); free( formatted ); - errorHead->location = location_allocate( prg ); + error_head->location = location_allocate( prg ); - errorHead->location->name = deepest->location->name; - errorHead->location->line = line; - errorHead->location->column = column; - errorHead->location->byte = byte; + error_head->location->name = deepest->location->name; + error_head->location->line = line; + error_head->location->column = column; + error_head->location->byte = byte; } - tree_t *tree = constructString( prg, errorHead ); - colm_tree_downref( prg, sp, pdaRun->parseErrorText ); - pdaRun->parseErrorText = tree; - colm_tree_upref( pdaRun->parseErrorText ); + tree_t *tree = construct_string( prg, error_head ); + colm_tree_downref( prg, sp, pda_run->parse_error_text ); + pda_run->parse_error_text = tree; + colm_tree_upref( pda_run->parse_error_text ); } static void attach_right_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, parse_tree_t *parseTree ) + struct pda_run *pda_run, parse_tree_t *parse_tree ) { - if ( pdaRun->accumIgnore == 0 ) + if ( pda_run->accum_ignore == 0 ) return; - if ( pdaRun->stackTop->id > 0 && - pdaRun->stackTop->id < prg->rtd->firstNonTermId ) + if ( pda_run->stack_top->id > 0 && + pda_run->stack_top->id < prg->rtd->first_non_term_id ) { /* OK, do it */ debug( prg, REALM_PARSE, "attaching right ignore\n" ); /* Reset. */ - assert( ! ( parseTree->flags & PF_RIGHT_IL_ATTACHED ) ); + assert( ! ( parse_tree->flags & PF_RIGHT_IL_ATTACHED ) ); - parse_tree_t *accum = pdaRun->accumIgnore; + parse_tree_t *accum = pda_run->accum_ignore; - parse_tree_t *stopAt = 0, *use = accum; + parse_tree_t *stop_at = 0, *use = accum; while ( use != 0 ) { if ( ! (use->flags & PF_RIGHT_IGNORE) ) - stopAt = use; + stop_at = use; use = use->next; } - if ( stopAt != 0 ) { + if ( stop_at != 0 ) { /* Stop at was set. Make it the last item in the igore list. Take * the rest. */ - accum = stopAt->next; - stopAt->next = 0; + accum = stop_at->next; + stop_at->next = 0; } else { /* Stop at was never set. All right ignore. Use it all. */ - pdaRun->accumIgnore = 0; + pda_run->accum_ignore = 0; } /* The data list needs to be extracted and reversed. The parse tree list * can remain in stack order. */ parse_tree_t *child = accum, *last = 0; - kid_t *dataChild = 0, *dataLast = 0; + kid_t *data_child = 0, *data_last = 0; while ( child ) { - dataChild = child->shadow; + data_child = child->shadow; parse_tree_t *next = child->next; /* Reverse the lists. */ - dataChild->next = dataLast; + data_child->next = data_last; child->next = last; /* Detach the parse tree from the data tree. */ child->shadow = 0; /* Keep the last for reversal. */ - dataLast = dataChild; + data_last = data_child; last = child; child = next; } /* Last is now the first. */ - parseTree->rightIgnore = last; + parse_tree->right_ignore = last; - if ( dataChild != 0 ) { + if ( data_child != 0 ) { debug( prg, REALM_PARSE, "attaching ignore right\n" ); - kid_t *ignoreKid = dataLast; + kid_t *ignore_kid = data_last; /* Copy the ignore list first if we need to attach it as a right * ignore. */ - tree_t *rightIgnore = 0; + tree_t *right_ignore = 0; - rightIgnore = tree_allocate( prg ); - rightIgnore->id = LEL_ID_IGNORE; - rightIgnore->child = ignoreKid; + right_ignore = tree_allocate( prg ); + right_ignore->id = LEL_ID_IGNORE; + right_ignore->child = ignore_kid; - tree_t *pushTo = parseTree->shadow->tree; + tree_t *push_to = parse_tree->shadow->tree; - pushTo = push_right_ignore( prg, pushTo, rightIgnore ); + push_to = push_right_ignore( prg, push_to, right_ignore ); - parseTree->shadow->tree = pushTo; + parse_tree->shadow->tree = push_to; - parseTree->flags |= PF_RIGHT_IL_ATTACHED; + parse_tree->flags |= PF_RIGHT_IL_ATTACHED; } } } static void attach_left_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, parse_tree_t *parseTree ) + struct pda_run *pda_run, parse_tree_t *parse_tree ) { /* Reset. */ - assert( ! ( parseTree->flags & PF_LEFT_IL_ATTACHED ) ); + assert( ! ( parse_tree->flags & PF_LEFT_IL_ATTACHED ) ); - parse_tree_t *accum = pdaRun->accumIgnore; - pdaRun->accumIgnore = 0; + parse_tree_t *accum = pda_run->accum_ignore; + pda_run->accum_ignore = 0; /* The data list needs to be extracted and reversed. The parse tree list * can remain in stack order. */ parse_tree_t *child = accum, *last = 0; - kid_t *dataChild = 0, *dataLast = 0; + kid_t *data_child = 0, *data_last = 0; while ( child ) { - dataChild = child->shadow; + data_child = child->shadow; parse_tree_t *next = child->next; /* Reverse the lists. */ - dataChild->next = dataLast; + data_child->next = data_last; child->next = last; /* Detach the parse tree from the data tree. */ child->shadow = 0; /* Keep the last for reversal. */ - dataLast = dataChild; + data_last = data_child; last = child; child = next; } /* Last is now the first. */ - parseTree->leftIgnore = last; + parse_tree->left_ignore = last; - if ( dataChild != 0 ) { + if ( data_child != 0 ) { debug( prg, REALM_PARSE, "attaching left ignore\n" ); - kid_t *ignoreKid = dataChild; + kid_t *ignore_kid = data_child; /* Make the ignore list for the left-ignore. */ - tree_t *leftIgnore = tree_allocate( prg ); - leftIgnore->id = LEL_ID_IGNORE; - leftIgnore->child = ignoreKid; + tree_t *left_ignore = tree_allocate( prg ); + left_ignore->id = LEL_ID_IGNORE; + left_ignore->child = ignore_kid; - tree_t *pushTo = parseTree->shadow->tree; + tree_t *push_to = parse_tree->shadow->tree; - pushTo = push_left_ignore( prg, pushTo, leftIgnore ); + push_to = push_left_ignore( prg, push_to, left_ignore ); - parseTree->shadow->tree = pushTo; + parse_tree->shadow->tree = push_to; - parseTree->flags |= PF_LEFT_IL_ATTACHED; + parse_tree->flags |= PF_LEFT_IL_ATTACHED; } } /* Not currently used. Need to revive this. WARNING: untested changes here */ static void detach_right_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, parse_tree_t *parseTree ) + struct pda_run *pda_run, parse_tree_t *parse_tree ) { /* Right ignore are immediately discarded since they are copies of * left-ignores. */ - tree_t *rightIgnore = 0; - if ( parseTree->flags & PF_RIGHT_IL_ATTACHED ) { - tree_t *popFrom = parseTree->shadow->tree; + tree_t *right_ignore = 0; + if ( parse_tree->flags & PF_RIGHT_IL_ATTACHED ) { + tree_t *pop_from = parse_tree->shadow->tree; - popFrom = popRightIgnore( prg, sp, popFrom, &rightIgnore ); + pop_from = pop_right_ignore( prg, sp, pop_from, &right_ignore ); - parseTree->shadow->tree = popFrom; + parse_tree->shadow->tree = pop_from; - parseTree->flags &= ~PF_RIGHT_IL_ATTACHED; + parse_tree->flags &= ~PF_RIGHT_IL_ATTACHED; } - if ( parseTree->rightIgnore != 0 ) { - assert( rightIgnore != 0 ); + if ( parse_tree->right_ignore != 0 ) { + assert( right_ignore != 0 ); /* Transfer the trees to accumIgnore. */ - parse_tree_t *ignore = parseTree->rightIgnore; - parseTree->rightIgnore = 0; + parse_tree_t *ignore = parse_tree->right_ignore; + parse_tree->right_ignore = 0; - kid_t *dataIgnore = rightIgnore->child; - rightIgnore->child = 0; + kid_t *data_ignore = right_ignore->child; + right_ignore->child = 0; parse_tree_t *last = 0; - kid_t *dataLast = 0; + kid_t *data_last = 0; while ( ignore != 0 ) { parse_tree_t *next = ignore->next; - kid_t *dataNext = dataIgnore->next; + kid_t *data_next = data_ignore->next; /* Put the data trees underneath the parse trees. */ - ignore->shadow = dataIgnore; + ignore->shadow = data_ignore; /* Reverse. */ ignore->next = last; - dataIgnore->next = dataLast; + data_ignore->next = data_last; /* Keep last for reversal. */ last = ignore; - dataLast = dataIgnore; + data_last = data_ignore; ignore = next; - dataIgnore = dataNext; + data_ignore = data_next; } - pdaRun->accumIgnore = last; + pda_run->accum_ignore = last; - colm_tree_downref( prg, sp, rightIgnore ); + colm_tree_downref( prg, sp, right_ignore ); } } static void detach_left_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, parse_tree_t *parseTree ) + struct pda_run *pda_run, parse_tree_t *parse_tree ) { /* Detach left. */ - tree_t *leftIgnore = 0; - if ( parseTree->flags & PF_LEFT_IL_ATTACHED ) { - tree_t *popFrom = parseTree->shadow->tree; + tree_t *left_ignore = 0; + if ( parse_tree->flags & PF_LEFT_IL_ATTACHED ) { + tree_t *pop_from = parse_tree->shadow->tree; - popFrom = popLeftIgnore( prg, sp, popFrom, &leftIgnore ); + pop_from = pop_left_ignore( prg, sp, pop_from, &left_ignore ); - parseTree->shadow->tree = popFrom; + parse_tree->shadow->tree = pop_from; - parseTree->flags &= ~PF_LEFT_IL_ATTACHED; + parse_tree->flags &= ~PF_LEFT_IL_ATTACHED; } - if ( parseTree->leftIgnore != 0 ) { - assert( leftIgnore != 0 ); + if ( parse_tree->left_ignore != 0 ) { + assert( left_ignore != 0 ); /* Transfer the trees to accumIgnore. */ - parse_tree_t *ignore = parseTree->leftIgnore; - parseTree->leftIgnore = 0; + parse_tree_t *ignore = parse_tree->left_ignore; + parse_tree->left_ignore = 0; - kid_t *dataIgnore = leftIgnore->child; - leftIgnore->child = 0; + kid_t *data_ignore = left_ignore->child; + left_ignore->child = 0; parse_tree_t *last = 0; - kid_t *dataLast = 0; + kid_t *data_last = 0; while ( ignore != 0 ) { parse_tree_t *next = ignore->next; - kid_t *dataNext = dataIgnore->next; + kid_t *data_next = data_ignore->next; /* Put the data trees underneath the parse trees. */ - ignore->shadow = dataIgnore; + ignore->shadow = data_ignore; /* Reverse. */ ignore->next = last; - dataIgnore->next = dataLast; + data_ignore->next = data_last; /* Keep last for reversal. */ last = ignore; - dataLast = dataIgnore; + data_last = data_ignore; ignore = next; - dataIgnore = dataNext; + data_ignore = data_next; } - pdaRun->accumIgnore = last; + pda_run->accum_ignore = last; } - colm_tree_downref( prg, sp, leftIgnore ); + colm_tree_downref( prg, sp, left_ignore ); } -static int is_parser_stop_finished( struct pda_run *pdaRun ) +static int is_parser_stop_finished( struct pda_run *pda_run ) { int done = - pdaRun->stackTop->next != 0 && - pdaRun->stackTop->next->next == 0 && - pdaRun->stackTop->id == pdaRun->stopTarget; + pda_run->stack_top->next != 0 && + pda_run->stack_top->next->next == 0 && + pda_run->stack_top->id == pda_run->stop_target; return done; } -static void handle_error( program_t *prg, tree_t **sp, struct pda_run *pdaRun ) +static void handle_error( program_t *prg, tree_t **sp, struct pda_run *pda_run ) { /* Check the result. */ - if ( pdaRun->parseError ) { + if ( pda_run->parse_error ) { /* Error occured in the top-level parser. */ - report_parse_error( prg, sp, pdaRun ); + report_parse_error( prg, sp, pda_run ); } else { - if ( is_parser_stop_finished( pdaRun ) ) { + if ( is_parser_stop_finished( pda_run ) ) { debug( prg, REALM_PARSE, "stopping the parse\n" ); - pdaRun->stopParsing = true; + pda_run->stop_parsing = true; } } } -static head_t *extract_match( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struct stream_impl *is ) +static head_t *extract_match( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is ) { - long length = pdaRun->toklen; + long length = pda_run->toklen; //debug( prg, REALM_PARSE, "extracting token of length: %ld\n", length ); - RunBuf *runBuf = pdaRun->consumeBuf; - if ( runBuf == 0 || length > ( FSM_BUFSIZE - runBuf->length ) ) { - runBuf = newRunBuf(); - runBuf->next = pdaRun->consumeBuf; - pdaRun->consumeBuf = runBuf; + RunBuf *run_buf = pda_run->consume_buf; + if ( run_buf == 0 || length > ( FSM_BUFSIZE - run_buf->length ) ) { + run_buf = new_run_buf(); + run_buf->next = pda_run->consume_buf; + pda_run->consume_buf = run_buf; } - char *dest = runBuf->data + runBuf->length; + char *dest = run_buf->data + run_buf->length; - is->funcs->getData( is, dest, length ); + is->funcs->get_data( is, dest, length ); location_t *location = location_allocate( prg ); - is->funcs->consumeData( prg, sp, is, length, location ); + is->funcs->consume_data( prg, sp, is, length, location ); - runBuf->length += length; + run_buf->length += length; - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; - pdaRun->tokstart = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; + pda_run->tokstart = 0; head_t *head = colm_string_alloc_pointer( prg, dest, length ); @@ -752,23 +752,23 @@ static head_t *extract_match( program_t *prg, tree_t **sp, struct pda_run *pdaRu return head; } -static head_t *peekMatch( program_t *prg, struct pda_run *pdaRun, struct stream_impl *is ) +static head_t *peek_match( program_t *prg, struct pda_run *pda_run, struct stream_impl *is ) { - long length = pdaRun->toklen; + long length = pda_run->toklen; - RunBuf *runBuf = pdaRun->consumeBuf; - if ( runBuf == 0 || length > ( FSM_BUFSIZE - runBuf->length ) ) { - runBuf = newRunBuf(); - runBuf->next = pdaRun->consumeBuf; - pdaRun->consumeBuf = runBuf; + RunBuf *run_buf = pda_run->consume_buf; + if ( run_buf == 0 || length > ( FSM_BUFSIZE - run_buf->length ) ) { + run_buf = new_run_buf(); + run_buf->next = pda_run->consume_buf; + pda_run->consume_buf = run_buf; } - char *dest = runBuf->data + runBuf->length; + char *dest = run_buf->data + run_buf->length; - is->funcs->getData( is, dest, length ); + is->funcs->get_data( is, dest, length ); - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; head_t *head = colm_string_alloc_pointer( prg, dest, length ); @@ -784,78 +784,78 @@ static head_t *peekMatch( program_t *prg, struct pda_run *pdaRun, struct stream_ static void send_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, struct stream_impl *is, long id ) + struct pda_run *pda_run, struct stream_impl *is, long id ) { - debug( prg, REALM_PARSE, "ignoring: %s\n", prg->rtd->lelInfo[id].name ); + debug( prg, REALM_PARSE, "ignoring: %s\n", prg->rtd->lel_info[id].name ); /* Make the ignore string. */ - head_t *ignoreStr = extract_match( prg, sp, pdaRun, is ); + head_t *ignore_str = extract_match( prg, sp, pda_run, is ); - debug( prg, REALM_PARSE, "ignoring: %.*s\n", ignoreStr->length, ignoreStr->data ); + debug( prg, REALM_PARSE, "ignoring: %.*s\n", ignore_str->length, ignore_str->data ); tree_t *tree = tree_allocate( prg ); tree->refs = 1; tree->id = id; - tree->tokdata = ignoreStr; + tree->tokdata = ignore_str; /* Send it to the pdaRun. */ - ignore_tree( prg, pdaRun, tree ); + ignore_tree( prg, pda_run, tree ); } static void send_token( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, struct stream_impl *is, long id ) + struct pda_run *pda_run, struct stream_impl *is, long id ) { - int emptyIgnore = pdaRun->accumIgnore == 0; + int empty_ignore = pda_run->accum_ignore == 0; /* Make the token data. */ - head_t *tokdata = extract_match( prg, sp, pdaRun, is ); + head_t *tokdata = extract_match( prg, sp, pda_run, is ); debug( prg, REALM_PARSE, "token: %s text: %.*s\n", - prg->rtd->lelInfo[id].name, - stringLength(tokdata), stringData(tokdata) ); + prg->rtd->lel_info[id].name, + string_length(tokdata), string_data(tokdata) ); - kid_t *input = make_token_with_data( prg, pdaRun, is, id, tokdata ); + kid_t *input = make_token_with_data( prg, pda_run, is, id, tokdata ); - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->id = input->tree->id; - parseTree->shadow = input; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->id = input->tree->id; + parse_tree->shadow = input; - pdaRun->parseInput = parseTree; + pda_run->parse_input = parse_tree; /* Store any alternate scanning region. */ - if ( input != 0 && pdaRun->pda_cs >= 0 ) - set_region( pdaRun, emptyIgnore, parseTree ); + if ( input != 0 && pda_run->pda_cs >= 0 ) + set_region( pda_run, empty_ignore, parse_tree ); } -static void send_tree( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struct stream_impl *is ) +static void send_tree( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is ) { kid_t *input = kid_allocate( prg ); - input->tree = is->funcs->consumeTree( is ); + input->tree = is->funcs->consume_tree( is ); - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->id = input->tree->id; - parseTree->flags |= PF_ARTIFICIAL; - parseTree->shadow = input; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->id = input->tree->id; + parse_tree->flags |= PF_ARTIFICIAL; + parse_tree->shadow = input; - pdaRun->parseInput = parseTree; + pda_run->parse_input = parse_tree; } -static void send_ignore_tree( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struct stream_impl *is ) +static void send_ignore_tree( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is ) { - tree_t *tree = is->funcs->consumeTree( is ); - ignore_tree_art( prg, pdaRun, tree ); + tree_t *tree = is->funcs->consume_tree( is ); + ignore_tree_art( prg, pda_run, tree ); } static void send_collect_ignore( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, struct stream_impl *is, int id ) + struct pda_run *pda_run, struct stream_impl *is, int id ) { debug( prg, REALM_PARSE, "token: CI\n" ); - int emptyIgnore = pdaRun->accumIgnore == 0; + int empty_ignore = pda_run->accum_ignore == 0; /* Make the token data. */ head_t *tokdata = head_allocate( prg ); @@ -865,40 +865,40 @@ static void send_collect_ignore( program_t *prg, tree_t **sp, tokdata->location->byte = is->byte; debug( prg, REALM_PARSE, "token: %s text: %.*s\n", - prg->rtd->lelInfo[id].name, - stringLength(tokdata), stringData(tokdata) ); + prg->rtd->lel_info[id].name, + string_length(tokdata), string_data(tokdata) ); - kid_t *input = make_token_with_data( prg, pdaRun, is, id, tokdata ); + kid_t *input = make_token_with_data( prg, pda_run, is, id, tokdata ); - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->id = input->tree->id; - parseTree->shadow = input; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->id = input->tree->id; + parse_tree->shadow = input; - pdaRun->parseInput = parseTree; + pda_run->parse_input = parse_tree; /* Store any alternate scanning region. */ - if ( input != 0 && pdaRun->pda_cs >= 0 ) - set_region( pdaRun, emptyIgnore, parseTree ); + if ( input != 0 && pda_run->pda_cs >= 0 ) + set_region( pda_run, empty_ignore, parse_tree ); } /* Offset can be used to look at the next nextRegionInd. */ -static int get_next_region( struct pda_run *pdaRun, int offset ) +static int get_next_region( struct pda_run *pda_run, int offset ) { - return pdaRun->pda_tables->tokenRegions[pdaRun->nextRegionInd+offset]; + return pda_run->pda_tables->token_regions[pda_run->next_region_ind+offset]; } -static int get_next_pre_region( struct pda_run *pdaRun ) +static int get_next_pre_region( struct pda_run *pda_run ) { - return pdaRun->pda_tables->tokenPreRegions[pdaRun->nextRegionInd]; + return pda_run->pda_tables->token_pre_regions[pda_run->next_region_ind]; } -static void send_eof( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struct stream_impl *is ) +static void send_eof( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is ) { debug( prg, REALM_PARSE, "token: _EOF\n" ); - colm_increment_steps( pdaRun ); + colm_increment_steps( pda_run ); head_t *head = head_allocate( prg ); head->location = location_allocate( prg ); @@ -910,56 +910,56 @@ static void send_eof( program_t *prg, tree_t **sp, struct pda_run *pdaRun, struc input->tree = tree_allocate( prg ); input->tree->refs = 1; - input->tree->id = prg->rtd->eofLelIds[pdaRun->parserId]; + input->tree->id = prg->rtd->eof_lel_ids[pda_run->parser_id]; input->tree->tokdata = head; /* Set the state using the state of the parser. */ - pdaRun->region = get_next_region( pdaRun, 0 ); - pdaRun->preRegion = get_next_pre_region( pdaRun ); - pdaRun->fsm_cs = pdaRun->fsm_tables->entryByRegion[pdaRun->region]; + pda_run->region = get_next_region( pda_run, 0 ); + pda_run->pre_region = get_next_pre_region( pda_run ); + pda_run->fsm_cs = pda_run->fsm_tables->entry_by_region[pda_run->region]; - parse_tree_t *parseTree = parse_tree_allocate( prg ); - parseTree->id = input->tree->id; - parseTree->shadow = input; + parse_tree_t *parse_tree = parse_tree_allocate( prg ); + parse_tree->id = input->tree->id; + parse_tree->shadow = input; - pdaRun->parseInput = parseTree; + pda_run->parse_input = parse_tree; } -static void new_token( program_t *prg, struct pda_run *pdaRun ) +static void new_token( program_t *prg, struct pda_run *pda_run ) { - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; - pdaRun->eof = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; + pda_run->eof = 0; /* Init the scanner vars. */ - pdaRun->act = 0; - pdaRun->tokstart = 0; - pdaRun->tokend = 0; - pdaRun->matchedToken = 0; + pda_run->act = 0; + pda_run->tokstart = 0; + pda_run->tokend = 0; + pda_run->matched_token = 0; /* Set the state using the state of the parser. */ - pdaRun->region = get_next_region( pdaRun, 0 ); - pdaRun->preRegion = get_next_pre_region( pdaRun ); - if ( pdaRun->preRegion > 0 ) { - pdaRun->fsm_cs = pdaRun->fsm_tables->entryByRegion[pdaRun->preRegion]; - pdaRun->next_cs = pdaRun->fsm_tables->entryByRegion[pdaRun->region]; + pda_run->region = get_next_region( pda_run, 0 ); + pda_run->pre_region = get_next_pre_region( pda_run ); + if ( pda_run->pre_region > 0 ) { + pda_run->fsm_cs = pda_run->fsm_tables->entry_by_region[pda_run->pre_region]; + pda_run->next_cs = pda_run->fsm_tables->entry_by_region[pda_run->region]; } else { - pdaRun->fsm_cs = pdaRun->fsm_tables->entryByRegion[pdaRun->region]; + pda_run->fsm_cs = pda_run->fsm_tables->entry_by_region[pda_run->region]; } /* Clear the mark array. */ - memset( pdaRun->mark, 0, sizeof(pdaRun->mark) ); + memset( pda_run->mark, 0, sizeof(pda_run->mark) ); } -static void push_bt_point( program_t *prg, struct pda_run *pdaRun ) +static void push_bt_point( program_t *prg, struct pda_run *pda_run ) { tree_t *tree = 0; - if ( pdaRun->accumIgnore != 0 ) - tree = pdaRun->accumIgnore->shadow->tree; - else if ( pdaRun->tokenList != 0 ) - tree = pdaRun->tokenList->kid->tree; + if ( pda_run->accum_ignore != 0 ) + tree = pda_run->accum_ignore->shadow->tree; + else if ( pda_run->token_list != 0 ) + tree = pda_run->token_list->kid->tree; if ( tree != 0 ) { debug( prg, REALM_PARSE, "pushing bt point with location byte %d\n", @@ -969,8 +969,8 @@ static void push_bt_point( program_t *prg, struct pda_run *pdaRun ) kid_t *kid = kid_allocate( prg ); kid->tree = tree; colm_tree_upref( tree ); - kid->next = pdaRun->btPoint; - pdaRun->btPoint = kid; + kid->next = pda_run->bt_point; + pda_run->bt_point = kid; } } @@ -983,116 +983,116 @@ static void push_bt_point( program_t *prg, struct pda_run *pdaRun ) #define SCAN_LANG_EL -2 #define SCAN_EOF -1 -static long scan_token( program_t *prg, struct pda_run *pdaRun, struct stream_impl *is ) +static long scan_token( program_t *prg, struct pda_run *pda_run, struct stream_impl *is ) { - if ( pdaRun->triggerUndo ) + if ( pda_run->trigger_undo ) return SCAN_UNDO; while ( true ) { char *pd = 0; int len = 0; - int type = is->funcs->getParseBlock( is, pdaRun->toklen, &pd, &len ); + int type = is->funcs->get_parse_block( is, pda_run->toklen, &pd, &len ); switch ( type ) { case INPUT_DATA: - pdaRun->p = pd; - pdaRun->pe = pd + len; + pda_run->p = pd; + pda_run->pe = pd + len; break; case INPUT_EOS: - pdaRun->p = pdaRun->pe = 0; - if ( pdaRun->tokstart != 0 ) - pdaRun->eof = 1; + pda_run->p = pda_run->pe = 0; + if ( pda_run->tokstart != 0 ) + pda_run->eof = 1; debug( prg, REALM_SCAN, "EOS *******************\n" ); break; case INPUT_EOF: - pdaRun->p = pdaRun->pe = 0; - if ( pdaRun->tokstart != 0 ) - pdaRun->eof = 1; + pda_run->p = pda_run->pe = 0; + if ( pda_run->tokstart != 0 ) + pda_run->eof = 1; else return SCAN_EOF; break; case INPUT_EOD: - pdaRun->p = pdaRun->pe = 0; + pda_run->p = pda_run->pe = 0; return SCAN_TRY_AGAIN_LATER; case INPUT_LANG_EL: - if ( pdaRun->tokstart != 0 ) - pdaRun->eof = 1; + if ( pda_run->tokstart != 0 ) + pda_run->eof = 1; else return SCAN_LANG_EL; break; case INPUT_TREE: - if ( pdaRun->tokstart != 0 ) - pdaRun->eof = 1; + if ( pda_run->tokstart != 0 ) + pda_run->eof = 1; else return SCAN_TREE; break; case INPUT_IGNORE: - if ( pdaRun->tokstart != 0 ) - pdaRun->eof = 1; + if ( pda_run->tokstart != 0 ) + pda_run->eof = 1; else return SCAN_IGNORE; break; } - prg->rtd->fsm_execute( pdaRun, is ); + prg->rtd->fsm_execute( pda_run, is ); /* First check if scanning stopped because we have a token. */ - if ( pdaRun->matchedToken > 0 ) { + if ( pda_run->matched_token > 0 ) { /* If the token has a marker indicating the end (due to trailing * context) then adjust data now. */ - struct lang_el_info *lelInfo = prg->rtd->lelInfo; - if ( lelInfo[pdaRun->matchedToken].markId >= 0 ) - pdaRun->p = pdaRun->mark[lelInfo[pdaRun->matchedToken].markId]; + struct lang_el_info *lel_info = prg->rtd->lel_info; + if ( lel_info[pda_run->matched_token].mark_id >= 0 ) + pda_run->p = pda_run->mark[lel_info[pda_run->matched_token].mark_id]; - return pdaRun->matchedToken; + return pda_run->matched_token; } /* Check for error. */ - if ( pdaRun->fsm_cs == pdaRun->fsm_tables->errorState ) { + if ( pda_run->fsm_cs == pda_run->fsm_tables->error_state ) { /* If a token was started, but not finished (tokstart != 0) then * restore data to the beginning of that token. */ - if ( pdaRun->tokstart != 0 ) - pdaRun->p = pdaRun->tokstart; + if ( pda_run->tokstart != 0 ) + pda_run->p = pda_run->tokstart; /* Check for a default token in the region. If one is there * then send it and continue with the processing loop. */ - if ( prg->rtd->regionInfo[pdaRun->region].defaultToken >= 0 ) { - pdaRun->toklen = 0; - return prg->rtd->regionInfo[pdaRun->region].defaultToken; + if ( prg->rtd->region_info[pda_run->region].default_token >= 0 ) { + pda_run->toklen = 0; + return prg->rtd->region_info[pda_run->region].default_token; } return SCAN_ERROR; } /* Check for no match on eof (trailing data that partially matches a token). */ - if ( pdaRun->eof ) + if ( pda_run->eof ) return SCAN_ERROR; /* Got here because the state machine didn't match a token or encounter * an error. Must be because we got to the end of the buffer data. */ - assert( pdaRun->p == pdaRun->pe ); + assert( pda_run->p == pda_run->pe ); } /* Should not be reached. */ return SCAN_ERROR; } -static tree_t *get_parsed_root( struct pda_run *pdaRun, int stop ) +static tree_t *get_parsed_root( struct pda_run *pda_run, int stop ) { - if ( pdaRun->parseError ) + if ( pda_run->parse_error ) return 0; else if ( stop ) { - if ( pdaRun->stackTop->shadow != 0 ) - return pdaRun->stackTop->shadow->tree; + if ( pda_run->stack_top->shadow != 0 ) + return pda_run->stack_top->shadow->tree; } else { - if ( pdaRun->stackTop->next->shadow != 0 ) - return pdaRun->stackTop->next->shadow->tree; + if ( pda_run->stack_top->next->shadow != 0 ) + return pda_run->stack_top->next->shadow->tree; } return 0; } @@ -1109,16 +1109,16 @@ free_tree: vm_push_ptree( pt->next ); } - if ( pt->leftIgnore != 0 ) { - vm_push_ptree( pt->leftIgnore ); + if ( pt->left_ignore != 0 ) { + vm_push_ptree( pt->left_ignore ); } if ( pt->child != 0 ) { vm_push_ptree( pt->child ); } - if ( pt->rightIgnore != 0 ) { - vm_push_ptree( pt->rightIgnore ); + if ( pt->right_ignore != 0 ) { + vm_push_ptree( pt->right_ignore ); } if ( pt->shadow != 0 ) { @@ -1135,114 +1135,114 @@ free_tree: } } -void colm_pda_clear( program_t *prg, tree_t **sp, struct pda_run *pdaRun ) +void colm_pda_clear( program_t *prg, tree_t **sp, struct pda_run *pda_run ) { - clear_fsm_run( prg, pdaRun ); + clear_fsm_run( prg, pda_run ); /* Remaining stack and parse trees underneath. */ - clear_parse_tree( prg, sp, pdaRun->stackTop ); - pdaRun->stackTop = 0; + clear_parse_tree( prg, sp, pda_run->stack_top ); + pda_run->stack_top = 0; /* Traverse the token list downreffing. */ - ref_t *ref = pdaRun->tokenList; + ref_t *ref = pda_run->token_list; while ( ref != 0 ) { ref_t *next = ref->next; kid_free( prg, (kid_t*)ref ); ref = next; } - pdaRun->tokenList = 0; + pda_run->token_list = 0; /* Traverse the btPoint list downreffing */ - kid_t *btp = pdaRun->btPoint; + kid_t *btp = pda_run->bt_point; while ( btp != 0 ) { kid_t *next = btp->next; colm_tree_downref( prg, sp, btp->tree ); kid_free( prg, (kid_t*)btp ); btp = next; } - pdaRun->btPoint = 0; + pda_run->bt_point = 0; /* Clear out any remaining ignores. */ - clear_parse_tree( prg, sp, pdaRun->accumIgnore ); - pdaRun->accumIgnore = 0; + clear_parse_tree( prg, sp, pda_run->accum_ignore ); + pda_run->accum_ignore = 0; /* Clear the input list (scanned tokes, sent trees). */ - clear_parse_tree( prg, sp, pdaRun->parseInput ); - pdaRun->parseInput = 0; + clear_parse_tree( prg, sp, pda_run->parse_input ); + pda_run->parse_input = 0; - colm_rcode_downref_all( prg, sp, &pdaRun->reverseCode ); - colm_rt_code_vect_empty( &pdaRun->reverseCode ); - colm_rt_code_vect_empty( &pdaRun->rcodeCollect ); + colm_rcode_downref_all( prg, sp, &pda_run->reverse_code ); + colm_rt_code_vect_empty( &pda_run->reverse_code ); + colm_rt_code_vect_empty( &pda_run->rcode_collect ); - colm_tree_downref( prg, sp, pdaRun->parseErrorText ); + colm_tree_downref( prg, sp, pda_run->parse_error_text ); } -void colm_pda_init( program_t *prg, struct pda_run *pdaRun, struct pda_tables *tables, - int parserId, long stopTarget, int revertOn, struct_t *context ) +void colm_pda_init( program_t *prg, struct pda_run *pda_run, struct pda_tables *tables, + int parser_id, long stop_target, int revert_on, struct_t *context ) { - memset( pdaRun, 0, sizeof(struct pda_run) ); + memset( pda_run, 0, sizeof(struct pda_run) ); - pdaRun->pda_tables = tables; - pdaRun->parserId = parserId; - pdaRun->stopTarget = stopTarget; - pdaRun->revertOn = revertOn; - pdaRun->targetSteps = -1; + pda_run->pda_tables = tables; + pda_run->parser_id = parser_id; + pda_run->stop_target = stop_target; + pda_run->revert_on = revert_on; + pda_run->target_steps = -1; debug( prg, REALM_PARSE, "initializing struct pda_run\n" ); /* FIXME: need the right one here. */ - pdaRun->pda_cs = prg->rtd->startStates[pdaRun->parserId]; + pda_run->pda_cs = prg->rtd->start_states[pda_run->parser_id]; kid_t *sentinal = kid_allocate( prg ); sentinal->tree = tree_allocate( prg ); sentinal->tree->refs = 1; /* Init the element allocation variables. */ - pdaRun->stackTop = parse_tree_allocate( prg ); - pdaRun->stackTop->state = -1; - pdaRun->stackTop->shadow = sentinal; + pda_run->stack_top = parse_tree_allocate( prg ); + pda_run->stack_top->state = -1; + pda_run->stack_top->shadow = sentinal; - pdaRun->numRetry = 0; - pdaRun->nextRegionInd = pdaRun->pda_tables->tokenRegionInds[pdaRun->pda_cs]; - pdaRun->stopParsing = false; - pdaRun->accumIgnore = 0; - pdaRun->btPoint = 0; - pdaRun->checkNext = false; - pdaRun->checkStop = false; + pda_run->num_retry = 0; + pda_run->next_region_ind = pda_run->pda_tables->token_region_inds[pda_run->pda_cs]; + pda_run->stop_parsing = false; + pda_run->accum_ignore = 0; + pda_run->bt_point = 0; + pda_run->check_next = false; + pda_run->check_stop = false; - prg->rtd->initBindings( pdaRun ); + prg->rtd->init_bindings( pda_run ); - initRtCodeVect( &pdaRun->reverseCode ); - initRtCodeVect( &pdaRun->rcodeCollect ); + init_rt_code_vect( &pda_run->reverse_code ); + init_rt_code_vect( &pda_run->rcode_collect ); - pdaRun->context = context; - pdaRun->parseError = 0; - pdaRun->parseInput = 0; - pdaRun->triggerUndo = 0; + pda_run->context = context; + pda_run->parse_error = 0; + pda_run->parse_input = 0; + pda_run->trigger_undo = 0; - pdaRun->tokenId = 0; + pda_run->token_id = 0; - pdaRun->onDeck = false; - pdaRun->parsed = 0; - pdaRun->reject = false; + pda_run->on_deck = false; + pda_run->parsed = 0; + pda_run->reject = false; - pdaRun->rcBlockCount = 0; + pda_run->rc_block_count = 0; - init_fsm_run( prg, pdaRun ); - new_token( prg, pdaRun ); + init_fsm_run( prg, pda_run ); + new_token( prg, pda_run ); } -static long stack_top_target( program_t *prg, struct pda_run *pdaRun ) +static long stack_top_target( program_t *prg, struct pda_run *pda_run ) { long state; - if ( pdaRun->stackTop->state < 0 ) - state = prg->rtd->startStates[pdaRun->parserId]; + if ( pda_run->stack_top->state < 0 ) + state = prg->rtd->start_states[pda_run->parser_id]; else { - unsigned shift = pdaRun->stackTop->id - - pdaRun->pda_tables->keys[pdaRun->stackTop->state<<1]; - unsigned offset = pdaRun->pda_tables->offsets[pdaRun->stackTop->state] + shift; - int index = pdaRun->pda_tables->indicies[offset]; - state = pdaRun->pda_tables->targs[index]; + unsigned shift = pda_run->stack_top->id - + pda_run->pda_tables->keys[pda_run->stack_top->state<<1]; + unsigned offset = pda_run->pda_tables->offsets[pda_run->stack_top->state] + shift; + int index = pda_run->pda_tables->indicies[offset]; + state = pda_run->pda_tables->targs[index]; } return state; } @@ -1261,9 +1261,9 @@ static long stack_top_target( program_t *prg, struct pda_run *pdaRun ) * -clears all alg structures */ -static int been_committed( parse_tree_t *parseTree ) +static int been_committed( parse_tree_t *parse_tree ) { - return parseTree->flags & PF_COMMITTED; + return parse_tree->flags & PF_COMMITTED; } static code_t *backup_over_rcode( code_t *rcode ) @@ -1277,8 +1277,8 @@ static code_t *backup_over_rcode( code_t *rcode ) /* The top level of the stack is linked right-to-left. Trees underneath are * linked left-to-right. */ -static void commit_kid( program_t *prg, struct pda_run *pdaRun, tree_t **root, - parse_tree_t *lel, code_t **rcode, long *causeReduce ) +static void commit_kid( program_t *prg, struct pda_run *pda_run, tree_t **root, + parse_tree_t *lel, code_t **rcode, long *cause_reduce ) { parse_tree_t *tree = 0; tree_t **sp = root; @@ -1287,7 +1287,7 @@ static void commit_kid( program_t *prg, struct pda_run *pdaRun, tree_t **root, head: /* Commit */ debug( prg, REALM_PARSE, "commit: visiting %s\n", - prg->rtd->lelInfo[lel->id].name ); + prg->rtd->lel_info[lel->id].name ); /* Load up the parsed tree. */ tree = lel; @@ -1298,11 +1298,11 @@ head: /* If tree caused some reductions, now is not the right time to backup * over the reverse code. We need to backup over the reductions first. Store * the count of the reductions and do it when the count drops to zero. */ - if ( tree->causeReduce > 0 ) { + if ( tree->cause_reduce > 0 ) { /* The top reduce block does not correspond to this alg. */ debug( prg, REALM_PARSE, "commit: causeReduce found, delaying backup: %ld\n", - (long)tree->causeReduce ); - *causeReduce = tree->causeReduce; + (long)tree->cause_reduce ); + *cause_reduce = tree->cause_reduce; } else { *rcode = backup_over_rcode( *rcode ); @@ -1324,13 +1324,13 @@ head: /* Check causeReduce, might be time to backup over the reverse code * belonging to a nonterminal that caused previous reductions. */ - if ( *causeReduce > 0 && - tree->id >= prg->rtd->firstNonTermId && + if ( *cause_reduce > 0 && + tree->id >= prg->rtd->first_non_term_id && !(tree->flags & PF_TERM_DUP) ) { - *causeReduce -= 1; + *cause_reduce -= 1; - if ( *causeReduce == 0 ) { + if ( *cause_reduce == 0 ) { debug( prg, REALM_PARSE, "commit: causeReduce dropped to zero, " "backing up over rcode\n" ); @@ -1389,28 +1389,28 @@ backup: goto backup; } - pdaRun->numRetry = 0; + pda_run->num_retry = 0; assert( sp == root ); } -static void commit_full( program_t *prg, tree_t **sp, struct pda_run *pdaRun, long causeReduce ) +static void commit_full( program_t *prg, tree_t **sp, struct pda_run *pda_run, long cause_reduce ) { debug( prg, REALM_PARSE, "running full commit\n" ); - parse_tree_t *parseTree = pdaRun->stackTop; - code_t *rcode = pdaRun->reverseCode.data + pdaRun->reverseCode.tabLen; + parse_tree_t *parse_tree = pda_run->stack_top; + code_t *rcode = pda_run->reverse_code.data + pda_run->reverse_code.tab_len; /* The top level of the stack is linked right to left. This is the * traversal order we need for committing. */ - while ( parseTree != 0 && !been_committed( parseTree ) ) { - commit_kid( prg, pdaRun, sp, parseTree, &rcode, &causeReduce ); - parseTree = parseTree->next; + while ( parse_tree != 0 && !been_committed( parse_tree ) ) { + commit_kid( prg, pda_run, sp, parse_tree, &rcode, &cause_reduce ); + parse_tree = parse_tree->next; } /* We cannot always clear all the rcode here. We may need to backup over * the parse statement. We depend on the context flag. */ - if ( !pdaRun->revertOn ) - colm_rcode_downref_all( prg, sp, &pdaRun->reverseCode ); + if ( !pda_run->revert_on ) + colm_rcode_downref_all( prg, sp, &pda_run->reverse_code ); } /* @@ -1424,70 +1424,70 @@ static void commit_full( program_t *prg, tree_t **sp, struct pda_run *pdaRun, lo * PCR_REVERSE */ static long parse_token( program_t *prg, tree_t **sp, - struct pda_run *pdaRun, struct stream_impl *is, long entry ) + struct pda_run *pda_run, struct stream_impl *is, long entry ) { int pos; unsigned int *action; - int rhsLen; + int rhs_len; int owner; - int induceReject; - int indPos; + int induce_reject; + int ind_pos; /* COROUTINE */ switch ( entry ) { case PCR_START: /* The scanner will send a null token if it can't find a token. */ - if ( pdaRun->parseInput == 0 ) - goto parseError; + if ( pda_run->parse_input == 0 ) + goto parse_error; /* This will cause parseInput to be lost. This * path should be traced. */ - if ( pdaRun->pda_cs < 0 ) + if ( pda_run->pda_cs < 0 ) return PCR_DONE; /* Record the state in the parse tree. */ - pdaRun->parseInput->state = pdaRun->pda_cs; + pda_run->parse_input->state = pda_run->pda_cs; again: - if ( pdaRun->parseInput == 0 ) + if ( pda_run->parse_input == 0 ) goto _out; - pdaRun->lel = pdaRun->parseInput; - pdaRun->curState = pdaRun->pda_cs; + pda_run->lel = pda_run->parse_input; + pda_run->cur_state = pda_run->pda_cs; - if ( pdaRun->lel->id < pdaRun->pda_tables->keys[pdaRun->curState<<1] || - pdaRun->lel->id > pdaRun->pda_tables->keys[(pdaRun->curState<<1)+1] ) + if ( pda_run->lel->id < pda_run->pda_tables->keys[pda_run->cur_state<<1] || + pda_run->lel->id > pda_run->pda_tables->keys[(pda_run->cur_state<<1)+1] ) { debug( prg, REALM_PARSE, "parse error, no transition 1\n" ); - push_bt_point( prg, pdaRun ); - goto parseError; + push_bt_point( prg, pda_run ); + goto parse_error; } - indPos = pdaRun->pda_tables->offsets[pdaRun->curState] + - (pdaRun->lel->id - pdaRun->pda_tables->keys[pdaRun->curState<<1]); + ind_pos = pda_run->pda_tables->offsets[pda_run->cur_state] + + (pda_run->lel->id - pda_run->pda_tables->keys[pda_run->cur_state<<1]); - owner = pdaRun->pda_tables->owners[indPos]; - if ( owner != pdaRun->curState ) { + owner = pda_run->pda_tables->owners[ind_pos]; + if ( owner != pda_run->cur_state ) { debug( prg, REALM_PARSE, "parse error, no transition 2\n" ); - push_bt_point( prg, pdaRun ); - goto parseError; + push_bt_point( prg, pda_run ); + goto parse_error; } - pos = pdaRun->pda_tables->indicies[indPos]; + pos = pda_run->pda_tables->indicies[ind_pos]; if ( pos < 0 ) { debug( prg, REALM_PARSE, "parse error, no transition 3\n" ); - push_bt_point( prg, pdaRun ); - goto parseError; + push_bt_point( prg, pda_run ); + goto parse_error; } /* Checking complete. */ - induceReject = false; - pdaRun->pda_cs = pdaRun->pda_tables->targs[pos]; - action = pdaRun->pda_tables->actions + pdaRun->pda_tables->actInds[pos]; - if ( pdaRun->lel->retryLower ) - action += pdaRun->lel->retryLower; + induce_reject = false; + pda_run->pda_cs = pda_run->pda_tables->targs[pos]; + action = pda_run->pda_tables->actions + pda_run->pda_tables->act_inds[pos]; + if ( pda_run->lel->retry_lower ) + action += pda_run->lel->retry_lower; /* * Shift @@ -1495,61 +1495,61 @@ again: if ( *action & act_sb ) { debug( prg, REALM_PARSE, "shifted: %s\n", - prg->rtd->lelInfo[pdaRun->lel->id].name ); + prg->rtd->lel_info[pda_run->lel->id].name ); /* Consume. */ - pdaRun->parseInput = pdaRun->parseInput->next; + pda_run->parse_input = pda_run->parse_input->next; - pdaRun->lel->state = pdaRun->curState; + pda_run->lel->state = pda_run->cur_state; /* If its a token then attach ignores and record it in the token list * of the next ignore attachment to use. */ - if ( pdaRun->lel->id < prg->rtd->firstNonTermId ) { - if ( pdaRun->lel->causeReduce == 0 ) - attach_right_ignore( prg, sp, pdaRun, pdaRun->stackTop ); + if ( pda_run->lel->id < prg->rtd->first_non_term_id ) { + if ( pda_run->lel->cause_reduce == 0 ) + attach_right_ignore( prg, sp, pda_run, pda_run->stack_top ); } - pdaRun->lel->next = pdaRun->stackTop; - pdaRun->stackTop = pdaRun->lel; + pda_run->lel->next = pda_run->stack_top; + pda_run->stack_top = pda_run->lel; /* If its a token then attach ignores and record it in the token list * of the next ignore attachment to use. */ - if ( pdaRun->lel->id < prg->rtd->firstNonTermId ) { - attach_left_ignore( prg, sp, pdaRun, pdaRun->lel ); + if ( pda_run->lel->id < prg->rtd->first_non_term_id ) { + attach_left_ignore( prg, sp, pda_run, pda_run->lel ); ref_t *ref = (ref_t*)kid_allocate( prg ); - ref->kid = pdaRun->lel->shadow; + ref->kid = pda_run->lel->shadow; //colm_tree_upref( pdaRun->tree ); - ref->next = pdaRun->tokenList; - pdaRun->tokenList = ref; + ref->next = pda_run->token_list; + pda_run->token_list = ref; } if ( action[1] == 0 ) - pdaRun->lel->retryLower = 0; + pda_run->lel->retry_lower = 0; else { - debug( prg, REALM_PARSE, "retry: %p\n", pdaRun->stackTop ); - pdaRun->lel->retryLower += 1; - assert( pdaRun->lel->retryUpper == 0 ); + debug( prg, REALM_PARSE, "retry: %p\n", pda_run->stack_top ); + pda_run->lel->retry_lower += 1; + assert( pda_run->lel->retry_upper == 0 ); /* FIXME: Has the retry already been counted? */ - pdaRun->numRetry += 1; + pda_run->num_retry += 1; } - pdaRun->shiftCount += 1; + pda_run->shift_count += 1; } /* * Commit */ - if ( pdaRun->pda_tables->commitLen[pos] != 0 ) { + if ( pda_run->pda_tables->commit_len[pos] != 0 ) { #if 0 - long causeReduce = 0; - if ( pdaRun->parseInput != 0 ) { - if ( pdaRun->parseInput->flags & PF_HAS_RCODE ) - causeReduce = pdaRun->parseInput->causeReduce; + long cause_reduce = 0; + if ( pda_run->parse_input != 0 ) { + if ( pda_run->parse_input->flags & PF_HAS_RCODE ) + cause_reduce = pda_run->parse_input->cause_reduce; } - commit_full( prg, sp, pdaRun, causeReduce ); + commit_full( prg, sp, pda_run, cause_reduce ); #endif - pdaRun->commitShiftCount = pdaRun->shiftCount; + pda_run->commit_shift_count = pda_run->shift_count; } /* @@ -1557,107 +1557,107 @@ again: */ if ( *action & act_rb ) { - int r, objectLength; + int r, object_length; parse_tree_t *last, *child; kid_t *attrs; - kid_t *dataLast, *dataChild; + kid_t *data_last, *data_child; /* If there was shift don't attach again. */ - if ( !( *action & act_sb ) && pdaRun->lel->id < prg->rtd->firstNonTermId ) - attach_right_ignore( prg, sp, pdaRun, pdaRun->stackTop ); + if ( !( *action & act_sb ) && pda_run->lel->id < prg->rtd->first_non_term_id ) + attach_right_ignore( prg, sp, pda_run, pda_run->stack_top ); - pdaRun->reduction = *action >> 2; + pda_run->reduction = *action >> 2; - if ( pdaRun->parseInput != 0 ) - pdaRun->parseInput->causeReduce += 1; + if ( pda_run->parse_input != 0 ) + pda_run->parse_input->cause_reduce += 1; kid_t *value = kid_allocate( prg ); value->tree = tree_allocate( prg ); value->tree->refs = 1; - value->tree->id = prg->rtd->prodInfo[pdaRun->reduction].lhsId; - value->tree->prod_num = prg->rtd->prodInfo[pdaRun->reduction].prodNum; + value->tree->id = prg->rtd->prod_info[pda_run->reduction].lhs_id; + value->tree->prod_num = prg->rtd->prod_info[pda_run->reduction].prod_num; - pdaRun->redLel = parse_tree_allocate( prg ); - pdaRun->redLel->id = prg->rtd->prodInfo[pdaRun->reduction].lhsId; - pdaRun->redLel->next = 0; - pdaRun->redLel->causeReduce = 0; - pdaRun->redLel->retryLower = 0; - pdaRun->redLel->shadow = value; + pda_run->red_lel = parse_tree_allocate( prg ); + pda_run->red_lel->id = prg->rtd->prod_info[pda_run->reduction].lhs_id; + pda_run->red_lel->next = 0; + pda_run->red_lel->cause_reduce = 0; + pda_run->red_lel->retry_lower = 0; + pda_run->red_lel->shadow = value; /* Transfer. */ - pdaRun->redLel->retryUpper = pdaRun->lel->retryLower; - pdaRun->lel->retryLower = 0; + pda_run->red_lel->retry_upper = pda_run->lel->retry_lower; + pda_run->lel->retry_lower = 0; /* Allocate the attributes. */ - objectLength = prg->rtd->lelInfo[pdaRun->redLel->id].objectLength; - attrs = allocAttrs( prg, objectLength ); + object_length = prg->rtd->lel_info[pda_run->red_lel->id].object_length; + attrs = alloc_attrs( prg, object_length ); /* Build the list of children. We will be giving up a reference when we * detach parse tree and data tree, but gaining the reference when we * put the children under the new data tree. No need to alter refcounts * here. */ - rhsLen = prg->rtd->prodInfo[pdaRun->reduction].length; + rhs_len = prg->rtd->prod_info[pda_run->reduction].length; child = last = 0; - dataChild = dataLast = 0; - for ( r = 0; r < rhsLen; r++ ) { + data_child = data_last = 0; + for ( r = 0; r < rhs_len; r++ ) { /* The child. */ - child = pdaRun->stackTop; - dataChild = child->shadow; + child = pda_run->stack_top; + data_child = child->shadow; /* Pop. */ - pdaRun->stackTop = pdaRun->stackTop->next; + pda_run->stack_top = pda_run->stack_top->next; /* Detach the parse tree from the data. */ child->shadow = 0; /* Reverse list. */ child->next = last; - dataChild->next = dataLast; + data_child->next = data_last; /* Track last for reversal. */ last = child; - dataLast = dataChild; + data_last = data_child; } - pdaRun->redLel->child = child; - pdaRun->redLel->shadow->tree->child = kidListConcat( attrs, dataChild ); + pda_run->red_lel->child = child; + pda_run->red_lel->shadow->tree->child = kid_list_concat( attrs, data_child ); debug( prg, REALM_PARSE, "reduced: %s rhsLen %d\n", - prg->rtd->prodInfo[pdaRun->reduction].name, rhsLen ); + prg->rtd->prod_info[pda_run->reduction].name, rhs_len ); if ( action[1] == 0 ) - pdaRun->redLel->retryUpper = 0; + pda_run->red_lel->retry_upper = 0; else { - pdaRun->redLel->retryUpper += 1; - assert( pdaRun->lel->retryLower == 0 ); - pdaRun->numRetry += 1; - debug( prg, REALM_PARSE, "retry: %p\n", pdaRun->redLel ); + pda_run->red_lel->retry_upper += 1; + assert( pda_run->lel->retry_lower == 0 ); + pda_run->num_retry += 1; + debug( prg, REALM_PARSE, "retry: %p\n", pda_run->red_lel ); } /* When the production is of zero length we stay in the same state. * Otherwise we use the state stored in the first child. */ - pdaRun->pda_cs = rhsLen == 0 ? pdaRun->curState : child->state; + pda_run->pda_cs = rhs_len == 0 ? pda_run->cur_state : child->state; - if ( prg->ctxDepParsing && prg->rtd->prodInfo[pdaRun->reduction].frameId >= 0 ) { + if ( prg->ctx_dep_parsing && prg->rtd->prod_info[pda_run->reduction].frame_id >= 0 ) { /* Frame info for reduction. */ - pdaRun->fi = &prg->rtd->frameInfo[prg->rtd->prodInfo[pdaRun->reduction].frameId]; - pdaRun->frameId = prg->rtd->prodInfo[pdaRun->reduction].frameId; - pdaRun->reject = false; - pdaRun->parsed = 0; - pdaRun->code = pdaRun->fi->codeWV; + pda_run->fi = &prg->rtd->frame_info[prg->rtd->prod_info[pda_run->reduction].frame_id]; + pda_run->frame_id = prg->rtd->prod_info[pda_run->reduction].frame_id; + pda_run->reject = false; + pda_run->parsed = 0; + pda_run->code = pda_run->fi->codeWV; /* COROUTINE */ return PCR_REDUCTION; case PCR_REDUCTION: - if ( prg->induceExit ) + if ( prg->induce_exit ) goto fail; /* If the lhs was stored and it changed then we need to restore the * original upon backtracking, otherwise downref since we took a * copy above. */ - if ( pdaRun->parsed != 0 ) { - if ( pdaRun->parsed != pdaRun->redLel->shadow->tree ) { + if ( pda_run->parsed != 0 ) { + if ( pda_run->parsed != pda_run->red_lel->shadow->tree ) { debug( prg, REALM_PARSE, "lhs tree was modified, " "adding a restore instruction\n" ); // @@ -1670,24 +1670,24 @@ again: // colm_tree_upref( pdaRun->redLel->tree ); /* Add the restore instruct. */ - append_code_val( &pdaRun->rcodeCollect, IN_RESTORE_LHS ); - append_word( &pdaRun->rcodeCollect, (word_t)pdaRun->parsed ); - append_code_val( &pdaRun->rcodeCollect, SIZEOF_CODE + SIZEOF_WORD ); + append_code_val( &pda_run->rcode_collect, IN_RESTORE_LHS ); + append_word( &pda_run->rcode_collect, (word_t)pda_run->parsed ); + append_code_val( &pda_run->rcode_collect, SIZEOF_CODE + SIZEOF_WORD ); } else { /* Not changed. Done with parsed. */ - colm_tree_downref( prg, sp, pdaRun->parsed ); + colm_tree_downref( prg, sp, pda_run->parsed ); } - pdaRun->parsed = 0; + pda_run->parsed = 0; } /* Pull out the reverse code, if any. */ - colm_make_reverse_code( pdaRun ); - colm_transfer_reverse_code( pdaRun, pdaRun->redLel ); + colm_make_reverse_code( pda_run ); + colm_transfer_reverse_code( pda_run, pda_run->red_lel ); /* Perhaps the execution environment is telling us we need to * reject the reduction. */ - induceReject = pdaRun->reject; + induce_reject = pda_run->reject; } /* If the left hand side was replaced then the only parse algorithm @@ -1695,277 +1695,277 @@ again: * else will be in the original. This requires that we restore first * when going backwards and when doing a commit. */ - if ( induceReject ) { + if ( induce_reject ) { debug( prg, REALM_PARSE, "error induced during reduction of %s\n", - prg->rtd->lelInfo[pdaRun->redLel->id].name ); - pdaRun->redLel->state = pdaRun->curState; - pdaRun->redLel->next = pdaRun->stackTop; - pdaRun->stackTop = pdaRun->redLel; + prg->rtd->lel_info[pda_run->red_lel->id].name ); + pda_run->red_lel->state = pda_run->cur_state; + pda_run->red_lel->next = pda_run->stack_top; + pda_run->stack_top = pda_run->red_lel; /* FIXME: What is the right argument here? */ - push_bt_point( prg, pdaRun ); - goto parseError; + push_bt_point( prg, pda_run ); + goto parse_error; } - pdaRun->redLel->next = pdaRun->parseInput; - pdaRun->parseInput = pdaRun->redLel; + pda_run->red_lel->next = pda_run->parse_input; + pda_run->parse_input = pda_run->red_lel; } goto again; -parseError: +parse_error: debug( prg, REALM_PARSE, "hit error, backtracking\n" ); #if 0 - if ( pdaRun->numRetry == 0 ) { + if ( pda_run->num_retry == 0 ) { debug( prg, REALM_PARSE, "out of retries failing parse\n" ); goto fail; } #endif while ( 1 ) { - if ( pdaRun->onDeck ) { + if ( pda_run->on_deck ) { debug( prg, REALM_BYTECODE, "dropping out for reverse code call\n" ); - pdaRun->frameId = -1; - pdaRun->code = colm_pop_reverse_code( &pdaRun->reverseCode ); + pda_run->frame_id = -1; + pda_run->code = colm_pop_reverse_code( &pda_run->reverse_code ); /* COROUTINE */ return PCR_REVERSE; case PCR_REVERSE: - colm_decrement_steps( pdaRun ); + colm_decrement_steps( pda_run ); } - else if ( pdaRun->checkNext ) { - pdaRun->checkNext = false; + else if ( pda_run->check_next ) { + pda_run->check_next = false; - if ( pdaRun->next > 0 && pdaRun->pda_tables->tokenRegions[pdaRun->next] != 0 ) { + if ( pda_run->next > 0 && pda_run->pda_tables->token_regions[pda_run->next] != 0 ) { debug( prg, REALM_PARSE, "found a new region\n" ); - pdaRun->numRetry -= 1; - pdaRun->pda_cs = stack_top_target( prg, pdaRun ); - pdaRun->nextRegionInd = pdaRun->next; + pda_run->num_retry -= 1; + pda_run->pda_cs = stack_top_target( prg, pda_run ); + pda_run->next_region_ind = pda_run->next; return PCR_DONE; } } - else if ( pdaRun->checkStop ) { - pdaRun->checkStop = false; + else if ( pda_run->check_stop ) { + pda_run->check_stop = false; - if ( pdaRun->stop ) { + if ( pda_run->stop ) { debug( prg, REALM_PARSE, "stopping the backtracking, " - "steps is %d\n", pdaRun->steps ); + "steps is %d\n", pda_run->steps ); - pdaRun->pda_cs = stack_top_target( prg, pdaRun ); + pda_run->pda_cs = stack_top_target( prg, pda_run ); goto _out; } } - else if ( pdaRun->parseInput != 0 ) { + else if ( pda_run->parse_input != 0 ) { /* Either we are dealing with a terminal that was shifted or a * nonterminal that was reduced. */ - if ( pdaRun->parseInput->id < prg->rtd->firstNonTermId ) { + if ( pda_run->parse_input->id < prg->rtd->first_non_term_id ) { /* This is a terminal. */ - assert( pdaRun->parseInput->retryUpper == 0 ); + assert( pda_run->parse_input->retry_upper == 0 ); - if ( pdaRun->parseInput->retryLower != 0 ) { - debug( prg, REALM_PARSE, "found retry targ: %p\n", pdaRun->parseInput ); + if ( pda_run->parse_input->retry_lower != 0 ) { + debug( prg, REALM_PARSE, "found retry targ: %p\n", pda_run->parse_input ); - pdaRun->numRetry -= 1; - pdaRun->pda_cs = pdaRun->parseInput->state; + pda_run->num_retry -= 1; + pda_run->pda_cs = pda_run->parse_input->state; goto again; } - if ( pdaRun->parseInput->causeReduce != 0 ) { + if ( pda_run->parse_input->cause_reduce != 0 ) { /* The terminal caused a reduce. Unshift the reduced thing * (will unreduce in the next step. */ - if ( pdaRun->shiftCount == pdaRun->commitShiftCount ) { + if ( pda_run->shift_count == pda_run->commit_shift_count ) { debug( prg, REALM_PARSE, "backed up to commit point, " "failing parse\n" ); goto fail; } - pdaRun->shiftCount -= 1; + pda_run->shift_count -= 1; - pdaRun->undoLel = pdaRun->stackTop; + pda_run->undo_lel = pda_run->stack_top; /* Check if we've arrived at the stack sentinal. This guard * is here to allow us to initially set numRetry to one to * cause the parser to backup all the way to the beginning * when an error occurs. */ - if ( pdaRun->undoLel->next == 0 ) + if ( pda_run->undo_lel->next == 0 ) break; /* Either we are dealing with a terminal that was * shifted or a nonterminal that was reduced. */ - assert( !(pdaRun->stackTop->id < prg->rtd->firstNonTermId) ); + assert( !(pda_run->stack_top->id < prg->rtd->first_non_term_id) ); debug( prg, REALM_PARSE, "backing up over non-terminal: %s\n", - prg->rtd->lelInfo[pdaRun->stackTop->id].name ); + prg->rtd->lel_info[pda_run->stack_top->id].name ); /* Pop the item from the stack. */ - pdaRun->stackTop = pdaRun->stackTop->next; + pda_run->stack_top = pda_run->stack_top->next; /* Queue it as next parseInput item. */ - pdaRun->undoLel->next = pdaRun->parseInput; - pdaRun->parseInput = pdaRun->undoLel; + pda_run->undo_lel->next = pda_run->parse_input; + pda_run->parse_input = pda_run->undo_lel; } else { - long region = pdaRun->parseInput->retryRegion; - pdaRun->next = region > 0 ? region + 1 : 0; - pdaRun->checkNext = true; - pdaRun->checkStop = true; + long region = pda_run->parse_input->retry_region; + pda_run->next = region > 0 ? region + 1 : 0; + pda_run->check_next = true; + pda_run->check_stop = true; - send_back( prg, sp, pdaRun, is, pdaRun->parseInput ); + send_back( prg, sp, pda_run, is, pda_run->parse_input ); - pdaRun->parseInput = 0; + pda_run->parse_input = 0; } } - else if ( pdaRun->parseInput->flags & PF_HAS_RCODE ) { + else if ( pda_run->parse_input->flags & PF_HAS_RCODE ) { debug( prg, REALM_PARSE, "tree has rcode, setting on deck\n" ); - pdaRun->onDeck = true; - pdaRun->parsed = 0; + pda_run->on_deck = true; + pda_run->parsed = 0; /* Only the RCODE flag was in the replaced lhs. All the rest is in * the the original. We read it after restoring. */ - pdaRun->parseInput->flags &= ~PF_HAS_RCODE; + pda_run->parse_input->flags &= ~PF_HAS_RCODE; } else { /* Remove it from the input queue. */ - pdaRun->undoLel = pdaRun->parseInput; - pdaRun->parseInput = pdaRun->parseInput->next; + pda_run->undo_lel = pda_run->parse_input; + pda_run->parse_input = pda_run->parse_input->next; /* Extract children from the child list. */ - parse_tree_t *first = pdaRun->undoLel->child; - pdaRun->undoLel->child = 0; + parse_tree_t *first = pda_run->undo_lel->child; + pda_run->undo_lel->child = 0; /* This will skip the ignores/attributes, etc. */ - kid_t *dataFirst = treeExtractChild( prg, pdaRun->undoLel->shadow->tree ); + kid_t *data_first = tree_extract_child( prg, pda_run->undo_lel->shadow->tree ); /* Walk the child list and and push the items onto the parsing * stack one at a time. */ while ( first != 0 ) { /* Get the next item ahead of time. */ parse_tree_t *next = first->next; - kid_t *dataNext = dataFirst->next; + kid_t *data_next = data_first->next; /* Push onto the stack. */ - first->next = pdaRun->stackTop; - pdaRun->stackTop = first; + first->next = pda_run->stack_top; + pda_run->stack_top = first; /* Reattach the data and the parse tree. */ - first->shadow = dataFirst; + first->shadow = data_first; first = next; - dataFirst = dataNext; + data_first = data_next; } /* If there is an parseInput queued, this is one less reduction it has * caused. */ - if ( pdaRun->parseInput != 0 ) - pdaRun->parseInput->causeReduce -= 1; + if ( pda_run->parse_input != 0 ) + pda_run->parse_input->cause_reduce -= 1; - if ( pdaRun->undoLel->retryUpper != 0 ) { + if ( pda_run->undo_lel->retry_upper != 0 ) { /* There is always an parseInput item here because reduce * conflicts only happen on a lookahead character. */ - assert( pdaRun->parseInput != pdaRun->undoLel ); - assert( pdaRun->parseInput != 0 ); - assert( pdaRun->undoLel->retryLower == 0 ); - assert( pdaRun->parseInput->retryUpper == 0 ); + assert( pda_run->parse_input != pda_run->undo_lel ); + assert( pda_run->parse_input != 0 ); + assert( pda_run->undo_lel->retry_lower == 0 ); + assert( pda_run->parse_input->retry_upper == 0 ); /* Transfer the retry from undoLel to parseInput. */ - pdaRun->parseInput->retryLower = pdaRun->undoLel->retryUpper; - pdaRun->parseInput->retryUpper = 0; - pdaRun->parseInput->state = stack_top_target( prg, pdaRun ); + pda_run->parse_input->retry_lower = pda_run->undo_lel->retry_upper; + pda_run->parse_input->retry_upper = 0; + pda_run->parse_input->state = stack_top_target( prg, pda_run ); } /* Free the reduced item. */ - colm_tree_downref( prg, sp, pdaRun->undoLel->shadow->tree ); - kid_free( prg, pdaRun->undoLel->shadow ); - parse_tree_free( prg, pdaRun->undoLel ); + colm_tree_downref( prg, sp, pda_run->undo_lel->shadow->tree ); + kid_free( prg, pda_run->undo_lel->shadow ); + parse_tree_free( prg, pda_run->undo_lel ); /* If the stacktop had right ignore attached, detach now. */ - if ( pdaRun->stackTop->flags & PF_RIGHT_IL_ATTACHED ) - detach_right_ignore( prg, sp, pdaRun, pdaRun->stackTop ); + if ( pda_run->stack_top->flags & PF_RIGHT_IL_ATTACHED ) + detach_right_ignore( prg, sp, pda_run, pda_run->stack_top ); } } - else if ( pdaRun->accumIgnore != 0 ) { + else if ( pda_run->accum_ignore != 0 ) { debug( prg, REALM_PARSE, "have accumulated ignore to undo\n" ); /* Send back any accumulated ignore tokens, then trigger error * in the the parser. */ - parse_tree_t *ignore = pdaRun->accumIgnore; - pdaRun->accumIgnore = pdaRun->accumIgnore->next; + parse_tree_t *ignore = pda_run->accum_ignore; + pda_run->accum_ignore = pda_run->accum_ignore->next; ignore->next = 0; - long region = ignore->retryRegion; - pdaRun->next = region > 0 ? region + 1 : 0; - pdaRun->checkNext = true; - pdaRun->checkStop = true; + long region = ignore->retry_region; + pda_run->next = region > 0 ? region + 1 : 0; + pda_run->check_next = true; + pda_run->check_stop = true; - send_back_ignore( prg, sp, pdaRun, is, ignore ); + send_back_ignore( prg, sp, pda_run, is, ignore ); colm_tree_downref( prg, sp, ignore->shadow->tree ); kid_free( prg, ignore->shadow ); parse_tree_free( prg, ignore ); } else { - if ( pdaRun->shiftCount == pdaRun->commitShiftCount ) { + if ( pda_run->shift_count == pda_run->commit_shift_count ) { debug( prg, REALM_PARSE, "backed up to commit point, failing parse\n" ); goto fail; } - pdaRun->shiftCount -= 1; + pda_run->shift_count -= 1; /* Now it is time to undo something. Pick an element from the top of * the stack. */ - pdaRun->undoLel = pdaRun->stackTop; + pda_run->undo_lel = pda_run->stack_top; /* Check if we've arrived at the stack sentinal. This guard is * here to allow us to initially set numRetry to one to cause the * parser to backup all the way to the beginning when an error * occurs. */ - if ( pdaRun->undoLel->next == 0 ) + if ( pda_run->undo_lel->next == 0 ) break; /* Either we are dealing with a terminal that was * shifted or a nonterminal that was reduced. */ - if ( pdaRun->stackTop->id < prg->rtd->firstNonTermId ) { + if ( pda_run->stack_top->id < prg->rtd->first_non_term_id ) { debug( prg, REALM_PARSE, "backing up over effective terminal: %s\n", - prg->rtd->lelInfo[pdaRun->stackTop->id].name ); + prg->rtd->lel_info[pda_run->stack_top->id].name ); /* Pop the item from the stack. */ - pdaRun->stackTop = pdaRun->stackTop->next; + pda_run->stack_top = pda_run->stack_top->next; /* Queue it as next parseInput item. */ - pdaRun->undoLel->next = pdaRun->parseInput; - pdaRun->parseInput = pdaRun->undoLel; + pda_run->undo_lel->next = pda_run->parse_input; + pda_run->parse_input = pda_run->undo_lel; /* Pop from the token list. */ - ref_t *ref = pdaRun->tokenList; - pdaRun->tokenList = ref->next; + ref_t *ref = pda_run->token_list; + pda_run->token_list = ref->next; kid_free( prg, (kid_t*)ref ); - assert( pdaRun->accumIgnore == 0 ); - detach_left_ignore( prg, sp, pdaRun, pdaRun->parseInput ); + assert( pda_run->accum_ignore == 0 ); + detach_left_ignore( prg, sp, pda_run, pda_run->parse_input ); } else { debug( prg, REALM_PARSE, "backing up over non-terminal: %s\n", - prg->rtd->lelInfo[pdaRun->stackTop->id].name ); + prg->rtd->lel_info[pda_run->stack_top->id].name ); /* Pop the item from the stack. */ - pdaRun->stackTop = pdaRun->stackTop->next; + pda_run->stack_top = pda_run->stack_top->next; /* Queue it as next parseInput item. */ - pdaRun->undoLel->next = pdaRun->parseInput; - pdaRun->parseInput = pdaRun->undoLel; + pda_run->undo_lel->next = pda_run->parse_input; + pda_run->parse_input = pda_run->undo_lel; } /* Undo attach of right ignore. */ - if ( pdaRun->stackTop->flags & PF_RIGHT_IL_ATTACHED ) - detach_right_ignore( prg, sp, pdaRun, pdaRun->stackTop ); + if ( pda_run->stack_top->flags & PF_RIGHT_IL_ATTACHED ) + detach_right_ignore( prg, sp, pda_run, pda_run->stack_top ); } } fail: - pdaRun->pda_cs = -1; - pdaRun->parseError = 1; + pda_run->pda_cs = -1; + pda_run->parse_error = 1; /* FIXME: do we still need to fall through here? A fail is permanent now, * no longer called into again. */ @@ -1973,7 +1973,7 @@ fail: return PCR_DONE; _out: - pdaRun->nextRegionInd = pdaRun->pda_tables->tokenRegionInds[pdaRun->pda_cs]; + pda_run->next_region_ind = pda_run->pda_tables->token_region_inds[pda_run->pda_cs]; /* COROUTINE */ case PCR_DONE: @@ -1992,16 +1992,16 @@ _out: * PCR_REVERSE */ -long colm_parse_loop( program_t *prg, tree_t **sp, struct pda_run *pdaRun, +long colm_parse_loop( program_t *prg, tree_t **sp, struct pda_run *pda_run, struct stream_impl *is, long entry ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; /* COROUTINE */ switch ( entry ) { case PCR_START: - pdaRun->stop = false; + pda_run->stop = false; while ( true ) { debug( prg, REALM_PARSE, "parse loop start %d:%d\n", is->line, is->column ); @@ -2009,70 +2009,70 @@ long colm_parse_loop( program_t *prg, tree_t **sp, struct pda_run *pdaRun, /* Pull the current scanner from the parser. This can change during * parsing due to inputStream pushes, usually for the purpose of includes. * */ - pdaRun->tokenId = scan_token( prg, pdaRun, is ); + pda_run->token_id = scan_token( prg, pda_run, is ); - if ( pdaRun->tokenId == SCAN_ERROR ) { - if ( pdaRun->preRegion >= 0 ) { - pdaRun->preRegion = -1; - pdaRun->fsm_cs = pdaRun->next_cs; + if ( pda_run->token_id == SCAN_ERROR ) { + if ( pda_run->pre_region >= 0 ) { + pda_run->pre_region = -1; + pda_run->fsm_cs = pda_run->next_cs; continue; } } - if ( pdaRun->tokenId == SCAN_ERROR && - ( prg->rtd->regionInfo[pdaRun->region].ciLelId > 0 ) ) + if ( pda_run->token_id == SCAN_ERROR && + ( prg->rtd->region_info[pda_run->region].ci_lel_id > 0 ) ) { debug( prg, REALM_PARSE, "sending a collect ignore\n" ); - send_collect_ignore( prg, sp, pdaRun, is, - prg->rtd->regionInfo[pdaRun->region].ciLelId ); + send_collect_ignore( prg, sp, pda_run, is, + prg->rtd->region_info[pda_run->region].ci_lel_id ); goto yes; } - if ( pdaRun->tokenId == SCAN_TRY_AGAIN_LATER ) { + if ( pda_run->token_id == SCAN_TRY_AGAIN_LATER ) { debug( prg, REALM_PARSE, "scanner says try again later\n" ); break; } - assert( pdaRun->parseInput == 0 ); - pdaRun->parseInput = 0; + assert( pda_run->parse_input == 0 ); + pda_run->parse_input = 0; /* Check for EOF. */ - if ( pdaRun->tokenId == SCAN_EOF ) { - is->eofSent = true; - send_eof( prg, sp, pdaRun, is ); + if ( pda_run->token_id == SCAN_EOF ) { + is->eof_sent = true; + send_eof( prg, sp, pda_run, is ); - pdaRun->frameId = prg->rtd->regionInfo[pdaRun->region].eofFrameId; + pda_run->frame_id = prg->rtd->region_info[pda_run->region].eof_frame_id; - if ( prg->ctxDepParsing && pdaRun->frameId >= 0 ) { + if ( prg->ctx_dep_parsing && pda_run->frame_id >= 0 ) { debug( prg, REALM_PARSE, "HAVE PRE_EOF BLOCK\n" ); - pdaRun->fi = &prg->rtd->frameInfo[pdaRun->frameId]; - pdaRun->code = pdaRun->fi->codeWV; + pda_run->fi = &prg->rtd->frame_info[pda_run->frame_id]; + pda_run->code = pda_run->fi->codeWV; /* COROUTINE */ return PCR_PRE_EOF; case PCR_PRE_EOF: - colm_make_reverse_code( pdaRun ); + colm_make_reverse_code( pda_run ); } } - else if ( pdaRun->tokenId == SCAN_UNDO ) { + else if ( pda_run->token_id == SCAN_UNDO ) { /* Fall through with parseInput = 0. FIXME: Do we need to send back ignore? */ debug( prg, REALM_PARSE, "invoking undo from the scanner\n" ); } - else if ( pdaRun->tokenId == SCAN_ERROR ) { + else if ( pda_run->token_id == SCAN_ERROR ) { /* Scanner error, maybe retry. */ - if ( pdaRun->accumIgnore == 0 && get_next_region( pdaRun, 1 ) != 0 ) { + if ( pda_run->accum_ignore == 0 && get_next_region( pda_run, 1 ) != 0 ) { debug( prg, REALM_PARSE, "scanner failed, trying next region\n" ); - pdaRun->nextRegionInd += 1; - goto skipSend; + pda_run->next_region_ind += 1; + goto skip_send; } else { // if ( pdaRun->numRetry > 0 ) { debug( prg, REALM_PARSE, "invoking parse error from the scanner\n" ); /* Fall through to send null (error). */ - push_bt_point( prg, pdaRun ); + push_bt_point( prg, pda_run ); } #if 0 else { @@ -2081,94 +2081,94 @@ long colm_parse_loop( program_t *prg, tree_t **sp, struct pda_run *pdaRun, /* There are no alternative scanning regions to try, nor are * there any alternatives stored in the current parse tree. No * choice but to end the parse. */ - push_bt_point( prg, pdaRun ); + push_bt_point( prg, pda_run ); - report_parse_error( prg, sp, pdaRun ); - pdaRun->parseError = 1; - goto skipSend; + report_parse_error( prg, sp, pda_run ); + pda_run->parse_error = 1; + goto skip_send; } #endif } - else if ( pdaRun->tokenId == SCAN_LANG_EL ) { + else if ( pda_run->token_id == SCAN_LANG_EL ) { debug( prg, REALM_PARSE, "sending an named lang el\n" ); /* A named language element (parsing colm program). */ - prg->rtd->sendNamedLangEl( prg, sp, pdaRun, is ); + prg->rtd->send_named_lang_el( prg, sp, pda_run, is ); } - else if ( pdaRun->tokenId == SCAN_TREE ) { + else if ( pda_run->token_id == SCAN_TREE ) { debug( prg, REALM_PARSE, "sending a tree\n" ); /* A tree already built. */ - send_tree( prg, sp, pdaRun, is ); + send_tree( prg, sp, pda_run, is ); } - else if ( pdaRun->tokenId == SCAN_IGNORE ) { + else if ( pda_run->token_id == SCAN_IGNORE ) { debug( prg, REALM_PARSE, "sending an ignore token\n" ); /* A tree to ignore. */ - send_ignore_tree( prg, sp, pdaRun, is ); - goto skipSend; + send_ignore_tree( prg, sp, pda_run, is ); + goto skip_send; } - else if ( prg->ctxDepParsing && lelInfo[pdaRun->tokenId].frameId >= 0 ) { + else if ( prg->ctx_dep_parsing && lel_info[pda_run->token_id].frame_id >= 0 ) { /* Has a generation action. */ debug( prg, REALM_PARSE, "token gen action: %s\n", - prg->rtd->lelInfo[pdaRun->tokenId].name ); + prg->rtd->lel_info[pda_run->token_id].name ); /* Make the token data. */ - pdaRun->tokdata = peekMatch( prg, pdaRun, is ); + pda_run->tokdata = peek_match( prg, pda_run, is ); /* Note that we don't update the position now. It is done when the token * data is pulled from the inputStream. */ - pdaRun->p = pdaRun->pe = 0; - pdaRun->toklen = 0; - pdaRun->eof = 0; + pda_run->p = pda_run->pe = 0; + pda_run->toklen = 0; + pda_run->eof = 0; - pdaRun->fi = &prg->rtd->frameInfo[prg->rtd->lelInfo[pdaRun->tokenId].frameId]; - pdaRun->frameId = prg->rtd->lelInfo[pdaRun->tokenId].frameId; - pdaRun->code = pdaRun->fi->codeWV; + pda_run->fi = &prg->rtd->frame_info[prg->rtd->lel_info[pda_run->token_id].frame_id]; + pda_run->frame_id = prg->rtd->lel_info[pda_run->token_id].frame_id; + pda_run->code = pda_run->fi->codeWV; /* COROUTINE */ return PCR_GENERATION; case PCR_GENERATION: - colm_make_reverse_code( pdaRun ); + colm_make_reverse_code( pda_run ); /* Finished with the match text. */ - stringFree( prg, pdaRun->tokdata ); + string_free( prg, pda_run->tokdata ); - goto skipSend; + goto skip_send; } - else if ( lelInfo[pdaRun->tokenId].ignore ) { + else if ( lel_info[pda_run->token_id].ignore ) { debug( prg, REALM_PARSE, "sending an ignore token: %s\n", - prg->rtd->lelInfo[pdaRun->tokenId].name ); + prg->rtd->lel_info[pda_run->token_id].name ); /* Is an ignore token. */ - send_ignore( prg, sp, pdaRun, is, pdaRun->tokenId ); - goto skipSend; + send_ignore( prg, sp, pda_run, is, pda_run->token_id ); + goto skip_send; } else { debug( prg, REALM_PARSE, "sending an a plain old token: %s\n", - prg->rtd->lelInfo[pdaRun->tokenId].name ); + prg->rtd->lel_info[pda_run->token_id].name ); /* Is a plain token. */ - send_token( prg, sp, pdaRun, is, pdaRun->tokenId ); + send_token( prg, sp, pda_run, is, pda_run->token_id ); } yes: - if ( pdaRun->parseInput != 0 ) - colm_transfer_reverse_code( pdaRun, pdaRun->parseInput ); + if ( pda_run->parse_input != 0 ) + colm_transfer_reverse_code( pda_run, pda_run->parse_input ); - if ( pdaRun->parseInput != 0 ) { + if ( pda_run->parse_input != 0 ) { /* If it's a nonterminal with a termdup then flip the parse tree to * the terminal. */ - if ( pdaRun->parseInput->id >= prg->rtd->firstNonTermId ) { - pdaRun->parseInput->id = - prg->rtd->lelInfo[pdaRun->parseInput->id].termDupId; - pdaRun->parseInput->flags |= PF_TERM_DUP; + if ( pda_run->parse_input->id >= prg->rtd->first_non_term_id ) { + pda_run->parse_input->id = + prg->rtd->lel_info[pda_run->parse_input->id].term_dup_id; + pda_run->parse_input->flags |= PF_TERM_DUP; } } - long pcr = parse_token( prg, sp, pdaRun, is, PCR_START ); + long pcr = parse_token( prg, sp, pda_run, is, PCR_START ); while ( pcr != PCR_DONE ) { @@ -2177,45 +2177,45 @@ yes: case PCR_REDUCTION: case PCR_REVERSE: - pcr = parse_token( prg, sp, pdaRun, is, entry ); + pcr = parse_token( prg, sp, pda_run, is, entry ); } assert( pcr == PCR_DONE ); - handle_error( prg, sp, pdaRun ); + handle_error( prg, sp, pda_run ); -skipSend: - new_token( prg, pdaRun ); +skip_send: + new_token( prg, pda_run ); /* Various stop conditions. This should all be coverned by one test * eventually. */ - if ( pdaRun->triggerUndo ) { + if ( pda_run->trigger_undo ) { debug( prg, REALM_PARSE, "parsing stopped by triggerUndo\n" ); break; } - if ( is->eofSent ) { + if ( is->eof_sent ) { debug( prg, REALM_PARSE, "parsing stopped by EOF\n" ); break; } - if ( pdaRun->stopParsing ) { + if ( pda_run->stop_parsing ) { debug( prg, REALM_PARSE, "scanner has been stopped\n" ); break; } - if ( pdaRun->stop ) { + if ( pda_run->stop ) { debug( prg, REALM_PARSE, "parsing has been stopped by consumedCount\n" ); break; } - if ( prg->induceExit ) { + if ( prg->induce_exit ) { debug( prg, REALM_PARSE, "parsing has been stopped by a call to exit\n" ); break; } - if ( pdaRun->parseError ) { + if ( pda_run->parse_error ) { debug( prg, REALM_PARSE, "parsing stopped by a parse error\n" ); break; } @@ -2229,18 +2229,18 @@ skipSend: } -long colm_parse_frag( program_t *prg, tree_t **sp, struct pda_run *pdaRun, - stream_t *input, long stopId, long entry ) +long colm_parse_frag( program_t *prg, tree_t **sp, struct pda_run *pda_run, + stream_t *input, long stop_id, long entry ) { /* COROUTINE */ switch ( entry ) { case PCR_START: - if ( ! pdaRun->parseError ) { - pdaRun->stopTarget = stopId; + if ( ! pda_run->parse_error ) { + pda_run->stop_target = stop_id; - long pcr = colm_parse_loop( prg, sp, pdaRun, - streamToImpl( input ), entry ); + long pcr = colm_parse_loop( prg, sp, pda_run, + stream_to_impl( input ), entry ); while ( pcr != PCR_DONE ) { @@ -2251,8 +2251,8 @@ long colm_parse_frag( program_t *prg, tree_t **sp, struct pda_run *pdaRun, case PCR_PRE_EOF: case PCR_REVERSE: - pcr = colm_parse_loop( prg, sp, pdaRun, - streamToImpl( input ), entry ); + pcr = colm_parse_loop( prg, sp, pda_run, + stream_to_impl( input ), entry ); } } @@ -2264,7 +2264,7 @@ long colm_parse_frag( program_t *prg, tree_t **sp, struct pda_run *pdaRun, } long colm_parse_finish( tree_t **result, program_t *prg, tree_t **sp, - struct pda_run *pdaRun, stream_t *input , int revertOn, long entry ) + struct pda_run *pda_run, stream_t *input , int revert_on, long entry ) { struct stream_impl *si; @@ -2272,13 +2272,13 @@ long colm_parse_finish( tree_t **result, program_t *prg, tree_t **sp, switch ( entry ) { case PCR_START: - if ( pdaRun->stopTarget <= 0 ) { - si = streamToImpl( input ); - si->funcs->setEof( si ); + if ( pda_run->stop_target <= 0 ) { + si = stream_to_impl( input ); + si->funcs->set_eof( si ); - if ( ! pdaRun->parseError ) { - si = streamToImpl( input ); - long pcr = colm_parse_loop( prg, sp, pdaRun, si, entry ); + if ( ! pda_run->parse_error ) { + si = stream_to_impl( input ); + long pcr = colm_parse_loop( prg, sp, pda_run, si, entry ); while ( pcr != PCR_DONE ) { @@ -2289,8 +2289,8 @@ long colm_parse_finish( tree_t **result, program_t *prg, tree_t **sp, case PCR_PRE_EOF: case PCR_REVERSE: - si = streamToImpl( input ); - pcr = colm_parse_loop( prg, sp, pdaRun, si, entry ); + si = stream_to_impl( input ); + pcr = colm_parse_loop( prg, sp, pda_run, si, entry ); } } } @@ -2300,10 +2300,10 @@ long colm_parse_finish( tree_t **result, program_t *prg, tree_t **sp, * work (at time of writing). */ //assert( (pdaRun->stopTarget > 0 && pdaRun->stopParsing) || streamToImpl( input )->eofSent ); - if ( !revertOn ) - commit_full( prg, sp, pdaRun, 0 ); + if ( !revert_on ) + commit_full( prg, sp, pda_run, 0 ); - tree_t *tree = get_parsed_root( pdaRun, pdaRun->stopTarget > 0 ); + tree_t *tree = get_parsed_root( pda_run, pda_run->stop_target > 0 ); colm_tree_upref( tree ); *result = tree; @@ -2315,28 +2315,28 @@ long colm_parse_finish( tree_t **result, program_t *prg, tree_t **sp, return PCR_DONE; } -long colm_parse_undo_frag( program_t *prg, tree_t **sp, struct pda_run *pdaRun, +long colm_parse_undo_frag( program_t *prg, tree_t **sp, struct pda_run *pda_run, stream_t *input, long steps, long entry ) { debug( prg, REALM_PARSE, "undo parse frag, target steps: %ld, pdarun steps: %ld\n", - steps, pdaRun->steps ); + steps, pda_run->steps ); - reset_token( pdaRun ); + reset_token( pda_run ); /* COROUTINE */ switch ( entry ) { case PCR_START: - if ( steps < pdaRun->steps ) { + if ( steps < pda_run->steps ) { /* Setup environment for going backwards until we reduced steps to * what we want. */ - pdaRun->numRetry += 1; - pdaRun->targetSteps = steps; - pdaRun->triggerUndo = 1; + pda_run->num_retry += 1; + pda_run->target_steps = steps; + pda_run->trigger_undo = 1; /* The parse loop will recognise the situation. */ - long pcr = colm_parse_loop( prg, sp, pdaRun, streamToImpl(input), entry ); + long pcr = colm_parse_loop( prg, sp, pda_run, stream_to_impl(input), entry ); while ( pcr != PCR_DONE ) { /* COROUTINE */ @@ -2346,13 +2346,13 @@ long colm_parse_undo_frag( program_t *prg, tree_t **sp, struct pda_run *pdaRun, case PCR_PRE_EOF: case PCR_REVERSE: - pcr = colm_parse_loop( prg, sp, pdaRun, streamToImpl(input), entry ); + pcr = colm_parse_loop( prg, sp, pda_run, stream_to_impl(input), entry ); } /* Reset environment. */ - pdaRun->triggerUndo = 0; - pdaRun->targetSteps = -1; - pdaRun->numRetry -= 1; + pda_run->trigger_undo = 0; + pda_run->target_steps = -1; + pda_run->num_retry -= 1; } /* COROUTINE */ diff --git a/src/pdarun.h b/src/pdarun.h index a0b6ae80..5708f7fc 100644 --- a/src/pdarun.h +++ b/src/pdarun.h @@ -38,38 +38,38 @@ struct colm_program; struct fsm_tables { long *actions; - long *keyOffsets; - char *transKeys; - long *singleLengths; - long *rangeLengths; - long *indexOffsets; + long *key_offsets; + char *trans_keys; + long *single_lengths; + long *range_lengths; + long *index_offsets; long *transTargsWI; long *transActionsWI; - long *toStateActions; - long *fromStateActions; - long *eofActions; - long *eofTargs; - long *entryByRegion; - - long numStates; - long numActions; - long numTransKeys; - long numSingleLengths; - long numRangeLengths; - long numIndexOffsets; + long *to_state_actions; + long *from_state_actions; + long *eof_actions; + long *eof_targs; + long *entry_by_region; + + long num_states; + long num_actions; + long num_trans_keys; + long num_single_lengths; + long num_range_lengths; + long num_index_offsets; long numTransTargsWI; long numTransActionsWI; - long numRegions; + long num_regions; - long startState; - long firstFinal; - long errorState; + long start_state; + long first_final; + long error_state; - struct GenAction **actionSwitch; - long numActionSwitch; + struct GenAction **action_switch; + long num_action_switch; }; -void undoStreamPull( struct stream_impl *inputStream, const char *data, long length ); +void undo_stream_pull( struct stream_impl *input_stream, const char *data, long length ); #if SIZEOF_LONG != 4 && SIZEOF_LONG != 8 #error "SIZEOF_LONG contained an unexpected value" @@ -80,29 +80,29 @@ struct colm_execution; struct rt_code_vect { code_t *data; - long tabLen; - long allocLen; + long tab_len; + long alloc_len; /* FIXME: leak when freed. */ }; -void listAddAfter( list_t *list, list_el_t *prev_el, list_el_t *new_el ); -void listAddBefore( list_t *list, list_el_t *next_el, list_el_t *new_el ); +void list_add_after( list_t *list, list_el_t *prev_el, list_el_t *new_el ); +void list_add_before( list_t *list, list_el_t *next_el, list_el_t *new_el ); -void listPrepend( list_t *list, list_el_t *new_el ); -void listAppend( list_t *list, list_el_t *new_el ); +void list_prepend( list_t *list, list_el_t *new_el ); +void list_append( list_t *list, list_el_t *new_el ); -list_el_t *listDetach( list_t *list, list_el_t *el ); -list_el_t *listDetachFirst(list_t *list ); -list_el_t *listDetachLast(list_t *list ); +list_el_t *list_detach( list_t *list, list_el_t *el ); +list_el_t *list_detach_first(list_t *list ); +list_el_t *list_detach_last(list_t *list ); -long listLength(list_t *list); +long list_length(list_t *list); struct function_info { - long frameId; - long argSize; - long frameSize; + long frame_id; + long arg_size; + long frame_size; }; /* @@ -112,20 +112,20 @@ struct function_info struct pat_cons_info { long offset; - long numBindings; + long num_bindings; }; struct pat_cons_node { long id; - long prodNum; + long prod_num; long next; long child; - long bindId; + long bind_id; const char *data; long length; - long leftIgnore; - long rightIgnore; + long left_ignore; + long right_ignore; /* Just match nonterminal, don't go inside. */ unsigned char stop; @@ -136,41 +136,41 @@ struct pat_cons_node struct lang_el_info { const char *name; - const char *xmlTag; + const char *xml_tag; unsigned char repeat; unsigned char list; unsigned char literal; unsigned char ignore; - long frameId; + long frame_id; - long objectTypeId; - long ofiOffset; - long objectLength; + long object_type_id; + long ofi_offset; + long object_length; - long termDupId; - long markId; - long captureAttr; - long numCaptureAttr; + long term_dup_id; + long mark_id; + long capture_attr; + long num_capture_attr; }; struct struct_el_info { long size; short *trees; - long treesLen; + long trees_len; }; struct prod_info { - unsigned long lhsId; - short prodNum; + unsigned long lhs_id; + short prod_num; long length; const char *name; - long frameId; - unsigned char lhsUpref; + long frame_id; + unsigned char lhs_upref; unsigned char *copy; - long copyLen; + long copy_len; }; /* Must match the LocalType enum. */ @@ -193,17 +193,17 @@ struct frame_info code_t *codeWC; long codeLenWC; struct local_info *locals; - long localsLen; - long argSize; - long frameSize; - char retTree; + long locals_len; + long arg_size; + long frame_size; + char ret_tree; }; struct region_info { - long defaultToken; - long eofFrameId; - int ciLelId; + long default_token; + long eof_frame_id; + int ci_lel_id; }; typedef struct _CaptureAttr @@ -221,22 +221,22 @@ struct pda_tables int *keys; unsigned int *offsets; unsigned int *targs; - unsigned int *actInds; + unsigned int *act_inds; unsigned int *actions; - int *commitLen; - int *tokenRegionInds; - int *tokenRegions; - int *tokenPreRegions; - - int numIndicies; - int numKeys; - int numStates; - int numTargs; - int numActInds; - int numActions; - int numCommitLen; - int numRegionItems; - int numPreRegionItems; + int *commit_len; + int *token_region_inds; + int *token_regions; + int *token_pre_regions; + + int num_indicies; + int num_keys; + int num_states; + int num_targs; + int num_act_inds; + int num_actions; + int num_commit_len; + int num_region_items; + int num_pre_region_items; }; struct pool_block @@ -265,9 +265,9 @@ struct pda_run */ struct fsm_tables *fsm_tables; - RunBuf *consumeBuf; + RunBuf *consume_buf; - long region, preRegion; + long region, pre_region; long fsm_cs, next_cs, act; char *start; char *tokstart; @@ -277,71 +277,71 @@ struct pda_run /* Bits. */ char eof; - char returnResult; - char skipToklen; + char return_result; + char skip_toklen; char *mark[MARK_SLOTS]; - long matchedToken; + long matched_token; /* * Parsing */ - int numRetry; - parse_tree_t *stackTop; - ref_t *tokenList; + int num_retry; + parse_tree_t *stack_top; + ref_t *token_list; int pda_cs; - int nextRegionInd; + int next_region_ind; struct pda_tables *pda_tables; - int parserId; + int parser_id; /* Reused. */ - struct rt_code_vect rcodeCollect; - struct rt_code_vect reverseCode; + struct rt_code_vect rcode_collect; + struct rt_code_vect reverse_code; - int stopParsing; - long stopTarget; + int stop_parsing; + long stop_target; - parse_tree_t *accumIgnore; + parse_tree_t *accum_ignore; - kid_t *btPoint; + kid_t *bt_point; struct bindings *bindings; - int revertOn; + int revert_on; struct colm_struct *context; int stop; - int parseError; + int parse_error; long steps; - long targetSteps; - long shiftCount; - long commitShiftCount; + long target_steps; + long shift_count; + long commit_shift_count; - int onDeck; + int on_deck; /* * Data we added when refactoring the parsing engine into a coroutine. */ - parse_tree_t *parseInput; + parse_tree_t *parse_input; struct frame_info *fi; int reduction; - parse_tree_t *redLel; - int curState; + parse_tree_t *red_lel; + int cur_state; parse_tree_t *lel; - int triggerUndo; + int trigger_undo; - int tokenId; + int token_id; head_t *tokdata; - int frameId; + int frame_id; int next; - parse_tree_t *undoLel; + parse_tree_t *undo_lel; - int checkNext; - int checkStop; + int check_next; + int check_stop; /* The lhs is sometimes saved before reduction actions in case it is * replaced and we need to restore it on backtracking */ @@ -352,24 +352,24 @@ struct pda_run /* Instruction pointer to use when we stop parsing and execute code. */ code_t *code; - int rcBlockCount; + int rc_block_count; - tree_t *parseErrorText; + tree_t *parse_error_text; }; -void colm_pda_init( struct colm_program *prg, struct pda_run *pdaRun, - struct pda_tables *tables, int parserId, long stopTarget, - int revertOn, struct colm_struct *context ); +void colm_pda_init( struct colm_program *prg, struct pda_run *pda_run, + struct pda_tables *tables, int parser_id, long stop_target, + int revert_on, struct colm_struct *context ); void colm_pda_clear( struct colm_program *prg, struct colm_tree **sp, - struct pda_run *pdaRun ); + struct pda_run *pda_run ); void colm_rt_code_vect_replace( struct rt_code_vect *vect, long pos, const code_t *val, long len ); void colm_rt_code_vect_empty( struct rt_code_vect *vect ); void colm_rt_code_vect_remove( struct rt_code_vect *vect, long pos, long len ); -void initRtCodeVect( struct rt_code_vect *codeVect ); +void init_rt_code_vect( struct rt_code_vect *code_vect ); inline static void append_code_val( struct rt_code_vect *vect, const code_t val ); inline static void append_code_vect( struct rt_code_vect *vect, const code_t *val, long len ); @@ -378,12 +378,12 @@ inline static void append_word( struct rt_code_vect *vect, word_t word ); inline static void append_code_vect( struct rt_code_vect *vect, const code_t *val, long len ) { - colm_rt_code_vect_replace( vect, vect->tabLen, val, len ); + colm_rt_code_vect_replace( vect, vect->tab_len, val, len ); } inline static void append_code_val( struct rt_code_vect *vect, const code_t val ) { - colm_rt_code_vect_replace( vect, vect->tabLen, &val, 1 ); + colm_rt_code_vect_replace( vect, vect->tab_len, &val, 1 ); } inline static void append_half( struct rt_code_vect *vect, half_t half ) @@ -408,11 +408,11 @@ inline static void append_word( struct rt_code_vect *vect, word_t word ) #endif } -void colm_increment_steps( struct pda_run *pdaRun ); -void colm_decrement_steps( struct pda_run *pdaRun ); +void colm_increment_steps( struct pda_run *pda_run ); +void colm_decrement_steps( struct pda_run *pda_run ); -void colm_clear_stream_impl( struct colm_program *prg, tree_t **sp, struct stream_impl *inputStream ); -void colm_clear_source_stream( struct colm_program *prg, tree_t **sp, struct stream_impl *sourceStream ); +void colm_clear_stream_impl( struct colm_program *prg, tree_t **sp, struct stream_impl *input_stream ); +void colm_clear_source_stream( struct colm_program *prg, tree_t **sp, struct stream_impl *source_stream ); #define PCR_START 1 #define PCR_DONE 2 @@ -422,26 +422,26 @@ void colm_clear_source_stream( struct colm_program *prg, tree_t **sp, struct str #define PCR_REVERSE 6 head_t *colm_stream_pull( struct colm_program *prg, struct colm_tree **sp, - struct pda_run *pdaRun, struct stream_impl *is, long length ); + struct pda_run *pda_run, struct stream_impl *is, long length ); head_t *colm_string_alloc_pointer( struct colm_program *prg, const char *data, long length ); -void colm_stream_push_text( struct stream_impl *inputStream, const char *data, long length ); -void colm_stream_push_tree( struct stream_impl *inputStream, tree_t *tree, int ignore ); -void colm_stream_push_stream( struct stream_impl *inputStream, tree_t *tree ); +void colm_stream_push_text( struct stream_impl *input_stream, const char *data, long length ); +void colm_stream_push_tree( struct stream_impl *input_stream, tree_t *tree, int ignore ); +void colm_stream_push_stream( struct stream_impl *input_stream, tree_t *tree ); void colm_undo_stream_push( struct colm_program *prg, tree_t **sp, - struct stream_impl *inputStream, long length ); + struct stream_impl *input_stream, long length ); -kid_t *make_token_with_data( struct colm_program *prg, struct pda_run *pdaRun, - struct stream_impl *inputStream, int id, head_t *tokdata ); +kid_t *make_token_with_data( struct colm_program *prg, struct pda_run *pda_run, + struct stream_impl *input_stream, int id, head_t *tokdata ); -long colm_parse_loop( struct colm_program *prg, tree_t **sp, struct pda_run *pdaRun, - struct stream_impl *inputStream, long entry ); +long colm_parse_loop( struct colm_program *prg, tree_t **sp, struct pda_run *pda_run, + struct stream_impl *input_stream, long entry ); -long colm_parse_frag( struct colm_program *prg, tree_t **sp, struct pda_run *pdaRun, - stream_t *input, long stopId, long entry ); +long colm_parse_frag( struct colm_program *prg, tree_t **sp, struct pda_run *pda_run, + stream_t *input, long stop_id, long entry ); long colm_parse_finish( tree_t **result, struct colm_program *prg, tree_t **sp, - struct pda_run *pdaRun, stream_t *input , int revertOn, long entry ); -long colm_parse_undo_frag( struct colm_program *prg, tree_t **sp, struct pda_run *pdaRun, + struct pda_run *pda_run, stream_t *input , int revert_on, long entry ); +long colm_parse_undo_frag( struct colm_program *prg, tree_t **sp, struct pda_run *pda_run, stream_t *input, long steps, long entry ); #ifdef __cplusplus diff --git a/src/pool.c b/src/pool.c index 1d84c516..d5da6ab5 100644 --- a/src/pool.c +++ b/src/pool.c @@ -26,46 +26,46 @@ #include #include -void init_pool_alloc( struct pool_alloc *poolAlloc, int sizeofT ) +void init_pool_alloc( struct pool_alloc *pool_alloc, int sizeofT ) { - poolAlloc->head = 0; - poolAlloc->nextel = FRESH_BLOCK; - poolAlloc->pool = 0; - poolAlloc->sizeofT = sizeofT; + pool_alloc->head = 0; + pool_alloc->nextel = FRESH_BLOCK; + pool_alloc->pool = 0; + pool_alloc->sizeofT = sizeofT; } -static void *pool_alloc_allocate( struct pool_alloc *poolAlloc ) +static void *pool_alloc_allocate( struct pool_alloc *pool_alloc ) { //debug( REALM_POOL, "pool allocation\n" ); #ifdef POOL_MALLOC - void *res = malloc( poolAlloc->sizeofT ); - memset( res, 0, poolAlloc->sizeofT ); + void *res = malloc( pool_alloc->sizeofT ); + memset( res, 0, pool_alloc->sizeofT ); return res; #else - void *newEl = 0; - if ( poolAlloc->pool == 0 ) { - if ( poolAlloc->nextel == FRESH_BLOCK ) { - struct pool_block *newBlock = (struct pool_block*)malloc( sizeof(struct pool_block) ); - newBlock->data = malloc( poolAlloc->sizeofT * FRESH_BLOCK ); - newBlock->next = poolAlloc->head; - poolAlloc->head = newBlock; - poolAlloc->nextel = 0; + void *new_el = 0; + if ( pool_alloc->pool == 0 ) { + if ( pool_alloc->nextel == FRESH_BLOCK ) { + struct pool_block *new_block = (struct pool_block*)malloc( sizeof(struct pool_block) ); + new_block->data = malloc( pool_alloc->sizeofT * FRESH_BLOCK ); + new_block->next = pool_alloc->head; + pool_alloc->head = new_block; + pool_alloc->nextel = 0; } - newEl = (char*)poolAlloc->head->data + poolAlloc->sizeofT * poolAlloc->nextel++; + new_el = (char*)pool_alloc->head->data + pool_alloc->sizeofT * pool_alloc->nextel++; } else { - newEl = poolAlloc->pool; - poolAlloc->pool = poolAlloc->pool->next; + new_el = pool_alloc->pool; + pool_alloc->pool = pool_alloc->pool->next; } - memset( newEl, 0, poolAlloc->sizeofT ); - return newEl; + memset( new_el, 0, pool_alloc->sizeofT ); + return new_el; #endif } -void pool_alloc_free( struct pool_alloc *poolAlloc, void *el ) +void pool_alloc_free( struct pool_alloc *pool_alloc, void *el ) { #if 0 /* Some sanity checking. Best not to normally run with this on. */ @@ -80,14 +80,14 @@ void pool_alloc_free( struct pool_alloc *poolAlloc, void *el ) free( el ); #else struct pool_item *pi = (struct pool_item*) el; - pi->next = poolAlloc->pool; - poolAlloc->pool = pi; + pi->next = pool_alloc->pool; + pool_alloc->pool = pi; #endif } -void pool_alloc_clear( struct pool_alloc *poolAlloc ) +void pool_alloc_clear( struct pool_alloc *pool_alloc ) { - struct pool_block *block = poolAlloc->head; + struct pool_block *block = pool_alloc->head; while ( block != 0 ) { struct pool_block *next = block->next; free( block->data ); @@ -95,18 +95,18 @@ void pool_alloc_clear( struct pool_alloc *poolAlloc ) block = next; } - poolAlloc->head = 0; - poolAlloc->nextel = 0; - poolAlloc->pool = 0; + pool_alloc->head = 0; + pool_alloc->nextel = 0; + pool_alloc->pool = 0; } -long pool_alloc_num_lost( struct pool_alloc *poolAlloc ) +long pool_alloc_num_lost( struct pool_alloc *pool_alloc ) { /* Count the number of items allocated. */ long lost = 0; - struct pool_block *block = poolAlloc->head; + struct pool_block *block = pool_alloc->head; if ( block != 0 ) { - lost = poolAlloc->nextel; + lost = pool_alloc->nextel; block = block->next; while ( block != 0 ) { lost += FRESH_BLOCK; @@ -115,7 +115,7 @@ long pool_alloc_num_lost( struct pool_alloc *poolAlloc ) } /* Subtract. Items that are on the free list. */ - struct pool_item *pi = poolAlloc->pool; + struct pool_item *pi = pool_alloc->pool; while ( pi != 0 ) { lost -= 1; pi = pi->next; @@ -130,22 +130,22 @@ long pool_alloc_num_lost( struct pool_alloc *poolAlloc ) kid_t *kid_allocate( program_t *prg ) { - return (kid_t*) pool_alloc_allocate( &prg->kidPool ); + return (kid_t*) pool_alloc_allocate( &prg->kid_pool ); } void kid_free( program_t *prg, kid_t *el ) { - pool_alloc_free( &prg->kidPool, el ); + pool_alloc_free( &prg->kid_pool, el ); } void kid_clear( program_t *prg ) { - pool_alloc_clear( &prg->kidPool ); + pool_alloc_clear( &prg->kid_pool ); } long kid_num_lost( program_t *prg ) { - return pool_alloc_num_lost( &prg->kidPool ); + return pool_alloc_num_lost( &prg->kid_pool ); } /* @@ -154,22 +154,22 @@ long kid_num_lost( program_t *prg ) tree_t *tree_allocate( program_t *prg ) { - return (tree_t*) pool_alloc_allocate( &prg->treePool ); + return (tree_t*) pool_alloc_allocate( &prg->tree_pool ); } void tree_free( program_t *prg, tree_t *el ) { - pool_alloc_free( &prg->treePool, el ); + pool_alloc_free( &prg->tree_pool, el ); } void tree_clear( program_t *prg ) { - pool_alloc_clear( &prg->treePool ); + pool_alloc_clear( &prg->tree_pool ); } long tree_num_lost( program_t *prg ) { - return pool_alloc_num_lost( &prg->treePool ); + return pool_alloc_num_lost( &prg->tree_pool ); } /* @@ -178,22 +178,22 @@ long tree_num_lost( program_t *prg ) parse_tree_t *parse_tree_allocate( program_t *prg ) { - return (parse_tree_t*) pool_alloc_allocate( &prg->parseTreePool ); + return (parse_tree_t*) pool_alloc_allocate( &prg->parse_tree_pool ); } void parse_tree_free( program_t *prg, parse_tree_t *el ) { - pool_alloc_free( &prg->parseTreePool, el ); + pool_alloc_free( &prg->parse_tree_pool, el ); } void parse_tree_clear( program_t *prg ) { - pool_alloc_clear( &prg->parseTreePool ); + pool_alloc_clear( &prg->parse_tree_pool ); } long parse_tree_num_lost( program_t *prg ) { - return pool_alloc_num_lost( &prg->parseTreePool ); + return pool_alloc_num_lost( &prg->parse_tree_pool ); } /* @@ -202,22 +202,22 @@ long parse_tree_num_lost( program_t *prg ) head_t *head_allocate( program_t *prg ) { - return (head_t*) pool_alloc_allocate( &prg->headPool ); + return (head_t*) pool_alloc_allocate( &prg->head_pool ); } void head_free( program_t *prg, head_t *el ) { - pool_alloc_free( &prg->headPool, el ); + pool_alloc_free( &prg->head_pool, el ); } void head_clear( program_t *prg ) { - pool_alloc_clear( &prg->headPool ); + pool_alloc_clear( &prg->head_pool ); } long head_num_lost( program_t *prg ) { - return pool_alloc_num_lost( &prg->headPool ); + return pool_alloc_num_lost( &prg->head_pool ); } /* @@ -226,20 +226,20 @@ long head_num_lost( program_t *prg ) location_t *location_allocate( program_t *prg ) { - return (location_t*) pool_alloc_allocate( &prg->locationPool ); + return (location_t*) pool_alloc_allocate( &prg->location_pool ); } void location_free( program_t *prg, location_t *el ) { - pool_alloc_free( &prg->locationPool, el ); + pool_alloc_free( &prg->location_pool, el ); } void location_clear( program_t *prg ) { - pool_alloc_clear( &prg->locationPool ); + pool_alloc_clear( &prg->location_pool ); } long location_num_lost( program_t *prg ) { - return pool_alloc_num_lost( &prg->locationPool ); + return pool_alloc_num_lost( &prg->location_pool ); } diff --git a/src/pool.h b/src/pool.h index dec72df9..1879e39e 100644 --- a/src/pool.h +++ b/src/pool.h @@ -33,7 +33,7 @@ extern "C" { #endif -void init_pool_alloc( struct pool_alloc *poolAlloc, int sizeofT ); +void init_pool_alloc( struct pool_alloc *pool_alloc, int sizeofT ); kid_t *kid_allocate( program_t *prg ); void kid_free( program_t *prg, kid_t *el ); @@ -46,7 +46,7 @@ void tree_clear( program_t *prg ); long tree_num_lost( program_t *prg ); parse_tree_t *parse_tree_allocate( program_t *prg ); -void parseTreeFree( program_t *prg, parse_tree_t *el ); +void parse_tree_free( program_t *prg, parse_tree_t *el ); void parse_tree_clear( program_t *prg ); long parse_tree_num_lost( program_t *prg ); diff --git a/src/program.c b/src/program.c index 18064548..2f8e889a 100644 --- a/src/program.c +++ b/src/program.c @@ -38,7 +38,7 @@ static void colm_alloc_global( program_t *prg ) { /* Alloc the global. */ - prg->global = colm_struct_new( prg, prg->rtd->globalId ) ; + prg->global = colm_struct_new( prg, prg->rtd->global_id ) ; } void vm_init( program_t *prg ) @@ -49,33 +49,33 @@ void vm_init( program_t *prg ) b->offset = 0; b->next = 0; - prg->stackBlock = b; + prg->stack_block = b; - prg->sb_beg = prg->stackBlock->data; - prg->sb_end = prg->stackBlock->data + prg->stackBlock->len; + prg->sb_beg = prg->stack_block->data; + prg->sb_end = prg->stack_block->data + prg->stack_block->len; - prg->stackRoot = prg->sb_end; + prg->stack_root = prg->sb_end; } tree_t **colm_vm_root( program_t *prg ) { - return prg->stackRoot; + return prg->stack_root; } tree_t **vm_bs_add( program_t *prg, tree_t **sp, int n ) { /* Close off the current block. */ - if ( prg->stackBlock != 0 ) { - prg->stackBlock->offset = sp - prg->stackBlock->data; - prg->sb_total += prg->stackBlock->len - prg->stackBlock->offset; + if ( prg->stack_block != 0 ) { + prg->stack_block->offset = sp - prg->stack_block->data; + prg->sb_total += prg->stack_block->len - prg->stack_block->offset; } if ( prg->reserve != 0 && prg->reserve->len >= n) { struct stack_block *b = prg->reserve; - b->next = prg->stackBlock; + b->next = prg->stack_block; b->offset = 0; - prg->stackBlock = b; + prg->stack_block = b; prg->reserve = 0; } else { @@ -83,16 +83,16 @@ tree_t **vm_bs_add( program_t *prg, tree_t **sp, int n ) int size = VM_STACK_SIZE; if ( n > size ) size = n; - b->next = prg->stackBlock; + b->next = prg->stack_block; b->data = malloc( sizeof(tree_t*) * size ); b->len = size; b->offset = 0; - prg->stackBlock = b; + prg->stack_block = b; } - prg->sb_beg = prg->stackBlock->data; - prg->sb_end = prg->stackBlock->data + prg->stackBlock->len; + prg->sb_beg = prg->stack_block->data; + prg->sb_end = prg->stack_block->data + prg->stack_block->len; return prg->sb_end; } @@ -100,7 +100,7 @@ tree_t **vm_bs_add( program_t *prg, tree_t **sp, int n ) tree_t **vm_bs_pop( program_t *prg, tree_t **sp, int n ) { while ( 1 ) { - tree_t **end = prg->stackBlock->data + prg->stackBlock->len; + tree_t **end = prg->stack_block->data + prg->stack_block->len; int remaining = end - sp; /* Don't have to free this block. Remaining values to pop leave us @@ -110,7 +110,7 @@ tree_t **vm_bs_pop( program_t *prg, tree_t **sp, int n ) return sp; } - if ( prg->stackBlock->next == 0 ) { + if ( prg->stack_block->next == 0 ) { /* Don't delete the sentinal stack block. Returns the end as in the * creation of the first stack block. */ return prg->sb_end; @@ -124,29 +124,29 @@ tree_t **vm_bs_pop( program_t *prg, tree_t **sp, int n ) } /* Pop the stack block. */ - struct stack_block *b = prg->stackBlock; - prg->stackBlock = prg->stackBlock->next; + struct stack_block *b = prg->stack_block; + prg->stack_block = prg->stack_block->next; prg->reserve = b; /* Setup the bounds. Note that we restore the full block, which is * necessary to honour any CONTIGUOUS statements that counted on it * before a subsequent CONTIGUOUS triggered a new block. */ - prg->sb_beg = prg->stackBlock->data; - prg->sb_end = prg->stackBlock->data + prg->stackBlock->len; + prg->sb_beg = prg->stack_block->data; + prg->sb_end = prg->stack_block->data + prg->stack_block->len; /* Update the total stack usage. */ - prg->sb_total -= prg->stackBlock->len - prg->stackBlock->offset; + prg->sb_total -= prg->stack_block->len - prg->stack_block->offset; n -= remaining; - sp = prg->stackBlock->data + prg->stackBlock->offset; + sp = prg->stack_block->data + prg->stack_block->offset; } } void vm_clear( program_t *prg ) { - while ( prg->stackBlock != 0 ) { - struct stack_block *b = prg->stackBlock; - prg->stackBlock = prg->stackBlock->next; + while ( prg->stack_block != 0 ) { + struct stack_block *b = prg->stack_block; + prg->stack_block = prg->stack_block->next; free( b->data ); free( b ); @@ -160,12 +160,12 @@ void vm_clear( program_t *prg ) tree_t *colm_return_val( struct colm_program *prg ) { - return prg->returnVal; + return prg->return_val; } -void colm_set_debug( program_t *prg, long activeRealm ) +void colm_set_debug( program_t *prg, long active_realm ) { - prg->activeRealm = activeRealm; + prg->active_realm = active_realm; } program_t *colm_new_program( struct colm_sections *rtd ) @@ -177,16 +177,16 @@ program_t *colm_new_program( struct colm_sections *rtd ) assert( sizeof(pointer_t) <= sizeof(tree_t) ); prg->rtd = rtd; - prg->ctxDepParsing = 1; + prg->ctx_dep_parsing = 1; - init_pool_alloc( &prg->kidPool, sizeof(kid_t) ); - init_pool_alloc( &prg->treePool, sizeof(tree_t) ); - init_pool_alloc( &prg->parseTreePool, sizeof(parse_tree_t) ); - init_pool_alloc( &prg->headPool, sizeof(head_t) ); - init_pool_alloc( &prg->locationPool, sizeof(location_t) ); + init_pool_alloc( &prg->kid_pool, sizeof(kid_t) ); + init_pool_alloc( &prg->tree_pool, sizeof(tree_t) ); + init_pool_alloc( &prg->parse_tree_pool, sizeof(parse_tree_t) ); + init_pool_alloc( &prg->head_pool, sizeof(head_t) ); + init_pool_alloc( &prg->location_pool, sizeof(location_t) ); - prg->trueVal = (tree_t*) 1; - prg->falseVal = (tree_t*) 0; + prg->true_val = (tree_t*) 1; + prg->false_val = (tree_t*) 0; /* Allocate the global variable. */ colm_alloc_global( prg ); @@ -198,7 +198,7 @@ program_t *colm_new_program( struct colm_sections *rtd ) void colm_run_program( program_t *prg, int argc, const char **argv ) { - if ( prg->rtd->rootCodeLen == 0 ) + if ( prg->rtd->root_code_len == 0 ) return; /* Make the arguments available to the program. */ @@ -207,9 +207,9 @@ void colm_run_program( program_t *prg, int argc, const char **argv ) Execution execution; memset( &execution, 0, sizeof(execution) ); - execution.frameId = prg->rtd->rootFrameId; + execution.frame_id = prg->rtd->root_frame_id; - colm_execute( prg, &execution, prg->rtd->rootCode ); + colm_execute( prg, &execution, prg->rtd->root_code ); /* Clear the arg and stack. */ prg->argc = 0; @@ -228,35 +228,35 @@ static void colm_clear_heap( program_t *prg, tree_t **sp ) int colm_delete_program( program_t *prg ) { - tree_t **sp = prg->stackRoot; - int exitStatus = prg->exitStatus; + tree_t **sp = prg->stack_root; + int exit_status = prg->exit_status; - colm_tree_downref( prg, sp, prg->returnVal ); + colm_tree_downref( prg, sp, prg->return_val ); colm_clear_heap( prg, sp ); colm_tree_downref( prg, sp, prg->error ); #if DEBUG - long kidLost = kid_num_lost( prg ); - long treeLost = tree_num_lost( prg ); - long parseTreeLost = parse_tree_num_lost( prg ); - long headLost = head_num_lost( prg ); - long locationLost = location_num_lost( prg ); + long kid_lost = kid_num_lost( prg ); + long tree_lost = tree_num_lost( prg ); + long parse_tree_lost = parse_tree_num_lost( prg ); + long head_lost = head_num_lost( prg ); + long location_lost = location_num_lost( prg ); - if ( kidLost ) - message( "warning: lost kids: %ld\n", kidLost ); + if ( kid_lost ) + message( "warning: lost kids: %ld\n", kid_lost ); - if ( treeLost ) - message( "warning: lost trees: %ld\n", treeLost ); + if ( tree_lost ) + message( "warning: lost trees: %ld\n", tree_lost ); - if ( parseTreeLost ) - message( "warning: lost parse trees: %ld\n", parseTreeLost ); + if ( parse_tree_lost ) + message( "warning: lost parse trees: %ld\n", parse_tree_lost ); - if ( headLost ) - message( "warning: lost heads: %ld\n", headLost ); + if ( head_lost ) + message( "warning: lost heads: %ld\n", head_lost ); - if ( locationLost ) - message( "warning: lost locations: %ld\n", locationLost ); + if ( location_lost ) + message( "warning: lost locations: %ld\n", location_lost ); #endif kid_clear( prg ); @@ -265,7 +265,7 @@ int colm_delete_program( program_t *prg ) parse_tree_clear( prg ); location_clear( prg ); - RunBuf *rb = prg->allocRunBuf; + RunBuf *rb = prg->alloc_run_buf; while ( rb != 0 ) { RunBuf *next = rb->next; free( rb ); @@ -276,5 +276,5 @@ int colm_delete_program( program_t *prg ) free( prg ); - return exitStatus; + return exit_status; } diff --git a/src/program.h b/src/program.h index d74d4480..9949b386 100644 --- a/src/program.h +++ b/src/program.h @@ -34,71 +34,71 @@ struct stack_block struct colm_sections { - struct lang_el_info *lelInfo; - long numLangEls; + struct lang_el_info *lel_info; + long num_lang_els; - struct struct_el_info *selInfo; - long numStructEls; + struct struct_el_info *sel_info; + long num_struct_els; - struct prod_info *prodInfo; - long numProds; + struct prod_info *prod_info; + long num_prods; - struct region_info *regionInfo; - long numRegions; + struct region_info *region_info; + long num_regions; - code_t *rootCode; - long rootCodeLen; - long rootFrameId; + code_t *root_code; + long root_code_len; + long root_frame_id; - struct frame_info *frameInfo; - long numFrames; + struct frame_info *frame_info; + long num_frames; - struct function_info *functionInfo; - long numFunctions; + struct function_info *function_info; + long num_functions; - struct pat_cons_info *patReplInfo; - long numPatterns; + struct pat_cons_info *pat_repl_info; + long num_patterns; - struct pat_cons_node *patReplNodes; - long numPatternNodes; + struct pat_cons_node *pat_repl_nodes; + long num_pattern_nodes; - struct generic_info *genericInfo; - long numGenerics; + struct generic_info *generic_info; + long num_generics; - long argvGenericId; + long argv_generic_id; const char **litdata; long *litlen; head_t **literals; - long numLiterals; + long num_literals; - CaptureAttr *captureAttr; - long numCapturedAttr; + CaptureAttr *capture_attr; + long num_captured_attr; - struct fsm_tables *fsmTables; - struct pda_tables *pdaTables; - int *startStates; - int *eofLelIds; - int *parserLelIds; - long numParsers; + struct fsm_tables *fsm_tables; + struct pda_tables *pda_tables; + int *start_states; + int *eof_lel_ids; + int *parser_lel_ids; + long num_parsers; - long globalSize; + long global_size; - long firstNonTermId; + long first_non_term_id; - long integerId; - long stringId; - long anyId; - long eofId; - long noTokenId; - long globalId; - long argvElId; + long integer_id; + long string_id; + long any_id; + long eof_id; + long no_token_id; + long global_id; + long argv_el_id; - void (*fsm_execute)( struct pda_run *pdaRun, struct stream_impl *inputStream ); - void (*sendNamedLangEl)( struct colm_program *prg, tree_t **tree, - struct pda_run *pdaRun, struct stream_impl *inputStream ); - void (*initBindings)( struct pda_run *pdaRun ); - void (*popBinding)( struct pda_run *pdaRun, parse_tree_t *tree ); + void (*fsm_execute)( struct pda_run *pda_run, struct stream_impl *input_stream ); + void (*send_named_lang_el)( struct colm_program *prg, tree_t **tree, + struct pda_run *pda_run, struct stream_impl *input_stream ); + void (*init_bindings)( struct pda_run *pda_run ); + void (*pop_binding)( struct pda_run *pda_run, parse_tree_t *tree ); }; @@ -110,46 +110,46 @@ struct heap_list struct colm_program { - long activeRealm; + long active_realm; int argc; const char **argv; - unsigned char ctxDepParsing; + unsigned char ctx_dep_parsing; struct colm_sections *rtd; struct colm_struct *global; - int induceExit; - int exitStatus; + int induce_exit; + int exit_status; - struct pool_alloc kidPool; - struct pool_alloc treePool; - struct pool_alloc parseTreePool; - struct pool_alloc headPool; - struct pool_alloc locationPool; + struct pool_alloc kid_pool; + struct pool_alloc tree_pool; + struct pool_alloc parse_tree_pool; + struct pool_alloc head_pool; + struct pool_alloc location_pool; - tree_t *trueVal; - tree_t *falseVal; + tree_t *true_val; + tree_t *false_val; struct heap_list heap; - stream_t *stdinVal; - stream_t *stdoutVal; - stream_t *stderrVal; + stream_t *stdin_val; + stream_t *stdout_val; + stream_t *stderr_val; tree_t *error; - RunBuf *allocRunBuf; + RunBuf *alloc_run_buf; /* Current stack block limits. Changed when crossing block boundaries. */ tree_t **sb_beg; tree_t **sb_end; long sb_total; struct stack_block *reserve; - struct stack_block *stackBlock; - tree_t **stackRoot; + struct stack_block *stack_block; + tree_t **stack_root; /* Returned value for main program and any exported functions. */ - tree_t *returnVal; + tree_t *return_val; }; #endif diff --git a/src/redfsm.cc b/src/redfsm.cc index 39d750cd..17ca9ac3 100644 --- a/src/redfsm.cc +++ b/src/redfsm.cc @@ -836,18 +836,18 @@ fsm_tables *RedFsm::makeFsmTables() int pos, curKeyOffset, curIndOffset; fsm_tables *fsmTables = new fsm_tables; - fsmTables->numStates = stateList.length(); + fsmTables->num_states = stateList.length(); /* * actions */ - fsmTables->numActions = 1; + fsmTables->num_actions = 1; for ( GenActionTableMap::Iter act = actionMap; act.lte(); act++ ) - fsmTables->numActions += 1 + act->key.length(); + fsmTables->num_actions += 1 + act->key.length(); pos = 0; - fsmTables->actions = new long[fsmTables->numActions]; + fsmTables->actions = new long[fsmTables->num_actions]; fsmTables->actions[pos++] = 0; for ( GenActionTableMap::Iter act = actionMap; act.lte(); act++ ) { fsmTables->actions[pos++] = act->key.length(); @@ -859,10 +859,10 @@ fsm_tables *RedFsm::makeFsmTables() * keyOffset */ pos = 0, curKeyOffset = 0; - fsmTables->keyOffsets = new long[fsmTables->numStates]; + fsmTables->key_offsets = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) { /* Store the current offset. */ - fsmTables->keyOffsets[pos++] = curKeyOffset; + fsmTables->key_offsets[pos++] = curKeyOffset; /* Move the key offset ahead. */ curKeyOffset += st->outSingle.length() + st->outRange.length()*2; @@ -871,20 +871,20 @@ fsm_tables *RedFsm::makeFsmTables() /* * transKeys */ - fsmTables->numTransKeys = 0; + fsmTables->num_trans_keys = 0; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) { - fsmTables->numTransKeys += st->outSingle.length(); - fsmTables->numTransKeys += 2 * st->outRange.length(); + fsmTables->num_trans_keys += st->outSingle.length(); + fsmTables->num_trans_keys += 2 * st->outRange.length(); } pos = 0; - fsmTables->transKeys = new char[fsmTables->numTransKeys]; + fsmTables->trans_keys = new char[fsmTables->num_trans_keys]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) { for ( RedTransList::Iter stel = st->outSingle; stel.lte(); stel++ ) - fsmTables->transKeys[pos++] = stel->lowKey.getVal(); + fsmTables->trans_keys[pos++] = stel->lowKey.getVal(); for ( RedTransList::Iter rtel = st->outRange; rtel.lte(); rtel++ ) { - fsmTables->transKeys[pos++] = rtel->lowKey.getVal(); - fsmTables->transKeys[pos++] = rtel->highKey.getVal(); + fsmTables->trans_keys[pos++] = rtel->lowKey.getVal(); + fsmTables->trans_keys[pos++] = rtel->highKey.getVal(); } } @@ -892,25 +892,25 @@ fsm_tables *RedFsm::makeFsmTables() * singleLengths */ pos = 0; - fsmTables->singleLengths = new long[fsmTables->numStates]; + fsmTables->single_lengths = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) - fsmTables->singleLengths[pos++] = st->outSingle.length(); + fsmTables->single_lengths[pos++] = st->outSingle.length(); /* * rangeLengths */ pos = 0; - fsmTables->rangeLengths = new long[fsmTables->numStates]; + fsmTables->range_lengths = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) - fsmTables->rangeLengths[pos++] = st->outRange.length(); + fsmTables->range_lengths[pos++] = st->outRange.length(); /* * indexOffsets */ pos = 0, curIndOffset = 0; - fsmTables->indexOffsets = new long[fsmTables->numStates]; + fsmTables->index_offsets = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) { - fsmTables->indexOffsets[pos++] = curIndOffset; + fsmTables->index_offsets[pos++] = curIndOffset; curIndOffset += st->outSingle.length() + st->outRange.length(); if ( st->defTrans != 0 ) @@ -969,63 +969,63 @@ fsm_tables *RedFsm::makeFsmTables() * toStateActions */ pos = 0; - fsmTables->toStateActions = new long[fsmTables->numStates]; + fsmTables->to_state_actions = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) - fsmTables->toStateActions[pos++] = toStateAction( st ); + fsmTables->to_state_actions[pos++] = toStateAction( st ); /* * fromStateActions */ pos = 0; - fsmTables->fromStateActions = new long[fsmTables->numStates]; + fsmTables->from_state_actions = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) - fsmTables->fromStateActions[pos++] = fromStateAction( st ); + fsmTables->from_state_actions[pos++] = fromStateAction( st ); /* * eofActions */ pos = 0; - fsmTables->eofActions = new long[fsmTables->numStates]; + fsmTables->eof_actions = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) - fsmTables->eofActions[pos++] = eofAction( st ); + fsmTables->eof_actions[pos++] = eofAction( st ); /* * eofTargs */ pos = 0; - fsmTables->eofTargs = new long[fsmTables->numStates]; + fsmTables->eof_targs = new long[fsmTables->num_states]; for ( RedStateList::Iter st = stateList; st.lte(); st++ ) { int targ = -1; if ( st->eofTrans != 0 ) targ = st->eofTrans->targ->id; - fsmTables->eofTargs[pos++] = targ; + fsmTables->eof_targs[pos++] = targ; } /* Start state. */ - fsmTables->startState = startState->id; + fsmTables->start_state = startState->id; /* First final state. */ - fsmTables->firstFinal = ( firstFinState != 0 ) ? + fsmTables->first_final = ( firstFinState != 0 ) ? firstFinState->id : nextStateId; /* The error state. */ - fsmTables->errorState = ( errState != 0 ) ? + fsmTables->error_state = ( errState != 0 ) ? errState->id : -1; /* The array pointing to actions. */ pos = 0; - fsmTables->numActionSwitch = genActionList.length(); - fsmTables->actionSwitch = new GenAction*[fsmTables->numActionSwitch]; + fsmTables->num_action_switch = genActionList.length(); + fsmTables->action_switch = new GenAction*[fsmTables->num_action_switch]; for ( GenActionList::Iter act = genActionList; act.lte(); act++ ) - fsmTables->actionSwitch[pos++] = act; + fsmTables->action_switch[pos++] = act; /* * entryByRegion */ - fsmTables->numRegions = regionToEntry.length()+1; - fsmTables->entryByRegion = new long[fsmTables->numRegions]; - fsmTables->entryByRegion[0] = fsmTables->errorState; + fsmTables->num_regions = regionToEntry.length()+1; + fsmTables->entry_by_region = new long[fsmTables->num_regions]; + fsmTables->entry_by_region[0] = fsmTables->error_state; pos = 1; for ( RegionToEntry::Iter en = regionToEntry; en.lte(); en++ ) { @@ -1033,8 +1033,8 @@ fsm_tables *RedFsm::makeFsmTables() RedEntryMapEl *entryMapEl = redEntryMap.find( *en ); /* Save it off. */ - fsmTables->entryByRegion[pos++] = entryMapEl != 0 ? entryMapEl->value - : fsmTables->errorState; + fsmTables->entry_by_region[pos++] = entryMapEl != 0 ? entryMapEl->value + : fsmTables->error_state; } return fsmTables; diff --git a/src/string.c b/src/string.c index 9003eb1e..2a1c5674 100644 --- a/src/string.c +++ b/src/string.c @@ -31,18 +31,18 @@ str_t *string_prefix( program_t *prg, str_t *str, long len ) { - head_t *head = stringAllocFull( prg, str->value->data, len ); - return (str_t*)constructString( prg, head ); + head_t *head = string_alloc_full( prg, str->value->data, len ); + return (str_t*)construct_string( prg, head ); } str_t *string_suffix( program_t *prg, str_t *str, long pos ) { long len = str->value->length - pos; - head_t *head = stringAllocFull( prg, str->value->data + pos, len ); - return (str_t*)constructString( prg, head ); + head_t *head = string_alloc_full( prg, str->value->data + pos, len ); + return (str_t*)construct_string( prg, head ); } -tree_t *constructString( program_t *prg, head_t *s ) +tree_t *construct_string( program_t *prg, head_t *s ) { str_t *str = (str_t*) tree_allocate( prg ); str->id = LEL_ID_STR; @@ -59,12 +59,12 @@ tree_t *constructString( program_t *prg, head_t *s ) * nulls. */ -head_t *stringCopy( program_t *prg, head_t *head ) +head_t *string_copy( program_t *prg, head_t *head ) { head_t *result = 0; if ( head != 0 ) { if ( (char*)(head+1) == head->data ) - result = stringAllocFull( prg, head->data, head->length ); + result = string_alloc_full( prg, head->data, head->length ); else result = colm_string_alloc_pointer( prg, head->data, head->length ); @@ -79,7 +79,7 @@ head_t *stringCopy( program_t *prg, head_t *head ) return result; } -void stringFree( program_t *prg, head_t *head ) +void string_free( program_t *prg, head_t *head ) { if ( head != 0 ) { if ( head->location != 0 ) @@ -96,27 +96,27 @@ void stringFree( program_t *prg, head_t *head ) } } -const char *stringData( head_t *head ) +const char *string_data( head_t *head ) { if ( head == 0 ) return 0; return head->data; } -long stringLength( head_t *head ) +long string_length( head_t *head ) { if ( head == 0 ) return 0; return head->length; } -void stringShorten( head_t *head, long newlen ) +void string_shorten( head_t *head, long newlen ) { assert( newlen <= head->length ); head->length = newlen; } -head_t *initStrSpace( long length ) +head_t *init_str_space( long length ) { /* Find the length and allocate the space for the shared string. */ head_t *head = (head_t*) malloc( sizeof(head_t) + length ); @@ -131,10 +131,10 @@ head_t *initStrSpace( long length ) } /* Create from a c-style string. */ -head_t *stringAllocFull( program_t *prg, const char *data, long length ) +head_t *string_alloc_full( program_t *prg, const char *data, long length ) { /* Init space for the data. */ - head_t *head = initStrSpace( length ); + head_t *head = init_str_space( length ); /* Copy in the data. */ memcpy( (head+1), data, length ); @@ -155,13 +155,13 @@ head_t *colm_string_alloc_pointer( program_t *prg, const char *data, long length return head; } -head_t *concatStr( head_t *s1, head_t *s2 ) +head_t *concat_str( head_t *s1, head_t *s2 ) { long s1Len = s1->length; long s2Len = s2->length; /* Init space for the data. */ - head_t *head = initStrSpace( s1Len + s2Len ); + head_t *head = init_str_space( s1Len + s2Len ); /* Copy in the data. */ memcpy( (head+1), s1->data, s1Len ); @@ -170,11 +170,11 @@ head_t *concatStr( head_t *s1, head_t *s2 ) return head; } -head_t *stringToUpper( head_t *s ) +head_t *string_to_upper( head_t *s ) { /* Init space for the data. */ long len = s->length; - head_t *head = initStrSpace( len ); + head_t *head = init_str_space( len ); /* Copy in the data. */ const char *src = s->data; @@ -186,11 +186,11 @@ head_t *stringToUpper( head_t *s ) return head; } -head_t *stringToLower( head_t *s ) +head_t *string_to_lower( head_t *s ) { /* Init space for the data. */ long len = s->length; - head_t *head = initStrSpace( len ); + head_t *head = init_str_space( len ); /* Copy in the data. */ const char *src = s->data; @@ -204,7 +204,7 @@ head_t *stringToLower( head_t *s ) /* Compare two strings. If identical returns 1, otherwise 0. */ -word_t cmpString( head_t *s1, head_t *s2 ) +word_t cmp_string( head_t *s1, head_t *s2 ) { if ( s1->length < s2->length ) return -1; @@ -217,7 +217,7 @@ word_t cmpString( head_t *s1, head_t *s2 ) } } -word_t strAtoi( head_t *str ) +word_t str_atoi( head_t *str ) { /* FIXME: need to implement this by hand. There is no null terminator. */ char *nulled = (char*)malloc( str->length + 1 ); @@ -228,7 +228,7 @@ word_t strAtoi( head_t *str ) return res; } -word_t strAtoo( head_t *str ) +word_t str_atoo( head_t *str ) { /* FIXME: need to implement this by hand. There is no null terminator. */ char *nulled = (char*)malloc( str->length + 1 ); @@ -239,14 +239,14 @@ word_t strAtoo( head_t *str ) return res; } -head_t *intToStr( program_t *prg, word_t i ) +head_t *int_to_str( program_t *prg, word_t i ) { char data[20]; sprintf( data, "%ld", i ); - return stringAllocFull( prg, data, strlen(data) ); + return string_alloc_full( prg, data, strlen(data) ); } -word_t strUord16( head_t *head ) +word_t str_uord16( head_t *head ) { uchar *data = (uchar*)(head->data); ulong res; @@ -255,26 +255,26 @@ word_t strUord16( head_t *head ) return res; } -word_t strUord8( head_t *head ) +word_t str_uord8( head_t *head ) { uchar *data = (uchar*)(head->data); ulong res = (ulong)data[0]; return res; } -head_t *makeLiteral( program_t *prg, long offset ) +head_t *make_literal( program_t *prg, long offset ) { return colm_string_alloc_pointer( prg, prg->rtd->litdata[offset], prg->rtd->litlen[offset] ); } -head_t *stringSprintf( program_t *prg, str_t *format, long integer ) +head_t *string_sprintf( program_t *prg, str_t *format, long integer ) { - head_t *formatHead = format->value; - long written = snprintf( 0, 0, stringData(formatHead), integer ); - head_t *head = initStrSpace( written+1 ); - written = snprintf( (char*)head->data, written+1, stringData(formatHead), integer ); + head_t *format_head = format->value; + long written = snprintf( 0, 0, string_data(format_head), integer ); + head_t *head = init_str_space( written+1 ); + written = snprintf( (char*)head->data, written+1, string_data(format_head), integer ); head->length -= 1; return head; } diff --git a/src/struct.c b/src/struct.c index 8beb9e2d..80ae37bf 100644 --- a/src/struct.c +++ b/src/struct.c @@ -40,7 +40,7 @@ struct colm_struct *colm_struct_new_size( program_t *prg, int size ) struct colm_struct *colm_struct_new( program_t *prg, int id ) { - struct colm_struct *s = colm_struct_new_size( prg, prg->rtd->selInfo[id].size ); + struct colm_struct *s = colm_struct_new_size( prg, prg->rtd->sel_info[id].size ); s->id = id; return s; } @@ -54,8 +54,8 @@ void colm_struct_delete( program_t *prg, tree_t **sp, struct colm_struct *el ) } if ( el->id >= 0 ) { - short *t = prg->rtd->selInfo[el->id].trees; - int i, len = prg->rtd->selInfo[el->id].treesLen; + short *t = prg->rtd->sel_info[el->id].trees; + int i, len = prg->rtd->sel_info[el->id].trees_len; for ( i = 0; i < len; i++ ) { tree_t *tree = colm_struct_get_field( el, tree_t*, t[i] ); colm_tree_downref( prg, sp, tree ); @@ -69,8 +69,8 @@ void colm_parser_destroy( program_t *prg, tree_t **sp, struct colm_struct *s ) struct colm_parser *parser = (struct colm_parser*) s; /* Free the PDA run. */ - colm_pda_clear( prg, sp, parser->pdaRun ); - free( parser->pdaRun ); + colm_pda_clear( prg, sp, parser->pda_run ); + free( parser->pda_run ); /* Free the result. */ colm_tree_downref( prg, sp, parser->result ); @@ -78,11 +78,11 @@ void colm_parser_destroy( program_t *prg, tree_t **sp, struct colm_struct *s ) parser_t *colm_parser_new( program_t *prg, struct generic_info *gi ) { - struct pda_run *pdaRun = malloc( sizeof(struct pda_run) ); + struct pda_run *pda_run = malloc( sizeof(struct pda_run) ); /* Start off the parsing process. */ - colm_pda_init( prg, pdaRun, prg->rtd->pdaTables, - gi->parserId, 0, 0, 0 ); + colm_pda_init( prg, pda_run, prg->rtd->pda_tables, + gi->parser_id, 0, 0, 0 ); size_t memsize = sizeof(struct colm_parser); struct colm_parser *parser = (struct colm_parser*) malloc( memsize ); @@ -91,7 +91,7 @@ parser_t *colm_parser_new( program_t *prg, struct generic_info *gi ) parser->id = STRUCT_INBUILT_ID; parser->destructor = &colm_parser_destroy; - parser->pdaRun = pdaRun; + parser->pda_run = pda_run; return parser; } @@ -119,11 +119,11 @@ map_t *colm_map_new( struct colm_program *prg ) return map; } -struct_t *colm_construct_generic( program_t *prg, long genericId ) +struct_t *colm_construct_generic( program_t *prg, long generic_id ) { - struct generic_info *genericInfo = &prg->rtd->genericInfo[genericId]; - struct_t *newGeneric = 0; - switch ( genericInfo->type ) { + struct generic_info *generic_info = &prg->rtd->generic_info[generic_id]; + struct_t *new_generic = 0; + switch ( generic_info->type ) { case GEN_MAP_EL: case GEN_LIST_EL: break; @@ -132,25 +132,25 @@ struct_t *colm_construct_generic( program_t *prg, long genericId ) case GEN_VMAP: { map_t *map = colm_map_new( prg ); - map->genericInfo = genericInfo; - newGeneric = (struct_t*) map; + map->generic_info = generic_info; + new_generic = (struct_t*) map; break; } case GEN_LIST: case GEN_VLIST: { list_t *list = colm_list_new( prg ); - list->genericInfo = genericInfo; - newGeneric = (struct_t*) list; + list->generic_info = generic_info; + new_generic = (struct_t*) list; break; } case GEN_PARSER: { - parser_t *parser = colm_parser_new( prg, genericInfo ); + parser_t *parser = colm_parser_new( prg, generic_info ); parser->input = colm_stream_new( prg ); - newGeneric = (struct_t*) parser; + new_generic = (struct_t*) parser; break; } } - return newGeneric; + return new_generic; } diff --git a/src/struct.h b/src/struct.h index 1ffb9af7..e70d7502 100644 --- a/src/struct.h +++ b/src/struct.h @@ -31,7 +31,7 @@ typedef struct colm_parser void *buffer[10]; - struct pda_run *pdaRun; + struct pda_run *pda_run; struct colm_stream *input; tree_t *result; } parser_t; @@ -66,8 +66,8 @@ typedef struct colm_list void *buffer[8]; list_el_t *head, *tail; - long listLen; - struct generic_info *genericInfo; + long list_len; + struct generic_info *generic_info; } list_t; typedef struct colm_map_el @@ -91,8 +91,8 @@ typedef struct colm_map void *buffer[8]; struct colm_map_el *head, *tail, *root; - long treeSize; - struct generic_info *genericInfo; + long tree_size; + struct generic_info *generic_info; } map_t; struct colm_struct *colm_struct_new_size( struct colm_program *prg, int size ); @@ -117,13 +117,13 @@ struct colm_struct *colm_struct_inbuilt( struct colm_program *prg, int size, ((void*)el) - (field * sizeof(void*)) - sizeof(struct colm_struct) #define colm_generic_el_container( prg, el, genId ) \ - colm_struct_container( el, prg->rtd->genericInfo[genId].elOffset ) + colm_struct_container( el, prg->rtd->generic_info[genId].el_offset ) #define colm_struct_to_list_el( prg, obj, genId ) \ - colm_struct_get_addr( obj, list_el_t*, prg->rtd->genericInfo[genId].elOffset ) + colm_struct_get_addr( obj, list_el_t*, prg->rtd->generic_info[genId].el_offset ) #define colm_struct_to_map_el( prg, obj, genId ) \ - colm_struct_get_addr( obj, map_el_t*, prg->rtd->genericInfo[genId].elOffset ) + colm_struct_get_addr( obj, map_el_t*, prg->rtd->generic_info[genId].el_offset ) parser_t *colm_parser_new( struct colm_program *prg, struct generic_info *gi ); stream_t *colm_stream_new( struct colm_program *prg ); @@ -131,20 +131,20 @@ stream_t *colm_stream_new_struct( struct colm_program *prg ); list_t *colm_list_new( struct colm_program *prg ); struct colm_struct *colm_list_get( struct colm_program *prg, list_t *list, - word_t genId, word_t field ); + word_t gen_id, word_t field ); struct colm_struct *colm_list_el_get( struct colm_program *prg, - list_el_t *listEl, word_t genId, word_t field ); + list_el_t *list_el, word_t gen_id, word_t field ); list_el_t *colm_list_detach_head( list_t *list ); list_el_t *colm_list_detach_tail( list_t *list ); long colm_list_length( list_t *list ); map_t *colm_map_new( struct colm_program *prg ); struct colm_struct *colm_map_el_get( struct colm_program *prg, - map_el_t *mapEl, word_t genId, word_t field ); + map_el_t *map_el, word_t gen_id, word_t field ); struct colm_struct *colm_map_get( struct colm_program *prg, map_t *map, - word_t genId, word_t field ); + word_t gen_id, word_t field ); -struct colm_struct *colm_construct_generic( struct colm_program *prg, long genericId ); +struct colm_struct *colm_construct_generic( struct colm_program *prg, long generic_id ); #define STRUCT_INBUILT_ID -1 diff --git a/src/tree.c b/src/tree.c index 33f693f0..3370a793 100644 --- a/src/tree.c +++ b/src/tree.c @@ -39,7 +39,7 @@ #define BUFFER_INITIAL_SIZE 4096 -kid_t *allocAttrs( program_t *prg, long length ) +kid_t *alloc_attrs( program_t *prg, long length ) { kid_t *cur = 0; long i; @@ -51,7 +51,7 @@ kid_t *allocAttrs( program_t *prg, long length ) return cur; } -void freeAttrs( program_t *prg, kid_t *attrs ) +void free_attrs( program_t *prg, kid_t *attrs ) { kid_t *cur = attrs; while ( cur != 0 ) { @@ -61,7 +61,7 @@ void freeAttrs( program_t *prg, kid_t *attrs ) } } -void freeKidList( program_t *prg, kid_t *kid ) +void free_kid_list( program_t *prg, kid_t *kid ) { while ( kid != 0 ) { kid_t *next = kid->next; @@ -149,7 +149,7 @@ int colm_list_last( tree_t *tree ) return kid->next == 0; } -kid_t *getAttrKid( tree_t *tree, long pos ) +kid_t *get_attr_kid( tree_t *tree, long pos ) { long i; kid_t *kid = tree->child; @@ -164,7 +164,7 @@ kid_t *getAttrKid( tree_t *tree, long pos ) return kid; } -kid_t *kidListConcat( kid_t *list1, kid_t *list2 ) +kid_t *kid_list_concat( kid_t *list1, kid_t *list2 ) { if ( list1 == 0 ) return list2; @@ -195,72 +195,72 @@ value_t colm_get_pointer_val( tree_t *ptr ) tree_t *colm_construct_term( program_t *prg, word_t id, head_t *tokdata ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; tree_t *tree = tree_allocate( prg ); tree->id = id; tree->refs = 0; tree->tokdata = tokdata; - int objectLength = lelInfo[tree->id].objectLength; - tree->child = allocAttrs( prg, objectLength ); + int object_length = lel_info[tree->id].object_length; + tree->child = alloc_attrs( prg, object_length ); return tree; } -kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ); +kid_t *construct_kid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ); -static kid_t *constructIgnoreList( program_t *prg, long ignoreInd ) +static kid_t *construct_ignore_list( program_t *prg, long ignore_ind ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; kid_t *first = 0, *last = 0; - while ( ignoreInd >= 0 ) { - head_t *ignoreData = colm_string_alloc_pointer( prg, nodes[ignoreInd].data, - nodes[ignoreInd].length ); + while ( ignore_ind >= 0 ) { + head_t *ignore_data = colm_string_alloc_pointer( prg, nodes[ignore_ind].data, + nodes[ignore_ind].length ); - tree_t *ignTree = tree_allocate( prg ); - ignTree->refs = 1; - ignTree->id = nodes[ignoreInd].id; - ignTree->tokdata = ignoreData; + tree_t *ign_tree = tree_allocate( prg ); + ign_tree->refs = 1; + ign_tree->id = nodes[ignore_ind].id; + ign_tree->tokdata = ignore_data; - kid_t *ignKid = kid_allocate( prg ); - ignKid->tree = ignTree; - ignKid->next = 0; + kid_t *ign_kid = kid_allocate( prg ); + ign_kid->tree = ign_tree; + ign_kid->next = 0; if ( last == 0 ) - first = ignKid; + first = ign_kid; else - last->next = ignKid; + last->next = ign_kid; - ignoreInd = nodes[ignoreInd].next; - last = ignKid; + ignore_ind = nodes[ignore_ind].next; + last = ign_kid; } return first; } -static kid_t *constructLeftIgnoreList( program_t *prg, long pat ) +static kid_t *construct_left_ignore_list( program_t *prg, long pat ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; - return constructIgnoreList( prg, nodes[pat].leftIgnore ); + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; + return construct_ignore_list( prg, nodes[pat].left_ignore ); } -static kid_t *constructRightIgnoreList( program_t *prg, long pat ) +static kid_t *construct_right_ignore_list( program_t *prg, long pat ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; - return constructIgnoreList( prg, nodes[pat].rightIgnore ); + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; + return construct_ignore_list( prg, nodes[pat].right_ignore ); } -static void insLeftIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList ) +static void ins_left_ignore( program_t *prg, tree_t *tree, tree_t *ignore_list ) { assert( ! (tree->flags & AF_LEFT_IGNORE) ); /* Allocate. */ kid_t *kid = kid_allocate( prg ); - kid->tree = ignoreList; - colm_tree_upref( ignoreList ); + kid->tree = ignore_list; + colm_tree_upref( ignore_list ); /* Attach it. */ kid->next = tree->child; @@ -269,14 +269,14 @@ static void insLeftIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList ) tree->flags |= AF_LEFT_IGNORE; } -static void insRightIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList ) +static void ins_right_ignore( program_t *prg, tree_t *tree, tree_t *ignore_list ) { assert( ! (tree->flags & AF_RIGHT_IGNORE) ); /* Insert an ignore head in the child list. */ kid_t *kid = kid_allocate( prg ); - kid->tree = ignoreList; - colm_tree_upref( ignoreList ); + kid->tree = ignore_list; + colm_tree_upref( ignore_list ); /* Attach it. */ if ( tree->flags & AF_LEFT_IGNORE ) { @@ -291,57 +291,57 @@ static void insRightIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList ) tree->flags |= AF_RIGHT_IGNORE; } -tree_t *push_right_ignore( program_t *prg, tree_t *pushTo, tree_t *rightIgnore ) +tree_t *push_right_ignore( program_t *prg, tree_t *push_to, tree_t *right_ignore ) { /* About to alter the data tree. Split first. */ - pushTo = splitTree( prg, pushTo ); + push_to = split_tree( prg, push_to ); - if ( pushTo->flags & AF_RIGHT_IGNORE ) { + if ( push_to->flags & AF_RIGHT_IGNORE ) { /* The previous token already has a right ignore. Merge by * attaching it as a left ignore of the new list. */ - kid_t *curIgnore = treeRightIgnoreKid( prg, pushTo ); - insLeftIgnore( prg, rightIgnore, curIgnore->tree ); + kid_t *cur_ignore = tree_right_ignore_kid( prg, push_to ); + ins_left_ignore( prg, right_ignore, cur_ignore->tree ); /* Replace the current ignore. Safe to access refs here because we just * upreffed it in insLeftIgnore. */ - curIgnore->tree->refs -= 1; - curIgnore->tree = rightIgnore; - colm_tree_upref( rightIgnore ); + cur_ignore->tree->refs -= 1; + cur_ignore->tree = right_ignore; + colm_tree_upref( right_ignore ); } else { /* Attach The ignore list. */ - insRightIgnore( prg, pushTo, rightIgnore ); + ins_right_ignore( prg, push_to, right_ignore ); } - return pushTo; + return push_to; } -tree_t *push_left_ignore( program_t *prg, tree_t *pushTo, tree_t *leftIgnore ) +tree_t *push_left_ignore( program_t *prg, tree_t *push_to, tree_t *left_ignore ) { - pushTo = splitTree( prg, pushTo ); + push_to = split_tree( prg, push_to ); /* Attach as left ignore to the token we are sending. */ - if ( pushTo->flags & AF_LEFT_IGNORE ) { + if ( push_to->flags & AF_LEFT_IGNORE ) { /* The token already has a left-ignore. Merge by attaching it as a * right ignore of the new list. */ - kid_t *curIgnore = treeLeftIgnoreKid( prg, pushTo ); - insRightIgnore( prg, leftIgnore, curIgnore->tree ); + kid_t *cur_ignore = tree_left_ignore_kid( prg, push_to ); + ins_right_ignore( prg, left_ignore, cur_ignore->tree ); /* Replace the current ignore. Safe to upref here because we just * upreffed it in insRightIgnore. */ - curIgnore->tree->refs -= 1; - curIgnore->tree = leftIgnore; - colm_tree_upref( leftIgnore ); + cur_ignore->tree->refs -= 1; + cur_ignore->tree = left_ignore; + colm_tree_upref( left_ignore ); } else { /* Attach the ignore list. */ - insLeftIgnore( prg, pushTo, leftIgnore ); + ins_left_ignore( prg, push_to, left_ignore ); } - return pushTo; + return push_to; } -static void remLeftIgnore( program_t *prg, tree_t **sp, tree_t *tree ) +static void rem_left_ignore( program_t *prg, tree_t **sp, tree_t *tree ) { assert( tree->flags & AF_LEFT_IGNORE ); @@ -353,7 +353,7 @@ static void remLeftIgnore( program_t *prg, tree_t **sp, tree_t *tree ) tree->flags &= ~AF_LEFT_IGNORE; } -static void remRightIgnore( program_t *prg, tree_t **sp, tree_t *tree ) +static void rem_right_ignore( program_t *prg, tree_t **sp, tree_t *tree ) { assert( tree->flags & AF_RIGHT_IGNORE ); @@ -373,75 +373,75 @@ static void remRightIgnore( program_t *prg, tree_t **sp, tree_t *tree ) tree->flags &= ~AF_RIGHT_IGNORE; } -tree_t *popRightIgnore( program_t *prg, tree_t **sp, tree_t *popFrom, tree_t **rightIgnore ) +tree_t *pop_right_ignore( program_t *prg, tree_t **sp, tree_t *pop_from, tree_t **right_ignore ) { /* Modifying the tree we are detaching from. */ - popFrom = splitTree( prg, popFrom ); + pop_from = split_tree( prg, pop_from ); - kid_t *riKid = treeRightIgnoreKid( prg, popFrom ); + kid_t *ri_kid = tree_right_ignore_kid( prg, pop_from ); /* If the right ignore has a left ignore, then that was the original * right ignore. */ - kid_t *li = treeLeftIgnoreKid( prg, riKid->tree ); + kid_t *li = tree_left_ignore_kid( prg, ri_kid->tree ); if ( li != 0 ) { colm_tree_upref( li->tree ); - remLeftIgnore( prg, sp, riKid->tree ); - *rightIgnore = riKid->tree; - colm_tree_upref( *rightIgnore ); - riKid->tree = li->tree; + rem_left_ignore( prg, sp, ri_kid->tree ); + *right_ignore = ri_kid->tree; + colm_tree_upref( *right_ignore ); + ri_kid->tree = li->tree; } else { - *rightIgnore = riKid->tree; - colm_tree_upref( *rightIgnore ); - remRightIgnore( prg, sp, popFrom ); + *right_ignore = ri_kid->tree; + colm_tree_upref( *right_ignore ); + rem_right_ignore( prg, sp, pop_from ); } - return popFrom; + return pop_from; } -tree_t *popLeftIgnore( program_t *prg, tree_t **sp, tree_t *popFrom, tree_t **leftIgnore ) +tree_t *pop_left_ignore( program_t *prg, tree_t **sp, tree_t *pop_from, tree_t **left_ignore ) { /* Modifying, make the write safe. */ - popFrom = splitTree( prg, popFrom ); + pop_from = split_tree( prg, pop_from ); - kid_t *liKid = treeLeftIgnoreKid( prg, popFrom ); + kid_t *li_kid = tree_left_ignore_kid( prg, pop_from ); /* If the left ignore has a right ignore, then that was the original * left ignore. */ - kid_t *ri = treeRightIgnoreKid( prg, liKid->tree ); + kid_t *ri = tree_right_ignore_kid( prg, li_kid->tree ); if ( ri != 0 ) { colm_tree_upref( ri->tree ); - remRightIgnore( prg, sp, liKid->tree ); - *leftIgnore = liKid->tree; - colm_tree_upref( *leftIgnore ); - liKid->tree = ri->tree; + rem_right_ignore( prg, sp, li_kid->tree ); + *left_ignore = li_kid->tree; + colm_tree_upref( *left_ignore ); + li_kid->tree = ri->tree; } else { - *leftIgnore = liKid->tree; - colm_tree_upref( *leftIgnore ); - remLeftIgnore( prg, sp, popFrom ); + *left_ignore = li_kid->tree; + colm_tree_upref( *left_ignore ); + rem_left_ignore( prg, sp, pop_from ); } - return popFrom; + return pop_from; } -tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, long langElId ) +tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, long lang_el_id ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; tree_t *tree = 0; tree = tree_allocate( prg ); - tree->id = langElId; + tree->id = lang_el_id; tree->refs = 1; tree->tokdata = 0; tree->prod_num = 0; - int objectLength = lelInfo[tree->id].objectLength; + int object_length = lel_info[tree->id].object_length; - kid_t *attrs = allocAttrs( prg, objectLength ); + kid_t *attrs = alloc_attrs( prg, object_length ); kid_t *child = 0; - tree->child = kidListConcat( attrs, child ); + tree->child = kid_list_concat( attrs, child ); return tree; } @@ -450,36 +450,36 @@ tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, lo * return a zero-ref tree. */ tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long pat ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; + struct lang_el_info *lel_info = prg->rtd->lel_info; tree_t *tree = 0; - if ( nodes[pat].bindId > 0 ) { + if ( nodes[pat].bind_id > 0 ) { /* All bindings have been uprefed. */ - tree = bindings[nodes[pat].bindId]; + tree = bindings[nodes[pat].bind_id]; - long ignore = nodes[pat].leftIgnore; - tree_t *leftIgnore = 0; + long ignore = nodes[pat].left_ignore; + tree_t *left_ignore = 0; if ( ignore >= 0 ) { - kid_t *ignore = constructLeftIgnoreList( prg, pat ); + kid_t *ignore = construct_left_ignore_list( prg, pat ); - leftIgnore = tree_allocate( prg ); - leftIgnore->id = LEL_ID_IGNORE; - leftIgnore->child = ignore; + left_ignore = tree_allocate( prg ); + left_ignore->id = LEL_ID_IGNORE; + left_ignore->child = ignore; - tree = push_left_ignore( prg, tree, leftIgnore ); + tree = push_left_ignore( prg, tree, left_ignore ); } - ignore = nodes[pat].rightIgnore; - tree_t *rightIgnore = 0; + ignore = nodes[pat].right_ignore; + tree_t *right_ignore = 0; if ( ignore >= 0 ) { - kid_t *ignore = constructRightIgnoreList( prg, pat ); + kid_t *ignore = construct_right_ignore_list( prg, pat ); - rightIgnore = tree_allocate( prg ); - rightIgnore->id = LEL_ID_IGNORE; - rightIgnore->child = ignore; + right_ignore = tree_allocate( prg ); + right_ignore->id = LEL_ID_IGNORE; + right_ignore->child = ignore; - tree = push_right_ignore( prg, tree, rightIgnore ); + tree = push_right_ignore( prg, tree, right_ignore ); } } else { @@ -489,51 +489,51 @@ tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long tree->tokdata = nodes[pat].length == 0 ? 0 : colm_string_alloc_pointer( prg, nodes[pat].data, nodes[pat].length ); - tree->prod_num = nodes[pat].prodNum; + tree->prod_num = nodes[pat].prod_num; - int objectLength = lelInfo[tree->id].objectLength; + int object_length = lel_info[tree->id].object_length; - kid_t *attrs = allocAttrs( prg, objectLength ); - kid_t *child = constructKid( prg, bindings, + kid_t *attrs = alloc_attrs( prg, object_length ); + kid_t *child = construct_kid( prg, bindings, 0, nodes[pat].child ); - tree->child = kidListConcat( attrs, child ); + tree->child = kid_list_concat( attrs, child ); /* Right first, then left. */ - kid_t *ignore = constructRightIgnoreList( prg, pat ); + kid_t *ignore = construct_right_ignore_list( prg, pat ); if ( ignore != 0 ) { - tree_t *ignoreList = tree_allocate( prg ); - ignoreList->id = LEL_ID_IGNORE; - ignoreList->refs = 1; - ignoreList->child = ignore; + tree_t *ignore_list = tree_allocate( prg ); + ignore_list->id = LEL_ID_IGNORE; + ignore_list->refs = 1; + ignore_list->child = ignore; - kid_t *ignoreHead = kid_allocate( prg ); - ignoreHead->tree = ignoreList; - ignoreHead->next = tree->child; - tree->child = ignoreHead; + kid_t *ignore_head = kid_allocate( prg ); + ignore_head->tree = ignore_list; + ignore_head->next = tree->child; + tree->child = ignore_head; tree->flags |= AF_RIGHT_IGNORE; } - ignore = constructLeftIgnoreList( prg, pat ); + ignore = construct_left_ignore_list( prg, pat ); if ( ignore != 0 ) { - tree_t *ignoreList = tree_allocate( prg ); - ignoreList->id = LEL_ID_IGNORE; - ignoreList->refs = 1; - ignoreList->child = ignore; + tree_t *ignore_list = tree_allocate( prg ); + ignore_list->id = LEL_ID_IGNORE; + ignore_list->refs = 1; + ignore_list->child = ignore; - kid_t *ignoreHead = kid_allocate( prg ); - ignoreHead->tree = ignoreList; - ignoreHead->next = tree->child; - tree->child = ignoreHead; + kid_t *ignore_head = kid_allocate( prg ); + ignore_head->tree = ignore_list; + ignore_head->next = tree->child; + tree->child = ignore_head; tree->flags |= AF_LEFT_IGNORE; } int i; - for ( i = 0; i < lelInfo[tree->id].numCaptureAttr; i++ ) { + for ( i = 0; i < lel_info[tree->id].num_capture_attr; i++ ) { long ci = pat+1+i; - CaptureAttr *ca = prg->rtd->captureAttr + lelInfo[tree->id].captureAttr + i; + CaptureAttr *ca = prg->rtd->capture_attr + lel_info[tree->id].capture_attr + i; tree_t *attr = tree_allocate( prg ); attr->id = nodes[ci].id; attr->refs = 1; @@ -548,9 +548,9 @@ tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long return tree; } -kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ) +kid_t *construct_kid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; kid_t *kid = 0; if ( pat != -1 ) { @@ -558,7 +558,7 @@ kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ) kid->tree = colm_construct_tree( prg, kid, bindings, pat ); /* Recurse down next. */ - kid_t *next = constructKid( prg, bindings, + kid_t *next = construct_kid( prg, bindings, kid, nodes[pat].next ); kid->next = next; @@ -569,26 +569,26 @@ kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat ) tree_t *colm_construct_token( program_t *prg, tree_t **args, long nargs ) { - value_t idInt = (value_t)args[0]; - str_t *textStr = (str_t*)args[1]; + value_t id_int = (value_t)args[0]; + str_t *text_str = (str_t*)args[1]; - long id = (long)idInt; - head_t *tokdata = stringCopy( prg, textStr->value ); + long id = (long)id_int; + head_t *tokdata = string_copy( prg, text_str->value ); - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; tree_t *tree; - if ( lelInfo[id].ignore ) { + if ( lel_info[id].ignore ) { tree = tree_allocate( prg ); tree->refs = 1; tree->id = id; tree->tokdata = tokdata; } else { - long objectLength = lelInfo[id].objectLength; - assert( nargs-2 <= objectLength ); + long object_length = lel_info[id].object_length; + assert( nargs-2 <= object_length ); - kid_t *attrs = allocAttrs( prg, objectLength ); + kid_t *attrs = alloc_attrs( prg, object_length ); tree = tree_allocate( prg ); tree->id = id; @@ -606,25 +606,25 @@ tree_t *colm_construct_token( program_t *prg, tree_t **args, long nargs ) return tree; } -tree_t *castTree( program_t *prg, int langElId, tree_t *tree ) +tree_t *cast_tree( program_t *prg, int lang_el_id, tree_t *tree ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; /* Need to keep a lookout for next down. If * copying it, return the copy. */ - tree_t *newTree = tree_allocate( prg ); + tree_t *new_tree = tree_allocate( prg ); - newTree->id = langElId; - newTree->tokdata = stringCopy( prg, tree->tokdata ); + new_tree->id = lang_el_id; + new_tree->tokdata = string_copy( prg, tree->tokdata ); /* Invalidate the production number. */ - newTree->prod_num = -1; + new_tree->prod_num = -1; /* Copy the child list. Start with ignores, then the list. */ kid_t *child = tree->child, *last = 0; /* Flags we are interested in. */ - newTree->flags |= tree->flags & ( AF_LEFT_IGNORE | AF_RIGHT_IGNORE ); + new_tree->flags |= tree->flags & ( AF_LEFT_IGNORE | AF_RIGHT_IGNORE ); int ignores = 0; if ( tree->flags & AF_LEFT_IGNORE ) @@ -634,78 +634,78 @@ tree_t *castTree( program_t *prg, int langElId, tree_t *tree ) /* Igores. */ while ( ignores-- > 0 ) { - kid_t *newKid = kid_allocate( prg ); + kid_t *new_kid = kid_allocate( prg ); - newKid->tree = child->tree; - newKid->next = 0; - newKid->tree->refs += 1; + new_kid->tree = child->tree; + new_kid->next = 0; + new_kid->tree->refs += 1; /* Store the first child. */ if ( last == 0 ) - newTree->child = newKid; + new_tree->child = new_kid; else - last->next = newKid; + last->next = new_kid; child = child->next; - last = newKid; + last = new_kid; } /* Skip over the source's attributes. */ - int objectLength = lelInfo[tree->id].objectLength; - while ( objectLength-- > 0 ) + int object_length = lel_info[tree->id].object_length; + while ( object_length-- > 0 ) child = child->next; /* Allocate the target type's kids. */ - objectLength = lelInfo[langElId].objectLength; - while ( objectLength-- > 0 ) { - kid_t *newKid = kid_allocate( prg ); + object_length = lel_info[lang_el_id].object_length; + while ( object_length-- > 0 ) { + kid_t *new_kid = kid_allocate( prg ); - newKid->tree = 0; - newKid->next = 0; + new_kid->tree = 0; + new_kid->next = 0; /* Store the first child. */ if ( last == 0 ) - newTree->child = newKid; + new_tree->child = new_kid; else - last->next = newKid; + last->next = new_kid; - last = newKid; + last = new_kid; } /* Copy the source's children. */ while ( child != 0 ) { - kid_t *newKid = kid_allocate( prg ); + kid_t *new_kid = kid_allocate( prg ); - newKid->tree = child->tree; - newKid->next = 0; - newKid->tree->refs += 1; + new_kid->tree = child->tree; + new_kid->next = 0; + new_kid->tree->refs += 1; /* Store the first child. */ if ( last == 0 ) - newTree->child = newKid; + new_tree->child = new_kid; else - last->next = newKid; + last->next = new_kid; child = child->next; - last = newKid; + last = new_kid; } - return newTree; + return new_tree; } -tree_t *makeTree( program_t *prg, tree_t **args, long nargs ) +tree_t *make_tree( program_t *prg, tree_t **args, long nargs ) { - value_t idInt = (value_t)args[0]; + value_t id_int = (value_t)args[0]; - long id = (long)idInt; - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + long id = (long)id_int; + struct lang_el_info *lel_info = prg->rtd->lel_info; tree_t *tree = tree_allocate( prg ); tree->id = id; tree->refs = 1; - long objectLength = lelInfo[id].objectLength; - kid_t *attrs = allocAttrs( prg, objectLength ); + long object_length = lel_info[id].object_length; + kid_t *attrs = alloc_attrs( prg, object_length ); kid_t *last = 0, *child = 0; for ( id = 1; id < nargs; id++ ) { @@ -721,81 +721,81 @@ tree_t *makeTree( program_t *prg, tree_t **args, long nargs ) last = kid; } - tree->child = kidListConcat( attrs, child ); + tree->child = kid_list_concat( attrs, child ); return tree; } -int testFalse( program_t *prg, tree_t *tree ) +int test_false( program_t *prg, tree_t *tree ) { int flse = ( tree == 0 || - tree == prg->falseVal + tree == prg->false_val ); return flse; } -kid_t *copyIgnoreList( program_t *prg, kid_t *ignoreHeader ) +kid_t *copy_ignore_list( program_t *prg, kid_t *ignore_header ) { - kid_t *newHeader = kid_allocate( prg ); - kid_t *last = 0, *ic = (kid_t*)ignoreHeader->tree; + kid_t *new_header = kid_allocate( prg ); + kid_t *last = 0, *ic = (kid_t*)ignore_header->tree; while ( ic != 0 ) { - kid_t *newIc = kid_allocate( prg ); + kid_t *new_ic = kid_allocate( prg ); - newIc->tree = ic->tree; - newIc->tree->refs += 1; + new_ic->tree = ic->tree; + new_ic->tree->refs += 1; /* List pointers. */ if ( last == 0 ) - newHeader->tree = (tree_t*)newIc; + new_header->tree = (tree_t*)new_ic; else - last->next = newIc; + last->next = new_ic; ic = ic->next; - last = newIc; + last = new_ic; } - return newHeader; + return new_header; } -kid_t *copyKidList( program_t *prg, kid_t *kidList ) +kid_t *copy_kid_list( program_t *prg, kid_t *kid_list ) { - kid_t *newList = 0, *last = 0, *ic = kidList; + kid_t *new_list = 0, *last = 0, *ic = kid_list; while ( ic != 0 ) { - kid_t *newIc = kid_allocate( prg ); + kid_t *new_ic = kid_allocate( prg ); - newIc->tree = ic->tree; - colm_tree_upref( newIc->tree ); + new_ic->tree = ic->tree; + colm_tree_upref( new_ic->tree ); /* List pointers. */ if ( last == 0 ) - newList = newIc; + new_list = new_ic; else - last->next = newIc; + last->next = new_ic; ic = ic->next; - last = newIc; + last = new_ic; } - return newList; + return new_list; } /* New tree has zero ref. */ -tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **newNextDown ) +tree_t *copy_real_tree( program_t *prg, tree_t *tree, kid_t *old_next_down, kid_t **new_next_down ) { /* Need to keep a lookout for next down. If * copying it, return the copy. */ - tree_t *newTree = tree_allocate( prg ); + tree_t *new_tree = tree_allocate( prg ); - newTree->id = tree->id; - newTree->tokdata = stringCopy( prg, tree->tokdata ); - newTree->prod_num = tree->prod_num; + new_tree->id = tree->id; + new_tree->tokdata = string_copy( prg, tree->tokdata ); + new_tree->prod_num = tree->prod_num; /* Copy the child list. Start with ignores, then the list. */ kid_t *child = tree->child, *last = 0; /* Left ignores. */ if ( tree->flags & AF_LEFT_IGNORE ) { - newTree->flags |= AF_LEFT_IGNORE; + new_tree->flags |= AF_LEFT_IGNORE; // kid_t *newHeader = copyIgnoreList( prg, child ); // // /* Always the head. */ @@ -807,7 +807,7 @@ tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t ** /* Right ignores. */ if ( tree->flags & AF_RIGHT_IGNORE ) { - newTree->flags |= AF_RIGHT_IGNORE; + new_tree->flags |= AF_RIGHT_IGNORE; // kid_t *newHeader = copyIgnoreList( prg, child ); // if ( last == 0 ) // newTree->child = newHeader; @@ -819,34 +819,34 @@ tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t ** /* Attributes and children. */ while ( child != 0 ) { - kid_t *newKid = kid_allocate( prg ); + kid_t *new_kid = kid_allocate( prg ); /* Watch out for next down. */ - if ( child == oldNextDown ) - *newNextDown = newKid; + if ( child == old_next_down ) + *new_next_down = new_kid; - newKid->tree = child->tree; - newKid->next = 0; + new_kid->tree = child->tree; + new_kid->next = 0; /* May be an attribute. */ - if ( newKid->tree != 0 ) - newKid->tree->refs += 1; + if ( new_kid->tree != 0 ) + new_kid->tree->refs += 1; /* Store the first child. */ if ( last == 0 ) - newTree->child = newKid; + new_tree->child = new_kid; else - last->next = newKid; + last->next = new_kid; child = child->next; - last = newKid; + last = new_kid; } - return newTree; + return new_tree; } -tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **newNextDown ) +tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *old_next_down, kid_t **new_next_down ) { // struct lang_el_info *lelInfo = prg->rtd->lelInfo; // long genericId = lelInfo[tree->id].genericId; @@ -863,28 +863,28 @@ tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t // else if ( tree->id == LEL_ID_STREAM ) // assert(false); else { - tree = copyRealTree( prg, tree, oldNextDown, newNextDown ); + tree = copy_real_tree( prg, tree, old_next_down, new_next_down ); } assert( tree->refs == 0 ); return tree; } -tree_t *splitTree( program_t *prg, tree_t *tree ) +tree_t *split_tree( program_t *prg, tree_t *tree ) { if ( tree != 0 ) { assert( tree->refs >= 1 ); if ( tree->refs > 1 ) { - kid_t *oldNextDown = 0, *newNextDown = 0; - tree_t *newTree = colm_copy_tree( prg, tree, oldNextDown, &newNextDown ); - colm_tree_upref( newTree ); + kid_t *old_next_down = 0, *new_next_down = 0; + tree_t *new_tree = colm_copy_tree( prg, tree, old_next_down, &new_next_down ); + colm_tree_upref( new_tree ); /* Downref the original. Don't need to consider freeing because * refs were > 1. */ tree->refs -= 1; - tree = newTree; + tree = new_tree; } assert( tree->refs == 1 ); @@ -894,7 +894,7 @@ tree_t *splitTree( program_t *prg, tree_t *tree ) /* We can't make recursive calls here since the tree we are freeing may be * very large. Need the VM stack. */ -void treeFreeRec( program_t *prg, tree_t **sp, tree_t *tree ) +void tree_free_rec( program_t *prg, tree_t **sp, tree_t *tree ) { tree_t **top = vm_ptop(); // struct lang_el_info *lelInfo; @@ -913,13 +913,13 @@ free_tree: break; case LEL_ID_STR: { str_t *str = (str_t*) tree; - stringFree( prg, str->value ); + string_free( prg, str->value ); tree_free( prg, tree ); break; } default: { if ( tree->id != LEL_ID_IGNORE ) - stringFree( prg, tree->tokdata ); + string_free( prg, tree->tokdata ); /* Attributes and grammar-based children. */ kid_t *child = tree->child; @@ -958,13 +958,13 @@ void colm_tree_downref( program_t *prg, tree_t **sp, tree_t *tree ) assert( tree->refs > 0 ); tree->refs -= 1; if ( tree->refs == 0 ) - treeFreeRec( prg, sp, tree ); + tree_free_rec( prg, sp, tree ); } } /* We can't make recursive calls here since the tree we are freeing may be * very large. Need the VM stack. */ -void objectFreeRec( program_t *prg, tree_t **sp, tree_t *tree ) +void object_free_rec( program_t *prg, tree_t **sp, tree_t *tree ) { tree_t **top = vm_ptop(); // struct lang_el_info *lelInfo; @@ -976,7 +976,7 @@ free_tree: switch ( tree->id ) { case LEL_ID_STR: { str_t *str = (str_t*) tree; - stringFree( prg, str->value ); + string_free( prg, str->value ); tree_free( prg, tree ); break; } @@ -993,7 +993,7 @@ free_tree: // } default: { if ( tree->id != LEL_ID_IGNORE ) - stringFree( prg, tree->tokdata ); + string_free( prg, tree->tokdata ); /* Attributes and grammar-based children. */ kid_t *child = tree->child; @@ -1020,20 +1020,20 @@ free_tree: } } -void objectDownref( program_t *prg, tree_t **sp, tree_t *tree ) +void object_downref( program_t *prg, tree_t **sp, tree_t *tree ) { if ( tree != 0 ) { assert( tree->refs > 0 ); tree->refs -= 1; if ( tree->refs == 0 ) - objectFreeRec( prg, sp, tree ); + object_free_rec( prg, sp, tree ); } } /* Find the first child of a tree. */ -kid_t *treeChild( program_t *prg, const tree_t *tree ) +kid_t *tree_child( program_t *prg, const tree_t *tree ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; kid_t *kid = tree->child; if ( tree->flags & AF_LEFT_IGNORE ) @@ -1042,18 +1042,18 @@ kid_t *treeChild( program_t *prg, const tree_t *tree ) kid = kid->next; /* Skip over attributes. */ - long objectLength = lelInfo[tree->id].objectLength; + long object_length = lel_info[tree->id].object_length; long a; - for ( a = 0; a < objectLength; a++ ) + for ( a = 0; a < object_length; a++ ) kid = kid->next; return kid; } /* Detach at the first real child of a tree. */ -kid_t *treeExtractChild( program_t *prg, tree_t *tree ) +kid_t *tree_extract_child( program_t *prg, tree_t *tree ) { - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; kid_t *kid = tree->child, *last = 0; if ( tree->flags & AF_LEFT_IGNORE ) @@ -1062,8 +1062,8 @@ kid_t *treeExtractChild( program_t *prg, tree_t *tree ) kid = kid->next; /* Skip over attributes. */ - long a, objectLength = lelInfo[tree->id].objectLength; - for ( a = 0; a < objectLength; a++ ) { + long a, object_length = lel_info[tree->id].object_length; + for ( a = 0; a < object_length; a++ ) { last = kid; kid = kid->next; } @@ -1078,7 +1078,7 @@ kid_t *treeExtractChild( program_t *prg, tree_t *tree ) /* Find the first child of a tree. */ -kid_t *treeAttr( program_t *prg, const tree_t *tree ) +kid_t *tree_attr( program_t *prg, const tree_t *tree ) { kid_t *kid = tree->child; @@ -1090,14 +1090,14 @@ kid_t *treeAttr( program_t *prg, const tree_t *tree ) return kid; } -tree_t *treeLeftIgnore( program_t *prg, tree_t *tree ) +tree_t *tree_left_ignore( program_t *prg, tree_t *tree ) { if ( tree->flags & AF_LEFT_IGNORE ) return tree->child->tree; return 0; } -tree_t *treeRightIgnore( program_t *prg, tree_t *tree ) +tree_t *tree_right_ignore( program_t *prg, tree_t *tree ) { if ( tree->flags & AF_RIGHT_IGNORE ) { if ( tree->flags & AF_LEFT_IGNORE ) @@ -1108,14 +1108,14 @@ tree_t *treeRightIgnore( program_t *prg, tree_t *tree ) return 0; } -kid_t *treeLeftIgnoreKid( program_t *prg, tree_t *tree ) +kid_t *tree_left_ignore_kid( program_t *prg, tree_t *tree ) { if ( tree->flags & AF_LEFT_IGNORE ) return tree->child; return 0; } -kid_t *treeRightIgnoreKid( program_t *prg, tree_t *tree ) +kid_t *tree_right_ignore_kid( program_t *prg, tree_t *tree ) { if ( tree->flags & AF_RIGHT_IGNORE ) { if ( tree->flags & AF_LEFT_IGNORE ) @@ -1126,15 +1126,15 @@ kid_t *treeRightIgnoreKid( program_t *prg, tree_t *tree ) return 0; } -void refSetValue( program_t *prg, tree_t **sp, ref_t *ref, tree_t *v ) +void ref_set_value( program_t *prg, tree_t **sp, ref_t *ref, tree_t *v ) { colm_tree_downref( prg, sp, ref->kid->tree ); ref->kid->tree = v; } -tree_t *getRhsEl( program_t *prg, tree_t *lhs, long position ) +tree_t *get_rhs_el( program_t *prg, tree_t *lhs, long position ) { - kid_t *pos = treeChild( prg, lhs ); + kid_t *pos = tree_child( prg, lhs ); while ( position > 0 ) { pos = pos->next; position -= 1; @@ -1142,9 +1142,9 @@ tree_t *getRhsEl( program_t *prg, tree_t *lhs, long position ) return pos->tree; } -kid_t *getRhsElKid( program_t *prg, tree_t *lhs, long position ) +kid_t *get_rhs_el_kid( program_t *prg, tree_t *lhs, long position ) { - kid_t *pos = treeChild( prg, lhs ); + kid_t *pos = tree_child( prg, lhs ); while ( position > 0 ) { pos = pos->next; position -= 1; @@ -1158,9 +1158,9 @@ tree_t *colm_get_rhs_val( program_t *prg, tree_t *tree, int *a ) int i, len = a[0]; for ( i = 0; i < len; i++ ) { int prod_num = a[1 + i * 2]; - int childNum = a[1 + i * 2 + 1]; + int child_num = a[1 + i * 2 + 1]; if ( tree->prod_num == prod_num ) - return getRhsEl( prg, tree, childNum ); + return get_rhs_el( prg, tree, child_num ); } return 0; } @@ -1178,24 +1178,24 @@ tree_t *colm_tree_get_field( tree_t *tree, word_t field ) return colm_get_attr( tree, field ); } -kid_t *getFieldKid( tree_t *tree, word_t field ) +kid_t *get_field_kid( tree_t *tree, word_t field ) { - return getAttrKid( tree, field ); + return get_attr_kid( tree, field ); } -tree_t *getFieldSplit( program_t *prg, tree_t *tree, word_t field ) +tree_t *get_field_split( program_t *prg, tree_t *tree, word_t field ) { tree_t *val = colm_get_attr( tree, field ); - tree_t *split = splitTree( prg, val ); + tree_t *split = split_tree( prg, val ); colm_tree_set_attr( tree, field, split ); return split; } /* This must traverse in the same order that the bindId assignments are done * in. */ -int matchPattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int checkNext ) +int match_pattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int check_next ) { - struct pat_cons_node *nodes = prg->rtd->patReplNodes; + struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes; /* match node, recurse on children. */ if ( pat != -1 && kid != 0 ) { @@ -1204,35 +1204,35 @@ int matchPattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int c * the data against the token data. */ if ( nodes[pat].data != 0 ) { /* Check the length of token text. */ - if ( nodes[pat].length != stringLength( kid->tree->tokdata ) ) + if ( nodes[pat].length != string_length( kid->tree->tokdata ) ) return false; /* Check the token text data. */ if ( nodes[pat].length > 0 && memcmp( nodes[pat].data, - stringData( kid->tree->tokdata ), nodes[pat].length ) != 0 ) + string_data( kid->tree->tokdata ), nodes[pat].length ) != 0 ) return false; } /* No failure, all okay. */ - if ( nodes[pat].bindId > 0 ) { - bindings[nodes[pat].bindId] = kid->tree; + if ( nodes[pat].bind_id > 0 ) { + bindings[nodes[pat].bind_id] = kid->tree; } /* If we didn't match a terminal duplicate of a nonterm then check * down the children. */ if ( !nodes[pat].stop ) { /* Check for failure down child branch. */ - int childCheck = matchPattern( bindings, prg, - nodes[pat].child, treeChild( prg, kid->tree ), true ); - if ( ! childCheck ) + int child_check = match_pattern( bindings, prg, + nodes[pat].child, tree_child( prg, kid->tree ), true ); + if ( ! child_check ) return false; } /* If checking next, then look for failure there. */ - if ( checkNext ) { - int nextCheck = matchPattern( bindings, prg, + if ( check_next ) { + int next_check = match_pattern( bindings, prg, nodes[pat].next, kid->next, true ); - if ( ! nextCheck ) + if ( ! next_check ) return false; } @@ -1270,7 +1270,7 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 ) return 1; } else if ( tree1->id == LEL_ID_STR ) { - cmpres = cmpString( ((str_t*)tree1)->value, ((str_t*)tree2)->value ); + cmpres = cmp_string( ((str_t*)tree1)->value, ((str_t*)tree2)->value ); if ( cmpres != 0 ) return cmpres; } @@ -1280,14 +1280,14 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 ) else if ( tree1->tokdata != 0 && tree2->tokdata == 0 ) return 1; else if ( tree1->tokdata != 0 && tree2->tokdata != 0 ) { - cmpres = cmpString( tree1->tokdata, tree2->tokdata ); + cmpres = cmp_string( tree1->tokdata, tree2->tokdata ); if ( cmpres != 0 ) return cmpres; } } - kid_t *kid1 = treeChild( prg, tree1 ); - kid_t *kid2 = treeChild( prg, tree2 ); + kid_t *kid1 = tree_child( prg, tree1 ); + kid_t *kid2 = tree_child( prg, tree2 ); while ( true ) { if ( kid1 == 0 && kid2 == 0 ) @@ -1307,10 +1307,10 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 ) } -void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef ) +void split_ref( program_t *prg, tree_t ***psp, ref_t *from_ref ) { /* Go up the chain of kids, turing the pointers down. */ - ref_t *last = 0, *ref = fromRef, *next = 0; + ref_t *last = 0, *ref = from_ref, *next = 0; while ( ref->next != 0 ) { next = ref->next; ref->next = last; @@ -1322,33 +1322,33 @@ void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef ) /* Now traverse the list, which goes down. */ while ( ref != 0 ) { if ( ref->kid->tree->refs > 1 ) { - ref_t *nextDown = ref->next; - while ( nextDown != 0 && nextDown->kid == ref->kid ) - nextDown = nextDown->next; + ref_t *next_down = ref->next; + while ( next_down != 0 && next_down->kid == ref->kid ) + next_down = next_down->next; - kid_t *oldNextKidDown = nextDown != 0 ? nextDown->kid : 0; - kid_t *newNextKidDown = 0; + kid_t *old_next_kid_down = next_down != 0 ? next_down->kid : 0; + kid_t *new_next_kid_down = 0; - tree_t *newTree = colm_copy_tree( prg, ref->kid->tree, - oldNextKidDown, &newNextKidDown ); - colm_tree_upref( newTree ); + tree_t *new_tree = colm_copy_tree( prg, ref->kid->tree, + old_next_kid_down, &new_next_kid_down ); + colm_tree_upref( new_tree ); /* Downref the original. Don't need to consider freeing because * refs were > 1. */ ref->kid->tree->refs -= 1; - while ( ref != 0 && ref != nextDown ) { + while ( ref != 0 && ref != next_down ) { next = ref->next; ref->next = 0; - ref->kid->tree = newTree; + ref->kid->tree = new_tree; ref = next; } /* Correct kid pointers down from ref. */ - while ( nextDown != 0 && nextDown->kid == oldNextKidDown ) { - nextDown->kid = newNextKidDown; - nextDown = nextDown->next; + while ( next_down != 0 && next_down->kid == old_next_kid_down ) { + next_down->kid = new_next_kid_down; + next_down = next_down->next; } } else { @@ -1360,7 +1360,7 @@ void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef ) } } -tree_t *setListMem( list_t *list, half_t field, tree_t *value ) +tree_t *set_list_mem( list_t *list, half_t field, tree_t *value ) { if ( value != 0 ) assert( value->refs >= 1 ); @@ -1382,13 +1382,13 @@ tree_t *setListMem( list_t *list, half_t field, tree_t *value ) return existing; } -struct tree_pair mapRemove( program_t *prg, map_t *map, tree_t *key ) +struct tree_pair map_remove( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *mapEl = mapImplFind( prg, map, key ); + map_el_t *map_el = map_impl_find( prg, map, key ); struct tree_pair result = { 0, 0 }; - if ( mapEl != 0 ) { - mapDetach( prg, map, mapEl ); - result.key = mapEl->key; + if ( map_el != 0 ) { + map_detach( prg, map, map_el ); + result.key = map_el->key; //mapElFree( prg, mapEl ); } @@ -1396,16 +1396,16 @@ struct tree_pair mapRemove( program_t *prg, map_t *map, tree_t *key ) } #if 0 -tree_t *mapUnstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing ) +tree_t *map_unstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing ) { tree_t *stored = 0; if ( existing == 0 ) { - map_el_t *mapEl = mapDetachByKey( prg, map, key ); + map_el_t *map_el = map_detach_by_key( prg, map, key ); // stored = mapEl->tree; - mapElFree( prg, mapEl ); + map_el_free( prg, map_el ); } else { - map_el_t *mapEl = mapImplFind( prg, map, key ); + map_el_t *map_el = map_impl_find( prg, map, key ); // stored = mapEl->tree; //mapEl->tree = existing; } @@ -1413,19 +1413,19 @@ tree_t *mapUnstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing ) } #endif -tree_t *mapFind( program_t *prg, map_t *map, tree_t *key ) +tree_t *map_find( program_t *prg, map_t *map, tree_t *key ) { // map_el_t *mapEl = mapImplFind( prg, map, key ); // return mapEl == 0 ? 0 : mapEl->tree; return 0; } -long mapLength( map_t *map ) +long map_length( map_t *map ) { - return map->treeSize; + return map->tree_size; } -void listPushTail( program_t *prg, list_t *list, tree_t *val ) +void list_push_tail( program_t *prg, list_t *list, tree_t *val ) { // if ( val != 0 ) // assert( val->refs >= 1 ); @@ -1434,7 +1434,7 @@ void listPushTail( program_t *prg, list_t *list, tree_t *val ) // listAppend( list, listEl ); } -void listPushHead( program_t *prg, list_t *list, tree_t *val ) +void list_push_head( program_t *prg, list_t *list, tree_t *val ) { // if ( val != 0 ) // assert( val->refs >= 1 ); @@ -1443,7 +1443,7 @@ void listPushHead( program_t *prg, list_t *list, tree_t *val ) // listPrepend( list, listEl ); } -tree_t *listRemoveEnd( program_t *prg, list_t *list ) +tree_t *list_remove_end( program_t *prg, list_t *list ) { // tree_t *tree = list->tail->value; // listElFree( prg, listDetachLast( list ) ); @@ -1451,7 +1451,7 @@ tree_t *listRemoveEnd( program_t *prg, list_t *list ) return 0; } -tree_t *listRemoveHead( program_t *prg, list_t *list ) +tree_t *list_remove_head( program_t *prg, list_t *list ) { // tree_t *tree = list->head; // listDetachFirst( list ); @@ -1459,7 +1459,7 @@ tree_t *listRemoveHead( program_t *prg, list_t *list ) return 0; } -tree_t *getParserMem( parser_t *parser, word_t field ) +tree_t *get_parser_mem( parser_t *parser, word_t field ) { tree_t *result = 0; switch ( field ) { @@ -1468,8 +1468,8 @@ tree_t *getParserMem( parser_t *parser, word_t field ) break; } case 1: { - struct pda_run *pdaRun = parser->pdaRun; - result = pdaRun->parseErrorText; + struct pda_run *pda_run = parser->pda_run; + result = pda_run->parse_error_text; break; } default: { @@ -1480,7 +1480,7 @@ tree_t *getParserMem( parser_t *parser, word_t field ) return result; } -tree_t *getListMemSplit( program_t *prg, list_t *list, word_t field ) +tree_t *get_list_mem_split( program_t *prg, list_t *list, word_t field ) { tree_t *sv = 0; switch ( field ) { @@ -1501,11 +1501,11 @@ tree_t *getListMemSplit( program_t *prg, list_t *list, word_t field ) #if 0 -int mapInsert( program_t *prg, map_t *map, tree_t *key, tree_t *element ) +int map_insert( program_t *prg, map_t *map, tree_t *key, tree_t *element ) { - map_el_t *mapEl = mapInsertKey( prg, map, key, 0 ); + map_el_t *map_el = map_insert_key( prg, map, key, 0 ); - if ( mapEl != 0 ) { + if ( map_el != 0 ) { //mapEl->tree = element; return true; } @@ -1515,31 +1515,31 @@ int mapInsert( program_t *prg, map_t *map, tree_t *key, tree_t *element ) #endif #if 0 -void mapUnremove( program_t *prg, map_t *map, tree_t *key, tree_t *element ) +void map_unremove( program_t *prg, map_t *map, tree_t *key, tree_t *element ) { - map_el_t *mapEl = mapInsertKey( prg, map, key, 0 ); - assert( mapEl != 0 ); + map_el_t *map_el = map_insert_key( prg, map, key, 0 ); + assert( map_el != 0 ); //mapEl->tree = element; } #endif #if 0 -tree_t *mapUninsert( program_t *prg, map_t *map, tree_t *key ) +tree_t *map_uninsert( program_t *prg, map_t *map, tree_t *key ) { - map_el_t *el = mapDetachByKey( prg, map, key ); + map_el_t *el = map_detach_by_key( prg, map, key ); // tree_t *val = el->tree; - mapElFree( prg, el ); + map_el_free( prg, el ); // return val; return 0; } #endif #if 0 -tree_t *mapStore( program_t *prg, map_t *map, tree_t *key, tree_t *element ) +tree_t *map_store( program_t *prg, map_t *map, tree_t *key, tree_t *element ) { - tree_t *oldTree = 0; - map_el_t *elInTree = 0; - map_el_t *mapEl = mapInsertKey( prg, map, key, &elInTree ); + tree_t *old_tree = 0; + map_el_t *el_in_tree = 0; + map_el_t *map_el = map_insert_key( prg, map, key, &el_in_tree ); // if ( mapEl != 0 ) // mapEl->tree = element; @@ -1549,11 +1549,11 @@ tree_t *mapStore( program_t *prg, map_t *map, tree_t *key, tree_t *element ) // elInTree->tree = element; // } - return oldTree; + return old_tree; } #endif -static tree_t *treeSearchKid( program_t *prg, kid_t *kid, long id ) +static tree_t *tree_search_kid( program_t *prg, kid_t *kid, long id ) { /* This node the one? */ if ( kid->tree->id == id ) @@ -1562,31 +1562,31 @@ static tree_t *treeSearchKid( program_t *prg, kid_t *kid, long id ) tree_t *res = 0; /* Search children. */ - kid_t *child = treeChild( prg, kid->tree ); + kid_t *child = tree_child( prg, kid->tree ); if ( child != 0 ) - res = treeSearchKid( prg, child, id ); + res = tree_search_kid( prg, child, id ); /* Search siblings. */ if ( res == 0 && kid->next != 0 ) - res = treeSearchKid( prg, kid->next, id ); + res = tree_search_kid( prg, kid->next, id ); return res; } -tree_t *treeSearch( program_t *prg, tree_t *tree, long id ) +tree_t *tree_search( program_t *prg, tree_t *tree, long id ) { tree_t *res = 0; if ( tree->id == id ) res = tree; else { - kid_t *child = treeChild( prg, tree ); + kid_t *child = tree_child( prg, tree ); if ( child != 0 ) - res = treeSearchKid( prg, child, id ); + res = tree_search_kid( prg, child, id ); } return res; } -static location_t *locSearchKid( program_t *prg, kid_t *kid ) +static location_t *loc_search_kid( program_t *prg, kid_t *kid ) { /* This node the one? */ if ( kid->tree->tokdata != 0 && kid->tree->tokdata->location != 0 ) @@ -1595,108 +1595,108 @@ static location_t *locSearchKid( program_t *prg, kid_t *kid ) location_t *res = 0; /* Search children. */ - kid_t *child = treeChild( prg, kid->tree ); + kid_t *child = tree_child( prg, kid->tree ); if ( child != 0 ) - res = locSearchKid( prg, child ); + res = loc_search_kid( prg, child ); /* Search siblings. */ if ( res == 0 && kid->next != 0 ) - res = locSearchKid( prg, kid->next ); + res = loc_search_kid( prg, kid->next ); return res; } -location_t *locSearch( program_t *prg, tree_t *tree ) +location_t *loc_search( program_t *prg, tree_t *tree ) { location_t *res = 0; if ( tree->tokdata != 0 && tree->tokdata->location != 0 ) return tree->tokdata->location; - kid_t *child = treeChild( prg, tree ); + kid_t *child = tree_child( prg, tree ); if ( child != 0 ) - res = locSearchKid( prg, child ); + res = loc_search_kid( prg, child ); return res; } struct colm_location *colm_find_location( program_t *prg, tree_t *tree ) { - return locSearch( prg, tree ); + return loc_search( prg, tree ); } /* * tree_t Printing */ -void xmlEscapeData( struct colm_print_args *printArgs, const char *data, long len ) +void xml_escape_data( struct colm_print_args *print_args, const char *data, long len ) { int i; for ( i = 0; i < len; i++ ) { if ( data[i] == '<' ) - printArgs->out( printArgs, "<", 4 ); + print_args->out( print_args, "<", 4 ); else if ( data[i] == '>' ) - printArgs->out( printArgs, ">", 4 ); + print_args->out( print_args, ">", 4 ); else if ( data[i] == '&' ) - printArgs->out( printArgs, "&", 5 ); + print_args->out( print_args, "&", 5 ); else if ( (32 <= data[i] && data[i] <= 126) || data[i] == '\t' || data[i] == '\n' || data[i] == '\r' ) { - printArgs->out( printArgs, &data[i], 1 ); + print_args->out( print_args, &data[i], 1 ); } else { char out[64]; sprintf( out, "&#%u;", ((unsigned)data[i]) ); - printArgs->out( printArgs, out, strlen(out) ); + print_args->out( print_args, out, strlen(out) ); } } } -void initStrCollect( StrCollect *collect ) +void init_str_collect( StrCollect *collect ) { collect->data = (char*) malloc( BUFFER_INITIAL_SIZE ); collect->allocated = BUFFER_INITIAL_SIZE; collect->length = 0; } -void strCollectDestroy( StrCollect *collect ) +void str_collect_destroy( StrCollect *collect ) { free( collect->data ); } -void strCollectAppend( StrCollect *collect, const char *data, long len ) +void str_collect_append( StrCollect *collect, const char *data, long len ) { - long newLen = collect->length + len; - if ( newLen > collect->allocated ) { - collect->allocated = newLen * 2; + long new_len = collect->length + len; + if ( new_len > collect->allocated ) { + collect->allocated = new_len * 2; collect->data = (char*) realloc( collect->data, collect->allocated ); } memcpy( collect->data + collect->length, data, len ); collect->length += len; } -void strCollectClear( StrCollect *collect ) +void str_collect_clear( StrCollect *collect ) { collect->length = 0; } #define INT_SZ 32 -void printStr( struct colm_print_args *printArgs, head_t *str ) +void print_str( struct colm_print_args *print_args, head_t *str ) { - printArgs->out( printArgs, (char*)(str->data), str->length ); + print_args->out( print_args, (char*)(str->data), str->length ); } -void appendCollect( struct colm_print_args *args, const char *data, int length ) +void append_collect( struct colm_print_args *args, const char *data, int length ) { - strCollectAppend( (StrCollect*) args->arg, data, length ); + str_collect_append( (StrCollect*) args->arg, data, length ); } -void appendFile( struct colm_print_args *args, const char *data, int length ) +void append_file( struct colm_print_args *args, const char *data, int length ) { fwrite( data, 1, length, (FILE*)args->arg ); } -void appendFd( struct colm_print_args *args, const char *data, int length ) +void append_fd( struct colm_print_args *args, const char *data, int length ) { int fd = (long)args->arg; int res = write( fd, data, length ); @@ -1704,27 +1704,27 @@ void appendFd( struct colm_print_args *args, const char *data, int length ) message( "write error on fd: %d: %s\n", fd, strerror(errno) ); } -tree_t *treeTrim( struct colm_program *prg, tree_t **sp, tree_t *tree ) +tree_t *tree_trim( struct colm_program *prg, tree_t **sp, tree_t *tree ) { debug( prg, REALM_PARSE, "attaching left ignore\n" ); /* Make the ignore list for the left-ignore. */ - tree_t *leftIgnore = tree_allocate( prg ); - leftIgnore->id = LEL_ID_IGNORE; - leftIgnore->flags |= AF_SUPPRESS_RIGHT; + tree_t *left_ignore = tree_allocate( prg ); + left_ignore->id = LEL_ID_IGNORE; + left_ignore->flags |= AF_SUPPRESS_RIGHT; - tree = push_left_ignore( prg, tree, leftIgnore ); + tree = push_left_ignore( prg, tree, left_ignore ); debug( prg, REALM_PARSE, "attaching ignore right\n" ); /* Copy the ignore list first if we need to attach it as a right * ignore. */ - tree_t *rightIgnore = 0; - rightIgnore = tree_allocate( prg ); - rightIgnore->id = LEL_ID_IGNORE; - rightIgnore->flags |= AF_SUPPRESS_LEFT; + tree_t *right_ignore = 0; + right_ignore = tree_allocate( prg ); + right_ignore->id = LEL_ID_IGNORE; + right_ignore->flags |= AF_SUPPRESS_LEFT; - tree = push_right_ignore( prg, tree, rightIgnore ); + tree = push_right_ignore( prg, tree, right_ignore ); return tree; } @@ -1748,12 +1748,12 @@ enum VisitType #define TF_TERM_SEEN 0x1 -void printKid( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid ) +void print_kid( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid ) { enum ReturnType rt; kid_t *parent = 0; - kid_t *leadingIgnore = 0; - enum VisitType visitType; + kid_t *leading_ignore = 0; + enum VisitType visit_type; int flags = 0; /* Iterate the kids passed in. We are expecting a next, which will allow us @@ -1777,7 +1777,7 @@ rec_call: vm_push_kid( parent ); vm_push_kid( kid ); parent = kid; - kid = treeLeftIgnoreKid( prg, kid->tree ); + kid = tree_left_ignore_kid( prg, kid->tree ); vm_push_type( enum ReturnType, CollectIgnoreLeft ); goto rec_call; rec_return_ign_left: @@ -1786,75 +1786,75 @@ rec_call: } if ( kid->tree->id == LEL_ID_IGNORE ) - visitType = IgnoreWrapper; + visit_type = IgnoreWrapper; else if ( parent != 0 && parent->tree->id == LEL_ID_IGNORE ) - visitType = IgnoreData; - else if ( kid->tree->id < prg->rtd->firstNonTermId ) - visitType = Term; + visit_type = IgnoreData; + else if ( kid->tree->id < prg->rtd->first_non_term_id ) + visit_type = Term; else - visitType = NonTerm; + visit_type = NonTerm; - debug( prg, REALM_PRINT, "visit type: %d\n", visitType ); + debug( prg, REALM_PRINT, "visit type: %d\n", visit_type ); - if ( visitType == IgnoreData ) { + if ( visit_type == IgnoreData ) { debug( prg, REALM_PRINT, "putting %p on ignore list\n", kid->tree ); - kid_t *newIgnore = kid_allocate( prg ); - newIgnore->next = leadingIgnore; - leadingIgnore = newIgnore; - leadingIgnore->tree = kid->tree; + kid_t *new_ignore = kid_allocate( prg ); + new_ignore->next = leading_ignore; + leading_ignore = new_ignore; + leading_ignore->tree = kid->tree; goto skip_node; } - if ( visitType == IgnoreWrapper ) { - kid_t *newIgnore = kid_allocate( prg ); - newIgnore->next = leadingIgnore; - leadingIgnore = newIgnore; - leadingIgnore->tree = kid->tree; + if ( visit_type == IgnoreWrapper ) { + kid_t *new_ignore = kid_allocate( prg ); + new_ignore->next = leading_ignore; + leading_ignore = new_ignore; + leading_ignore->tree = kid->tree; /* Don't skip. */ } /* print leading ignore? Triggered by terminals. */ - if ( visitType == Term ) { + if ( visit_type == Term ) { /* Reverse the leading ignore list. */ - if ( leadingIgnore != 0 ) { + if ( leading_ignore != 0 ) { kid_t *ignore = 0, *last = 0; /* Reverse the list and take the opportunity to implement the * suppress left. */ while ( true ) { - kid_t *next = leadingIgnore->next; - leadingIgnore->next = last; + kid_t *next = leading_ignore->next; + leading_ignore->next = last; - if ( leadingIgnore->tree->flags & AF_SUPPRESS_LEFT ) { + if ( leading_ignore->tree->flags & AF_SUPPRESS_LEFT ) { /* We are moving left. Chop off the tail. */ debug( prg, REALM_PRINT, "suppressing left\n" ); - freeKidList( prg, next ); + free_kid_list( prg, next ); break; } if ( next == 0 ) break; - last = leadingIgnore; - leadingIgnore = next; + last = leading_ignore; + leading_ignore = next; } /* Print the leading ignore list. Also implement the suppress right * in the process. */ - if ( printArgs->comm && (!printArgs->trim || (flags & TF_TERM_SEEN && kid->tree->id > 0)) ) { - ignore = leadingIgnore; + if ( print_args->comm && (!print_args->trim || (flags & TF_TERM_SEEN && kid->tree->id > 0)) ) { + ignore = leading_ignore; while ( ignore != 0 ) { if ( ignore->tree->flags & AF_SUPPRESS_RIGHT ) break; if ( ignore->tree->id != LEL_ID_IGNORE ) { - vm_push_type( enum VisitType, visitType ); - vm_push_kid( leadingIgnore ); + vm_push_type( enum VisitType, visit_type ); + vm_push_kid( leading_ignore ); vm_push_kid( ignore ); vm_push_kid( parent ); vm_push_kid( kid ); - leadingIgnore = 0; + leading_ignore = 0; kid = ignore; parent = 0; @@ -1866,8 +1866,8 @@ rec_call: kid = vm_pop_kid(); parent = vm_pop_kid(); ignore = vm_pop_kid(); - leadingIgnore = vm_pop_kid(); - visitType = vm_pop_type(enum VisitType); + leading_ignore = vm_pop_kid(); + visit_type = vm_pop_type(enum VisitType); } ignore = ignore->next; @@ -1875,35 +1875,35 @@ rec_call: } /* Free the leading ignore list. */ - freeKidList( prg, leadingIgnore ); - leadingIgnore = 0; + free_kid_list( prg, leading_ignore ); + leading_ignore = 0; } } - if ( visitType == Term || visitType == NonTerm ) { + if ( visit_type == Term || visit_type == NonTerm ) { /* Open the tree. */ - printArgs->open_tree( prg, sp, printArgs, parent, kid ); + print_args->open_tree( prg, sp, print_args, parent, kid ); } - if ( visitType == Term ) + if ( visit_type == Term ) flags |= TF_TERM_SEEN; - if ( visitType == Term || visitType == IgnoreData ) { + if ( visit_type == Term || visit_type == IgnoreData ) { /* Print contents. */ - if ( kid->tree->id < prg->rtd->firstNonTermId ) { + if ( kid->tree->id < prg->rtd->first_non_term_id ) { debug( prg, REALM_PRINT, "printing terminal %p\n", kid->tree ); if ( kid->tree->id != 0 ) - printArgs->print_term( prg, sp, printArgs, kid ); + print_args->print_term( prg, sp, print_args, kid ); } } /* Print children. */ - kid_t *child = printArgs->attr ? - treeAttr( prg, kid->tree ) : - treeChild( prg, kid->tree ); + kid_t *child = print_args->attr ? + tree_attr( prg, kid->tree ) : + tree_child( prg, kid->tree ); if ( child != 0 ) { - vm_push_type( enum VisitType, visitType ); + vm_push_type( enum VisitType, visit_type ); vm_push_kid( parent ); vm_push_kid( kid ); parent = kid; @@ -1916,12 +1916,12 @@ rec_call: } kid = vm_pop_kid(); parent = vm_pop_kid(); - visitType = vm_pop_type(enum VisitType); + visit_type = vm_pop_type(enum VisitType); } - if ( visitType == Term || visitType == NonTerm ) { + if ( visit_type == Term || visit_type == NonTerm ) { /* close the tree. */ - printArgs->close_tree( prg, sp, printArgs, parent, kid ); + print_args->close_tree( prg, sp, print_args, parent, kid ); } skip_node: @@ -1933,7 +1933,7 @@ skip_node: vm_push_kid( parent ); vm_push_kid( kid ); parent = kid; - kid = treeRightIgnoreKid( prg, kid->tree ); + kid = tree_right_ignore_kid( prg, kid->tree ); vm_push_type( enum ReturnType, CollectIgnoreRight ); goto rec_call; rec_return_ign_right: @@ -1965,17 +1965,17 @@ skip_null: } } -void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, tree_t *tree ) +void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args *print_args, tree_t *tree ) { if ( tree == 0 ) - printArgs->out( printArgs, "NIL", 3 ); + print_args->out( print_args, "NIL", 3 ); else { /* This term tree allows us to print trailing ignores. */ - tree_t termTree; - memset( &termTree, 0, sizeof(termTree) ); + tree_t term_tree; + memset( &term_tree, 0, sizeof(term_tree) ); kid_t kid, term; - term.tree = &termTree; + term.tree = &term_tree; term.next = 0; term.flags = 0; @@ -1983,22 +1983,22 @@ void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args * kid.next = &term; kid.flags = 0; - printKid( prg, sp, printArgs, &kid ); + print_kid( prg, sp, print_args, &kid ); } } -void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid ) +void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid ) { debug( prg, REALM_PRINT, "printing term %p\n", kid->tree ); if ( kid->tree->id == LEL_ID_PTR ) { char buf[INT_SZ]; - printArgs->out( printArgs, "#", 1 ); + print_args->out( print_args, "#", 1 ); sprintf( buf, "%p", (void*) ((pointer_t*)kid->tree)->value ); - printArgs->out( printArgs, buf, strlen(buf) ); + print_args->out( print_args, buf, strlen(buf) ); } else if ( kid->tree->id == LEL_ID_STR ) { - printStr( printArgs, ((str_t*)kid->tree)->value ); + print_str( print_args, ((str_t*)kid->tree)->value ); } // else if ( kid->tree->id == LEL_ID_STREAM ) { // char buf[INT_SZ]; @@ -2007,10 +2007,10 @@ void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args * // printArgs->out( printArgs, buf, strlen(buf) ); // } else if ( kid->tree->tokdata != 0 && - stringLength( kid->tree->tokdata ) > 0 ) + string_length( kid->tree->tokdata ) > 0 ) { - printArgs->out( printArgs, stringData( kid->tree->tokdata ), - stringLength( kid->tree->tokdata ) ); + print_args->out( print_args, string_data( kid->tree->tokdata ), + string_length( kid->tree->tokdata ) ); } } @@ -2020,103 +2020,103 @@ void colm_print_null( program_t *prg, tree_t **sp, { } -void openTreeXml( program_t *prg, tree_t **sp, struct colm_print_args *args, +void open_tree_xml( program_t *prg, tree_t **sp, struct colm_print_args *args, kid_t *parent, kid_t *kid ) { /* Skip the terminal that is for forcing trailing ignores out. */ if ( kid->tree->id == 0 ) return; - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; /* List flattening: skip the repeats and lists that are a continuation of * the list. */ if ( parent != 0 && parent->tree->id == kid->tree->id && kid->next == 0 && - ( lelInfo[parent->tree->id].repeat || lelInfo[parent->tree->id].list ) ) + ( lel_info[parent->tree->id].repeat || lel_info[parent->tree->id].list ) ) { return; } - const char *name = lelInfo[kid->tree->id].xmlTag; + const char *name = lel_info[kid->tree->id].xml_tag; args->out( args, "<", 1 ); args->out( args, name, strlen( name ) ); args->out( args, ">", 1 ); } -void printTermXml( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid ) +void print_term_xml( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid ) { //kid_t *child; - /*child = */ treeChild( prg, kid->tree ); + /*child = */ tree_child( prg, kid->tree ); if ( kid->tree->id == LEL_ID_PTR ) { char ptr[32]; sprintf( ptr, "%p\n", (void*)((pointer_t*)kid->tree)->value ); - printArgs->out( printArgs, ptr, strlen(ptr) ); + print_args->out( print_args, ptr, strlen(ptr) ); } else if ( kid->tree->id == LEL_ID_STR ) { head_t *head = (head_t*) ((str_t*)kid->tree)->value; - xmlEscapeData( printArgs, (char*)(head->data), head->length ); + xml_escape_data( print_args, (char*)(head->data), head->length ); } - else if ( 0 < kid->tree->id && kid->tree->id < prg->rtd->firstNonTermId && + else if ( 0 < kid->tree->id && kid->tree->id < prg->rtd->first_non_term_id && kid->tree->id != LEL_ID_IGNORE && kid->tree->tokdata != 0 && - stringLength( kid->tree->tokdata ) > 0 ) + string_length( kid->tree->tokdata ) > 0 ) { - xmlEscapeData( printArgs, stringData( kid->tree->tokdata ), - stringLength( kid->tree->tokdata ) ); + xml_escape_data( print_args, string_data( kid->tree->tokdata ), + string_length( kid->tree->tokdata ) ); } } -void closeTreeXml( program_t *prg, tree_t **sp, struct colm_print_args *args, kid_t *parent, kid_t *kid ) +void close_tree_xml( program_t *prg, tree_t **sp, struct colm_print_args *args, kid_t *parent, kid_t *kid ) { /* Skip the terminal that is for forcing trailing ignores out. */ if ( kid->tree->id == 0 ) return; - struct lang_el_info *lelInfo = prg->rtd->lelInfo; + struct lang_el_info *lel_info = prg->rtd->lel_info; /* List flattening: skip the repeats and lists that are a continuation of * the list. */ if ( parent != 0 && parent->tree->id == kid->tree->id && kid->next == 0 && - ( lelInfo[parent->tree->id].repeat || lelInfo[parent->tree->id].list ) ) + ( lel_info[parent->tree->id].repeat || lel_info[parent->tree->id].list ) ) { return; } - const char *name = lelInfo[kid->tree->id].xmlTag; + const char *name = lel_info[kid->tree->id].xml_tag; args->out( args, "out( args, name, strlen( name ) ); args->out( args, ">", 1 ); } -void printTreeCollect( program_t *prg, tree_t **sp, StrCollect *collect, tree_t *tree, int trim ) +void print_tree_collect( program_t *prg, tree_t **sp, StrCollect *collect, tree_t *tree, int trim ) { - struct colm_print_args printArgs = { collect, true, false, trim, &appendCollect, + struct colm_print_args print_args = { collect, true, false, trim, &append_collect, &colm_print_null, &colm_print_term_tree, &colm_print_null }; - colm_print_tree_args( prg, sp, &printArgs, tree ); + colm_print_tree_args( prg, sp, &print_args, tree ); } -void printTreeFile( program_t *prg, tree_t **sp, FILE *out, tree_t *tree, int trim ) +void print_tree_file( program_t *prg, tree_t **sp, FILE *out, tree_t *tree, int trim ) { - struct colm_print_args printArgs = { out, true, false, trim, &appendFile, + struct colm_print_args print_args = { out, true, false, trim, &append_file, &colm_print_null, &colm_print_term_tree, &colm_print_null }; - colm_print_tree_args( prg, sp, &printArgs, tree ); + colm_print_tree_args( prg, sp, &print_args, tree ); } -void printTreeFd( program_t *prg, tree_t **sp, int fd, tree_t *tree, int trim ) +void print_tree_fd( program_t *prg, tree_t **sp, int fd, tree_t *tree, int trim ) { - struct colm_print_args printArgs = { (void*)((long)fd), true, false, trim, &appendFd, + struct colm_print_args print_args = { (void*)((long)fd), true, false, trim, &append_fd, &colm_print_null, &colm_print_term_tree, &colm_print_null }; - colm_print_tree_args( prg, sp, &printArgs, tree ); + colm_print_tree_args( prg, sp, &print_args, tree ); } -void printXmlStdout( program_t *prg, tree_t **sp, tree_t *tree, int commAttr, int trim ) +void print_xml_stdout( program_t *prg, tree_t **sp, tree_t *tree, int comm_attr, int trim ) { - struct colm_print_args printArgs = { stdout, commAttr, commAttr, trim, &appendFile, - &openTreeXml, &printTermXml, &closeTreeXml }; - colm_print_tree_args( prg, sp, &printArgs, tree ); + struct colm_print_args print_args = { stdout, comm_attr, comm_attr, trim, &append_file, + &open_tree_xml, &print_term_xml, &close_tree_xml }; + colm_print_tree_args( prg, sp, &print_args, tree ); } diff --git a/src/tree.h b/src/tree.h index b11c33d9..d5858b6f 100644 --- a/src/tree.h +++ b/src/tree.h @@ -92,18 +92,18 @@ typedef struct colm_parse_tree struct colm_parse_tree *child; struct colm_parse_tree *next; - struct colm_parse_tree *leftIgnore; - struct colm_parse_tree *rightIgnore; + struct colm_parse_tree *left_ignore; + struct colm_parse_tree *right_ignore; kid_t *shadow; /* Parsing algorithm. */ long state; - short causeReduce; + short cause_reduce; /* Retry vars. Might be able to unify lower and upper. */ - long retryRegion; - char retryLower; - char retryUpper; + long retry_region; + char retry_lower; + char retry_upper; } parse_tree_t; typedef struct colm_pointer @@ -135,17 +135,17 @@ struct generic_info { long type; - long elType; - long elStructId; - long elOffset; + long el_type; + long el_struct_id; + long el_offset; - enum TYPE keyType; - long keyOffset; + enum TYPE key_type; + long key_offset; - enum TYPE valueType; - long valueOffset; + enum TYPE value_type; + long value_offset; - long parserId; + long parser_id; }; enum IterType @@ -158,41 +158,41 @@ enum IterType typedef struct _TreeIter { enum IterType type; - ref_t rootRef; + ref_t root_ref; ref_t ref; - long searchId; - tree_t **stackRoot; - long argSize; - long yieldSize; - long rootSize; + long search_id; + tree_t **stack_root; + long arg_size; + long yield_size; + long root_size; } tree_iter_t; typedef struct colm_generic_iter { enum IterType type; - ref_t rootRef; + ref_t root_ref; ref_t ref; - tree_t **stackRoot; - long argSize; - long yieldSize; - long rootSize; - long genericId; + tree_t **stack_root; + long arg_size; + long yield_size; + long root_size; + long generic_id; } generic_iter_t; /* This must overlay tree iter because some of the same bytecodes are used. */ typedef struct _RevTreeIter { enum IterType type; - ref_t rootRef; + ref_t root_ref; ref_t ref; - long searchId; - tree_t **stackRoot; - long argSize; - long yieldSize; - long rootSize; + long search_id; + tree_t **stack_root; + long arg_size; + long yield_size; + long root_size; /* For detecting a split at the leaf. */ - kid_t *kidAtYield; + kid_t *kid_at_yield; long children; } rev_tree_iter_t; @@ -201,92 +201,92 @@ typedef struct colm_user_iter enum IterType type; /* The current item. */ ref_t ref; - tree_t **stackRoot; - long argSize; - long yieldSize; - long rootSize; + tree_t **stack_root; + long arg_size; + long yield_size; + long root_size; code_t *resume; tree_t **frame; - long searchId; + long search_id; } user_iter_t; void colm_tree_upref( tree_t *tree ); void colm_tree_downref( struct colm_program *prg, tree_t **sp, tree_t *tree ); long colm_cmp_tree( struct colm_program *prg, const tree_t *tree1, const tree_t *tree2 ); -tree_t *push_right_ignore( struct colm_program *prg, tree_t *pushTo, tree_t *rightIgnore ); -tree_t *push_left_ignore( struct colm_program *prg, tree_t *pushTo, tree_t *leftIgnore ); -tree_t *popRightIgnore( struct colm_program *prg, tree_t **sp, - tree_t *popFrom, tree_t **rightIgnore ); -tree_t *popLeftIgnore( struct colm_program *prg, tree_t **sp, - tree_t *popFrom, tree_t **leftIgnore ); -tree_t *treeLeftIgnore( struct colm_program *prg, tree_t *tree ); -tree_t *treeRightIgnore( struct colm_program *prg, tree_t *tree ); -kid_t *treeLeftIgnoreKid( struct colm_program *prg, tree_t *tree ); -kid_t *treeRightIgnoreKid( struct colm_program *prg, tree_t *tree ); -kid_t *treeChild( struct colm_program *prg, const tree_t *tree ); -kid_t *treeAttr( struct colm_program *prg, const tree_t *tree ); -kid_t *kidListConcat( kid_t *list1, kid_t *list2 ); -kid_t *treeExtractChild( struct colm_program *prg, tree_t *tree ); -kid_t *reverseKidList( kid_t *kid ); +tree_t *push_right_ignore( struct colm_program *prg, tree_t *push_to, tree_t *right_ignore ); +tree_t *push_left_ignore( struct colm_program *prg, tree_t *push_to, tree_t *left_ignore ); +tree_t *pop_right_ignore( struct colm_program *prg, tree_t **sp, + tree_t *pop_from, tree_t **right_ignore ); +tree_t *pop_left_ignore( struct colm_program *prg, tree_t **sp, + tree_t *pop_from, tree_t **left_ignore ); +tree_t *tree_left_ignore( struct colm_program *prg, tree_t *tree ); +tree_t *tree_right_ignore( struct colm_program *prg, tree_t *tree ); +kid_t *tree_left_ignore_kid( struct colm_program *prg, tree_t *tree ); +kid_t *tree_right_ignore_kid( struct colm_program *prg, tree_t *tree ); +kid_t *tree_child( struct colm_program *prg, const tree_t *tree ); +kid_t *tree_attr( struct colm_program *prg, const tree_t *tree ); +kid_t *kid_list_concat( kid_t *list1, kid_t *list2 ); +kid_t *tree_extract_child( struct colm_program *prg, tree_t *tree ); +kid_t *reverse_kid_list( kid_t *kid ); tree_t *colm_construct_pointer( struct colm_program *prg, colm_value_t value ); tree_t *colm_construct_term( struct colm_program *prg, word_t id, head_t *tokdata ); tree_t *colm_construct_tree( struct colm_program *prg, kid_t *kid, tree_t **bindings, long pat ); tree_t *colm_construct_object( struct colm_program *prg, kid_t *kid, - tree_t **bindings, long langElId ); + tree_t **bindings, long lang_el_id ); tree_t *colm_construct_token( struct colm_program *prg, tree_t **args, long nargs ); -int testFalse( struct colm_program *prg, tree_t *tree ); -tree_t *makeTree( struct colm_program *prg, tree_t **args, long nargs ); -stream_t *openFile( struct colm_program *prg, tree_t *name, tree_t *mode ); +int test_false( struct colm_program *prg, tree_t *tree ); +tree_t *make_tree( struct colm_program *prg, tree_t **args, long nargs ); +stream_t *open_file( struct colm_program *prg, tree_t *name, tree_t *mode ); stream_t *colm_stream_open_file( struct colm_program *prg, tree_t *name, tree_t *mode ); stream_t *colm_stream_open_fd( struct colm_program *prg, char *name, long fd ); -kid_t *copyIgnoreList( struct colm_program *prg, kid_t *ignoreHeader ); -kid_t *copyKidList( struct colm_program *prg, kid_t *kidList ); +kid_t *copy_ignore_list( struct colm_program *prg, kid_t *ignore_header ); +kid_t *copy_kid_list( struct colm_program *prg, kid_t *kid_list ); void colm_stream_free( struct colm_program *prg, stream_t *s ); tree_t *colm_copy_tree( struct colm_program *prg, tree_t *tree, - kid_t *oldNextDown, kid_t **newNextDown ); + kid_t *old_next_down, kid_t **new_next_down ); colm_value_t colm_get_pointer_val( tree_t *pointer ); tree_t *colm_tree_get_field( tree_t *tree, word_t field ); -tree_t *getFieldSplit( struct colm_program *prg, tree_t *tree, word_t field ); -tree_t *getRhsEl( struct colm_program *prg, tree_t *lhs, long position ); -kid_t *getRhsElKid( struct colm_program *prg, tree_t *lhs, long position ); +tree_t *get_field_split( struct colm_program *prg, tree_t *tree, word_t field ); +tree_t *get_rhs_el( struct colm_program *prg, tree_t *lhs, long position ); +kid_t *get_rhs_el_kid( struct colm_program *prg, tree_t *lhs, long position ); void colm_tree_set_field( struct colm_program *prg, tree_t *tree, long field, tree_t *value ); -void setTriterCur( struct colm_program *prg, tree_iter_t *iter, tree_t *tree ); -void setUiterCur( struct colm_program *prg, user_iter_t *uiter, tree_t *tree ); -void refSetValue( struct colm_program *prg, tree_t **sp, ref_t *ref, tree_t *v ); -tree_t *treeSearch( struct colm_program *prg, tree_t *tree, long id ); -location_t *locSearch( struct colm_program *prg, tree_t *tree ); +void set_triter_cur( struct colm_program *prg, tree_iter_t *iter, tree_t *tree ); +void set_uiter_cur( struct colm_program *prg, user_iter_t *uiter, tree_t *tree ); +void ref_set_value( struct colm_program *prg, tree_t **sp, ref_t *ref, tree_t *v ); +tree_t *tree_search( struct colm_program *prg, tree_t *tree, long id ); +location_t *loc_search( struct colm_program *prg, tree_t *tree ); -int matchPattern( tree_t **bindings, struct colm_program *prg, - long pat, kid_t *kid, int checkNext ); -tree_t *treeIterDerefCur( tree_iter_t *iter ); +int match_pattern( tree_t **bindings, struct colm_program *prg, + long pat, kid_t *kid, int check_next ); +tree_t *tree_iter_deref_cur( tree_iter_t *iter ); /* For making references of attributes. */ -kid_t *getFieldKid( tree_t *tree, word_t field ); - -tree_t *copyRealTree( struct colm_program *prg, tree_t *tree, - kid_t *oldNextDown, kid_t **newNextDown ); -void splitIterCur( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); -tree_t *setListMem( list_t *list, half_t field, tree_t *value ); - -void listPushTail( struct colm_program *prg, list_t *list, tree_t *val ); -void listPushHead( struct colm_program *prg, list_t *list, tree_t *val ); -tree_t *listRemoveEnd( struct colm_program *prg, list_t *list ); -tree_t *listRemoveHead( struct colm_program *prg, list_t *list ); -tree_t *getListMemSplit( struct colm_program *prg, list_t *list, word_t field ); -tree_t *getParserMem( parser_t *parser, word_t field ); - -tree_t *treeIterAdvance( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); -tree_t *treeIterNextChild( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); -tree_t *treeRevIterPrevChild( struct colm_program *prg, tree_t ***psp, rev_tree_iter_t *iter ); -tree_t *treeIterNextRepeat( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); -tree_t *treeIterPrevRepeat( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); +kid_t *get_field_kid( tree_t *tree, word_t field ); + +tree_t *copy_real_tree( struct colm_program *prg, tree_t *tree, + kid_t *old_next_down, kid_t **new_next_down ); +void split_iter_cur( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); +tree_t *set_list_mem( list_t *list, half_t field, tree_t *value ); + +void list_push_tail( struct colm_program *prg, list_t *list, tree_t *val ); +void list_push_head( struct colm_program *prg, list_t *list, tree_t *val ); +tree_t *list_remove_end( struct colm_program *prg, list_t *list ); +tree_t *list_remove_head( struct colm_program *prg, list_t *list ); +tree_t *get_list_mem_split( struct colm_program *prg, list_t *list, word_t field ); +tree_t *get_parser_mem( parser_t *parser, word_t field ); + +tree_t *tree_iter_advance( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); +tree_t *tree_iter_next_child( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); +tree_t *tree_rev_iter_prev_child( struct colm_program *prg, tree_t ***psp, rev_tree_iter_t *iter ); +tree_t *tree_iter_next_repeat( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); +tree_t *tree_iter_prev_repeat( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); /* An automatically grown buffer for collecting tokens. Always reuses space; * never down resizes. */ @@ -297,50 +297,50 @@ typedef struct _StrCollect int length; } StrCollect; -void initStrCollect( StrCollect *collect ); -void strCollectDestroy( StrCollect *collect ); -void strCollectAppend( StrCollect *collect, const char *data, long len ); -void strCollectClear( StrCollect *collect ); -tree_t *treeTrim( struct colm_program *prg, tree_t **sp, tree_t *tree ); +void init_str_collect( StrCollect *collect ); +void str_collect_destroy( StrCollect *collect ); +void str_collect_append( StrCollect *collect, const char *data, long len ); +void str_collect_clear( StrCollect *collect ); +tree_t *tree_trim( struct colm_program *prg, tree_t **sp, tree_t *tree ); -void printTreeCollect( struct colm_program *prg, tree_t **sp, +void print_tree_collect( struct colm_program *prg, tree_t **sp, StrCollect *collect, tree_t *tree, int trim ); -void printTreeFile( struct colm_program *prg, tree_t **sp, FILE *out, tree_t *tree, int trim ); -void printTreeFd( struct colm_program *prg, tree_t **sp, int fd, tree_t *tree, int trim ); -void printXmlStdout( struct colm_program *prg, tree_t **sp, - tree_t *tree, int commAttr, int trim ); +void print_tree_file( struct colm_program *prg, tree_t **sp, FILE *out, tree_t *tree, int trim ); +void print_tree_fd( struct colm_program *prg, tree_t **sp, int fd, tree_t *tree, int trim ); +void print_xml_stdout( struct colm_program *prg, tree_t **sp, + tree_t *tree, int comm_attr, int trim ); /* * Iterators. */ user_iter_t *colm_uiter_create( struct colm_program *prg, tree_t ***psp, - struct function_info *fi, long searchId ); -void uiterInit( struct colm_program *prg, tree_t **sp, user_iter_t *uiter, - struct function_info *fi, int revertOn ); + struct function_info *fi, long search_id ); +void uiter_init( struct colm_program *prg, tree_t **sp, user_iter_t *uiter, + struct function_info *fi, int revert_on ); -void colm_init_tree_iter( tree_iter_t *treeIter, tree_t **stackRoot, - long argSize, long rootSize, const ref_t *rootRef, int searchId ); -void colm_init_rev_tree_iter( rev_tree_iter_t *revTriter, tree_t **stackRoot, - long argSize, long rootSize, const ref_t *rootRef, int searchId, int children ); -void colm_init_user_iter( user_iter_t *userIter, tree_t **stackRoot, long rootSize, - long argSize, long searchId ); +void colm_init_tree_iter( tree_iter_t *tree_iter, tree_t **stack_root, + long arg_size, long root_size, const ref_t *root_ref, int search_id ); +void colm_init_rev_tree_iter( rev_tree_iter_t *rev_triter, tree_t **stack_root, + long arg_size, long root_size, const ref_t *root_ref, int search_id, int children ); +void colm_init_user_iter( user_iter_t *user_iter, tree_t **stack_root, long root_size, + long arg_size, long search_id ); void colm_tree_iter_destroy( struct colm_program *prg, tree_t ***psp, tree_iter_t *iter ); void colm_rev_tree_iter_destroy( struct colm_program *prg, tree_t ***psp, rev_tree_iter_t *iter ); void colm_uiter_destroy( struct colm_program *prg, tree_t ***psp, user_iter_t *uiter ); void colm_uiter_unwind( struct colm_program *prg, tree_t ***psp, user_iter_t *uiter ); -tree_t *castTree( struct colm_program *prg, int langElId, tree_t *tree ); -struct stream_impl *streamToImpl( stream_t *ptr ); +tree_t *cast_tree( struct colm_program *prg, int lang_el_id, tree_t *tree ); +struct stream_impl *stream_to_impl( stream_t *ptr ); -void colm_init_list_iter( generic_iter_t *listIter, tree_t **stackRoot, - long argSize, long rootSize, const ref_t *rootRef, int genericId ); +void colm_init_list_iter( generic_iter_t *list_iter, tree_t **stack_root, + long arg_size, long root_size, const ref_t *root_ref, int generic_id ); void colm_list_iter_destroy( struct colm_program *prg, tree_t ***psp, generic_iter_t *iter ); tree_t *colm_list_iter_advance( struct colm_program *prg, tree_t ***psp, generic_iter_t *iter ); tree_t *colm_list_iter_deref_cur( struct colm_program *prg, generic_iter_t *iter ); -void colm_list_append( struct colm_list *list, struct colm_list_el *newEl ); -void colm_list_prepend( struct colm_list *list, struct colm_list_el *newEl ); +void colm_list_append( struct colm_list *list, struct colm_list_el *new_el ); +void colm_list_prepend( struct colm_list *list, struct colm_list_el *new_el ); void colm_vlist_append( struct colm_program *prg, list_t *list, value_t value ); void colm_vlist_prepend( struct colm_program *prg, list_t *list, value_t value ); @@ -351,8 +351,8 @@ value_t colm_viter_deref_cur( struct colm_program *prg, generic_iter_t *iter ); str_t *string_prefix( program_t *prg, str_t *str, long len ); str_t *string_suffix( program_t *prg, str_t *str, long pos ); -head_t *stringAllocFull( struct colm_program *prg, const char *data, long length ); -tree_t *constructString( struct colm_program *prg, head_t *s ); +head_t *string_alloc_full( struct colm_program *prg, const char *data, long length ); +tree_t *construct_string( struct colm_program *prg, head_t *s ); #if defined(__cplusplus) } diff --git a/test/ext1.lm b/test/ext1.lm index edafc611..a06f7ea2 100644 --- a/test/ext1.lm +++ b/test/ext1.lm @@ -21,8 +21,8 @@ str_t *c_alphcount( program_t *prg, tree_t **sp, str_t *a1 ) char strc[64]; sprintf( strc, "%d", count ); - head_t *h = stringAllocFull( prg, strc, strlen( strc ) ); - tree_t *s = constructString( prg, h ); + head_t *h = string_alloc_full( prg, strc, strlen( strc ) ); + tree_t *s = construct_string( prg, h ); colm_tree_upref( s ); colm_tree_downref( prg, sp, a1 ); return (str_t*)s; -- cgit v1.2.1