From c860c61607117582abd8f23881eed87957197484 Mon Sep 17 00:00:00 2001 From: Adrian Thurston Date: Sun, 8 Sep 2019 21:11:17 -0600 Subject: moved the original colm src dir to /colm --- src/bytecode.c | 4938 -------------------------------------------------------- 1 file changed, 4938 deletions(-) delete mode 100644 src/bytecode.c (limited to 'src/bytecode.c') diff --git a/src/bytecode.c b/src/bytecode.c deleted file mode 100644 index fe0026fc..00000000 --- a/src/bytecode.c +++ /dev/null @@ -1,4938 +0,0 @@ -/* - * Copyright 2006-2018 Adrian Thurston - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#include - -#include -#if defined(HAVE_SYS_WAIT_H) -#include -#endif -#include -#include -#include -#include -#include -#include - -#include -#include - -#define TRUE_VAL 1 -#define FALSE_VAL 0 - -#if SIZEOF_LONG != 4 && SIZEOF_LONG != 8 - #error "SIZEOF_LONG contained an unexpected value" -#endif - -#define read_byte( i ) do { \ - i = ((uchar) *instr++); \ -} while(0) - -#define read_half( i ) do { \ - i = ((word_t) *instr++); \ - i |= ((word_t) *instr++) << 8; \ -} while(0) - -/* There are better ways. */ -#if SIZEOF_LONG == 4 - - #define read_type( type, i ) do { \ - word_t w; \ - w = ((word_t) *instr++); \ - w |= ((word_t) *instr++) << 8; \ - w |= ((word_t) *instr++) << 16; \ - w |= ((word_t) *instr++) << 24; \ - i = (type) w; \ - } while(0) - - #define read_type_p( Type, i, p ) do { \ - i = ((Type) p[0]); \ - i |= ((Type) p[1]) << 8; \ - i |= ((Type) p[2]) << 16; \ - i |= ((Type) p[3]) << 24; \ - } while(0) - - #define consume_word() instr += 4 - -#else - - #define read_type( type, i ) do { \ - word_t _w; \ - _w = ((word_t) *instr++); \ - _w |= ((word_t) *instr++) << 8; \ - _w |= ((word_t) *instr++) << 16; \ - _w |= ((word_t) *instr++) << 24; \ - _w |= ((word_t) *instr++) << 32; \ - _w |= ((word_t) *instr++) << 40; \ - _w |= ((word_t) *instr++) << 48; \ - _w |= ((word_t) *instr++) << 56; \ - i = (type) _w; \ - } while(0) - - #define read_type_p( type, i, p ) do { \ - i = ((type) p[0]); \ - i |= ((type) p[1]) << 8; \ - i |= ((type) p[2]) << 16; \ - i |= ((type) p[3]) << 24; \ - i |= ((type) p[4]) << 32; \ - i |= ((type) p[5]) << 40; \ - i |= ((type) p[6]) << 48; \ - i |= ((type) p[7]) << 56; \ - } while(0) - - #define consume_word() instr += 8 -#endif - -#define read_tree( i ) read_type( tree_t*, i ) -#define read_parser( i ) read_type( parser_t*, i ) -#define read_word( i ) read_type( word_t, i ) -#define read_stream( i ) read_type( stream_t*, i ) -#define read_input( i ) read_type( input_t*, i ) - -#define read_word_p( i, p ) read_type_p( word_t, i, p ) - -#define consume_byte() instr += 1 -#define consume_half() instr += 2 - -static void rcode_downref( program_t *prg, tree_t **sp, code_t *instr ); - -static void make_stdin( program_t *prg ) -{ - if ( prg->stdin_val == 0 ) - prg->stdin_val = colm_stream_open_fd( prg, "", 0 ); -} - -static void make_stdout( program_t *prg ) -{ - if ( prg->stdout_val == 0 ) - prg->stdout_val = colm_stream_open_fd( prg, "", 1 ); -} - -static void make_stderr( program_t *prg ) -{ - if ( prg->stderr_val == 0 ) - prg->stderr_val = colm_stream_open_fd( prg, "", 2 ); -} - -static void flush_streams( program_t *prg ) -{ - if ( prg->stdout_val != 0 ) { - struct stream_impl *si = prg->stdout_val->impl; - si->funcs->flush_stream( prg, si ); - } - - if ( prg->stderr_val != 0 ) { - struct stream_impl *si = prg->stderr_val->impl; - si->funcs->flush_stream( prg, si ); - } -} - -void colm_parser_set_context( program_t *prg, tree_t **sp, parser_t *parser, struct_t *val ) -{ - parser->pda_run->context = val; -} - -static head_t *tree_to_str_xml( program_t *prg, tree_t **sp, tree_t *tree, int trim, int attrs ) -{ - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - - colm_print_tree_collect_xml( prg, sp, &collect, tree, trim ); - - /* Set up the input stream. */ - head_t *ret = string_alloc_full( prg, collect.data, collect.length ); - - str_collect_destroy( &collect ); - - return ret; -} - -static head_t *tree_to_str_xml_ac( program_t *prg, tree_t **sp, tree_t *tree, int trim, int attrs ) -{ - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - - colm_print_tree_collect_xml_ac( prg, sp, &collect, tree, trim ); - - /* Set up the input stream. */ - head_t *ret = string_alloc_full( prg, collect.data, collect.length ); - - str_collect_destroy( &collect ); - - return ret; -} - -static head_t *tree_to_str_postfix( program_t *prg, tree_t **sp, tree_t *tree, int trim, int attrs ) -{ - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - - colm_postfix_tree_collect( prg, sp, &collect, tree, trim ); - - /* Set up the input stream. */ - head_t *ret = string_alloc_full( prg, collect.data, collect.length ); - - str_collect_destroy( &collect ); - - return ret; -} - - -static word_t stream_append_text( program_t *prg, tree_t **sp, input_t *dest, tree_t *input, int trim ) -{ - long length = 0; - struct input_impl *impl = input_to_impl( dest ); - - if ( input->id == LEL_ID_PTR ) { - assert(false); - } - else { - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - colm_print_tree_collect( prg, sp, &collect, input, trim ); - - /* Load it into the input. */ - impl->funcs->append_data( prg, impl, collect.data, collect.length ); - length = collect.length; - str_collect_destroy( &collect ); - } - - return length; -} - -static word_t stream_append_tree( program_t *prg, tree_t **sp, input_t *dest, tree_t *to_append ) -{ - long length = 0; - struct input_impl *impl = input_to_impl( dest ); - - if ( to_append->id == LEL_ID_PTR ) { - assert(false); - } - else if ( to_append->id == LEL_ID_STR ) { - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - colm_print_tree_collect( prg, sp, &collect, to_append, false ); - - /* Load it into the to_append. */ - impl->funcs->append_data( prg, impl, collect.data, collect.length ); - length = collect.length; - str_collect_destroy( &collect ); - } - else { - colm_tree_upref( prg, to_append ); - impl->funcs->append_tree( prg, impl, to_append ); - } - - return length; -} - -static word_t stream_append_stream( program_t *prg, tree_t **sp, input_t *dest, stream_t *stream ) -{ - long length = 0; - - struct input_impl *impl = input_to_impl( dest ); - impl->funcs->append_stream( prg, impl, stream ); - - return length; -} - -static void stream_undo_append( program_t *prg, tree_t **sp, - struct input_impl *is, tree_t *input, long length ) -{ - if ( input->id == LEL_ID_PTR ) - assert(false); - else if ( input->id == LEL_ID_STR ) - is->funcs->undo_append_data( prg, is, length ); - else { - is->funcs->undo_append_data( prg, is, length ); - } -} - -static void stream_undo_append_stream( program_t *prg, tree_t **sp, struct input_impl *is, - tree_t *input, long length ) -{ - is->funcs->undo_append_stream( prg, is ); -} - -static tree_t *stream_pull_bc( program_t *prg, tree_t **sp, struct pda_run *pda_run, - input_t *input, tree_t *length ) -{ - long len = ((long)length); - struct input_impl *impl = input_to_impl( input ); - head_t *tokdata = colm_stream_pull( prg, sp, pda_run, impl, len ); - return construct_string( prg, tokdata ); -} - - -static void undo_stream_pull( struct colm_program *prg, struct input_impl *is, const char *data, long length ) -{ - //debug( REALM_PARSE, "undoing stream pull\n" ); - is->funcs->undo_consume_data( prg, is, data, length ); -} - -static void undo_pull( program_t *prg, input_t *input, tree_t *str ) -{ - struct input_impl *impl = input_to_impl( input ); - const char *data = string_data( ( (str_t*)str )->value ); - long length = string_length( ( (str_t*)str )->value ); - undo_stream_pull( prg, impl, data, length ); -} - -static long stream_push( program_t *prg, tree_t **sp, struct input_impl *in, tree_t *tree, int ignore ) -{ - long length = -1; - if ( tree->id == LEL_ID_PTR ) { - assert(false); - } - else if ( tree->id == LEL_ID_STR ) { - /* This should become a compile error. If it's text, it's up to the - * scanner to decide. Want to force it then send a token. */ - assert( !ignore ); - - /* Collect the tree data. */ - str_collect_t collect; - init_str_collect( &collect ); - colm_print_tree_collect( prg, sp, &collect, tree, false ); - - colm_stream_push_text( prg, in, collect.data, collect.length ); - length = collect.length; - str_collect_destroy( &collect ); - - } - else { - colm_tree_upref( prg, tree ); - colm_stream_push_tree( prg, in, tree, ignore ); - } - - return length; -} - -static long stream_push_stream( program_t *prg, tree_t **sp, - struct input_impl *in, stream_t *stream ) -{ - colm_stream_push_stream( prg, in, stream ); - return -1; -} - -static void set_local( execution_t *exec, long field, tree_t *tree ) -{ - if ( tree != 0 ) - assert( tree->refs >= 1 ); - vm_set_local( exec, field, tree ); -} - -static tree_t *get_local_split( program_t *prg, execution_t *exec, long field ) -{ - tree_t *val = vm_get_local( exec, field ); - 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_t *exec, struct local_info *locals, long locals_len ) -{ - long 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 ); - - tree_t *tree = (tree_t*) vm_get_local( exec, (long)locals[i].offset ); - colm_tree_downref( prg, sp, tree ); - } - } -} - -static void downref_locals( program_t *prg, tree_t ***psp, - execution_t *exec, struct local_info *locals, long locals_len ) -{ - long 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", - (long)locals[i].offset ); - tree_t *tree = (tree_t*) vm_get_local( exec, (long)locals[i].offset ); - colm_tree_downref( prg, *psp, tree ); - break; - } - case LI_Iter: { - debug( prg, REALM_BYTECODE, "local iter downref: %ld\n", - (long)locals[i].offset ); - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal( exec, (long)locals[i].offset ); - colm_tree_iter_destroy( prg, psp, iter ); - break; - } - case LI_RevIter: { - debug( prg, REALM_BYTECODE, "local rev iter downref: %ld\n", - (long)locals[i].offset ); - rev_tree_iter_t *riter = (rev_tree_iter_t*) vm_get_plocal( exec, - (long)locals[i].offset ); - colm_rev_tree_iter_destroy( prg, psp, riter ); - break; - } - case LI_UserIter: { - debug( prg, REALM_BYTECODE, "local user iter downref: %ld\n", - (long)locals[i].offset ); - user_iter_t *uiter = (user_iter_t*) vm_get_local( exec, locals[i].offset ); - colm_uiter_unwind( prg, psp, uiter ); - break; - } - } - } -} - -static tree_t *construct_arg0( program_t *prg, int argc, const char **argv, const int *argl ) -{ - tree_t *arg0 = 0; - if ( argc > 0 ) { - size_t len = argl != 0 ? argl[0] : strlen(argv[0]); - head_t *head = colm_string_alloc_pointer( prg, argv[0], len ); - arg0 = construct_string( prg, head ); - colm_tree_upref( prg, arg0 ); - } - return arg0; -} - -static list_t *construct_argv( program_t *prg, int argc, const char **argv, const int *argl ) -{ - list_t *list = (list_t*)colm_construct_generic( prg, prg->rtd->argv_generic_id, 0 ); - int i; - for ( i = 1; i < argc; i++ ) { - size_t len = argl != 0 ? argl[i] : strlen(argv[i]); - head_t *head = colm_string_alloc_pointer( prg, argv[i], len ); - tree_t *arg = construct_string( prg, head ); - colm_tree_upref( prg, arg ); - - struct_t *strct = colm_struct_new_size( prg, 16 ); - strct->id = prg->rtd->argv_el_id; - colm_struct_set_field( strct, tree_t*, 0, arg ); - list_el_t *list_el = colm_struct_get_addr( strct, list_el_t*, 1 ); - colm_list_append( list, list_el ); - } - - return list; -} - - -static list_t *construct_stds( program_t *prg ) -{ - make_stdout( prg ); - - list_t *list = (list_t*)colm_construct_generic( prg, prg->rtd->stds_generic_id, 0 ); - - struct_t *strct = colm_struct_new_size( prg, 16 ); - strct->id = prg->rtd->stds_el_id; - colm_struct_set_field( strct, stream_t*, 0, prg->stdout_val ); - list_el_t *list_el = colm_struct_get_addr( strct, list_el_t*, 1 ); - colm_list_append( list, list_el ); - - return list; -} - -/* - * Execution environment - */ - -void colm_rcode_downref_all( program_t *prg, tree_t **sp, struct rt_code_vect *rev ) -{ - while ( rev->tab_len > 0 ) { - /* Read the length */ - 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->tab_len - len - SIZEOF_WORD; - prcode = rev->data + start; - - /* Execute it. */ - rcode_downref( prg, sp, prcode ); - - /* Backup over it. */ - rev->tab_len -= len + SIZEOF_WORD; - } -} - -static code_t *pcr_call( program_t *prg, execution_t *exec, tree_t ***psp, code_t *instr, parser_t *parser ) -{ - tree_t **sp = *psp; - - int frame_size = 0; - if ( parser->pda_run->frame_id >= 0 ) { - struct frame_info *fi = &prg->rtd->frame_info[parser->pda_run->frame_id]; - frame_size = fi->frame_size; - } - - vm_contiguous( 8 + frame_size ); - - vm_push_type( tree_t**, exec->frame_ptr ); - vm_push_type( tree_t**, exec->iframe_ptr ); - vm_push_type( long, exec->frame_id ); - vm_push_type( word_t, exec->steps ); - vm_push_type( word_t, exec->pcr ); - vm_push_parser( exec->parser ); - vm_push_type( word_t, exec->WV ); - - /* Return back to this instruction. We are alternating between - * parsing and calling instructions. */ - code_t *return_to = instr - SIZEOF_CODE; - vm_push_type( code_t*, return_to ); - - exec->frame_ptr = 0; - exec->iframe_ptr = 0; - exec->frame_id = 0; - exec->steps = 0; - exec->parser = parser; - - instr = parser->pda_run->code; - exec->WV = 1; - - exec->frame_id = parser->pda_run->frame_id; - - if ( parser->pda_run->frame_id >= 0 ) { - struct frame_info *fi = &prg->rtd->frame_info[parser->pda_run->frame_id]; - - exec->frame_ptr = vm_ptop(); - vm_pushn( fi->frame_size ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); - } - - *psp = sp; - return instr; -} - -void colm_execute( program_t *prg, execution_t *exec, code_t *code ) -{ - tree_t **sp = prg->stack_root; - - 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->frame_size; - vm_contiguous( stretch ); - - vm_push_tree( 0 ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - - 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->locals_len ); - vm_popn( fi->frame_size ); - - vm_pop_ignore(); - vm_pop_ignore(); - colm_tree_downref( prg, sp, prg->return_val ); - prg->return_val = vm_pop_tree(); - vm_pop_ignore(); - - prg->stack_root = sp; -} - -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; - prg->argv = 0; - prg->argl = 0; - - execution_t execution; - memset( &execution, 0, sizeof(execution) ); - - tree_t **sp = prg->stack_root; - - struct frame_info *fi = &prg->rtd->frame_info[frame_id]; - code_t *code = fi->codeWC; - - vm_pushn( param_count ); - execution.call_args = vm_ptop(); - memset( vm_ptop(), 0, sizeof(word_t) * param_count ); - - int p; - for ( p = 0; p < param_count; p++ ) { - if ( params[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 = construct_string( prg, head ); - colm_tree_upref( prg, tree ); - ((tree_t**)execution.call_args)[p] = tree; - } - } - - 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.call_args ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - vm_push_tree( 0 ); - - execution.frame_id = frame_id; - - 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->return_val ); - prg->return_val = execution.ret_val; - - vm_popn( param_count ); - - assert( sp == prg->stack_root ); - - return prg->return_val; -}; - -int colm_make_reverse_code( struct pda_run *pda_run ) -{ - 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 ( rcode_collect->tab_len == 0 ) - return false; - - if ( pda_run->rc_block_count == 0 ) { - /* One reverse code run for the DECK terminator. */ - 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 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 = rcode_collect->data + rcode_collect->tab_len; - while ( p != rcode_collect->data ) { - p--; - long len = *p; - p = p - len; - append_code_vect( reverse_code, p, len ); - } - - /* Stop, then place a total length in the global stack. */ - 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. */ - rcode_collect->tab_len = 0; - - pda_run->rc_block_count += 1; - colm_increment_steps( pda_run ); - - return true; -} - -void colm_transfer_reverse_code( struct pda_run *pda_run, parse_tree_t *parse_tree ) -{ - if ( pda_run->rc_block_count > 0 ) { - //debug( REALM_PARSE, "attaching reverse code to token\n" ); - parse_tree->flags |= PF_HAS_RCODE; - pda_run->rc_block_count = 0; - } -} - -static void rcode_unit_term( execution_t *exec ) -{ - append_code_val( &exec->parser->pda_run->rcode_collect, exec->rcode_unit_len ); - exec->rcode_unit_len = 0; -} - -static void rcode_unit_start( execution_t *exec ) -{ - exec->rcode_unit_len = 0; -} - -static void rcode_code( execution_t *exec, const code_t code ) -{ - append_code_val( &exec->parser->pda_run->rcode_collect, code ); - exec->rcode_unit_len += SIZEOF_CODE; -} - -static void rcode_half( execution_t *exec, const half_t half ) -{ - append_half( &exec->parser->pda_run->rcode_collect, half ); - exec->rcode_unit_len += SIZEOF_HALF; -} - -static void rcode_word( execution_t *exec, const word_t 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 *all_rev ) -{ - /* Read the length */ - 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 = all_rev->tab_len - len - SIZEOF_WORD; - prcode = all_rev->data + start; - - /* Backup over it. */ - all_rev->tab_len -= len + SIZEOF_WORD; - return prcode; -} - -tree_t **colm_execute_code( program_t *prg, execution_t *exec, tree_t **sp, code_t *instr ) -{ - /* When we exit we are going to verify that we did not eat up any stack - * space. */ - tree_t **root = sp; - code_t c; - -again: - c = *instr++; - //debug( REALM_BYTECODE, "--in 0x%x\n", c ); - - switch ( c ) { - case IN_RESTORE_LHS: { - tree_t *restore; - read_tree( restore ); - - debug( prg, REALM_BYTECODE, "IN_RESTORE_LHS\n" ); - 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: { - debug( prg, REALM_BYTECODE, "IN_LOAD_NIL\n" ); - vm_push_tree( 0 ); - break; - } - case IN_LOAD_TREE: { - tree_t *tree; - read_tree( tree ); - vm_push_tree( tree ); - debug( prg, REALM_BYTECODE, "IN_LOAD_TREE %p id: %d refs: %d\n", - tree, tree->id, tree->refs ); - break; - } - case IN_LOAD_WORD: { - debug( prg, REALM_BYTECODE, "IN_LOAD_WORD\n" ); - word_t w; - read_word( w ); - vm_push_type( word_t, w ); - break; - } - case IN_LOAD_TRUE: { - debug( prg, REALM_BYTECODE, "IN_LOAD_TRUE\n" ); - //colm_tree_upref( prg, 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, prg->falseVal ); - vm_push_tree( prg->false_val ); - break; - } - case IN_LOAD_INT: { - word_t i; - read_word( i ); - - debug( prg, REALM_BYTECODE, "IN_LOAD_INT %d\n", i ); - - value_t value = i; - vm_push_value( value ); - break; - } - case IN_LOAD_STR: { - word_t offset; - read_word( offset ); - - debug( prg, REALM_BYTECODE, "IN_LOAD_STR %d\n", offset ); - - head_t *lit = make_literal( prg, offset ); - tree_t *tree = construct_string( prg, lit ); - colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - case IN_READ_REDUCE: { - half_t generic_id; - half_t reducer_id; - read_half( generic_id ); - read_half( reducer_id ); - - input_t *input = vm_pop_input(); - - debug( prg, REALM_BYTECODE, "IN_READ_REDUCE %hd %hd\n", generic_id, reducer_id ); - - prg->rtd->read_reduce( prg, reducer_id, input ); - - vm_push_tree( 0 ); - - break; - } - - /* - * LOAD_GLOBAL - */ - case IN_LOAD_GLOBAL_R: { - debug( prg, REALM_BYTECODE, "IN_LOAD_GLOBAL_R\n" ); - - vm_push_struct( prg->global ); - break; - } - case IN_LOAD_GLOBAL_WV: { - debug( prg, REALM_BYTECODE, "IN_LOAD_GLOBAL_WV\n" ); - - assert( exec->WV ); - - vm_push_struct( prg->global ); - - /* Set up the reverse instruction. */ - rcode_unit_start( exec ); - rcode_code( exec, IN_LOAD_GLOBAL_BKT ); - break; - } - case IN_LOAD_GLOBAL_WC: { - debug( prg, REALM_BYTECODE, "IN_LOAD_GLOBAL_WC\n" ); - - assert( !exec->WV ); - - /* This is identical to the _R version, but using it for writing - * would be confusing. */ - vm_push_struct( prg->global ); - break; - } - case IN_LOAD_GLOBAL_BKT: { - debug( prg, REALM_BYTECODE, "IN_LOAD_GLOBAL_BKT\n" ); - - vm_push_struct( prg->global ); - break; - } - - case IN_LOAD_INPUT_R: { - debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_R\n" ); - - assert( exec->parser != 0 ); - vm_push_input( exec->parser->input ); - break; - } - case IN_LOAD_INPUT_WV: { - debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_WV\n" ); - - assert( exec->WV ); - - assert( exec->parser != 0 ); - vm_push_input( exec->parser->input ); - - /* Set up the reverse instruction. */ - rcode_unit_start( exec ); - rcode_code( exec, IN_LOAD_INPUT_BKT ); - rcode_word( exec, (word_t)exec->parser->input ); - break; - } - case IN_LOAD_INPUT_WC: { - debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_WC\n" ); - - assert( !exec->WV ); - - assert( exec->parser != 0 ); - vm_push_input( exec->parser->input ); - break; - } - case IN_LOAD_INPUT_BKT: { - tree_t *accum_stream; - read_tree( accum_stream ); - - debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_BKT\n" ); - - colm_tree_upref( prg, 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->pda_run->context ); - break; - } - case IN_LOAD_CONTEXT_WV: { - debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_WV\n" ); - - assert( exec->WV ); - - vm_push_type( struct_t *, exec->parser->pda_run->context ); - - /* Set up the reverse instruction. */ - rcode_unit_start( exec ); - rcode_code( exec, IN_LOAD_CONTEXT_BKT ); - break; - } - case IN_LOAD_CONTEXT_WC: { - debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_WC\n" ); - - assert( !exec->WV ); - - /* This is identical to the _R version, but using it for writing - * would be confusing. */ - 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->pda_run->context ); - break; - } - - case IN_SET_PARSER_CONTEXT: { - debug( prg, REALM_BYTECODE, "IN_SET_PARSER_CONTEXT\n" ); - - struct_t *strct = vm_pop_struct(); - parser_t *parser = vm_pop_parser(); - - colm_parser_set_context( prg, sp, parser, strct ); - - vm_push_parser( parser ); - break; - } - - case IN_SET_PARSER_INPUT: { - debug( prg, REALM_BYTECODE, "IN_SET_PARSER_INPUT\n" ); - - input_t *to_replace_with = vm_pop_input(); - parser_t *parser = vm_pop_parser(); - - parser->input = to_replace_with; - - vm_push_parser( parser ); - - break; - } - - case IN_INIT_CAPTURES: { - consume_byte(); - - debug( prg, REALM_BYTECODE, "IN_INIT_CAPTURES\n" ); - - /* If there are captures (this is a translate block) then copy them into - * the local frame now. */ - struct lang_el_info *lel_info = prg->rtd->lel_info; - struct pda_run *pda_run = exec->parser->pda_run; - char **mark = pda_run->mark; - - int i, num_capture_attr = lel_info[pda_run->token_id].num_capture_attr; - for ( i = 0; i < 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 = construct_string( prg, data ); - colm_tree_upref( prg, string ); - set_local( exec, -1 - i, string ); - } - break; - } - case IN_INIT_RHS_EL: { - half_t position; - short field; - read_half( position ); - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_INIT_RHS_EL %hd\n", field ); - - tree_t *val = get_rhs_el( prg, exec->parser->pda_run->red_lel->shadow->tree, position ); - colm_tree_upref( prg, val ); - vm_set_local(exec, field, val); - break; - } - - case IN_INIT_LHS_EL: { - short field; - read_half( field ); - - 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->pda_run->red_lel->shadow->tree; - - /* Save it. */ - colm_tree_upref( prg, val ); - exec->parser->pda_run->parsed = val; - - exec->parser->pda_run->red_lel->shadow->tree = 0; - vm_set_local(exec, field, val); - break; - } - case IN_STORE_LHS_EL: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_STORE_LHS_EL %hd\n", field ); - - tree_t *val = vm_get_local(exec, field); - vm_set_local(exec, field, 0); - exec->parser->pda_run->red_lel->shadow->tree = val; - break; - } - case IN_UITER_ADVANCE: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_ADVANCE\n" ); - - /* Get the iterator. */ - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - - long yield_size = vm_ssize() - uiter->root_size; - assert( uiter->yield_size == yield_size ); - - /* Fix the return instruction pointer. */ - uiter->stack_root[-IFR_AA + IFR_RIN] = (SW)instr; - - instr = uiter->resume; - exec->frame_ptr = uiter->frame; - exec->iframe_ptr = &uiter->stack_root[-IFR_AA]; - break; - } - case IN_UITER_GET_CUR_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_GET_CUR_R\n" ); - - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - tree_t *val = uiter->ref.kid->tree; - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_UITER_GET_CUR_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_GET_CUR_WC\n" ); - - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - split_ref( prg, &sp, &uiter->ref ); - tree_t *split = uiter->ref.kid->tree; - colm_tree_upref( prg, split ); - vm_push_tree( split ); - break; - } - case IN_UITER_SET_CUR_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_SET_CUR_WC\n" ); - - tree_t *t = vm_pop_tree(); - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - split_ref( prg, &sp, &uiter->ref ); - tree_t *old = uiter->ref.kid->tree; - set_uiter_cur( prg, uiter, t ); - colm_tree_downref( prg, sp, old ); - break; - } - case IN_GET_LOCAL_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_R %hd\n", field ); - - tree_t *val = vm_get_local(exec, field); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_LOCAL_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_WC %hd\n", field ); - - tree_t *split = get_local_split( prg, exec, field ); - colm_tree_upref( prg, split ); - vm_push_tree( split ); - break; - } - case IN_SET_LOCAL_WC: { - short field; - read_half( field ); - debug( prg, REALM_BYTECODE, "IN_SET_LOCAL_WC %hd\n", field ); - - tree_t *val = vm_pop_tree(); - colm_tree_downref( prg, sp, vm_get_local(exec, field) ); - set_local( exec, field, val ); - break; - } - case IN_GET_LOCAL_VAL_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_VAL_R %hd\n", field ); - - tree_t *val = vm_get_local(exec, field); - vm_push_tree( val ); - break; - } - case IN_SET_LOCAL_VAL_WC: { - short field; - read_half( field ); - debug( prg, REALM_BYTECODE, "IN_SET_LOCAL_VAL_WC %hd\n", field ); - - tree_t *val = vm_pop_tree(); - vm_set_local(exec, field, val); - break; - } - case IN_SAVE_RET: { - debug( prg, REALM_BYTECODE, "IN_SAVE_RET\n" ); - - value_t val = vm_pop_value(); - vm_set_local(exec, FR_RV, (tree_t*)val); - break; - } - case IN_GET_LOCAL_REF_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_REF_R\n" ); - - ref_t *ref = (ref_t*) vm_get_plocal(exec, field); - tree_t *val = ref->kid->tree; - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_LOCAL_REF_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LOCAL_REF_WC\n" ); - - ref_t *ref = (ref_t*) vm_get_plocal(exec, field); - split_ref( prg, &sp, ref ); - tree_t *val = ref->kid->tree; - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_SET_LOCAL_REF_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_LOCAL_REF_WC\n" ); - - tree_t *val = vm_pop_tree(); - ref_t *ref = (ref_t*) vm_get_plocal(exec, field); - split_ref( prg, &sp, ref ); - ref_set_value( prg, sp, ref, val ); - break; - } - case IN_GET_FIELD_TREE_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_TREE_R %d\n", field ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = colm_tree_get_field( obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_FIELD_TREE_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_TREE_WC %d\n", field ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *split = get_field_split( prg, obj, field ); - colm_tree_upref( prg, split ); - vm_push_tree( split ); - break; - } - case IN_GET_FIELD_TREE_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_TREE_WV\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *split = get_field_split( prg, obj, field ); - colm_tree_upref( prg, split ); - vm_push_tree( split ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_GET_FIELD_TREE_BKT ); - rcode_half( exec, field ); - break; - } - case IN_GET_FIELD_TREE_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_TREE_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *split = get_field_split( prg, obj, field ); - colm_tree_upref( prg, split ); - vm_push_tree( split ); - break; - } - case IN_SET_FIELD_TREE_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_TREE_WC %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - /* Downref the old value. */ - tree_t *prev = colm_tree_get_field( obj, field ); - colm_tree_downref( prg, sp, prev ); - - colm_tree_set_field( prg, obj, field, val ); - break; - } - case IN_SET_FIELD_TREE_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_TREE_WV %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - /* Save the old value, then set the field. */ - tree_t *prev = colm_tree_get_field( obj, field ); - colm_tree_set_field( prg, obj, field, val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_SET_FIELD_TREE_BKT ); - rcode_half( exec, field ); - rcode_word( exec, (word_t)prev ); - rcode_unit_term( exec ); - break; - } - case IN_SET_FIELD_TREE_BKT: { - short field; - tree_t *val; - read_half( field ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_TREE_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - /* Downref the old value. */ - tree_t *prev = colm_tree_get_field( obj, field ); - colm_tree_downref( prg, sp, prev ); - - colm_tree_set_field( prg, obj, field, val ); - break; - } - case IN_SET_FIELD_TREE_LEAVE_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_TREE_LEAVE_WC\n" ); - - /* Note that we don't downref the object here because we are - * leaving it on the stack. */ - tree_t *obj = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - - /* Downref the old value. */ - tree_t *prev = colm_tree_get_field( obj, field ); - colm_tree_downref( prg, sp, prev ); - - /* Set the field. */ - colm_tree_set_field( prg, obj, field, val ); - - /* Leave the object on the top of the stack. */ - vm_push_tree( obj ); - break; - } - case IN_GET_FIELD_VAL_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_VAL_R %d\n", field ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *pointer = colm_tree_get_field( obj, field ); - value_t value = 0; - if ( pointer != 0 ) - value = colm_get_pointer_val( pointer ); - vm_push_value( value ); - break; - } - case IN_SET_FIELD_VAL_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_VAL_WC %d\n", field ); - - tree_t *obj = vm_pop_tree(); - value_t value = vm_pop_value(); - colm_tree_downref( prg, sp, obj ); - - /* Downref the old value. */ - tree_t *prev = colm_tree_get_field( obj, field ); - colm_tree_downref( prg, sp, prev ); - - /* Make it into a pointer. */ - tree_t *pointer = colm_construct_pointer( prg, value ); - colm_tree_upref( prg, pointer ); - - colm_tree_set_field( prg, obj, field, pointer ); - break; - } - case IN_NEW_STRUCT: { - short id; - read_half( id ); - - debug( prg, REALM_BYTECODE, "IN_NEW_STRUCT %hd\n", id ); - struct_t *item = colm_struct_new( prg, id ); - vm_push_struct( item ); - break; - } - case IN_NEW_STREAM: { - debug( prg, REALM_BYTECODE, "IN_NEW_STREAM\n" ); - stream_t *item = colm_stream_open_collect( prg ); - vm_push_stream( item ); - break; - } - case IN_GET_COLLECT_STRING: { - debug( prg, REALM_BYTECODE, "IN_GET_COLLECT_STRING\n" ); - stream_t *stream = vm_pop_stream(); - str_t *str = collect_string( prg, stream ); - colm_tree_upref( prg, (tree_t*)str ); - vm_push_string( str ); - break; - } - case IN_GET_STRUCT_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_STRUCT_R %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = colm_struct_get_field( obj, tree_t*, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_STRUCT_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_STRUCT_WC %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = colm_struct_get_field( obj, tree_t*, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - - break; - } - case IN_GET_STRUCT_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_STRUCT_WV\n" ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = colm_struct_get_field( obj, tree_t*, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_GET_STRUCT_BKT ); - rcode_half( exec, field ); - break; - } - case IN_GET_STRUCT_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_STRUCT_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *split = get_field_split( prg, obj, field ); - colm_tree_upref( prg, split ); - vm_push_tree( split ); - break; - } - case IN_SET_STRUCT_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_WC %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - - /* Downref the old value. */ - tree_t *prev = colm_struct_get_field( obj, tree_t*, field ); - colm_tree_downref( prg, sp, prev ); - colm_struct_set_field( obj, tree_t*, field, val ); - break; - } - case IN_SET_STRUCT_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_WV %d\n", field ); - - struct_t *obj = vm_pop_struct(); - tree_t *val = vm_pop_tree(); - - /* Save the old value, then set the field. */ - tree_t *prev = colm_struct_get_field( obj, tree_t*, field ); - colm_struct_set_field( obj, tree_t*, field, val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_SET_STRUCT_BKT ); - rcode_half( exec, field ); - rcode_word( exec, (word_t)prev ); - rcode_unit_term( exec ); - break; - } - case IN_SET_STRUCT_BKT: { - short field; - tree_t *val; - read_half( field ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - - /* Downref the old value. */ - tree_t *prev = colm_struct_get_field( obj, tree_t*, field ); - colm_tree_downref( prg, sp, prev ); - - colm_struct_set_field( obj, tree_t*, field, val ); - break; - } - case IN_GET_STRUCT_VAL_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_STRUCT_VAL_R %d\n", field ); - - tree_t *obj = vm_pop_tree(); - tree_t *val = colm_struct_get_field( obj, tree_t*, field ); - vm_push_tree( val ); - break; - } - case IN_SET_STRUCT_VAL_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_VAL_WC %d\n", field ); - - struct_t *strct = vm_pop_struct(); - tree_t *val = vm_pop_tree(); - - colm_struct_set_field( strct, tree_t*, field, val ); - break; - } - case IN_SET_STRUCT_VAL_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_VAL_WV %d\n", field ); - - struct_t *strct = vm_pop_struct(); - tree_t *val = vm_pop_tree(); - - tree_t *prev = colm_struct_get_field( strct, tree_t*, field ); - colm_struct_set_field( strct, tree_t*, field, val ); - - rcode_code( exec, IN_SET_STRUCT_VAL_BKT ); - rcode_half( exec, field ); - rcode_word( exec, (word_t)prev ); - rcode_unit_term( exec ); - break; - } - case IN_SET_STRUCT_VAL_BKT: { - short field; - tree_t *val; - read_half( field ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_VAL_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - - colm_struct_set_field( obj, tree_t*, field, val ); - break; - } - case IN_GET_RHS_VAL_R: { - debug( prg, REALM_BYTECODE, "IN_GET_RHS_VAL_R\n" ); - int i, done = 0; - uchar len; - - tree_t *obj = vm_pop_tree(), *val = 0; - colm_tree_downref( prg, sp, obj ); - - read_byte( len ); - for ( i = 0; i < len; i++ ) { - 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; - } - } - - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_POP_TREE: { - debug( prg, REALM_BYTECODE, "IN_POP_TREE\n" ); - - tree_t *val = vm_pop_tree(); - colm_tree_downref( prg, sp, val ); - break; - } - case IN_POP_VAL: { - debug( prg, REALM_BYTECODE, "IN_POP_VAL\n" ); - - vm_pop_tree(); - break; - } - case IN_POP_N_WORDS: { - short n; - read_half( n ); - - debug( prg, REALM_BYTECODE, "IN_POP_N_WORDS %hd\n", n ); - - vm_popn( n ); - break; - } - case IN_INT_TO_STR: { - debug( prg, REALM_BYTECODE, "IN_INT_TO_STR\n" ); - - value_t i = vm_pop_value(); - head_t *res = int_to_str( prg, (long)i ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - break; - } - case IN_TREE_TO_STR_XML: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR_XML_AC\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str_xml( prg, sp, tree, false, false ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TO_STR_XML_AC: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR_XML_AC\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str_xml_ac( prg, sp, tree, false, false ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TO_STR_POSTFIX: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR_XML_AC\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str_postfix( prg, sp, tree, false, false ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TO_STR: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str( prg, sp, tree, false, false ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TO_STR_TRIM: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR_TRIM\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str( prg, sp, tree, true, false ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TO_STR_TRIM_A: { - debug( prg, REALM_BYTECODE, "IN_TREE_TO_STR_TRIM_A\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *res = tree_to_str( prg, sp, tree, true, true ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TREE_TRIM: { - debug( prg, REALM_BYTECODE, "IN_TREE_TRIM\n" ); - - tree_t *tree = vm_pop_tree(); - tree_t *trimmed = tree_trim( prg, sp, tree ); - vm_push_tree( trimmed ); - break; - } - case IN_CONCAT_STR: { - debug( prg, REALM_BYTECODE, "IN_CONCAT_STR\n" ); - - str_t *s2 = vm_pop_string(); - str_t *s1 = vm_pop_string(); - head_t *res = concat_str( s1->value, s2->value ); - tree_t *str = construct_string( prg, res ); - colm_tree_upref( prg, str ); - colm_tree_downref( prg, sp, (tree_t*)s1 ); - colm_tree_downref( prg, sp, (tree_t*)s2 ); - vm_push_tree( str ); - break; - } - - case IN_STR_LENGTH: { - debug( prg, REALM_BYTECODE, "IN_STR_LENGTH\n" ); - - str_t *str = vm_pop_string(); - long len = string_length( str->value ); - value_t res = len; - vm_push_value( res ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case IN_JMP_FALSE_TREE: { - short dist; - read_half( dist ); - - debug( prg, REALM_BYTECODE, "IN_JMP_FALSE_TREE %d\n", dist ); - - tree_t *tree = vm_pop_tree(); - if ( test_false( prg, tree ) ) - instr += dist; - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_JMP_TRUE_TREE: { - short dist; - read_half( dist ); - - debug( prg, REALM_BYTECODE, "IN_JMP_TRUE_TREE %d\n", dist ); - - tree_t *tree = vm_pop_tree(); - if ( !test_false( prg, tree ) ) - instr += dist; - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_JMP_FALSE_VAL: { - short dist; - read_half( dist ); - - debug( prg, REALM_BYTECODE, "IN_JMP_FALSE_VAL %d\n", dist ); - - tree_t *tree = vm_pop_tree(); - if ( tree == 0 ) - instr += dist; - break; - } - case IN_JMP_TRUE_VAL: { - short dist; - read_half( dist ); - - debug( prg, REALM_BYTECODE, "IN_JMP_TRUE_VAL %d\n", dist ); - - tree_t *tree = vm_pop_tree(); - if ( tree != 0 ) - instr += dist; - break; - } - case IN_JMP: { - short dist; - read_half( dist ); - - debug( prg, REALM_BYTECODE, "IN_JMP\n" ); - - instr += dist; - break; - } - case IN_REJECT: { - debug( prg, REALM_BYTECODE, "IN_REJECT\n" ); - exec->parser->pda_run->reject = true; - break; - } - - /* - * Binary comparison operators. - */ - case IN_TST_EQL_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_EQL_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r == 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_EQL_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_EQL_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = o1 == o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_NOT_EQL_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_NOT_EQL_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r != 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_NOT_EQL_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_NOT_EQL_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = o1 != o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_LESS_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_LESS_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t res = (long)o1 < (long)o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( res ); - break; - } - case IN_TST_LESS_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_LESS_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r < 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_LESS_EQL_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_LESS_EQL_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = (long)o1 <= (long)o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_LESS_EQL_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_LESS_EQL_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r <= 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_GRTR_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_GRTR_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = (long)o1 > (long)o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_GRTR_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_GRTR_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r > 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_GRTR_EQL_VAL: { - debug( prg, REALM_BYTECODE, "IN_TST_GRTR_EQL_VAL\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - - value_t val = (long)o1 >= (long)o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_GRTR_EQL_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_GRTR_EQL_TREE\n" ); - - tree_t *o2 = vm_pop_tree(); - tree_t *o1 = vm_pop_tree(); - long r = colm_cmp_tree( prg, o1, o2 ); - value_t val = r >= 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - colm_tree_downref( prg, sp, o1 ); - colm_tree_downref( prg, sp, o2 ); - break; - } - case IN_TST_LOGICAL_AND: { - debug( prg, REALM_BYTECODE, "IN_TST_LOGICAL_AND\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = o1 && o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - case IN_TST_LOGICAL_OR: { - debug( prg, REALM_BYTECODE, "IN_TST_LOGICAL_OR\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - value_t val = o1 || o2 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - - case IN_TST_NZ_TREE: { - debug( prg, REALM_BYTECODE, "IN_TST_NZ_TREE\n" ); - - tree_t *tree = vm_pop_tree(); - long r = !test_false( prg, tree ); - colm_tree_downref( prg, sp, tree ); - vm_push_value( r ); - break; - } - - case IN_NOT_VAL: { - debug( prg, REALM_BYTECODE, "IN_NOT_VAL\n" ); - - value_t o1 = vm_pop_value(); - value_t val = o1 == 0 ? TRUE_VAL : FALSE_VAL; - vm_push_value( val ); - break; - } - - case IN_NOT_TREE: { - debug( prg, REALM_BYTECODE, "IN_NOT_TREE\n" ); - - tree_t *tree = vm_pop_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 ); - break; - } - - case IN_ADD_INT: { - debug( prg, REALM_BYTECODE, "IN_ADD_INT\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - long r = (long)o1 + (long)o2; - value_t val = r; - vm_push_value( val ); - break; - } - case IN_MULT_INT: { - debug( prg, REALM_BYTECODE, "IN_MULT_INT\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - long r = (long)o1 * (long)o2; - value_t val = r; - vm_push_value( val ); - break; - } - case IN_DIV_INT: { - debug( prg, REALM_BYTECODE, "IN_DIV_INT\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - long r = (long)o1 / (long)o2; - value_t val = r; - vm_push_value( val ); - break; - } - case IN_SUB_INT: { - debug( prg, REALM_BYTECODE, "IN_SUB_INT\n" ); - - value_t o2 = vm_pop_value(); - value_t o1 = vm_pop_value(); - long r = (long)o1 - (long)o2; - value_t val = r; - vm_push_value( val ); - break; - } - case IN_DUP_VAL: { - debug( prg, REALM_BYTECODE, "IN_DUP_VAL\n" ); - - word_t val = (word_t)vm_top(); - vm_push_type( word_t, val ); - break; - } - case IN_DUP_TREE: { - debug( prg, REALM_BYTECODE, "IN_DUP_TREE\n" ); - - tree_t *val = vm_top(); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_TRITER_FROM_REF: { - short field; - half_t arg_size; - half_t search_type_id; - read_half( field ); - read_half( arg_size ); - read_half( search_type_id ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_FROM_REF " - "%hd %hd %hd\n", field, arg_size, search_type_id ); - - 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 **stack_root = vm_ptop(); - long root_size = vm_ssize(); - - colm_init_tree_iter( (tree_iter_t*)mem, stack_root, - arg_size, root_size, &root_ref, search_type_id ); - break; - } - case IN_TRITER_UNWIND: - case IN_TRITER_DESTROY: { - short field; - read_half( field ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - debug( prg, REALM_BYTECODE, "IN_TRITER_DESTROY %hd %d\n", - field, iter->yield_size ); - colm_tree_iter_destroy( prg, &sp, iter ); - break; - } - case IN_REV_TRITER_FROM_REF: { - short field; - half_t arg_size; - half_t search_type_id; - read_half( field ); - read_half( arg_size ); - read_half( search_type_id ); - - debug( prg, REALM_BYTECODE, "IN_REV_TRITER_FROM_REF " - "%hd %hd %hd\n", field, arg_size, search_type_id ); - - ref_t root_ref; - root_ref.kid = vm_pop_kid(); - root_ref.next = vm_pop_ref(); - - tree_t **stack_root = vm_ptop(); - long root_size = vm_ssize(); - - int children = 0; - kid_t *kid = tree_child( prg, root_ref.kid->tree ); - while ( kid != 0 ) { - vm_push_kid( kid ); - kid = kid->next; - children++; - } - - void *mem = vm_get_plocal(exec, field); - 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: - case IN_REV_TRITER_DESTROY: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_REV_TRITER_DESTROY\n" ); - - rev_tree_iter_t *iter = (rev_tree_iter_t*) vm_get_plocal(exec, field); - colm_rev_tree_iter_destroy( prg, &sp, iter ); - break; - } - case IN_TREE_SEARCH: { - word_t id; - read_word( id ); - - debug( prg, REALM_BYTECODE, "IN_TREE_SEARCH\n" ); - - tree_t *tree = vm_pop_tree(); - tree_t *res = tree_search( prg, tree, id ); - colm_tree_upref( prg, res ); - vm_push_tree( res ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_TRITER_ADVANCE: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_ADVANCE\n" ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = tree_iter_advance( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_TRITER_NEXT_CHILD: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_NEXT_CHILD\n" ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = tree_iter_next_child( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_REV_TRITER_PREV_CHILD: { - short field; - read_half( field ); - - 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 = tree_rev_iter_prev_child( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_TRITER_NEXT_REPEAT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_NEXT_REPEAT\n" ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = tree_iter_next_repeat( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_TRITER_PREV_REPEAT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_PREV_REPEAT\n" ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - tree_t *res = tree_iter_prev_repeat( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_TRITER_GET_CUR_R: { - short field; - read_half( field ); - - 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 = tree_iter_deref_cur( iter ); - colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - case IN_TRITER_GET_CUR_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_GET_CUR_WC\n" ); - - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - split_iter_cur( prg, &sp, iter ); - tree_t *tree = tree_iter_deref_cur( iter ); - colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - case IN_TRITER_SET_CUR_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_SET_CUR_WC\n" ); - - tree_t *tree = vm_pop_tree(); - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - 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 arg_size; - half_t generic_id; - read_half( field ); - read_half( arg_size ); - read_half( generic_id ); - - debug( prg, REALM_BYTECODE, "IN_GEN_ITER_FROM_REF " - "%hd %hd %hd\n", field, arg_size, generic_id ); - - 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 **stack_root = vm_ptop(); - long root_size = vm_ssize(); - - colm_init_list_iter( (generic_iter_t*)mem, stack_root, arg_size, - root_size, &root_ref, generic_id ); - break; - } - case IN_GEN_ITER_UNWIND: - case IN_GEN_ITER_DESTROY: { - short field; - read_half( field ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - - debug( prg, REALM_BYTECODE, "IN_LIST_ITER_DESTROY %d\n", iter->yield_size ); - - colm_list_iter_destroy( prg, &sp, iter ); - break; - } - case IN_LIST_ITER_ADVANCE: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_LIST_ITER_ADVANCE\n" ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - tree_t *res = colm_list_iter_advance( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_REV_LIST_ITER_ADVANCE: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_REV_LIST_ITER_ADVANCE\n" ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - tree_t *res = colm_rev_list_iter_advance( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_MAP_ITER_ADVANCE: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_MAP_ITER_ADVANCE\n" ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - tree_t *res = colm_map_iter_advance( prg, &sp, iter ); - //colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_GEN_ITER_GET_CUR_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GEN_ITER_GET_CUR_R\n" ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - tree_t *tree = colm_list_iter_deref_cur( prg, iter ); - //colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - case IN_GEN_VITER_GET_CUR_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GEN_VITER_GET_CUR_R\n" ); - - generic_iter_t *iter = (generic_iter_t*) vm_get_plocal(exec, field); - value_t value = colm_viter_deref_cur( prg, iter ); - vm_push_value( value ); - break; - } - case IN_MATCH: { - 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 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 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 = match_pattern( bindings, prg, root_node, &kid, false ); - - if ( !matched ) - memset( bindings, 0, sizeof(tree_t*)*(1+num_bindings) ); - else { - int b; - for ( b = 1; b <= num_bindings; b++ ) - assert( bindings[b] != 0 ); - } - - tree_t *result = matched ? tree : 0; - colm_tree_upref( prg, result ); - vm_push_tree( result ? tree : 0 ); - int b; - for ( b = 1; b <= num_bindings; b++ ) { - colm_tree_upref( prg, bindings[b] ); - vm_push_tree( bindings[b] ); - } - - colm_tree_downref( prg, sp, tree ); - break; - } - - case IN_PROD_NUM: { - debug( prg, REALM_BYTECODE, "IN_PROD_NUM\n" ); - - tree_t *tree = vm_pop_tree(); - colm_tree_downref( prg, sp, tree ); - - value_t v = tree->prod_num; - vm_push_value( v ); - break; - } - - case IN_PRINT_TREE: { - uchar trim; - read_byte( trim ); - - debug( prg, REALM_BYTECODE, "IN_PRINT_TREE %d\n", (int)trim ); - - tree_t *to_send = vm_pop_tree(); - stream_t *stream = vm_pop_stream(); - - struct stream_impl *si = stream_to_impl( stream ); - - int auto_trim; - if ( trim == TRIM_YES ) - auto_trim = true; - else if ( trim == TRIM_NO ) - auto_trim = false; - else - auto_trim = si->funcs->get_option( prg, si, 0 ); - - si->funcs->print_tree( prg, sp, si, to_send, auto_trim ); - vm_push_stream( stream ); - colm_tree_downref( prg, sp, to_send ); - break; - } - - case IN_SEND_TEXT_W: { - uchar trim; - read_byte( trim ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TEXT_W %d\n", (int)trim ); - - tree_t *to_send = vm_pop_tree(); - parser_t *parser = vm_pop_parser(); - - struct input_impl *si = input_to_impl( parser->input ); - - int auto_trim; - if ( trim == TRIM_YES ) - auto_trim = true; - else if ( trim == TRIM_NO ) - auto_trim = false; - else - auto_trim = si->funcs->get_option( prg, si, 0 ); - - word_t len = stream_append_text( prg, sp, parser->input, to_send, auto_trim ); - - vm_push_parser( parser ); - - if ( !exec->WV ) - colm_tree_downref( prg, sp, to_send ); - else { - rcode_unit_start( exec ); - rcode_code( exec, IN_SEND_TEXT_BKT ); - rcode_word( exec, (word_t) parser ); - rcode_word( exec, (word_t) to_send ); - rcode_word( exec, (word_t) len ); - rcode_unit_term( exec ); - } - - exec->steps = parser->pda_run->steps; - exec->pcr = PCR_START; - break; - } - - case IN_SEND_TEXT_BKT: { - parser_t *parser; - tree_t *sent; - word_t len; - read_parser( parser ); - read_tree( sent ); - read_word( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TEXT_BKT\n" ); - - struct input_impl *si = input_to_impl( parser->input ); - stream_undo_append( prg, sp, si, sent, len ); - - colm_tree_downref( prg, sp, sent ); - break; - } - - case IN_SEND_TREE_W: { - uchar trim; - read_byte( trim ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TREE_W %d\n", (int)trim ); - - tree_t *to_send = vm_pop_tree(); - parser_t *parser = vm_pop_parser(); - - struct input_impl *si = input_to_impl( parser->input ); - - int auto_trim; - if ( trim == TRIM_YES ) - auto_trim = true; - else if ( trim == TRIM_NO ) - auto_trim = false; - else - auto_trim = si->funcs->get_option( prg, si, 0 ); - - if ( auto_trim ) - to_send = tree_trim( prg, sp, to_send ); - - word_t len = stream_append_tree( prg, sp, parser->input, to_send ); - - vm_push_parser( parser ); - - if ( !exec->WV ) - colm_tree_downref( prg, sp, to_send ); - else { - rcode_unit_start( exec ); - rcode_code( exec, IN_SEND_TREE_BKT ); - rcode_word( exec, (word_t) parser ); - rcode_word( exec, (word_t) to_send ); - rcode_word( exec, (word_t) len ); - rcode_unit_term( exec ); - } - - exec->steps = parser->pda_run->steps; - exec->pcr = PCR_START; - break; - } - - case IN_SEND_TREE_BKT: { - parser_t *parser; - tree_t *sent; - word_t len; - read_parser( parser ); - read_tree( sent ); - read_word( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TREE_BKT\n" ); - - struct input_impl *si = input_to_impl( parser->input ); - stream_undo_append( prg, sp, si, sent, len ); - - colm_tree_downref( prg, sp, sent ); - break; - } - - case IN_SEND_NOTHING: { - parser_t *parser = vm_pop_parser(); - vm_push_parser( parser ); - exec->steps = parser->pda_run->steps; - exec->pcr = PCR_START; - break; - } - case IN_SEND_STREAM_W: { - debug( prg, REALM_BYTECODE, "IN_SEND_STREAM_W\n" ); - - stream_t *to_send = vm_pop_stream(); - parser_t *parser = vm_pop_parser(); - - word_t len = stream_append_stream( prg, sp, parser->input, to_send ); - - vm_push_parser( parser ); - - if ( exec->WV ) { - rcode_unit_start( exec ); - rcode_code( exec, IN_SEND_STREAM_BKT ); - rcode_word( exec, (word_t) parser ); - rcode_word( exec, (word_t) to_send ); - rcode_word( exec, (word_t) len ); - rcode_unit_term( exec ); - } - - exec->steps = parser->pda_run->steps; - exec->pcr = PCR_START; - - break; - } - - case IN_SEND_STREAM_BKT: { - parser_t *parser; - tree_t *sent; - word_t len; - read_parser( parser ); - read_tree( sent ); - read_word( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_STREAM_BKT\n" ); - - struct input_impl *si = input_to_impl( parser->input ); - stream_undo_append_stream( prg, sp, si, sent, len ); - break; - } - - case IN_SEND_EOF_W: { - struct input_impl *si; - - debug( prg, REALM_BYTECODE, "IN_SEND_EOF_W\n" ); - parser_t *parser = vm_pop_parser(); - vm_push_parser( parser ); - - si = input_to_impl( parser->input ); - si->funcs->set_eof_mark( prg, si, true ); - - if ( exec->WV ) { - rcode_unit_start( exec ); - rcode_code( exec, IN_SEND_EOF_BKT ); - rcode_word( exec, (word_t) parser ); - rcode_unit_term( exec ); - } - - exec->steps = parser->pda_run->steps; - exec->pcr = PCR_START; - break; - } - - case IN_SEND_EOF_BKT: { - parser_t *parser; - read_parser( parser ); - - debug( prg, REALM_BYTECODE, "IN_SEND_EOF_BKT\n" ); - - struct input_impl *si = input_to_impl( parser->input ); - si->funcs->set_eof_mark( prg, si, false ); - break; - } - - case IN_INPUT_CLOSE_WC: { - debug( prg, REALM_BYTECODE, "IN_INPUT_CLOSE_WC\n" ); - - stream_t *stream = vm_pop_stream(); - struct stream_impl *si = stream->impl; - - si->funcs->close_stream( prg, si ); - - vm_push_stream( stream ); - break; - } - case IN_INPUT_AUTO_TRIM_WC: { - debug( prg, REALM_BYTECODE, "IN_INPUT_AUTO_TRIM_WC\n" ); - - stream_t *stream = vm_pop_stream(); - value_t auto_trim = vm_pop_value(); - struct stream_impl *si = stream->impl; - - si->funcs->set_option( prg, si, 0, (long) auto_trim ); - - vm_push_stream( stream ); - break; - } - case IN_IINPUT_AUTO_TRIM_WC: { - debug( prg, REALM_BYTECODE, "IN_INPUT_AUTO_TRIM_WC\n" ); - - input_t *input = vm_pop_input(); - value_t auto_trim = vm_pop_value(); - struct input_impl *ii = input->impl; - - ii->funcs->set_option( prg, ii, 0, (long) auto_trim ); - - vm_push_input( input ); - break; - } - - case IN_SET_ERROR: { - debug( prg, REALM_BYTECODE, "IN_SET_ERROR\n" ); - - tree_t *error = vm_pop_tree(); - colm_tree_downref( prg, sp, prg->error ); - prg->error = error; - break; - } - - case IN_GET_ERROR: { - debug( prg, REALM_BYTECODE, "IN_GET_ERROR\n" ); - - vm_pop_tree(); - colm_tree_upref( prg, prg->error ); - vm_push_tree( prg->error ); - break; - } - - /* stream: - * Push value and stash current on IN_PCR_CALL. The instructions - * exectued by a call need access to the stream the parser was called - * with. We need to preserver the stream for the caller, so we push - * first set it to the current stream. - * pcr: - * Need to preserve the pcr value between pda run invocations. Push - * current pcr value and start fresh with a new value on PCR_CALL. - * steps: - * Init from the PDA run when we start to parse. Need to preserve the - * starting steps value from the start of parsing to the moment we - * write the backtrack instruction. Start fresh with a private value - * on a PCR_CALL by pushing and initializing. */ - - case IN_PARSE_INIT_BKT: { - debug( prg, REALM_BYTECODE, "IN_PARSE_INIT_BKT\n" ); - - parser_t *parser; - word_t steps; - - read_parser( parser ); - read_word( steps ); - - vm_push_parser( parser ); - - exec->steps = steps; - exec->pcr = PCR_START; - break; - } - - case IN_LOAD_RETVAL: { - debug( prg, REALM_BYTECODE, "IN_LOAD_RETVAL\n" ); - vm_push_tree( exec->ret_val ); - break; - } - - case IN_PCR_RET: { - debug( prg, REALM_BYTECODE, "IN_PCR_RET\n" ); - - 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->frame_size ); - } - - instr = vm_pop_type(code_t*); - - exec->WV = vm_pop_type(word_t); - exec->parser = vm_pop_parser(); - exec->pcr = vm_pop_type(word_t); - exec->steps = vm_pop_type(word_t); - exec->frame_id = vm_pop_type(long); - exec->iframe_ptr = vm_pop_type(tree_t**); - exec->frame_ptr = vm_pop_type(tree_t**); - - assert( instr != 0 ); - break; - } - - case IN_PCR_END_DECK: { - debug( prg, REALM_BYTECODE, "IN_PCR_END_DECK\n" ); - exec->parser->pda_run->on_deck = false; - break; - } - - case IN_PARSE_FRAG_W: { - parser_t *parser = vm_pop_parser(); - vm_push_parser( parser ); - - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_W\n" ); - - exec->pcr = colm_parse_frag( prg, sp, parser->pda_run, - parser->input, exec->pcr ); - - /* If done, jump to the terminating instruction, otherwise fall - * through to call some code, then jump back here. */ - if ( exec->pcr != PCR_DONE ) - instr = pcr_call( prg, exec, &sp, instr, parser ); - else { - if ( exec->WV ) { - rcode_unit_start( exec ); - - rcode_code( exec, IN_PARSE_INIT_BKT ); - rcode_word( exec, (word_t)parser ); - rcode_word( exec, (word_t)exec->steps ); - rcode_code( exec, IN_PARSE_FRAG_BKT ); - rcode_unit_term( exec ); - } - - if ( prg->induce_exit ) - goto out; - } - break; - } - - case IN_PARSE_FRAG_BKT: { - parser_t *parser = vm_pop_parser(); - vm_push_parser( parser ); - - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_BKT\n" ); - - exec->pcr = colm_parse_undo_frag( prg, sp, parser->pda_run, - parser->input, exec->pcr, exec->steps ); - - if ( exec->pcr != PCR_DONE ) - instr = pcr_call( prg, exec, &sp, instr, parser ); - else { - vm_pop_parser(); - } - break; - } - - case IN_REDUCE_COMMIT: { - parser_t *parser = vm_pop_parser(); - vm_push_parser( parser ); - - debug( prg, REALM_BYTECODE, "IN_REDUCE_COMMIT\n" ); - - colm_parse_reduce_commit( prg, sp, parser->pda_run ); - break; - } - - - case IN_INPUT_PULL_WV: { - debug( prg, REALM_BYTECODE, "IN_INPUT_PULL_WV\n" ); - - input_t *input = vm_pop_input(); - tree_t *len = vm_pop_tree(); - tree_t *string = stream_pull_bc( prg, sp, 0, input, len ); - colm_tree_upref( prg, string ); - vm_push_tree( string ); - - /* Single unit. */ - colm_tree_upref( prg, string ); - rcode_code( exec, IN_INPUT_PULL_BKT ); - rcode_word( exec, (word_t) string ); - rcode_unit_term( exec ); - - //colm_tree_downref( prg, sp, len ); - break; - } - - case IN_INPUT_PULL_WC: { - debug( prg, REALM_BYTECODE, "IN_INPUT_PULL_WC\n" ); - - input_t *input = vm_pop_input(); - tree_t *len = vm_pop_tree(); - tree_t *string = stream_pull_bc( prg, sp, 0, input, len ); - colm_tree_upref( prg, string ); - vm_push_tree( string ); - - //colm_tree_downref( prg, sp, len ); - break; - } - case IN_INPUT_PULL_BKT: { - tree_t *string; - read_tree( string ); - - input_t *input = vm_pop_input(); - - debug( prg, REALM_BYTECODE, "IN_INPUT_PULL_BKT\n" ); - - undo_pull( prg, input, string ); - colm_tree_downref( prg, sp, string ); - break; - } - case IN_INPUT_PUSH_WV: { - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_WV\n" ); - - input_t *input = vm_pop_input(); - tree_t *tree = vm_pop_tree(); - long len = stream_push( prg, sp, input_to_impl( input ), tree, false ); - vm_push_tree( 0 ); - - /* Single unit. */ - rcode_code( exec, IN_INPUT_PUSH_BKT ); - rcode_word( exec, len ); - rcode_unit_term( exec ); - - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_INPUT_PUSH_IGNORE_WV: { - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_IGNORE_WV\n" ); - - input_t *input = vm_pop_input(); - tree_t *tree = vm_pop_tree(); - long len = stream_push( prg, sp, input_to_impl( input ), tree, true ); - vm_push_tree( 0 ); - - /* Single unit. */ - rcode_code( exec, IN_INPUT_PUSH_BKT ); - rcode_word( exec, len ); - rcode_unit_term( exec ); - - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_INPUT_PUSH_BKT: { - word_t len; - read_word( len ); - - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_BKT %d\n", len ); - - input_t *input = vm_pop_input(); - colm_undo_stream_push( prg, sp, input_to_impl( input ), len ); - break; - } - case IN_INPUT_PUSH_STREAM_WV: { - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_STREAM_WV\n" ); - - input_t *input = vm_pop_input(); - stream_t *to_push = vm_pop_stream(); - long len = stream_push_stream( prg, sp, input_to_impl( input ), to_push ); - vm_push_tree( 0 ); - - /* Single unit. */ - rcode_code( exec, IN_INPUT_PUSH_BKT ); - rcode_word( exec, len ); - rcode_unit_term( exec ); - break; - } - case IN_INPUT_PUSH_STREAM_BKT: { - word_t len; - read_word( len ); - - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_STREAM_BKT %d\n", len ); - - input_t *input = vm_pop_input(); - colm_undo_stream_push( prg, sp, input_to_impl( input ), len ); - break; - } - case IN_CONS_GENERIC: { - half_t generic_id; - half_t stop_id; - read_half( generic_id ); - read_half( stop_id ); - - debug( prg, REALM_BYTECODE, "IN_CONS_GENERIC %hd %hd\n", generic_id, stop_id ); - - struct_t *gen = colm_construct_generic( prg, generic_id, stop_id ); - vm_push_struct( gen ); - break; - } - case IN_CONS_REDUCER: { - half_t generic_id; - half_t reducer_id; - read_half( generic_id ); - read_half( reducer_id ); - - debug( prg, REALM_BYTECODE, "IN_CONS_REDUCER %hd\n", generic_id ); - - struct_t *gen = colm_construct_reducer( prg, generic_id, reducer_id ); - vm_push_struct( gen ); - break; - } - case IN_CONS_OBJECT: { - half_t lang_el_id; - read_half( lang_el_id ); - - debug( prg, REALM_BYTECODE, "IN_CONS_OBJECT %hd\n", lang_el_id ); - - tree_t *repl_tree = colm_construct_object( prg, 0, 0, lang_el_id ); - vm_push_tree( repl_tree ); - break; - } - case IN_CONSTRUCT: { - 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 root_node = prg->rtd->pat_repl_info[pattern_id].offset; - - /* Note that bindIds are indexed at one. Add one spot for them. */ - int num_bindings = prg->rtd->pat_repl_info[pattern_id].num_bindings; - tree_t *bindings[1+num_bindings]; - - int b; - for ( b = 1; b <= num_bindings; b++ ) { - bindings[b] = vm_pop_tree(); - assert( bindings[b] != 0 ); - } - - tree_t *repl_tree = colm_construct_tree( prg, 0, bindings, root_node ); - - vm_push_tree( repl_tree ); - break; - } - case IN_CONSTRUCT_TERM: { - 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, token_id, str->value ); - colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_MAKE_TOKEN: { - uchar nargs; - int i; - read_byte( nargs ); - - debug( prg, REALM_BYTECODE, "IN_MAKE_TOKEN\n" ); - - tree_t *arg[nargs]; - for ( i = nargs-1; i >= 0; i-- ) - arg[i] = vm_pop_tree(); - - tree_t *result = colm_construct_token( prg, arg, nargs ); - for ( i = 1; i < nargs; i++ ) - colm_tree_downref( prg, sp, arg[i] ); - vm_push_tree( result ); - break; - } - case IN_MAKE_TREE: { - uchar nargs; - int i; - read_byte( nargs ); - - debug( prg, REALM_BYTECODE, "IN_MAKE_TREE\n" ); - - tree_t *arg[nargs]; - for ( i = nargs-1; i >= 0; i-- ) - arg[i] = vm_pop_tree(); - - tree_t *result = make_tree( prg, arg, nargs ); - for ( i = 1; i < nargs; i++ ) - colm_tree_downref( prg, sp, arg[i] ); - - vm_push_tree( result ); - break; - } - case IN_TREE_CAST: { - half_t lang_el_id; - read_half( lang_el_id ); - - debug( prg, REALM_BYTECODE, "IN_TREE_CAST %hd\n", lang_el_id ); - - tree_t *tree = vm_pop_tree(); - tree_t *res = cast_tree( prg, lang_el_id, tree ); - colm_tree_upref( prg, res ); - colm_tree_downref( prg, sp, tree ); - vm_push_tree( res ); - break; - } - case IN_PTR_ACCESS_WV: { - debug( prg, REALM_BYTECODE, "IN_PTR_ACCESS_WV\n" ); - - struct_t *ptr = vm_pop_struct(); - vm_push_struct( ptr ); - - /* This is an initial global load. Need to reverse execute it. */ - rcode_unit_start( exec ); - rcode_code( exec, IN_PTR_ACCESS_BKT ); - rcode_word( exec, (word_t) ptr ); - break; - } - case IN_PTR_ACCESS_BKT: { - word_t p; - read_word( p ); - - debug( prg, REALM_BYTECODE, "IN_PTR_ACCESS_BKT\n" ); - - struct_t *ptr = (struct_t*)p; - vm_push_type( struct_t *, ptr ); - break; - } - case IN_REF_FROM_LOCAL: { - short int field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_REF_FROM_LOCAL %hd\n", field ); - - /* First push the null next pointer, then the kid pointer. */ - kid_t *kid = (kid_t*)vm_get_plocal(exec, field); - vm_contiguous( 2 ); - vm_push_ref( 0 ); - vm_push_kid( kid ); - break; - } - case IN_REF_FROM_REF: { - short int field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_REF_FROM_REF %hd\n", field ); - - ref_t *ref = (ref_t*)vm_get_plocal(exec, field); - vm_contiguous( 2 ); - vm_push_ref( ref ); - vm_push_kid( ref->kid ); - break; - } - case IN_REF_FROM_QUAL_REF: { - short int back; - short int field; - read_half( back ); - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_REF_FROM_QUAL_REF\n" ); - - ref_t *ref = (ref_t*)(sp + back); - - tree_t *obj = ref->kid->tree; - kid_t *attr_kid = get_field_kid( obj, field ); - - vm_contiguous( 2 ); - vm_push_ref( ref ); - vm_push_kid( attr_kid ); - break; - } - case IN_RHS_REF_FROM_QUAL_REF: { - short int back; - int i, done = 0; - uchar len; - - read_half( back ); - - debug( prg, REALM_BYTECODE, "IN_RHS_REF_FROM_QUAL_REF\n" ); - - ref_t *ref = (ref_t*)(sp + back); - - tree_t *obj = ref->kid->tree; - kid_t *attr_kid = 0; - - read_byte( len ); - for ( i = 0; i < len; i++ ) { - 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( attr_kid ); - break; - } - case IN_REF_FROM_BACK: { - short int back; - read_half( back ); - - debug( prg, REALM_BYTECODE, "IN_REF_FROM_BACK %hd\n", back ); - - kid_t *ptr = (kid_t*)(sp + back); - - vm_contiguous( 2 ); - vm_push_ref( 0 ); - vm_push_kid( ptr ); - break; - } - case IN_TRITER_REF_FROM_CUR: { - short int field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_TRITER_REF_FROM_CUR\n" ); - - /* Push the next pointer first, then the kid. */ - tree_iter_t *iter = (tree_iter_t*) vm_get_plocal(exec, field); - ref_t *ref = &iter->ref; - vm_contiguous( 2 ); - vm_push_ref( ref ); - vm_push_kid( iter->ref.kid ); - break; - } - case IN_UITER_REF_FROM_CUR: { - short int field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_REF_FROM_CUR\n" ); - - /* Push the next pointer first, then the kid. */ - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - vm_contiguous( 2 ); - vm_push_ref( uiter->ref.next ); - vm_push_kid( uiter->ref.kid ); - break; - } - case IN_GET_TOKEN_DATA_R: { - debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_DATA_R\n" ); - - tree_t *tree = vm_pop_tree(); - head_t *data = string_copy( prg, tree->tokdata ); - tree_t *str = construct_string( prg, data ); - colm_tree_upref( prg, str ); - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_SET_TOKEN_DATA_WC: { - debug( prg, REALM_BYTECODE, "IN_SET_TOKEN_DATA_WC\n" ); - - tree_t *tree = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - head_t *head = string_copy( prg, ((str_t*)val)->value ); - string_free( prg, tree->tokdata ); - tree->tokdata = head; - - colm_tree_downref( prg, sp, tree ); - colm_tree_downref( prg, sp, val ); - break; - } - case IN_SET_TOKEN_DATA_WV: { - debug( prg, REALM_BYTECODE, "IN_SET_TOKEN_DATA_WV\n" ); - - tree_t *tree = vm_pop_tree(); - tree_t *val = vm_pop_tree(); - - head_t *oldval = tree->tokdata; - head_t *head = string_copy( prg, ((str_t*)val)->value ); - tree->tokdata = head; - - /* Set up reverse code. Needs no args. */ - rcode_code( exec, IN_SET_TOKEN_DATA_BKT ); - rcode_word( exec, (word_t)oldval ); - rcode_unit_term( exec ); - - colm_tree_downref( prg, sp, tree ); - colm_tree_downref( prg, sp, val ); - break; - } - case IN_SET_TOKEN_DATA_BKT: { - debug( prg, REALM_BYTECODE, "IN_SET_TOKEN_DATA_BKT \n" ); - - word_t oldval; - read_word( oldval ); - - tree_t *tree = vm_pop_tree(); - head_t *head = (head_t*)oldval; - string_free( prg, tree->tokdata ); - tree->tokdata = head; - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_GET_TOKEN_FILE_R: { - debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_FILE_R\n" ); - tree_t *tree = vm_pop_tree(); - tree_t *str = 0; - if ( tree->tokdata->location ) { - const char *fn = tree->tokdata->location->name; - head_t *data = string_alloc_full( prg, fn, strlen(fn) ); - str = construct_string( prg, data ); - colm_tree_upref( prg, str ); - } - vm_push_tree( str ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_GET_TOKEN_LINE_R: { - debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_LINE_R\n" ); - - tree_t *tree = vm_pop_tree(); - value_t integer = 0; - if ( tree->tokdata->location ) - integer = tree->tokdata->location->line; - vm_push_value( integer ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_GET_TOKEN_COL_R: { - debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_COL_R\n" ); - - tree_t *tree = vm_pop_tree(); - value_t integer = 0; - if ( tree->tokdata->location ) - integer = tree->tokdata->location->column; - vm_push_value( integer ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_GET_TOKEN_POS_R: { - debug( prg, REALM_BYTECODE, "IN_GET_TOKEN_POS_R\n" ); - - tree_t *tree = vm_pop_tree(); - value_t integer = 0; - if ( tree->tokdata->location ) - integer = tree->tokdata->location->byte; - vm_push_value( integer ); - colm_tree_downref( prg, sp, tree ); - break; - } - case IN_GET_MATCH_LENGTH_R: { - debug( prg, REALM_BYTECODE, "IN_GET_MATCH_LENGTH_R\n" ); - - 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 = string_copy( prg, exec->parser->pda_run->tokdata ); - tree_t *tree = construct_string( prg, s ); - colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - case IN_LIST_LENGTH: { - debug( prg, REALM_BYTECODE, "IN_LIST_LENGTH\n" ); - - list_t *list = vm_pop_list(); - long len = colm_list_length( list ); - value_t res = len; - vm_push_value( res ); - break; - } - case IN_GET_LIST_EL_MEM_R: { - 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 *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 gen_id, field; - read_half( gen_id ); - read_half( field ); - - debug( prg, REALM_BYTECODE, - "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, gen_id, field ); - vm_push_struct( val ); - break; - } - case IN_GET_LIST_MEM_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LIST_MEM_WC\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_LIST_MEM_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LIST_MEM_WV\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_GET_LIST_MEM_BKT ); - rcode_half( exec, field ); - break; - } - case IN_GET_LIST_MEM_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LIST_MEM_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_GET_VLIST_MEM_R: { - short gen_id, field; - read_half( gen_id ); - read_half( field ); - - debug( prg, REALM_BYTECODE, - "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, gen_id, field ); - - value_t val = colm_struct_get_field( el, value_t, 0 ); - vm_push_value( val ); - break; - } - case IN_GET_VLIST_MEM_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_VLIST_MEM_WC\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_VLIST_MEM_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_VLIST_MEM_WV\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_GET_LIST_MEM_BKT ); - rcode_half( exec, field ); - break; - } - case IN_GET_VLIST_MEM_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_VLIST_MEM_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - case IN_GET_PARSER_STREAM: { - debug( prg, REALM_BYTECODE, "IN_GET_PARSER_STREAM\n" ); - parser_t *parser = vm_pop_parser(); - vm_push_input( parser->input ); - break; - } - case IN_GET_PARSER_MEM_R: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_PARSER_MEM_R %hd\n", field ); - - parser_t *parser = vm_pop_parser(); - - tree_t *val = get_parser_mem( parser, field ); - - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - - case IN_GET_MAP_EL_MEM_R: { - 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 *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; - } - case IN_MAP_LENGTH: { - debug( prg, REALM_BYTECODE, "IN_MAP_LENGTH\n" ); - - tree_t *obj = vm_pop_tree(); - long len = map_length( (map_t*)obj ); - value_t res = len; - vm_push_value( res ); - break; - } - case IN_GET_MAP_MEM_R: { - short gen_id, field; - read_half( gen_id ); - read_half( field ); - - debug( prg, REALM_BYTECODE, - "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, gen_id, field ); - vm_push_struct( val ); - break; - } - case IN_GET_MAP_MEM_WC: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_MAP_MEM_WC\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - break; - } - case IN_GET_MAP_MEM_WV: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_MAP_MEM_WV\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *val = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, val ); - vm_push_tree( val ); - - /* Set up the reverse instruction. */ - rcode_code( exec, IN_GET_MAP_MEM_BKT ); - rcode_half( exec, field ); - break; - } - case IN_GET_MAP_MEM_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_MAP_MEM_BKT\n" ); - - tree_t *obj = vm_pop_tree(); - colm_tree_downref( prg, sp, obj ); - - tree_t *res = get_list_mem_split( prg, (list_t*)obj, field ); - colm_tree_upref( prg, res ); - vm_push_tree( res ); - break; - } - - case IN_STASH_ARG: { - half_t pos; - half_t size; - read_half( pos ); - read_half( size ); - - debug( prg, REALM_BYTECODE, "IN_STASH_ARG %hd %hd\n", pos, size ); - - while ( size > 0 ) { - value_t v = vm_pop_value(); - ((value_t*)exec->call_args)[pos] = v; - size -= 1; - pos += 1; - } - - break; - } - - case IN_PREP_ARGS: { - half_t size; - read_half( size ); - - debug( prg, REALM_BYTECODE, "IN_PREP_ARGS %hd\n", size ); - - vm_push_type( tree_t**, exec->call_args ); - vm_pushn( size ); - exec->call_args = vm_ptop(); - memset( vm_ptop(), 0, sizeof(word_t) * size ); - break; - } - - case IN_CLEAR_ARGS: { - half_t size; - read_half( size ); - - debug( prg, REALM_BYTECODE, "IN_CLEAR_ARGS %hd\n", size ); - - vm_popn( size ); - exec->call_args = vm_pop_type( tree_t** ); - break; - } - - case IN_HOST: { - half_t func_id; - read_half( func_id ); - - debug( prg, REALM_BYTECODE, "IN_HOST %hd\n", func_id ); - - sp = prg->rtd->host_call( prg, func_id, sp ); - break; - } - case IN_CALL_WV: { - half_t func_id; - read_half( func_id ); - - 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->frame_size ); - - 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->frame_ptr ); - vm_push_type( long, exec->frame_id ); - - instr = fr->codeWV; - exec->frame_id = fi->frame_id; - - 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 func_id; - read_half( func_id ); - - 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->frame_size ); - - vm_contiguous( FR_AA + fi->frame_size ); - - 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->frame_ptr ); - vm_push_type( long, exec->frame_id ); - - instr = fr->codeWC; - exec->frame_id = fi->frame_id; - - exec->frame_ptr = vm_ptop(); - vm_pushn( fr->frame_size ); - memset( vm_ptop(), 0, sizeof(word_t) * fr->frame_size ); - break; - } - case IN_YIELD: { - debug( prg, REALM_BYTECODE, "IN_YIELD\n" ); - - kid_t *kid = vm_pop_kid(); - ref_t *next = vm_pop_ref(); - user_iter_t *uiter = (user_iter_t*) vm_plocal_iframe( IFR_AA ); - - if ( kid == 0 || kid->tree == 0 || - 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->yield_size = vm_ssize() - uiter->root_size; - uiter->resume = instr; - uiter->frame = exec->frame_ptr; - - /* Restore the instruction and frame pointer. */ - instr = (code_t*) vm_local_iframe(IFR_RIN); - 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->true_val : prg->false_val; - //colm_tree_upref( prg, result ); - vm_push_tree( result ); - } - break; - } - case IN_UITER_CREATE_WV: { - short field; - half_t func_id, search_id; - read_half( field ); - read_half( func_id ); - read_half( search_id ); - - debug( prg, REALM_BYTECODE, "IN_UITER_CREATE_WV\n" ); - - struct function_info *fi = prg->rtd->function_info + func_id; - - vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frame_size ); - - 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 - * is slightly different for user iterators. We aren't going to do - * 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->call_args ); - vm_push_value( 0 ); - - vm_push_type( code_t*, 0 ); /* Return instruction pointer, */ - 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->frame_size ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); - - uiter_init( prg, sp, uiter, fi, true ); - break; - } - case IN_UITER_CREATE_WC: { - short field; - half_t func_id, search_id; - read_half( field ); - read_half( func_id ); - read_half( search_id ); - - debug( prg, REALM_BYTECODE, "IN_UITER_CREATE_WC\n" ); - - struct function_info *fi = prg->rtd->function_info + func_id; - - vm_contiguous( (sizeof(user_iter_t) / sizeof(word_t)) + FR_AA + fi->frame_size ); - - 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 - * is slightly different for user iterators. We aren't going to do - * 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->call_args ); - vm_push_value( 0 ); - - vm_push_type( code_t*, 0 ); /* Return instruction pointer, */ - 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->frame_size ); - memset( vm_ptop(), 0, sizeof(word_t) * fi->frame_size ); - - uiter_init( prg, sp, uiter, fi, false ); - break; - } - case IN_UITER_DESTROY: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_DESTROY %hd\n", field ); - - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - colm_uiter_destroy( prg, &sp, uiter ); - break; - } - - case IN_UITER_UNWIND: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_UITER_UNWIND %hd\n", field ); - - user_iter_t *uiter = (user_iter_t*) vm_get_local(exec, field); - colm_uiter_unwind( prg, &sp, uiter ); - break; - } - - case IN_RET: { - 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->frame_id = vm_pop_type(long); - exec->frame_ptr = vm_pop_type(tree_t**); - instr = vm_pop_type(code_t*); - exec->ret_val = vm_pop_tree(); - vm_pop_value(); - //vm_popn( fi->argSize ); - - 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. */ - if ( instr == 0 ){ - //assert( sp == root ); - return sp; - } - - /* Might be some unwind code. */ - { - short unwind_len; - read_half( unwind_len ); - if ( unwind_len > 0 ) { - instr += unwind_len; - debug( prg, REALM_BYTECODE, - "skipping unwind code length: %hd\n", unwind_len ); - } - } - - break; - } - case IN_TO_UPPER: { - debug( prg, REALM_BYTECODE, "IN_TO_UPPER\n" ); - - tree_t *in = vm_pop_tree(); - head_t *head = string_to_upper( in->tokdata ); - tree_t *upper = construct_string( prg, head ); - colm_tree_upref( prg, upper ); - vm_push_tree( upper ); - colm_tree_downref( prg, sp, in ); - break; - } - case IN_TO_LOWER: { - debug( prg, REALM_BYTECODE, "IN_TO_LOWER\n" ); - - tree_t *in = vm_pop_tree(); - head_t *head = string_to_lower( in->tokdata ); - tree_t *lower = construct_string( prg, head ); - colm_tree_upref( prg, lower ); - vm_push_tree( lower ); - colm_tree_downref( prg, sp, in ); - break; - } - case IN_OPEN_FILE: { - debug( prg, REALM_BYTECODE, "IN_OPEN_FILE\n" ); - - tree_t *mode = vm_pop_tree(); - tree_t *name = vm_pop_tree(); - stream_t *res = colm_stream_open_file( prg, name, mode ); - vm_push_stream( res ); - colm_tree_downref( prg, sp, name ); - colm_tree_downref( prg, sp, mode ); - break; - } - case IN_GET_CONST: { - short constValId; - read_half( constValId ); - - switch ( constValId ) { - case CONST_STDIN: { - debug( prg, REALM_BYTECODE, "CONST_STDIN\n" ); - - /* Pop the root object. */ - vm_pop_tree(); - - make_stdin( prg ); - - vm_push_stream( prg->stdin_val ); - break; - } - case CONST_STDOUT: { - debug( prg, REALM_BYTECODE, "CONST_STDOUT\n" ); - - /* Pop the root object. */ - vm_pop_tree(); - make_stdout( prg ); - - vm_push_stream( prg->stdout_val ); - break; - } - case CONST_STDERR: { - debug( prg, REALM_BYTECODE, "CONST_STDERR\n" ); - - /* Pop the root object. */ - vm_pop_tree(); - - make_stderr( prg ); - - vm_push_stream( prg->stderr_val ); - break; - } - case CONST_ARG: { - word_t offset; - read_word( offset ); - - debug( prg, REALM_BYTECODE, "CONST_ARG %d\n", offset ); - - /* Pop the root object. */ - vm_pop_tree(); - - head_t *lit = make_literal( prg, offset ); - tree_t *tree = construct_string( prg, lit ); - colm_tree_upref( prg, tree ); - vm_push_tree( tree ); - break; - } - } - break; - } - case IN_SYSTEM: { - debug( prg, REALM_BYTECODE, "IN_SYSTEM\n" ); - - vm_pop_tree(); - str_t *cmd = vm_pop_string(); - - char *cmd0 = malloc( cmd->value->length + 1 ); - memcpy( cmd0, cmd->value->data, cmd->value->length ); - cmd0[cmd->value->length] = 0; - - int res = system( cmd0 ); - - free( cmd0 ); - -#if defined(HAVE_SYS_WAIT_H) - if ( WIFSIGNALED( res ) ) - raise( WTERMSIG( res ) ); - res = WEXITSTATUS( res ); -#else - // WARNING: Check result -#endif - - colm_tree_downref( prg, sp, (tree_t*)cmd ); - - value_t val = res; - vm_push_value( val ); - break; - } - - case IN_DONE: - return sp; - - case IN_FN: { - c = *instr++; - switch ( c ) { - case FN_STR_ATOI: { - debug( prg, REALM_BYTECODE, "FN_STR_ATOI\n" ); - - str_t *str = vm_pop_string(); - word_t res = str_atoi( str->value ); - value_t integer = res; - vm_push_value( integer ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_STR_ATOO: { - debug( prg, REALM_BYTECODE, "FN_STR_ATOO\n" ); - - str_t *str = vm_pop_string(); - word_t res = str_atoo( str->value ); - value_t integer = res; - vm_push_value( integer ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_STR_UORD8: { - debug( prg, REALM_BYTECODE, "FN_STR_UORD8\n" ); - - str_t *str = vm_pop_string(); - word_t res = str_uord8( str->value ); - value_t integer = res; - vm_push_value( integer ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_STR_UORD16: { - debug( prg, REALM_BYTECODE, "FN_STR_UORD16\n" ); - - str_t *str = vm_pop_string(); - word_t res = str_uord16( str->value ); - value_t integer = res; - vm_push_value( integer ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_STR_PREFIX: { - debug( prg, REALM_BYTECODE, "FN_STR_PREFIX\n" ); - - str_t *str = vm_pop_string(); - value_t len = vm_pop_value(); - - str_t *res = string_prefix( prg, str, (long) len ); - colm_tree_upref( prg, (tree_t*) res ); - vm_push_string( res ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_STR_SUFFIX: { - debug( prg, REALM_BYTECODE, "FN_STR_SUFFIX\n" ); - - str_t *str = vm_pop_string(); - value_t pos = vm_pop_value(); - - str_t *res = string_suffix( prg, str, (long) pos ); - colm_tree_upref( prg, (tree_t*) res ); - vm_push_string( res ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_PREFIX: { - debug( prg, REALM_BYTECODE, "FN_PREFIX\n" ); - - value_t len = vm_pop_value(); - str_t *str = vm_pop_string(); - - str_t *res = string_prefix( prg, str, (long) len ); - colm_tree_upref( prg, (tree_t*) res ); - vm_push_string( res ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_SUFFIX: { - debug( prg, REALM_BYTECODE, "FN_SUFFIX\n" ); - - value_t pos = vm_pop_value(); - str_t *str = vm_pop_string(); - - str_t *res = string_suffix( prg, str, (long) pos ); - colm_tree_upref( prg, (tree_t*) res ); - vm_push_string( res ); - colm_tree_downref( prg, sp, (tree_t*)str ); - break; - } - case FN_SPRINTF: { - debug( prg, REALM_BYTECODE, "FN_SPRINTF\n" ); - - vm_pop_tree(); - value_t integer = vm_pop_value(); - str_t *format = vm_pop_string(); - head_t *res = string_sprintf( prg, format, (long)integer ); - str_t *str = (str_t*)construct_string( prg, res ); - colm_tree_upref( prg, (tree_t*)str ); - vm_push_string( str ); - colm_tree_downref( prg, sp, (tree_t*)format ); - break; - } - case FN_LOAD_ARG0: { - half_t field; - read_half( field ); - debug( prg, REALM_BYTECODE, "FN_LOAD_ARG0 %lu\n", field ); - - /* tree_t comes back upreffed. */ - tree_t *tree = construct_arg0( prg, prg->argc, prg->argv, prg->argl ); - tree_t *prev = colm_struct_get_field( prg->global, tree_t*, field ); - colm_tree_downref( prg, sp, prev ); - colm_struct_set_field( prg->global, tree_t*, field, tree ); - break; - } - case FN_LOAD_ARGV: { - half_t field; - read_half( field ); - debug( prg, REALM_BYTECODE, "FN_LOAD_ARGV %lu\n", field ); - - list_t *list = construct_argv( prg, prg->argc, prg->argv, prg->argl ); - colm_struct_set_field( prg->global, list_t*, field, list ); - break; - } - case FN_INIT_STDS: { - half_t field; - read_half( field ); - debug( prg, REALM_BYTECODE, "FN_INIT_STDS %lu\n", field ); - - list_t *list = construct_stds( prg ); - colm_struct_set_field( prg->global, list_t*, field, list ); - break; - } - case FN_STOP: { - debug( prg, REALM_BYTECODE, "FN_STOP\n" ); - - flush_streams( prg ); - goto out; - } - - case FN_LIST_PUSH_HEAD_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_HEAD_WC\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = vm_pop_struct(); - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_prepend( list, list_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - break; - } - case FN_LIST_PUSH_HEAD_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_HEAD_WV\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = vm_pop_struct(); - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_prepend( list, list_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - - /* Set up reverse code. Needs no args. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_LIST_PUSH_HEAD_BKT ); - rcode_unit_term( exec ); - break; - } - case FN_LIST_PUSH_HEAD_BKT: { - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_HEAD_BKT\n" ); - - list_t *list = vm_pop_list(); - colm_list_detach_head( list ); - break; - } - case FN_LIST_PUSH_TAIL_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_TAIL_WC\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = vm_pop_struct(); - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_append( list, list_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - break; - } - case FN_LIST_PUSH_TAIL_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_TAIL_WV\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = vm_pop_struct(); - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - colm_list_append( list, list_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - - /* Set up reverse code. Needs no args. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_LIST_PUSH_TAIL_BKT ); - rcode_unit_term( exec ); - break; - } - case FN_LIST_PUSH_TAIL_BKT: { - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_TAIL_BKT\n" ); - - list_t *list = vm_pop_list(); - colm_list_detach_tail( list ); - break; - } - case FN_LIST_POP_TAIL_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_TAIL_WC\n" ); - - list_t *list = vm_pop_list(); - - list_el_t *tail = list->tail; - colm_list_detach_tail( list ); - struct_t *s = colm_generic_el_container( prg, tail, gen_id ); - - vm_push_struct( s ); - break; - } - case FN_LIST_POP_TAIL_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_TAIL_WV\n" ); - - list_t *list = vm_pop_list(); - - list_el_t *tail = list->tail; - colm_list_detach_tail( list ); - struct_t *s = colm_generic_el_container( prg, tail, gen_id ); - - vm_push_struct( s ); - - /* Set up reverse. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_LIST_POP_TAIL_BKT ); - rcode_half( exec, gen_id ); - rcode_word( exec, (word_t)s ); - rcode_unit_term( exec ); - break; - } - case FN_LIST_POP_TAIL_BKT: { - short gen_id; - tree_t *val; - read_half( gen_id ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_TAIL_BKT\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = (struct_t*) val; - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - - colm_list_append( list, list_el ); - break; - } - case FN_LIST_POP_HEAD_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_HEAD_WC\n" ); - - list_t *list = vm_pop_list(); - - list_el_t *head = list->head; - colm_list_detach_head( list ); - struct_t *s = colm_generic_el_container( prg, head, gen_id ); - - vm_push_struct( s ); - break; - } - case FN_LIST_POP_HEAD_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_HEAD_WV\n" ); - - list_t *list = vm_pop_list(); - - list_el_t *head = list->head; - colm_list_detach_head( list ); - struct_t *s = colm_generic_el_container( prg, head, gen_id ); - - vm_push_struct( s ); - - /* Set up reverse. The result comes off the list downrefed. - * Need it up referenced for the reverse code too. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_LIST_POP_HEAD_BKT ); - rcode_half( exec, gen_id ); - rcode_word( exec, (word_t)s ); - rcode_unit_term( exec ); - break; - } - case FN_LIST_POP_HEAD_BKT: { - short gen_id; - tree_t *val; - read_half( gen_id ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_HEAD_BKT\n" ); - - list_t *list = vm_pop_list(); - struct_t *s = (struct_t*) val; - - list_el_t *list_el = colm_struct_to_list_el( prg, s, gen_id ); - - colm_list_prepend( list, list_el ); - break; - } - case FN_MAP_FIND: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_MAP_FIND %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - tree_t *key = vm_pop_tree(); - - map_el_t *map_el = colm_map_find( prg, map, key ); - - struct colm_struct *strct = map_el != 0 ? - colm_generic_el_container( prg, map_el, gen_id ) : 0; - - vm_push_struct( strct ); - - if ( map->generic_info->key_type == TYPE_TREE ) - colm_tree_downref( prg, sp, key ); - break; - } - case FN_MAP_INSERT_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_MAP_INSERT_WC %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - struct_t *s = vm_pop_struct(); - - map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - - colm_map_insert( prg, map, map_el ); - - vm_push_tree( prg->true_val ); - break; - } - case FN_MAP_INSERT_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_MAP_INSERT_WV %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - struct_t *s = vm_pop_struct(); - - map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - - map_el_t *inserted = colm_map_insert( prg, map, map_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_MAP_INSERT_BKT ); - rcode_half( exec, gen_id ); - rcode_code( exec, inserted != 0 ? 1 : 0 ); - rcode_word( exec, (word_t)map_el ); - rcode_unit_term( exec ); - break; - } - - case FN_MAP_INSERT_BKT: { - short gen_id; - uchar inserted; - word_t wmap_el; - - read_half( gen_id ); - read_byte( inserted ); - read_word( wmap_el ); - - map_el_t *map_el = (map_el_t*)wmap_el; - - debug( prg, REALM_BYTECODE, "FN_MAP_INSERT_BKT %d\n", - (int)inserted ); - - map_t *map = vm_pop_map(); - - if ( inserted ) - colm_map_detach( prg, map, map_el ); - break; - } - case FN_MAP_DETACH_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_MAP_DETACH_WC %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - struct_t *s = vm_pop_struct(); - - map_el_t *map_el = colm_struct_to_map_el( prg, s, gen_id ); - - colm_map_detach( prg, map, map_el ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - break; - } - case FN_MAP_DETACH_WV: { - debug( prg, REALM_BYTECODE, "FN_MAP_DETACH_WV\n" ); - - tree_t *obj = vm_pop_tree(); - tree_t *key = vm_pop_tree(); - struct tree_pair pair = map_remove( prg, (map_t*)obj, key ); - - colm_tree_upref( prg, pair.val ); - vm_push_tree( pair.val ); - - /* Reverse instruction. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_MAP_DETACH_BKT ); - rcode_word( exec, (word_t)pair.key ); - rcode_word( exec, (word_t)pair.val ); - rcode_unit_term( exec ); - - colm_tree_downref( prg, sp, obj ); - colm_tree_downref( prg, sp, key ); - break; - } - case FN_MAP_DETACH_BKT: { - tree_t *key, *val; - read_tree( key ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_MAP_DETACH_BKT\n" ); - - /* Either both or neither. */ - assert( ( key == 0 ) ^ ( val != 0 ) ); - - tree_t *obj = vm_pop_tree(); - #if 0 - if ( key != 0 ) - map_unremove( prg, (map_t*)obj, key, val ); - #endif - - colm_tree_downref( prg, sp, obj ); - break; - } - case FN_VMAP_INSERT_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VMAP_INSERT_WC %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - struct_t *value = vm_pop_struct(); - struct_t *key = vm_pop_struct(); - - colm_vmap_insert( prg, map, key, value ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - break; - } - case FN_VMAP_INSERT_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VMAP_INSERT_WV %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - struct_t *value = vm_pop_struct(); - struct_t *key = vm_pop_struct(); - - map_el_t *inserted = colm_vmap_insert( prg, map, key, value ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_VMAP_INSERT_BKT ); - rcode_half( exec, gen_id ); - rcode_code( exec, inserted != 0 ? 1 : 0 ); - rcode_word( exec, (word_t)inserted ); - rcode_unit_term( exec ); - break; - } - case FN_VMAP_INSERT_BKT: { - short gen_id; - uchar inserted; - word_t wmap_el; - - read_half( gen_id ); - read_byte( inserted ); - read_word( wmap_el ); - - map_el_t *map_el = (map_el_t*)wmap_el; - - debug( prg, REALM_BYTECODE, "FN_VMAP_INSERT_BKT %d\n", - (int)inserted ); - - map_t *map = vm_pop_map(); - - if ( inserted ) - colm_map_detach( prg, map, map_el ); - break; - } - case FN_VMAP_REMOVE_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VMAP_REMOVE_WC %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - tree_t *key = vm_pop_tree(); - - colm_vmap_remove( prg, map, key ); - - //colm_tree_upref( prg, prg->trueVal ); - vm_push_tree( prg->true_val ); - break; - } - case FN_VMAP_FIND: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VMAP_FIND %hd\n", gen_id ); - - map_t *map = vm_pop_map(); - tree_t *key = vm_pop_tree(); - - tree_t *result = colm_vmap_find( prg, map, key ); - - vm_push_tree( result ); - - if ( map->generic_info->key_type == TYPE_TREE ) - colm_tree_downref( prg, sp, key ); - break; - } - case FN_VLIST_PUSH_TAIL_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_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->true_val ); - break; - } - case FN_VLIST_PUSH_TAIL_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_PUSH_TAIL_WV %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->true_val ); - - /* Set up reverse code. Needs no args. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_VLIST_PUSH_TAIL_BKT ); - rcode_unit_term( exec ); - break; - } - case FN_VLIST_PUSH_TAIL_BKT: { - debug( prg, REALM_BYTECODE, "FN_VLIST_PUSH_TAIL_BKT\n" ); - - list_t *list = vm_pop_list(); - colm_list_detach_tail( list ); - break; - } - case FN_VLIST_PUSH_HEAD_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_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->true_val ); - break; - } - case FN_VLIST_PUSH_HEAD_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_PUSH_HEAD_WV %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->true_val ); - - /* Set up reverse code. Needs no args. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_VLIST_PUSH_HEAD_BKT ); - rcode_unit_term( exec ); - break; - } - case FN_VLIST_PUSH_HEAD_BKT: { - debug( prg, REALM_BYTECODE, "FN_VLIST_PUSH_HEAD_BKT\n" ); - - list_t *list = vm_pop_list(); - colm_list_detach_head( list ); - break; - } - case FN_VLIST_POP_HEAD_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_HEAD_WC %hd\n", gen_id ); - - list_t *list = vm_pop_list(); - - value_t result = colm_vlist_detach_head( prg, list ); - vm_push_value( result ); - break; - } - case FN_VLIST_POP_HEAD_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_HEAD_WV %hd\n", gen_id ); - - list_t *list = vm_pop_list(); - - value_t result = colm_vlist_detach_head( prg, list ); - vm_push_value( result ); - - /* Set up reverse. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_VLIST_POP_HEAD_BKT ); - rcode_half( exec, gen_id ); - rcode_word( exec, (word_t)result ); - rcode_unit_term( exec ); - break; - } - case FN_VLIST_POP_HEAD_BKT: { - short gen_id; - tree_t *val; - read_half( gen_id ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_HEAD_BKT\n" ); - - list_t *list = vm_pop_list(); - - colm_vlist_prepend( prg, list, (value_t)val ); - break; - } - case FN_VLIST_POP_TAIL_WC: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_TAIL_WC %hd\n", gen_id ); - - list_t *list = vm_pop_list(); - - value_t result = colm_vlist_detach_tail( prg, list ); - vm_push_value( result ); - break; - } - case FN_VLIST_POP_TAIL_WV: { - short gen_id; - read_half( gen_id ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_TAIL_WV %hd\n", gen_id ); - - list_t *list = vm_pop_list(); - - value_t result = colm_vlist_detach_tail( prg, list ); - vm_push_value( result ); - - /* Set up reverse. */ - rcode_code( exec, IN_FN ); - rcode_code( exec, FN_VLIST_POP_TAIL_BKT ); - rcode_half( exec, gen_id ); - rcode_word( exec, (word_t)result ); - rcode_unit_term( exec ); - break; - } - case FN_VLIST_POP_TAIL_BKT: { - short gen_id; - tree_t *val; - read_half( gen_id ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_VLIST_POP_TAIL_BKT\n" ); - - list_t *list = vm_pop_list(); - - colm_vlist_append( prg, list, (value_t)val ); - break; - } - - case FN_EXIT_HARD: { - debug( prg, REALM_BYTECODE, "FN_EXIT\n" ); - - vm_pop_tree(); - prg->exit_status = vm_pop_type(long); - prg->induce_exit = 1; - exit( prg->exit_status ); - } - case FN_EXIT: { - /* The unwind code follows the exit call (exception, see - * synthesis). */ - short unwind_len; - read_half( unwind_len ); - - debug( prg, REALM_BYTECODE, "FN_EXIT, unwind len: %hd\n", unwind_len ); - - vm_pop_tree(); - 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->frame_id == prg->rtd->root_frame_id ) - break; - - struct frame_info *fi = &prg->rtd->frame_info[exec->frame_id]; - - debug( prg, REALM_BYTECODE, "FN_EXIT, popping frame %s, " - "unwind-len %hd, arg-size %ld\n", - ( fi->name != 0 ? fi->name : "" ), - 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->locals_len ); - vm_popn( fi->frame_size ); - - /* Call layout. */ - exec->frame_id = vm_pop_type(long); - exec->frame_ptr = vm_pop_type(tree_t**); - instr = vm_pop_type(code_t*); - - tree_t *ret_val = vm_pop_tree(); - vm_pop_value(); - - /* The IN_PREP_ARGS stack data. */ - vm_popn( fi->arg_size ); - vm_pop_value(); - - if ( fi->ret_tree ) { - /* Problem here. */ - colm_tree_downref( prg, sp, ret_val ); - } - - read_half( unwind_len ); - } - - goto out; - } - default: { - fatal( "UNKNOWN FUNCTION: 0x%02x -- something is wrong\n", c ); - break; - }} - break; - } - - /* Halt is a default instruction given by the compiler when it is - * asked to generate and instruction it doesn't have. It is deliberate - * and can represent "not implemented" or "compiler error" because a - * variable holding instructions was not properly initialize. */ - case IN_HALT: { - fatal( "IN_HALT -- compiler did something wrong\n" ); - exit(1); - break; - } - default: { - fatal( "UNKNOWN INSTRUCTION: 0x%02x -- something is wrong\n", *(instr-1) ); - assert(false); - break; - } - } - goto again; - -out: - if ( ! prg->induce_exit ) - assert( sp == root ); - return sp; -} - -/* - * Deleteing rcode required downreffing any trees held by it. - */ -static void rcode_downref( program_t *prg, tree_t **sp, code_t *instr ) -{ -again: - switch ( *instr++ ) { - case IN_PARSE_INIT_BKT: { - debug( prg, REALM_BYTECODE, "IN_PARSE_INIT_BKT\n" ); - - consume_word(); //( parser ); - consume_word(); //( steps ); - - break; - } - case IN_SEND_EOF_BKT: { - debug( prg, REALM_BYTECODE, "IN_SEND_EOF_BKT\n" ); - consume_word(); //( parser ); - break; - } - - case IN_LOAD_TREE: { - tree_t *w; - read_tree( w ); - debug( prg, REALM_BYTECODE, "IN_LOAD_TREE %p\n", w ); - colm_tree_downref( prg, sp, w ); - break; - } - case IN_LOAD_WORD: { - consume_word(); - debug( prg, REALM_BYTECODE, "IN_LOAD_WORD\n" ); - break; - } - case IN_RESTORE_LHS: { - tree_t *restore; - read_tree( restore ); - debug( prg, REALM_BYTECODE, "IN_RESTORE_LHS\n" ); - colm_tree_downref( prg, sp, restore ); - break; - } - - case IN_PARSE_FRAG_BKT: { - debug( prg, REALM_BYTECODE, "IN_PARSE_FRAG_BKT\n" ); - break; - } - case IN_PCR_RET: { - debug( prg, REALM_BYTECODE, "IN_PCR_RET\n" ); - return; - } - case IN_PCR_END_DECK: { - debug( prg, REALM_BYTECODE, "IN_PCR_END_DECK\n" ); - return; - } - case IN_SEND_TEXT_BKT: { - tree_t *input; - - consume_word(); //( parser ); - read_tree( input ); - consume_word(); //( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TEXT_BKT\n" ); - - colm_tree_downref( prg, sp, input ); - break; - } - case IN_SEND_TREE_BKT: { - tree_t *input; - - consume_word(); //( parser ); - read_tree( input ); - consume_word(); //( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_TREE_BKT\n" ); - - colm_tree_downref( prg, sp, input ); - break; - } - case IN_SEND_STREAM_BKT: { - consume_word(); //( sptr ); - consume_word(); //( input ); - consume_word(); //( len ); - - debug( prg, REALM_BYTECODE, "IN_SEND_STREAM_BKT\n" ); - break; - } - - case IN_INPUT_PULL_BKT: { - tree_t *string; - read_tree( string ); - - debug( prg, REALM_BYTECODE, "IN_INPUT_PULL_BKT\n" ); - - colm_tree_downref( prg, sp, string ); - break; - } - case IN_INPUT_PUSH_BKT: { - consume_word(); //( len ); - - debug( prg, REALM_BYTECODE, "IN_INPUT_PUSH_BKT\n" ); - break; - } - case IN_LOAD_GLOBAL_BKT: { - debug( prg, REALM_BYTECODE, "IN_LOAD_GLOBAL_BKT\n" ); - break; - } - case IN_LOAD_CONTEXT_BKT: { - debug( prg, REALM_BYTECODE, "IN_LOAD_CONTEXT_BKT\n" ); - break; - } - case IN_LOAD_INPUT_BKT: { - consume_word(); //( input ); - debug( prg, REALM_BYTECODE, "IN_LOAD_INPUT_BKT\n" ); - break; - } - case IN_GET_FIELD_TREE_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_FIELD_TREE_BKT %hd\n", field ); - break; - } - case IN_SET_FIELD_TREE_BKT: { - short field; - tree_t *val; - read_half( field ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_FIELD_TREE_BKT %hd\n", field ); - - colm_tree_downref( prg, sp, val ); - break; - } - case IN_SET_STRUCT_BKT: { - short field; - tree_t *val; - read_half( field ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_BKT %hd\n", field ); - - colm_tree_downref( prg, sp, val ); - break; - } - case IN_SET_STRUCT_VAL_BKT: { - consume_half(); //( field ); - consume_word(); //( val ); - - debug( prg, REALM_BYTECODE, "IN_SET_STRUCT_VAL_BKT\n" ); - break; - } - case IN_PTR_ACCESS_BKT: { - consume_word(); //( ptr ); - - debug( prg, REALM_BYTECODE, "IN_PTR_ACCESS_BKT\n" ); - break; - } - case IN_SET_TOKEN_DATA_BKT: { - word_t oldval; - read_word( oldval ); - - debug( prg, REALM_BYTECODE, "IN_SET_TOKEN_DATA_BKT\n" ); - - head_t *head = (head_t*)oldval; - string_free( prg, head ); - break; - } - case IN_GET_LIST_MEM_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_LIST_MEM_BKT %hd\n", field ); - break; - } - case IN_GET_MAP_MEM_BKT: { - short field; - read_half( field ); - - debug( prg, REALM_BYTECODE, "IN_GET_MAP_MEM_BKT %hd\n", field ); - break; - } - case IN_FN: { - switch ( *instr++ ) { - case FN_LIST_PUSH_HEAD_BKT: { - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_HEAD_BKT\n" ); - break; - } - case FN_LIST_POP_HEAD_BKT: { - consume_half(); //( genId ); - consume_word(); //( val ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_HEAD_BKT\n" ); - - break; - } - case FN_LIST_PUSH_TAIL_BKT: { - debug( prg, REALM_BYTECODE, "FN_LIST_PUSH_TAIL_BKT\n" ); - break; - } - case FN_LIST_POP_TAIL_BKT: { - consume_half(); //( genId ); - consume_word(); //( val ); - - debug( prg, REALM_BYTECODE, "FN_LIST_POP_TAIL_BKT\n" ); - - break; - } - case FN_MAP_INSERT_BKT: { - uchar inserted; - - consume_half(); //( genId ); - read_byte( inserted ); - consume_word(); //( wmapEl ); - - debug( prg, REALM_BYTECODE, "FN_MAP_INSERT_BKT %d\n", - (int)inserted ); - break; - } - case FN_VMAP_INSERT_BKT: { - short gen_id; - uchar inserted; - //word_t wmap_el; - - read_half( gen_id ); - read_byte( inserted ); - consume_word(); //read_word( wmap_el ); - - //map_el_t *map_el = (map_el_t*)wmap_el; - - debug( prg, REALM_BYTECODE, "FN_VMAP_INSERT_BKT %d\n", - (int)inserted ); - - break; - } - case FN_MAP_DETACH_BKT: { - tree_t *key, *val; - read_tree( key ); - read_tree( val ); - - debug( prg, REALM_BYTECODE, "FN_MAP_DETACH_BKT\n" ); - - colm_tree_downref( prg, sp, key ); - colm_tree_downref( prg, sp, val ); - break; - } - - case FN_VLIST_PUSH_TAIL_BKT: { - break; - } - - case FN_VLIST_PUSH_HEAD_BKT: { - break; - } - - case FN_VLIST_POP_HEAD_BKT: { - short gen_id; - //word_t result; - read_half( gen_id ); - consume_word(); //read_word( result ); - break; - } - - case FN_VLIST_POP_TAIL_BKT: { - short gen_id; - //word_t result; - read_half( gen_id ); - consume_word(); //read_word( result ); - break; - } - - default: { - fatal( "UNKNOWN FUNCTION 0x%02x: -- reverse code downref\n", *(instr-1)); - assert(false); - }} - break; - } - default: { - fatal( "UNKNOWN INSTRUCTION 0x%02x: -- reverse code downref\n", *(instr-1)); - assert(false); - break; - } - } - goto again; -} - - -- cgit v1.2.1