Index: trunk.inline/test/t-mantis.c =================================================================== --- trunk.inline/test/t-mantis.c (Revision 2587) +++ trunk.inline/test/t-mantis.c (Arbeitskopie) @@ -180,6 +180,145 @@ return to_int("-"+num) == __INT_MIN__; :) }), + ({ "0000631-1", 0, + (: + int i=1; + + return funcall( + (: + if(i) + return funcall((: return i; :)); + :)) == 1; + :) + }), + ({ "0000631-2", 0, + (: + int i=1; + + return funcall( + function int() : int j = 2 + { + if(i) + return funcall((: return j; :)); + }) == 2; + :) + }), + ({ "0000631-3", 0, + (: + int i=1; + + return funcall( + function int() + { + int j = 2; + return funcall((: return i; :)); + }) == 1; + :) + }), + ({ "0000631-4", 0, + (: + int i=1; + + return funcall( + function int () + { + return funcall( + function int () : int j=i + { + return j; + }); + }); + :) + }), + ({ "0000631-5", 0, + (: + int a = 1; + + return funcall( + function int() : closure cl = (: a :) + { + return funcall(cl); + }) == 1; + :) + }), + ({ "0000631-6", 0, + (: + int a=1; + + return funcall( + function int () : int b = a+1; int c = b+1 + { + return c; + }) == 3; + :) + }), + ({ "0000631-7", 0, /* #631 in conjunction with #537. */ + (: + closure c; + + { + int a = 1; + } + + c = function int () : int b + { + return b; + }; + + return funcall(c) == 0; + :) + }), + ({ "0000631-8", 0, /* #631 in conjunction with #537. */ + (: + closure c; + + c = function int () : int b = 2 + { + return b; + }; + + { + int d; + + return d == 0; + } + + :) + }), + ({ "0000631-9", 0, /* Check, that the array is only freed once. */ + (: + closure c = function int() : string* a = ({ "" }) + { + return 0; + }; + + return closurep(c); /* As long as it doesn't crash... */ + :) + }), + ({ "0000631-10", 0, + function int(int a, int b, int c) + { + + return funcall(funcall(funcall( + function : + mixed i = 1; + mixed j = function : + mixed j = function { return i; } + { return j; }; + { return j; } + ))) == 1; + } + }), + ({ "0000631-11", 0, + (: + return funcall(function int() : + closure c = function int() : int a = 1 { return 2; }; + int b; + { + return b; + }) == 0; + :) + }), }); void run_test() Index: trunk.inline/src/prolang.y =================================================================== --- trunk.inline/src/prolang.y (Revision 2587) +++ trunk.inline/src/prolang.y (Arbeitskopie) @@ -622,6 +622,11 @@ /* Index of the enclosing inline closure, or -1 if none. */ + mp_int next; + /* Index of an enclosed inline closure. + * This is only used temporarily. + */ + /* --- Compilation information --- */ mp_uint end; /* While compiling the closure: end of the program code before @@ -2684,7 +2689,7 @@ #ifdef USE_NEW_INLINES /*-------------------------------------------------------------------------*/ static ident_t * -add_context_name (ident_t *ident, fulltype_t type, int num) +add_context_name (inline_closure_t *closure, ident_t *ident, fulltype_t type, int num) /* Declare a new context variable with the type for the * currently compiled inline closure. The references of are NOT adopted. @@ -2697,7 +2702,7 @@ int depth; block_scope_t * block; - depth = current_inline->block_depth+1; + depth = closure->block_depth+1; block = & block_scope[depth-1]; #ifdef DEBUG_INLINES @@ -2710,6 +2715,13 @@ { yyerror("Too many context variables"); } + else if (num < 0 + && (block->first_local + block->num_locals >= 256 + || block->first_local + block->num_locals >= MAX_LOCAL + )) + { + yyerror("Too many local variables"); + } else { ref_fulltype_data(&type); @@ -2724,9 +2736,21 @@ /* Initialize the ident */ ident->type = I_TYPE_LOCAL; - ident->u.local.num = num; ident->u.local.depth = depth; - ident->u.local.context = block->num_locals; + if (num < 0) + { + /* First initialize it as a local variable + * of the outer function, so they can be + * referenced during initialization. + */ + ident->u.local.num = block->first_local + block->num_locals; + ident->u.local.context = -1; + } + else + { + ident->u.local.num = num; + ident->u.local.context = block->num_locals; + } /* Put the ident into the list of all locals. */ @@ -2752,6 +2776,8 @@ /* Record the type */ type_of_context[block->num_locals] = type; + if (num < 0) + type_of_locals[ident->u.local.num] = type; block->num_locals++; } @@ -2782,46 +2808,115 @@ && depth <= current_inline->block_depth ) { - /* This local has been inherited - create the - * proper context variable. + inline_closure_t *closure; + mp_int closure_nr; + + closure = current_inline; + + /* Get the active enclosing closure. + * Skip closures whose context is currently being parsed. */ - if (ident->u.local.context >= 0) + do { - if (!current_inline->parse_context - && current_inline->prev != -1 - && depth <= INLINE_CLOSURE(current_inline->prev).block_depth - ) + closure_nr = closure->prev; + if (closure_nr == -1) + break; + closure = &(INLINE_CLOSURE(closure_nr)); + } + while (closure->parse_context); + + if (current_inline->parse_context && closure_nr == -1) + { + /* We're in the context initializer of the first inline closure. + * So this must be a reference to a local variable. + */ + *pType = LOCAL_TYPE(current_inline->full_local_type_start + + ident->u.local.num + ); + } + else + { + /* This local has been inherited - create the + * proper context variable. + * + * Let's go back to the first inline closure + * that has to inherit this variable. + * And record that path in the ->next pointer. + */ + + fulltype_t type; + + closure = current_inline; + closure_nr = closure - &(INLINE_CLOSURE(0)); + closure->next = -1; + + /* Go through all inline closures to our local variable + * and record this way using the .next pointers. + * + * Stop at the last inline closure before the variable's + * scope, because the information about that scope was + * saved there. + */ + for (;;) { - /* Can't use outer context variables when compiling - * an inline closure body. - */ - yyerrorf("Can't use context variable '%s' " - "across closure boundaries", get_txt(ident->name)); - ident = redeclare_local(ident, Type_Any, block_depth); - *pType = Type_Any; + inline_closure_t *outer_closure; + mp_int outer_closure_nr; + + outer_closure_nr = closure->prev; + if (outer_closure_nr == -1) + /* It is a local variable of the current function. */ + break; + + outer_closure = &(INLINE_CLOSURE(outer_closure_nr)); + outer_closure->next = closure_nr; + + if (outer_closure->block_depth < depth) + /* The variable belongs to outer_closure. */ + break; + + closure = outer_closure; + closure_nr = outer_closure_nr; } + + if (ident->u.local.context >= 0) + { + /* It's a context variable. */ + type = LOCAL_TYPE(closure->full_context_type_start + + ident->u.local.context + ); + } else { - /* We can use outer context variables when compiling - * an inline closure context. - */ - *pType = LOCAL_TYPE(current_inline->full_context_type_start - + ident->u.local.context - ); + /* It's a local variable. */ + type = LOCAL_TYPE(closure->full_local_type_start + + ident->u.local.num + ); } - } - else /* it's a local */ - { - fulltype_t type; - type = LOCAL_TYPE(current_inline->full_local_type_start - + ident->u.local.num - ); - if (!current_inline->parse_context) + /* Now pass this context variable through + * all surrounding inline closures. + */ + while (MY_TRUE) { - ref_fulltype_data(&type); - ident = add_context_name( ident, type, ident->u.local.num); + /* Skip closures whose context is being parsed, + * because current_inline is not created + * in their runtime. + */ + if (!closure->parse_context) + { + ref_fulltype_data(&type); + ident = add_context_name(closure, ident, type, + ident->u.local.context >= 0 + ? 256 + ident->u.local.context + : ident->u.local.num); + } + + if (closure->next == -1) + break; + + closure = &(INLINE_CLOSURE(closure->next)); } + *pType = type; } } @@ -2833,6 +2928,39 @@ return ident; } /* check_for_context_local() */ +/*-------------------------------------------------------------------------*/ +static void +adapt_context_names (void) + +/* Convert all explicit context variables + * from local variables to context variables. + */ + +{ + int depth; + block_scope_t *scope; + + depth = current_inline->block_depth+1; + scope = block_scope + depth - 1; + + /* Are there locals of the given depth? */ + if (all_locals && all_locals->u.local.depth >= depth) + { + ident_t *q = all_locals; + + while (q != NULL && q->u.local.depth > depth) + q = q->next_all; + + while (q != NULL && q->u.local.depth == depth) + { + q->u.local.context = q->u.local.num - scope->first_local; + q->u.local.num = -1; + + q = q->next_all; + } + } +} /* adapt_context_names() */ + #endif /* USE_NEW_INLINES */ /*-------------------------------------------------------------------------*/ @@ -5293,6 +5421,7 @@ * its rightful place. */ { + int num_explicit_context = 0; int depth = current_inline->block_depth+1; block_scope_t * context = &(block_scope[depth-1]); @@ -5337,8 +5466,16 @@ { if (lcmap[i] != -1) { - ins_f_code(F_LOCAL); - ins_byte(lcmap[i]); + if (lcmap[i] >= 256) + { + ins_f_code(F_CONTEXT_IDENTIFIER); + ins_byte(lcmap[i] - 256); + } + else + { + ins_f_code(F_LOCAL); + ins_byte(lcmap[i]); + } got_mapped = MY_TRUE; #ifdef DEBUG_INLINES printf("DEBUG: -> F_LOCAL %d\n", lcmap[i]); @@ -5353,16 +5490,21 @@ fatal("Explicite context var #%d has higher index than " "implicite context variables.", i); } + else + num_explicit_context++; } } /* Push local vars */ /* Add the context_closure instruction */ #ifdef DEBUG_INLINES -printf("DEBUG: -> F_CONTEXT_CLOSURE %d %d\n", current_inline->function, context->num_locals); +printf("DEBUG: -> F_CONTEXT_CLOSURE %d %d %d\n", current_inline->function + , num_explicit_context, context->num_locals - num_explicit_context); #endif /* DEBUG_INLINES */ ins_f_code(F_CONTEXT_CLOSURE); ins_short(current_inline->function); - ins_short(context->num_locals); + ins_byte(context->first_local); + ins_short(num_explicit_context); + ins_short(context->num_locals - num_explicit_context); } /* Complete F_CONTEXT_CLOSURE instruction */ @@ -6040,6 +6182,14 @@ /* deactivate argument scope while parsing explicit context */ block_scope[current_inline->block_depth+1].accessible = MY_FALSE; current_inline->parse_context = MY_TRUE; + assert(block_scope[current_inline->block_depth].first_local == 0); + if (current_inline->prev != -1 && INLINE_CLOSURE(current_inline->prev).parse_context) + { + block_scope_t *scope = block_scope + INLINE_CLOSURE(current_inline->prev).block_depth; + block_scope[current_inline->block_depth].first_local = scope->first_local + scope->num_locals; + } + else + block_scope[current_inline->block_depth].first_local = current_inline->num_locals; } inline_opt_context @@ -6049,10 +6199,54 @@ printf("DEBUG: After inline_opt_context: program size %"PRIuMPINT"\n", CURRENT_PROGRAM_SIZE); #endif /* DEBUG_INLINES */ + /* Complete the F_CLEAR_LOCALS at the beginning of the context block. */ + block_scope_t *scope = block_scope + current_inline->block_depth; + inline_closure_t *outer_closure; + int * outer_max_num_locals; + + if (scope->num_locals > scope->num_cleared) + { + mem_block[A_PROGRAM].block[scope->addr+2] + = (char)(scope->num_locals - scope->num_cleared); + } + /* reactivate argument scope */ block_scope[current_inline->block_depth+1].accessible = MY_TRUE; current_inline->parse_context = MY_FALSE; + adapt_context_names(); + /* Find the correct max_num_locals to update. + * That is the one of the last closure with parse_context set. + */ + outer_max_num_locals = &(current_inline->max_num_locals); + outer_closure = current_inline; + + while (outer_closure->prev != -1) + { + outer_closure = &(INLINE_CLOSURE(outer_closure->prev)); + if (!outer_closure->parse_context) + break; + outer_max_num_locals = &(outer_closure->max_num_locals); + } + + if (scope->first_local + scope->num_locals > *outer_max_num_locals) + *outer_max_num_locals = scope->first_local + scope->num_locals; + + /* Check whether we clobbered some other local or context variables. */ + if (scope->num_locals || scope->clobbered) + { + if (current_inline->prev != -1) + { + outer_closure = &(INLINE_CLOSURE(current_inline->prev)); + if (outer_closure->parse_context) + block_scope[outer_closure->block_depth].clobbered = MY_TRUE; + else + block_scope[current_inline->block_depth-1].clobbered = MY_TRUE; + } + else + block_scope[current_inline->block_depth-1].clobbered = MY_TRUE; + } + if (!inline_closure_prototype($4)) YYACCEPT; } @@ -6115,7 +6309,7 @@ printf("DEBUG: After L_END_INLINE: program size %"PRIuMPINT"\n", CURRENT_PROGRAM_SIZE); #endif /* DEBUG_INLINES */ - /* Complete the F_CLEAR_LOCALS at the baginning of the block. */ + /* Complete the F_CLEAR_LOCALS at the beginning of the block. */ block_scope_t *scope = block_scope + block_depth - 1; if (use_local_scopes && scope->num_locals > scope->num_cleared) @@ -13950,10 +14144,9 @@ q = name; } else - q = add_context_name(name, actual_type, -1); + q = add_context_name(current_inline, name, actual_type, -1); - lv->u.simple[0] = F_PUSH_CONTEXT_LVALUE; - lv->u.simple[1] = q->u.local.context; + scope = block_scope + current_inline->block_depth; } else { @@ -13961,30 +14154,32 @@ q = redeclare_local(name, actual_type, block_depth); else q = add_local_name(name, actual_type, block_depth); + } - if (use_local_scopes && scope->clobbered) - { - /* finish the previous CLEAR_LOCALS, if any */ - if (scope->num_locals - 1 > scope->num_cleared) - mem_block[A_PROGRAM].block[scope->addr+2] - = (char)(scope->num_locals - 1 - scope->num_cleared); - scope->clobbered = MY_FALSE; - scope->num_cleared = scope->num_locals - 1; - } - if (use_local_scopes && scope->num_locals == scope->num_cleared + 1) - { - /* First definition of a local, so insert the - * clear_locals bytecode and remember its position - */ - scope->addr = mem_block[A_PROGRAM].current_size; - ins_f_code(F_CLEAR_LOCALS); - ins_byte(scope->first_local + scope->num_cleared); - ins_byte(0); - } + if (use_local_scopes && scope->clobbered) + { + /* finish the previous CLEAR_LOCALS, if any */ + if (scope->num_locals - 1 > scope->num_cleared) + mem_block[A_PROGRAM].block[scope->addr+2] + = (char)(scope->num_locals - 1 - scope->num_cleared); + scope->clobbered = MY_FALSE; + scope->num_cleared = scope->num_locals - 1; + } - lv->u.simple[0] = F_PUSH_LOCAL_VARIABLE_LVALUE; - lv->u.simple[1] = q->u.local.num; + if (use_local_scopes && scope->num_locals == scope->num_cleared + 1) + { + /* First definition of a local, so insert the + * clear_locals bytecode and remember its position + */ + scope->addr = mem_block[A_PROGRAM].current_size; + ins_f_code(F_CLEAR_LOCALS); + ins_byte(scope->first_local + scope->num_cleared); + ins_byte(0); } + + lv->u.simple[0] = F_PUSH_LOCAL_VARIABLE_LVALUE; + lv->u.simple[1] = q->u.local.num; + #else /* USE_NEW_INLINES */ if (redeclare) q = redeclare_local(name, actual_type, block_depth); @@ -14024,38 +14219,16 @@ * initializer, as the default svalue-0 is not a valid float value. */ - Bool need_value = MY_FALSE; %line - -#ifdef USE_NEW_INLINES - /* When parsing context variables, the context_closure instruction - * expects a value on the stack. If we do a float initialization, - * we leave the 0.0 on the stack, otherwise we'll push a 0. - * For normal float locals, we'll create the bytecode to assign - * the float 0. - */ - need_value = current_inline && current_inline->parse_context; -#endif /* USE_NEW_INLINES */ - if (!(actual_type.typeflags & TYPE_MOD_POINTER) && (actual_type.typeflags & PRIMARY_TYPE_MASK) == TYPE_FLOAT ) { ins_f_code(F_FCONST0); + if (!add_lvalue_code(lv, F_VOID_ASSIGN)) + return; - if (!need_value) - { - if (!add_lvalue_code(lv, F_VOID_ASSIGN)) - return; - } - - need_value = MY_FALSE; } /* if (float variable) */ - - if (need_value) /* If we still need a value... */ - { - ins_number(0); - } } } /* define_local_variable() */ @@ -14097,18 +14270,8 @@ if (type2.typeflags & TYPE_MOD_REFERENCE) yyerror("Can't trace reference assignments"); - /* If we're parsing a context variable, just leave the - * value on the stack for the context_closure instruction. - * For normal locals, add the bytecode to create the lvalue - * and do the assignment. - */ -#ifdef USE_NEW_INLINES - if (!current_inline || !current_inline->parse_context) -#endif /* USE_NEW_INLINES */ - { - if (!add_lvalue_code(lv, F_VOID_ASSIGN)) - return; - } /* parsed context var */ + if (!add_lvalue_code(lv, F_VOID_ASSIGN)) + return; } /* init_local_variable() */ /*-------------------------------------------------------------------------*/ Index: trunk.inline/src/interpret.c =================================================================== --- trunk.inline/src/interpret.c (Revision 2587) +++ trunk.inline/src/interpret.c (Arbeitskopie) @@ -8543,7 +8543,7 @@ CASE(F_CLOSURE); /* --- closure --- */ #ifdef USE_NEW_INLINES - CASE(F_CONTEXT_CLOSURE); /* --- context_closure --- */ + CASE(F_CONTEXT_CLOSURE); /* --- context_closure --- */ #endif /* USE_NEW_INLINES */ { /* Push the closure value and onto the stack. @@ -8564,8 +8564,10 @@ * of the directly referenced inherited function. #ifdef USE_NEW_INLINES * - * If it is a context closure, the context is sized to and initialized - * with the uint16 values on the stack. + * If it is a context closure, the context is sized to + * uint16 + values, uint16 values + * are taken from the local variables beginning at , + * uint16 values are taken from the stack. #endif */ @@ -8573,18 +8575,21 @@ /* TODO: int32 */ int ix; /* TODO: uint16 */ unsigned short inhIndex; #ifdef USE_NEW_INLINES - unsigned short context_size; + unsigned short explicit_context_size, implicit_context_size; + svalue_t * explicit_context; #endif /* USE_NEW_INLINES */ inhIndex = 0; #ifdef USE_NEW_INLINES - context_size = 0; + explicit_context_size = implicit_context_size = 0; #endif /* USE_NEW_INLINES */ LOAD_SHORT(tmp_ushort, pc); #ifdef USE_NEW_INLINES if (instruction == F_CONTEXT_CLOSURE) { - LOAD_SHORT(context_size, pc); + explicit_context = fp + LOAD_UINT8(pc); + LOAD_SHORT(explicit_context_size, pc); + LOAD_SHORT(implicit_context_size, pc); } else { @@ -8603,7 +8608,7 @@ #ifndef USE_NEW_INLINES closure_literal(sp, ix, inhIndex); #else /* USE_NEW_INLINES */ - closure_literal(sp, ix, inhIndex, context_size); + closure_literal(sp, ix, inhIndex, explicit_context_size + implicit_context_size); #endif /* USE_NEW_INLINES */ /* If out of memory, this will set sp to svalue-0 and * throw an error. @@ -8618,13 +8623,29 @@ "closure type %d.\n", sp->x.closure_type); #endif /* Now copy the context values */ - if (context_size != 0) + if (explicit_context_size != 0) { unsigned short i; - svalue_t * arg = sp - context_size; svalue_t * context = sp->u.lambda->context; - for (i = 0; i < context_size; i++) + for (i = 0; i < explicit_context_size; i++) + { + transfer_svalue_no_free(context+i, explicit_context+i); + + /* Set it to T_INVALID, as it is still a variable of + * the function frame and will be freed on return. + */ + explicit_context[i].type = T_INVALID; + } + } + + if (implicit_context_size != 0) + { + unsigned short i; + svalue_t * arg = sp - implicit_context_size; + svalue_t * context = sp->u.lambda->context + explicit_context_size; + + for (i = 0; i < implicit_context_size; i++) transfer_svalue_no_free(context+i, arg+i); /* Now move the created closure to the new top of the stack */ Index: trunk.inline/CHANGELOG =================================================================== --- trunk.inline/CHANGELOG (Revision 2587) +++ trunk.inline/CHANGELOG (Arbeitskopie) @@ -1,6 +1,12 @@ This file lists all changes made to the game driver in all glory detail. See the file HISTORY for a user-oriented summary of all the changes. +??-May-2009 (Gnomi) + - (prolang.y, interpret.c) Corrected the handling of implicit context + variables in nested inline closures and allowed the initializers + of explicit context variables to reference other explicit context + variables. (Bug #631) + 18-May-2009 (Gnomi) - (pkg-xml2.c, arraylist.c, configure) Added support for XML parsing using libxml2. (Bug #538, thanks, Bardioc!)