/*main program*/
int main(int argc, char * argv[])
{
/* Init */
int ret;
int mpi_rank, mpi_size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
/*element initialization : domains are connected as a ring for this test*/
int num_elements=NUM_EL;
struct element * el_left=malloc(num_elements*sizeof(el_left[0]));
struct element * el_right=malloc(num_elements*sizeof(el_right[0]));
int i;
for(i=0; i<num_elements; i++)
{
init_element(el_left+i,i+1,((mpi_rank-1)+mpi_size)%mpi_size);
init_element(el_right+i,i+1,(mpi_rank+1)%mpi_size);
}
/* Communication loop */
for (i=0; i<NUM_LOOPS; i++) //number of "computations loops"
{
int e;
for (e=0; e<num_elements; e++) //Do something for each elements
{
insert_work_for_one_element(el_right+e);
insert_work_for_one_element(el_left+e);
}
}
/* End */
starpu_task_wait_for_all();
for(i=0; i<num_elements; i++)
{
free_element(el_left+i);
free_element(el_right+i);
}
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
FPRINTF(stderr, "No assert until end\n");
return 0;
}
void ls_core(t_d *d, char *path)
{
t_list_ls *list;
t_list_ls *lst_deb;
char *test;
list = NULL;
ls_core2(d);
lst_deb = list_dir(list, d, path, NULL);
if (d->denied == 0)
display_choose(lst_deb, d, path);
else
return (ls_core3(d, lst_deb));
d->nb_display = 1;
list = lst_deb;
while (list != NULL && d->tab_option[2] == 1)
{
if (list->c_type == 'd' && ft_strcmp("..", list->name) != 0
&& ft_strcmp(".", list->name) != 0)
{
test = ft_strdup(list->path);
ls_core(d, test);
free(test);
}
list = list->next;
}
free_element(lst_deb);
}
int main(int argc, char **argv)
{
char line_buffer[1024];
/* get input variables */
if (fgets(line_buffer, 1024, stdin) == NULL) {
fprintf(stderr, "fgets: crash\n");
exit(-1);
}
get_input_variables(line_buffer);
/* get circuit spec */
if (fgets(line_buffer, 1024, stdin) == NULL) {
fprintf(stderr, "fgets: crash\n");
exit(-1);
}
get_circuit(line_buffer);
replace_labels(circuit);
/* evaluate until eof */
while (fgets(line_buffer, 1024, stdin) != NULL) {
set_inputs(line_buffer);
final_val = evaluate(circuit);
}
printf("Result: %d\n", final_val);
free_element(circuit);
exit(0);
}
int
owlist_free_all
(
OWList * list,
void (* free_element) (void *)
)
{
int return_code = 0 ;
OWListIterator * iterator ;
void * element ;
iterator = owlist_iterator_new (list, OWLIST_WRITE) ;
if (iterator != NULL)
{
while (owlist_iterator_next (iterator) == 0)
{
element = owlist_iterator_get (iterator) ;
return_code |= owlist_iterator_remove (iterator) ;
free_element (element) ;
/* if free_element has a return code, it cannot be tested */
}
return_code |= owlist_iterator_free (iterator) ;
}
return_code |= owlist_free (list) ;
return return_code ;
}
void refresh_elements(internals_t * internP)
{
elemCell_t * cellP;
cellP = internP->elem_first;
while(cellP != NULL)
{
elemCell_t * nextCellP = cellP->next;
if ((cellP->element->elementType != SML_PE_STATUS)
&& (cellP->element->elementType != SML_PE_RESULTS))
{
cellP->next = internP->old_elem;
internP->old_elem = cellP;
}
else
{
free_element(cellP);
}
cellP = nextCellP;
}
internP->elem_first = NULL;
internP->elem_last = NULL;
}
/* has_metadata - parse document and report whether metadata is present */
gboolean has_metadata(char *text, int extensions) {
gboolean hasMeta;
element *result;
element *references;
element *notes;
element *labels;
GString *formatted_text;
formatted_text = preformat_text(text);
references = parse_references(formatted_text->str, extensions);
notes = parse_notes(formatted_text->str, extensions, references);
labels = parse_labels(formatted_text->str, extensions, references, notes);
result = parse_metadata_only(formatted_text->str, extensions);
hasMeta = FALSE;
if (result != NULL) {
if (result->children != NULL) {
hasMeta = TRUE;
free_element_list(result);
} else {
free_element(result);
}
}
free_element_list(references);
free_element_list(labels);
return hasMeta;
}
/**
* @brief Read and delete data from a dbuffer
* @param[in,out] buf the source buffer
* @param[out] data pointer to where the data should be copied
* @param[in] len maximum number of bytes to copy
* @return number of bytes copied
*
* @par
* Copies up to @c len bytes into @c data, and removes them from the dbuffer
*
* @par
* If the buffer does not contain at least @c len bytes, then as many
* bytes as are present will be copied.
*
* @par
* However many bytes are copied, exactly that many will be removed
* from the start of the dbuffer.
*/
size_t dbuffer_extract (struct dbuffer *buf, char *data, size_t len)
{
size_t extracted = 0;
if (!buf || !data || !len)
return 0;
while (len > 0 && buf->len > 0) {
const size_t l = (len < buf->head->len) ? len : buf->head->len;
struct dbuffer_element *e = buf->head;
memcpy(data, buf->start, l);
data += l;
len -= l;
buf->len -= l;
buf->space += l;
e->len -= l;
e->space += l;
extracted += l;
buf->start += l;
if (e->len == 0) {
if (e->next) {
buf->head = e->next;
free_element(e);
buf->space -= DBUFFER_ELEMENT_SIZE;
} else {
assert(buf->len == 0);
buf->end = &buf->head->data[0];
}
buf->start = &buf->head->data[0];
}
}
return extracted;
}
/**
* @brief Deletes data from a dbuffer
* @param[in,out] buf the target buffer
* @param[in] len number of bytes to delete
* Deletes the given number of bytes from the start of the dbuffer
*/
size_t dbuffer_remove (struct dbuffer *buf, size_t len)
{
size_t removed = 0;
if (!buf || !len)
return 0;
while (len > 0 && buf->len > 0) {
const size_t l = (len < buf->head->len) ? len : buf->head->len;
struct dbuffer_element *e = buf->head;
buf->len -= l;
buf->space += l;
len -= l;
e->len -= l;
e->space += l;
removed += l;
buf->start += l;
if (e->len == 0) {
if (e->next) {
buf->head = e->next;
free_element(e);
buf->space -= DBUFFER_ELEMENT_SIZE;
} else {
assert(buf->len == 0);
buf->end = &buf->head->data[0];
}
buf->start = &buf->head->data[0];
}
}
return removed;
}
/**
* @brief Deallocate a dbuffer
* @param[in,out] buf the dbuffer to deallocate
* Deallocates a dbuffer, and all memory it uses
*/
void free_dbuffer (struct dbuffer *buf)
{
struct dbuffer_element *e;
if (!buf)
return;
while ((e = buf->head)) {
buf->head = e->next;
free_element(e);
}
TH_MutexLock(dbuf_lock);
buf->next_free = free_dbuffer_list;
free_dbuffer_list = buf;
free_dbuffers++;
/* now we should free them, as we are still having a lot of them allocated */
while (free_dbuffers > DBUFFER_FREE_THRESHOLD) {
buf = free_dbuffer_list;
free_dbuffer_list = buf->next_free;
Mem_Free(buf);
free_dbuffers--;
allocated_dbuffers--;
}
TH_MutexUnlock(dbuf_lock);
}
static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
LONG ref;
TRACE("%p\n", This);
ref = InterlockedDecrement(&This->ref);
if (ref == 0) {
struct element *element, *element2;
IMalloc *imalloc = This->imalloc;
IXmlWriter_Flush(iface);
if (This->output) IUnknown_Release(&This->output->IXmlWriterOutput_iface);
/* element stack */
LIST_FOR_EACH_ENTRY_SAFE(element, element2, &This->elements, struct element, entry) {
list_remove(&element->entry);
free_element(This, element);
}
writer_free(This, This);
if (imalloc) IMalloc_Release(imalloc);
}
return ref;
}
void free_element(void *elem)
{
if ((TYPE(elem) == TYPE_INPUT) || (TYPE(elem) == TYPE_LABEL))
return;
if ((TYPE(elem) == TYPE_NOT) || (TYPE(elem) == TYPE_TFLIPFLOP)) {
free_element(UN_INPUT(elem));
free(elem);
return;
}
if ((TYPE(elem) == TYPE_OR) || (TYPE(elem) == TYPE_AND)) {
free_element(BINOP_INPUT_A(elem));
free_element(BINOP_INPUT_B(elem));
free(elem);
return;
}
}
void free_element_list(elemCell_t * cellP)
{
elemCell_t * tmpCellP;
while(cellP)
{
tmpCellP = cellP;
cellP = cellP->next;
free_element(tmpCellP);
}
}
/* free a dictionary */
void free_bt_dict(bt_dict *t)
{
if (t) {
free(t->key);
free_element(*t->val);
free(t->val);
free_bt_dict(t->left);
free_bt_dict(t->right);
free(t);
}
}
void set_inputs(char *buf)
{
int i, j = 0;
for (i = 0; buf[i] != '\0'; i++)
if (!isspace(buf[i])) {
if (j >= n_inputs) {
fprintf(stderr, "set_inputs crash(): too many input values given\n");
free_element(circuit);
exit(-1);
}
input_vector[j++].value = buf[i] - '0';
}
}
char evaluate(void *circuit)
{
switch (TYPE(circuit)) {
case TYPE_NOT:
return !(evaluate(UN_INPUT(circuit)));
case TYPE_OR:
return ((evaluate(BINOP_INPUT_A(circuit))) || (evaluate(BINOP_INPUT_B(circuit))));
case TYPE_AND:
return ((evaluate(BINOP_INPUT_A(circuit))) && (evaluate(BINOP_INPUT_B(circuit))));
case TYPE_TFLIPFLOP:
if (TFLIPFLOP_STATE(circuit) == 1)
TFLIPFLOP_STATE(circuit) = (evaluate(UN_INPUT(circuit)) == 0);
else
TFLIPFLOP_STATE(circuit) = (evaluate(UN_INPUT(circuit)) == 1);
return TFLIPFLOP_STATE(circuit);
case TYPE_INPUT:
return INPUT(circuit);
default:
fprintf(stderr, "evaluate crash: label should have been replaced\n");
free_element(circuit);
exit(-1);
}
}
void int_stree_free_node(SUFFIX_TREE tree, STREE_NODE node)
{
free_element(node);
}
void int_stree_free_leaf(SUFFIX_TREE tree, STREE_LEAF leaf)
{
free_element(leaf);
}
/*
* int_stree_free_{intleaf,leaf,node}
*
* Free the memory used for an INTLEAF, LEAF or NODE structure. Also,
* if the NODE structure uses a children array, free that space too.
*
* Parameters: ileaf/leaf/node - The structure to free.
*
* Return: nothing.
*/
void int_stree_free_intleaf(SUFFIX_TREE tree, STREE_INTLEAF intleaf)
{
free_element(intleaf);
}
/**
* Parses a new set variable
* @param Pointer to a string where the new set starts
* @return Returns a set structure with the values populated
**/
psetArray parse_set( char *setstring)
{
psetArray psa = NULL;
char *right = NULL;
char *var_start = NULL;
char *var_end = NULL;
setState state = start;
psetElement se = NULL;
psetArray t = NULL;
char temp[0x100];
if ( setstring == NULL ) {
goto end;
}
// Allocate the new set array
if ( allocate( sizeof(setArray), 0, (void**)&psa) != 0 ) {
psa = NULL;
goto end;
}
bzero( psa, sizeof(setArray) );
right = setstring;
while ( *right && state != error && state != close_set ) {
if ( *right == '|' ) {
switch (state) {
case start:
state = open_set;
break;
case open_double:
break;
case new_var:
state = error;
printf("!!Additional variable expected\n");
break;
case set_var:
bzero(temp, 0x100);
// Max value length of 10
if ( right-var_start > 10 ) {
printf("!!Invalid set data length\n");
state = error;
goto end;
}
cgc_memcpy( temp, var_start, right-var_start);
t = retrieve_set( temp );
if ( t == NULL ) {
printf("!!Cannot have a non-existant set as an element\n");
state = error;
break;
}
se = create_element( temp, SET );
if ( se == NULL ) {
printf("!!Failed to create element\n");
state = error;
break;
}
if ( element_in_set( psa, se ) ) {
printf("!!Elements must be unique\n");
free_element(se);
free_set_array( psa );
se = NULL;
psa = NULL;
state = error;
goto end;
}
if ( add_element_to_set( psa, se ) ) {
printf("Failed to ad el\n");
state = error;
goto end;
}
default:
state = close_set;
break;
};
} else if ( *right == '"' ) {
switch ( state ) {
case open_double:
state = close_double;
bzero(temp, 0x100);
// Max value length of 10
if ( right-var_start > 10 ) {
printf("!!Invalid set data length\n");
state = error;
goto end;
}
cgc_memcpy( temp, var_start, right-var_start);
se = create_element( temp, VALUE );
if ( se == NULL ) {
printf("Failed to cel\n");
state = error;
goto end;
}
if ( element_in_set( psa, se ) ) {
printf("!!Elements must be unique\n");
free_element(se);
free_set_array( psa );
se = NULL;
psa = NULL;
state = error;
goto end;
}
if ( add_element_to_set( psa, se ) ) {
printf("Failed to ad el\n");
state = error;
goto end;
}
break;
case set_end:
case set_var:
case close_double:
state = error;
printf("!!Malformed set\n");
break;
default:
state = open_double;
var_start = right+1;
break;
};
} else if ( *right == ' ') {
switch ( state ) {
case set_var:
var_end = right;
bzero( temp, 0x100 );
// Max set name is 15
if ( right-var_start > 15 ) {
printf("!!Invalid set name length\n");
state = error;
goto end;
}
cgc_memcpy( temp, var_start, right-var_start);
se = create_element( temp, SET );
if ( se == NULL ) {
printf("!!Create element failed\n");
state = error;
goto end;
}
if ( element_in_set( psa, se ) ) {
printf("!!Elements must be unique\n");
free_element(se);
free_set_array( psa );
se = NULL;
psa = NULL;
state = error;
goto end;
}
if ( add_element_to_set( psa, se ) ) {
printf("!!Failed to add element\n");
state = error;
goto end;
}
state = set_end;
break;
default:
break;
};
} else if ( *right == ',') {
switch ( state ) {
case open_set:
state = error;
printf("!!Malformed set\n");
break;
case set_var:
bzero( temp, 0x100 );
// Max set name is 15
if ( right-var_start > 15 ) {
printf("!!Invalid set name length\n");
state = error;
goto end;
}
cgc_memcpy( temp, var_start, right-var_start);
se = create_element( temp, SET );
if ( se == NULL ) {
printf("!!Failed to create element\n");
state = error;
goto end;
}
if ( element_in_set( psa, se ) ) {
printf("!!Elements must be unique\n");
free_element(se);
free_set_array( psa );
se = NULL;
psa = NULL;
state = error;
goto end;
}
if ( add_element_to_set( psa, se ) ) {
printf("!!Failed to add element\n");
state = error;
goto end;
}
state = new_var;
break;
case open_double:
printf("!!Improperly formated set\n");
state = error;
goto end;
break;
default:
state = new_var;
break;
};
} else {
switch( state ) {
case open_set:
case new_var:
state = set_var;
var_start = right;
break;
case close_double:
state = error;
printf("!!Invalid character\n");
goto end;
default:
break;
}
}
right++;
}
end:
if ( state != close_set ) {
free_set_array( psa );
psa = NULL;
}
return psa;
}
void tp_incr_commit(void)
{
uint4 duint4;
sgm_info *si;
cw_set_element *cse, *orig_cse, *prev_cse, *next_cse, *low_cse, *lower_cse;
tlevel_info *tli, *prev_tli = NULL, *last_prev_tli = NULL;
global_tlvl_info
*gtli, *prev_gtli;
srch_blk_status *tp_srch_status;
for (si = first_sgm_info; si != NULL; si = si->next_sgm_info)
{
for (cse = si->first_cw_set; cse; cse = orig_cse->next_cw_set)
{
orig_cse = cse;
TRAVERSE_TO_LATEST_CSE(cse);
assert(dollar_tlevel >= cse->t_level);
if (dollar_tlevel == cse->t_level)
{
cse->t_level--;
low_cse = cse->low_tlevel;
if (low_cse && low_cse->t_level == cse->t_level) /* delete the duplicate link */
{
lower_cse = low_cse->low_tlevel;
if (lower_cse)
{
assert(lower_cse->t_level < cse->t_level);
lower_cse->high_tlevel = cse;
cse->low_tlevel = lower_cse;
assert(low_cse->new_buff);
if (!cse->new_buff)
{ /* if we never needed to build in the new level, copy the
* built copy of the older level before going back to that level
*/
assert(!cse->done && low_cse->done);
cse->new_buff = low_cse->new_buff;
} else
free_element(si->new_buff_list,
(char *)low_cse->new_buff - sizeof(que_ent));
free_element(si->tlvl_cw_set_list, (char *)low_cse);
orig_cse = cse;
} else
{
/* In this case, there are only two elements in the horizontal list out of
* which we are going to delete one. We prefer to copy the second link into
* the first and delete the second (rather than simply deleting the first), since
* the first element may be an intermediate element in the vertical list and
* buddy list wont permit use of both free_element() and free_last_n_elements()
* with a given list together.
* This might disturb the tp_srch_status->ptr, so reset it properly.
*/
tp_srch_status = (srch_blk_status *)lookup_hashtab_ent(si->blks_in_use,
(void *)cse->blk, &duint4);
assert(!tp_srch_status || tp_srch_status->ptr == cse);
if (tp_srch_status)
tp_srch_status->ptr = low_cse;
assert(low_cse == orig_cse);
/* Members that may not be uptodate in cse need to be copied back from low_cse.
* They are next_cw_set, prev_cw_set, new_buff and done.
*/
prev_cse = low_cse->prev_cw_set;
next_cse = low_cse->next_cw_set;
assert(low_cse->new_buff);
if (!cse->new_buff)
{ /* if we never needed to build in the new level, copy the
* built copy of the older level before going back to that level
*/
assert(!cse->done && low_cse->done);
cse->new_buff = low_cse->new_buff;
} else
free_element(si->new_buff_list,
(char *)low_cse->new_buff - sizeof(que_ent));
memcpy(low_cse, cse, sizeof(cw_set_element));
low_cse->next_cw_set = next_cse;
low_cse->prev_cw_set = prev_cse;
low_cse->high_tlevel = NULL;
low_cse->low_tlevel = NULL;
free_element(si->tlvl_cw_set_list, (char *)cse);
orig_cse = low_cse;
}
} else
assert(low_cse || orig_cse == cse);
}
}/* for (cse) */
/* delete the tlvl_info for this t_level */
for (tli = si->tlvl_info_head; tli; tli = tli->next_tlevel_info)
{
if (tli->t_level >= dollar_tlevel)
break;
prev_tli = tli;
}
assert(!tli || !tli->next_tlevel_info);
if (prev_tli)
prev_tli->next_tlevel_info = NULL;
else
si->tlvl_info_head = NULL;
if (tli)
free_last_n_elements(si->tlvl_info_list, 1);
}/* for (si) */
/* delete the global (across all segments) tlvl info for this t_level */
for (prev_gtli = NULL, gtli = global_tlvl_info_head; gtli; gtli = gtli->next_global_tlvl_info)
{
if (dollar_tlevel <= gtli->t_level)
break;
prev_gtli = gtli;
}
assert(!global_tlvl_info_head || gtli);
assert(!gtli || !gtli->next_global_tlvl_info);
assert(!prev_gtli || (gtli && (dollar_tlevel == gtli->t_level)));
FREE_GBL_TLVL_INFO(gtli);
if (prev_gtli)
prev_gtli->next_global_tlvl_info = NULL;
else
global_tlvl_info_head = NULL;
}
void ls_core3(t_d *d, t_list_ls *lst_deb)
{
d->denied = 0;
free_element(lst_deb);
return ;
}
void tp_incr_commit(void)
{
sgm_info *si;
cw_set_element *cse, *orig_cse, *prev_cse, *next_cse, *low_cse, *lower_cse;
tlevel_info *tli, *prev_tli = NULL, *last_prev_tli = NULL;
global_tlvl_info *gtli, *prev_gtli;
srch_blk_status *tp_srch_status;
ht_ent_int4 *tabent;
for (si = first_sgm_info; si != NULL; si = si->next_sgm_info)
{
for (cse = si->first_cw_set; cse; cse = orig_cse->next_cw_set)
{
orig_cse = cse;
TRAVERSE_TO_LATEST_CSE(cse);
assert(dollar_tlevel >= cse->t_level);
if (dollar_tlevel == cse->t_level)
{
cse->t_level--;
low_cse = cse->low_tlevel;
if (low_cse && low_cse->t_level == cse->t_level) /* delete the duplicate link */
{
lower_cse = low_cse->low_tlevel;
assert((low_cse->done && low_cse->new_buff) || (n_gds_t_op < cse->mode));
if (lower_cse)
{
assert(lower_cse->t_level < cse->t_level);
lower_cse->high_tlevel = cse;
cse->low_tlevel = lower_cse;
if (!cse->new_buff)
{ /* if we never needed to build in the new level, copy the built copy
* (if any) of the older level before going back to that level
*/
assert(!cse->done);
cse->new_buff = low_cse->new_buff;
} else if (low_cse->new_buff)
free_element(si->new_buff_list, (char *)low_cse->new_buff);
free_element(si->tlvl_cw_set_list, (char *)low_cse);
orig_cse = cse;
} else
{ /* In this case, there are only two elements in the horizontal list out of
* which we are going to delete one. We prefer to copy the second link into
* the first and delete the second (rather than simply deleting the first), since
* the first element may be an intermediate element in the vertical list and
* buddy list wont permit use of both free_element() and free_last_n_elements()
* with a given list together. This might disturb the tp_srch_status->cse, so
* reset it properly. Note that if cse->mode is gds_t_create, there will be no
* tp_srch_status entry allotted for cse->blk (one will be there only for the
* chain.flag representation of this to-be-created block). Same case with mode of
* kill_t_create as it also corresponds to a non-existent block#. Therefore dont
* try looking up the hashtable for this block in those cases.
*/
assert((gds_t_create == cse->mode) || (kill_t_create == cse->mode)
|| (gds_t_write == cse->mode) || (kill_t_write == cse->mode));
if ((gds_t_create != cse->mode) && (kill_t_create != cse->mode))
{
if (NULL != (tabent = lookup_hashtab_int4(si->blks_in_use,
(uint4 *)&cse->blk)))
tp_srch_status = tabent->value;
else
tp_srch_status = NULL;
assert(!tp_srch_status || tp_srch_status->cse == cse);
if (tp_srch_status)
tp_srch_status->cse = low_cse;
}
assert(low_cse == orig_cse);
/* Members that may not be uptodate in cse need to be copied back from low_cse.
* They are next_cw_set, prev_cw_set, new_buff and done.
*/
prev_cse = low_cse->prev_cw_set;
next_cse = low_cse->next_cw_set;
if (!cse->new_buff)
{ /* if we never needed to build in the new level, copy the
* built copy of the older level before going back to that level
*/
assert(!cse->done);
cse->new_buff = low_cse->new_buff;
} else if (low_cse->new_buff)
free_element(si->new_buff_list, (char *)low_cse->new_buff);
memcpy(low_cse, cse, SIZEOF(cw_set_element));
low_cse->next_cw_set = next_cse;
low_cse->prev_cw_set = prev_cse;
low_cse->high_tlevel = NULL;
low_cse->low_tlevel = NULL;
free_element(si->tlvl_cw_set_list, (char *)cse);
orig_cse = low_cse;
}
} else
assert(low_cse || orig_cse == cse);
}
}/* for (cse) */
/* delete the tlvl_info for this t_level */
for (tli = si->tlvl_info_head; tli; tli = tli->next_tlevel_info)
{
if (tli->t_level >= dollar_tlevel)
break;
prev_tli = tli;
}
assert(!tli || !tli->next_tlevel_info);
if (prev_tli)
prev_tli->next_tlevel_info = NULL;
else
si->tlvl_info_head = NULL;
if (tli)
free_last_n_elements(si->tlvl_info_list, 1);
}/* for (si) */
/* delete the global (across all segments) tlvl info for this t_level */
for (prev_gtli = NULL, gtli = global_tlvl_info_head; gtli; gtli = gtli->next_global_tlvl_info)
{
if (dollar_tlevel <= gtli->t_level)
break;
prev_gtli = gtli;
}
assert(!global_tlvl_info_head || gtli);
assert(!gtli || !gtli->next_global_tlvl_info);
assert(!prev_gtli || (gtli && (dollar_tlevel == gtli->t_level)));
FREE_GBL_TLVL_INFO(gtli);
if (prev_gtli)
prev_gtli->next_global_tlvl_info = NULL;
else
global_tlvl_info_head = NULL;
}
