/*
* clean-up and exit the software
*/
int main_exit( void)
{
/*
* print the symbol table
*/
#ifdef YYDEBUG
if( IS_FLAGS_SYMBOL( data.flags))
{
print_symbol_table();
}
#endif
/*
* deallocate the symbol table list
*/
free_tuple_list( data.symbol_table);
free_tuple_list( data.symbol_table_free);
/*
* check if memory leak
*/
if( data.memory)
fprintf( stderr, "Error: memory deallocation error: %d\n", data.memory);
/*
* check if compiler warnings
*/
if( data.warnings)
fprintf( stderr, "Warning: compiler warnings: %d\n", data.warnings);
/*
* check if compiler errors
*/
if( data.errors)
fprintf( stderr, "Error: compiler errors: %d\n", data.errors);
return( data.errors);
}
/*
* convert postfix expression into tuple
$$.tuple = tuple_postfix_expr( $1.tuple, 0);
$$.tuple = tuple_postfix_expr( $1.tuple, $3.tuple);
*/
TUPLE *tuple_postfix_expr( TUPLE *postfix_expr, TUPLE *argument_expr_list)
{
TUPLE *lists;
TUPLE *tuple_next;
/*
* special case is printf, after each argument insert call to printf
*/
if( ! strcmp( postfix_expr->buffer, "printf"))
{
for( lists = argument_expr_list; lists; )
{
if( lists->mask & MASK_W_REG)
{
tuple_next = lists->next;
lists->next = new_tuple( I_CALL, 0, 0, MASK_LABEL, "printf", sizeof( "printf") + 1); /* call printf */
lists->next->next = tuple_next;
lists = lists->next->next;
}
else
{
lists = lists->next;
}
}
free_tuple_list( postfix_expr);
return( argument_expr_list);
}
postfix_expr->token = I_CALL;
postfix_expr->mask = MASK_LABEL;
tuple_tail_to_head( postfix_expr, argument_expr_list);
return( postfix_expr);
}
/*
* update a value of an identifier in symbol table
$$.tuple = symbol_init_declarator( $1.tuple, $3.tuple);
*/
TUPLE *symbol_init_declarator( TUPLE *declarator, TUPLE *initializer)
{
TUPLE *lists;
/*
* can be a list of identifiers
*/
for( lists = declarator; lists; lists = lists->next)
{
/*
* create a symbol with this value and copy it to identifier list
*/
if( initializer)
{
create_symbol( 0, initializer->value, lists->buffer, lists->length);
lists->value = initializer->value;
}
else
create_symbol( 0, 0, lists->buffer, lists->length);
}
/*
* free the initializer linked list
*/
free_tuple_list( initializer);
return( declarator);
}
/*
* code generator for the pic16f84 processor
code_generator_pic16f84( $1.tuple);
*/
void code_generator_pic16f84( TUPLE *tuple_list)
{
TUPLE *tuple;
/*
* debug tuple list
*/
#ifdef YYDEBUG
if( IS_FLAGS_DEBUG( data.flags))
print_tuple_list( tuple_list);
#endif
/*
* generate the header
*/
code_generator_pic_prefix();
/*
* walk the tuple list and generate PIC16F85 assembler code
*/
for( tuple = tuple_list; tuple; tuple = tuple->next)
{
code_generator_instr( tuple);
}
/*
* generate the end of pic code
*/
code_generator_pic_postfix();
/*
* deallocate the tuple linked list
*/
free_tuple_list( tuple_list);
return;
}
/*
* generate initialize code for this list of identifiers
$$.tuple = tuple_declaration( $1.token, $$.tuple);
*/
TUPLE *tuple_declaration( int declaration_specifiers, TUPLE *init_declarator_list)
{
TUPLE *lists;
TUPLE *symbol;
TUPLE *tuple;
TUPLE *tuple_head = 0;
/*
* can be a list of identifiers
*/
for( lists = init_declarator_list; lists; lists = lists->next)
{
/*
* find the identifier in the symbol table (shall already be there!)
*/
symbol = find_symbol( 0, lists->buffer, lists->length);
/*
* generate the intermediate code to initialize the variables
*/
if( symbol)
{
if( symbol->level == 0 || symbol->value)
{
tuple = new_tuple( I_MOV, symbol->value, 0, MASK_VALUE, 0, 0);
tuple_head = tuple_tail_to_head( tuple_head, tuple);
}
if( IS_FLAGS_ADDRESS( data.flags))
tuple = new_tuple( I_MOV, 0, symbol->address, MASK_ADDRESS, 0, 0);
else
tuple = new_tuple( I_MOV, 0, 0, MASK_LABEL, symbol->buffer, symbol->length);
tuple->level = symbol->level;
tuple_head = tuple_tail_to_head( tuple_head, tuple);
}
}
free_tuple_list( init_declarator_list);
return( tuple_head);
}
void backwards(int * trace, int * max_used_color,
int * vertex_max_color, int * current_vertex,
int * satur_degree, Graph * graph, tuple * base,
int * popularity, int * coloring,
int * depth, int upper_bound, int lower_bound) {
// Se determina la posición en la traza donde se encuentra
// el vértice desde el cual se hace backtracking
int vertex_position = lin_search(trace, *current_vertex, *depth);
// Se averigua si el vértice de donde se parte
// el backtracking es la raiz
if (vertex_position == 0) {
int vertex_color = graph[trace[vertex_position]].color;
update_all(trace, graph, base, popularity, *depth,
vertex_position, satur_degree);
// Quitamos su color del FC
graph[trace[vertex_position]].FC[vertex_color] = 0;
// Se determina el máximo color utilizado hasta ahora
max_color(popularity, max_used_color, upper_bound);
if (valid_FC(graph, trace[vertex_position],lower_bound+1)) {
*current_vertex = trace[vertex_position];
*vertex_max_color = 0;
return;
}
else {
// Se ha llegado a la raiz y no hay mas colores
// posibles que introducir
*current_vertex = -1;
return;
}
}
else {
tuple_list * candidates = NULL;
if (vertex_position == -1) {
// Significa que el vértice donde quedó forward
// tuvo FC vació, por lo tanto no se encontró en
// la traza. Se llama directamente label
candidates = label(graph, *depth + 1,
*max_used_color, trace, *current_vertex);
vertex_position = *depth + 1;
}
else {
// Se logró una coloración completa. Por lo tanto:
// Se decolorean todos los vértices subiendo en el
// árbol hasta llegar al vértice de mínimo rango
// con el mayor color usado en la coloración parcial actual
update_all(trace, graph, base, popularity, *depth,
vertex_position, satur_degree);
// Se procede a hacer el etiquetado partiendo del vértice
// con coloración más alta y de rango mínimo. O partiendo
// del vértice cuyo FC se hizo vacío
candidates = label(graph, vertex_position,
*max_used_color, trace, *current_vertex);
}
// Se verifica que la lista de candidatos del label
// sea distinta de Nula. En caso contrario no hay más
// backtracking que hacer y se consiguió una coloración
while (candidates != NULL) {
int vertex_color = graph[candidates->vertex].color;
// Se decolorean todos los vértices que están a partir
// de una posición anterior desde donde se hizo labeling
// hasta el vértice de rango máximo entre todos los
// etiquetados
update_all(trace, graph, base, popularity,
vertex_position - 1, candidates->position,
satur_degree);
// Se elimina de su FC el color que tiene actualmente
graph[candidates->vertex].FC[vertex_color] = 0;
// Se determina el máximo color utilizado hasta ahora
max_color(popularity, max_used_color, upper_bound);
// Se verifica que el vértice de máximo rango etiquetado
// no tenga un FC vacío. Al ser su FC no vació se hace
// retornar el algoritmo
if (valid_FC(graph, candidates->vertex, *max_used_color)) {
// Se determina la posición en la traza
// del vértice de mínimo rango que tiene
// el color máximo utilizado
det_vertex_max_color(graph, trace,*max_used_color,
vertex_max_color, candidates->position);
// Se indica la posición en la traza del vértice
// del cual se parte para hacer forward.
*current_vertex = candidates->vertex;
*depth = candidates->position;
free_tuple_list(candidates);
return;
}
else {
tuple_list * tmp = candidates;
candidates = candidates->next;
tmp->next = NULL;
free_tuple_list(tmp);
}
}
}
// La lista CP está vacía por lo tanto se retorna el
// algoritmo con current_vertex siendo cero.
*current_vertex = -1;
return;
}
/*
* if main( int argc, char *argv[]) then delete parameters
$$.tuple = tuple_parameter_list( $1.tuple, $3.tuple);
*/
TUPLE *tuple_parameter_list( TUPLE *parameter_list, TUPLE *parameter_declaration)
{
free_tuple_list( parameter_list);
free_tuple_list( parameter_declaration);
return( (TUPLE*)0);
}
