304 lines
7.1 KiB
C
304 lines
7.1 KiB
C
#include <vslc.h>
|
|
|
|
static void node_print ( node_t *root, int nesting );
|
|
static void simplify_tree ( node_t **simplified, node_t *root );
|
|
static void node_finalize ( node_t *discard );
|
|
|
|
|
|
static void destroy_subtree ( node_t *discard );
|
|
|
|
typedef struct stem_t *stem;
|
|
struct stem_t { const char *str; stem next; };
|
|
static void
|
|
tree_print(node_t* root, stem head)
|
|
{
|
|
if (!root)
|
|
return;
|
|
|
|
|
|
static const char *sdown = " │", *slast = " └", *snone = " ";
|
|
struct stem_t col = {0, 0}, *tail;
|
|
|
|
for (tail = head; tail; tail = tail->next) {
|
|
if (!tail->next) {
|
|
if (!strcmp(sdown, tail->str))
|
|
printf(" ├");
|
|
else
|
|
printf("%s", tail->str);
|
|
break;
|
|
}
|
|
printf("%s", tail->str);
|
|
}
|
|
|
|
printf("──%s", node_string[root->type] );
|
|
if ( root->type == IDENTIFIER_DATA ||
|
|
root->type == STRING_DATA ||
|
|
root->type == EXPRESSION ||
|
|
root->type == RELATION)
|
|
printf("(%s)", (char *) root->data);
|
|
else if (root->type == NUMBER_DATA)
|
|
printf ( "(%ld)", *((int64_t *)root->data) );
|
|
putchar ( '\n' );
|
|
|
|
if (!root->n_children) return;
|
|
|
|
if (tail && tail->str == slast)
|
|
tail->str = snone;
|
|
|
|
if (!tail) tail = head = &col;
|
|
else tail->next = &col;
|
|
|
|
for ( int64_t i=0; i < root->n_children; i++ ) {
|
|
col.str = root->n_children - i - 1 ? sdown : slast;
|
|
tree_print(root->children[i], head);
|
|
}
|
|
tail->next = 0;
|
|
}
|
|
|
|
|
|
/* External interface */
|
|
void
|
|
destroy_syntax_tree ( void )
|
|
{
|
|
destroy_subtree ( root );
|
|
}
|
|
|
|
|
|
void
|
|
simplify_syntax_tree ( void )
|
|
{
|
|
simplify_tree ( &root, root );
|
|
}
|
|
|
|
|
|
void
|
|
print_syntax_tree ( void )
|
|
{
|
|
//node_print ( root, 0 );
|
|
tree_print(root, 0);
|
|
}
|
|
|
|
// Changed so it returns the pointer to the new node, can be used as before, but makes the parser file cleaner
|
|
node_t*
|
|
node_init (node_t *nd, node_index_t type, void *data, uint64_t n_children, ...)
|
|
{
|
|
va_list child_list;
|
|
*nd = (node_t) {
|
|
.type = type,
|
|
.data = data,
|
|
.entry = NULL,
|
|
.n_children = n_children,
|
|
.children = (node_t **) malloc ( n_children * sizeof(node_t *) )
|
|
};
|
|
va_start ( child_list, n_children );
|
|
for ( uint64_t i=0; i<n_children; i++ )
|
|
nd->children[i] = va_arg ( child_list, node_t * );
|
|
va_end ( child_list );
|
|
|
|
return nd;
|
|
}
|
|
|
|
|
|
/* Internal choices */
|
|
static void
|
|
node_print ( node_t *root, int nesting )
|
|
{
|
|
if ( root != NULL )
|
|
{
|
|
printf ( "%*c%s", nesting, ' ', node_string[root->type] );
|
|
if ( root->type == IDENTIFIER_DATA ||
|
|
root->type == STRING_DATA ||
|
|
root->type == EXPRESSION )
|
|
printf ( "(%s)", (char *) root->data );
|
|
else if ( root->type == NUMBER_DATA )
|
|
printf ( "(%ld)", *((int64_t *)root->data) );
|
|
putchar ( '\n' );
|
|
for ( int64_t i=0; i<root->n_children; i++ )
|
|
node_print ( root->children[i], nesting+1 );
|
|
}
|
|
else
|
|
printf ( "%*c%p\n", nesting, ' ', root );
|
|
}
|
|
|
|
|
|
static void
|
|
node_finalize ( node_t *discard )
|
|
{
|
|
if ( discard != NULL )
|
|
{
|
|
free ( discard->data );
|
|
free ( discard->children );
|
|
free ( discard );
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
destroy_subtree ( node_t *discard )
|
|
{
|
|
if ( discard != NULL )
|
|
{
|
|
for ( uint64_t i=0; i<discard->n_children; i++ )
|
|
destroy_subtree ( discard->children[i] );
|
|
node_finalize ( discard );
|
|
}
|
|
}
|
|
|
|
static void
|
|
prune_children(node_t **simplified, node_t *root)
|
|
{
|
|
if (!root)
|
|
return;
|
|
|
|
node_t *result = root;
|
|
switch (root->type)
|
|
{
|
|
case GLOBAL:
|
|
//case ARGUMENT_LIST:
|
|
//case PARAMETER_LIST:
|
|
case STATEMENT:
|
|
case PRINT_ITEM:
|
|
case PRINT_STATEMENT:
|
|
result = root->children[0];
|
|
|
|
// The print_statement only contains a print_list, still need a print_statement.
|
|
if (root->type == PRINT_STATEMENT)
|
|
result->type = PRINT_STATEMENT;
|
|
|
|
node_finalize(root);
|
|
break;
|
|
}
|
|
|
|
*simplified = result;
|
|
}
|
|
|
|
|
|
static void
|
|
resolve_constant_expressions(node_t **simplified, node_t *root)
|
|
{
|
|
if (!root)
|
|
return;
|
|
|
|
if (root->type != EXPRESSION)
|
|
return;
|
|
|
|
node_t *result = root;
|
|
|
|
switch (root->n_children)
|
|
{
|
|
case 1:
|
|
result = root->children[0];
|
|
|
|
if (root->data &&
|
|
result->type == NUMBER_DATA &&
|
|
result->data)
|
|
{
|
|
switch (*((char*)root->data))
|
|
{
|
|
case '-':
|
|
*((int64_t*)result->data) *= -1;
|
|
break;
|
|
case '~':
|
|
*((int64_t*)result->data) = ~*((int64_t*)result->data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
node_finalize(root);
|
|
break;
|
|
|
|
case 2:
|
|
// Both children needs to be numbers to resolve constants
|
|
if (root->children[0]->type == NUMBER_DATA &&
|
|
root->children[1]->type == NUMBER_DATA)
|
|
{
|
|
// Check if children does not contain null pointers
|
|
if (!root->children[0]->data)
|
|
break;
|
|
if (!root->children[1]->data)
|
|
break;
|
|
|
|
// Check if data field is not null pointer
|
|
if (!root->data)
|
|
break;
|
|
|
|
result = root->children[0];
|
|
int64_t
|
|
*lhs = result->data,
|
|
*rhs = root->children[1]->data;
|
|
|
|
switch (*(char*)root->data)
|
|
{
|
|
case '|': *lhs |= *rhs; break;
|
|
case '^': *lhs ^= *rhs; break;
|
|
case '&': *lhs &= *rhs; break;
|
|
case '+': *lhs += *rhs; break;
|
|
case '-': *lhs -= *rhs; break;
|
|
case '*': *lhs *= *rhs; break;
|
|
case '/': *lhs /= *rhs; break;
|
|
}
|
|
|
|
node_finalize(root->children[1]);
|
|
node_finalize(root);
|
|
}
|
|
|
|
|
|
break;
|
|
}
|
|
*simplified = result;
|
|
}
|
|
|
|
static void
|
|
flatten(node_t **simplified, node_t *root)
|
|
{
|
|
/* This will flatten left-expanded lists */
|
|
if (!root)
|
|
return;
|
|
|
|
node_t **new_children, *result = root;
|
|
switch (root->type)
|
|
{
|
|
case GLOBAL_LIST:
|
|
case STATEMENT_LIST:
|
|
case PRINT_LIST:
|
|
case EXPRESSION_LIST:
|
|
case VARIABLE_LIST:
|
|
case DECLARATION_LIST:
|
|
// Check if node have more than two children
|
|
if (root->n_children < 2)
|
|
break;
|
|
|
|
result = root->children[0];
|
|
result->n_children++;
|
|
|
|
// Realloc the array of children to the new size
|
|
if (!(new_children = realloc(result->children, result->n_children * sizeof(node_t*))))
|
|
break;
|
|
// if successs, insert the new array
|
|
result->children = new_children;
|
|
|
|
// Insert child at the end
|
|
result->children[result->n_children - 1] = root->children[1];
|
|
|
|
node_finalize(root);
|
|
break;
|
|
}
|
|
|
|
*simplified = result;
|
|
}
|
|
|
|
static void
|
|
simplify_tree ( node_t **simplified, node_t *root )
|
|
{
|
|
if (!root)
|
|
return;
|
|
|
|
for (int i = 0; i < root->n_children; i++)
|
|
simplify_tree(&root->children[i], root->children[i]);
|
|
|
|
prune_children(&root, root);
|
|
resolve_constant_expressions(&root, root);
|
|
flatten(&root, root);
|
|
|
|
*simplified = root;
|
|
} |