newblockalgo.c File Reference

Go to the source code of this file.

Functions
complexity	new_block_to_complexity (list block, transformer precond, list effects_list)

Function Documentation

new_block_to_complexity()

complexity new_block_to_complexity	(	list	block,
		transformer	precond,
		list	effects_list
	)

initilize the complexity as zero complexity

variables in final complexity result

get reverse order, because we want to go over the complexity bottom-up

Get the must_be_written variables from the block effects, which means that these variables should NOT be contained in the block complexity results

begining of trace

find each stmt of the block

Get the un-evaluated complexity for the stmt

Get the precondition for the stmt

Get the cumulated effects of the stmt

Obtain all the eventual variables from the complexity result

Find from effects that which variable is must be written

if var is in var_comp and is must_be_written variable

Evaluate that variable to complexity

add the complexity togather

verification of the final complexity

end of trace

Definition at line 27 of file newblockalgo.c.

{
    complexity comp = make_zero_complexity();
    /* initilize the complexity as zero complexity */
 
    Pbase final_var_comp = NIL;
    /* variables in final complexity result */
 
    list block_reverse = gen_nreverse(block);
    /* get reverse order, because we want to go over the complexity
       bottom-up */
 
    Pbase block_var_must = var_in_must_be_written(effects_list);
    /* Get the must_be_written variables from the block effects,
       which means that these variables should NOT be contained in
       the block complexity results */
 
    trace_on("block"); /* begining of trace */
 
    MAPL (pa, {
        statement stat = STATEMENT(CAR(pa)); /* find each stmt of the block */
 
        complexity ctemp = statement_to_complexity(stat, precond, effects_list);
        /* Get the un-evaluated complexity for the stmt */
 
        transformer prec = load_statement_precondition(stat);
        /* Get the precondition for the stmt */
 
        list cumu_list = load_statement_cumulated_effects(stat);
        /* Get the cumulated effects of the stmt */
 
        Pbase var_comp = var_in_comp(ctemp);
        /* Obtain all the eventual variables from the complexity result */
 
        Pbase var_must = var_in_must_be_written(cumu_list);
        /* Find from effects that which variable is must be written */
 
        for ( var in (var_comp and var_must) ) {
            /* if var is in var_comp and is must_be_written variable */
 
            complexity csubst = evaluate_var_to_complexity(var, cumu_list, prec);
            /* Evaluate that variable to complexity */
 
            if ( csubst is not unknown )
                complexity_var_subst(ctmp, var, csubst);
            else
                complexity_var_subst(ctmp, var, UU_);
        }
 
        complexity_add(&comp, ctemp);
        /* add the complexity togather */
    }, block_reverse);
 
    complexity_check_and_warn("block_to_complexity", comp);    
    /* verification of the final complexity */
 
    trace_off(); /* end of trace */
    return(comp);
}

References CAR, complexity_add(), complexity_check_and_warn(), complexity_var_subst(), evaluate_var_to_complexity(), gen_nreverse(), load_statement_precondition(), make_zero_complexity(), MAPL, NIL, STATEMENT, statement_to_complexity(), trace_off(), and trace_on().

Here is the call graph for this function: