oyvindskaaden/TDT4205
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Start PS4

Browse Source
This commit is contained in:
Øyvind Skaaden
2022-03-12 18:09:07 +01:00
parent 7a3af1c302
commit 4717d45e30
27 changed files with 1212 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
exercises/04/vslc/src/ir.c Normal file
View File

@@ -0,0 +1,76 @@
#include <vslc.h>
// Externally visible, for the generator
extern tlhash_t *global_names;
extern char **string_list;
extern size_t n_string_list, stringc;
// Implementation choices, only relevant internally
static void find_globals ( void );
/** @param function Function's symbol table entry
* @param root Function's root node */
static void bind_names ( symbol_t *function, node_t *root );
void
create_symbol_table ( void )
{
/* TODO: traverse the syntax tree and create the symbol table */
// ! Example code solely to demonstrate usage of tlhash. Make sure to remove
// ! or comment this out when implementing your solution.
// Initialize table
tlhash_t *my_table = (tlhash_t*)malloc(sizeof(tlhash_t));
tlhash_init(my_table, 64);
char *my_key0 = "key"; // Keep in mind that these are stack allocated for simplicity, yours should not
char *my_val0 = "valuable"; // Also, I'm using strings as values, you will be using symbol_t pointers
char *my_key1 = "another_key";
char *my_val1 = "more valuable";
// Insert some values to the table. Remember that the length of a string
// interpreted as an array is the string length plus one '\0' character
tlhash_insert(my_table, my_key0, strlen(my_key0)+1, my_val0);
tlhash_insert(my_table, my_key1, strlen(my_key1)+1, my_val1);
// Iterate keys and lookup their values
size_t size = tlhash_size(my_table);
char **keys = (char **)malloc(size);
tlhash_keys(my_table, keys);
char *val;
for (int i = 0; i < size; i++) {
tlhash_lookup(my_table, keys[i], strlen(keys[i])+1, &val);
printf("my_table[%s] = \"%s\"\n", keys[i], val);
}
// Free allocated memory when done with the symbol table
tlhash_finalize(my_table);
free(my_table);
free(keys);
}
void
print_symbol_table ( void )
{
/* TODO: output its contents */
}
void
destroy_symbol_table ( void )
{
/* TODO: release memory allocated to the symbol table */
}
void
find_globals ( void )
{
/* TODO: Populate symbol table with global variables and functions */
}
void
bind_names ( symbol_t *function, node_t *root )
{
/* TODO: Bind names and string literals in local symbol table */
}

34
exercises/04/vslc/src/nodetypes.c Normal file
View File

@@ -0,0 +1,34 @@
#define STRING(x) #x
char *node_string[30] = {
STRING(PROGRAM),
STRING(GLOBAL_LIST),
STRING(GLOBAL),
STRING(STATEMENT_LIST),
STRING(PRINT_LIST),
STRING(EXPRESSION_LIST),
STRING(VARIABLE_LIST),
STRING(ARGUMENT_LIST),
STRING(PARAMETER_LIST),
STRING(DECLARATION_LIST),
STRING(FUNCTION),
STRING(STATEMENT),
STRING(BLOCK),
STRING(ASSIGNMENT_STATEMENT),
STRING(ADD_STATEMENT),
STRING(SUBTRACT_STATEMENT),
STRING(MULTIPLY_STATEMENT),
STRING(DIVIDE_STATEMENT),
STRING(RETURN_STATEMENT),
STRING(PRINT_STATEMENT),
STRING(NULL_STATEMENT),
STRING(IF_STATEMENT),
STRING(WHILE_STATEMENT),
STRING(EXPRESSION),
STRING(RELATION),
STRING(DECLARATION),
STRING(PRINT_ITEM),
STRING(IDENTIFIER_DATA),
STRING(NUMBER_DATA),
STRING(STRING_DATA)
};
#undef STRING

181
exercises/04/vslc/src/parser.y Normal file
View File

@@ -0,0 +1,181 @@
%{
#include <vslc.h>
#define N0C(n,t,d) do { \
node_init ( n = malloc(sizeof(node_t)), t, d, 0 ); \
} while ( false )
#define N1C(n,t,d,a) do { \
node_init ( n = malloc(sizeof(node_t)), t, d, 1, a ); \
} while ( false )
#define N2C(n,t,d,a,b) do { \
node_init ( n = malloc(sizeof(node_t)), t, d, 2, a, b ); \
} while ( false )
#define N3C(n,t,d,a,b,c) do { \
node_init ( n = malloc(sizeof(node_t)), t, d, 3, a, b, c ); \
} while ( false )
%}
%left '|'
%left '^'
%left '&'
%left '+' '-'
%left '*' '/'
%nonassoc UMINUS
%right '~'
%expect 1
%token FUNC PRINT RETURN CONTINUE IF THEN ELSE WHILE DO OPENBLOCK CLOSEBLOCK
%token VAR NUMBER IDENTIFIER STRING
%%
program :
global_list { N1C ( root, PROGRAM, NULL, $1 ); }
;
global_list :
global { N1C ( $$, GLOBAL_LIST, NULL, $1 ); }
| global_list global { N2C ( $$, GLOBAL_LIST, NULL, $1, $2 ); }
;
global:
function { N1C ( $$, GLOBAL, NULL, $1 ); }
| declaration { N1C ( $$, GLOBAL, NULL, $1 ); }
;
statement_list :
statement { N1C ( $$, STATEMENT_LIST, NULL, $1 ); }
| statement_list statement { N2C ( $$, STATEMENT_LIST, NULL, $1, $2 ); }
;
print_list :
print_item { N1C ( $$, PRINT_LIST, NULL, $1 ); }
| print_list ',' print_item { N2C ( $$, PRINT_LIST, NULL, $1, $3 ); }
;
expression_list :
expression { N1C ( $$, EXPRESSION_LIST, NULL, $1 ); }
| expression_list ',' expression { N2C($$, EXPRESSION_LIST, NULL, $1, $3); }
;
variable_list :
identifier { N1C ( $$, VARIABLE_LIST, NULL, $1 ); }
| variable_list ',' identifier { N2C ( $$, VARIABLE_LIST, NULL, $1, $3 ); }
;
argument_list :
expression_list { N1C ( $$, ARGUMENT_LIST, NULL, $1 ); }
| /* epsilon */ { $$ = NULL; }
;
parameter_list :
variable_list { N1C ( $$, PARAMETER_LIST, NULL, $1 ); }
| /* epsilon */ { $$ = NULL; }
;
declaration_list :
declaration { N1C ( $$, DECLARATION_LIST, NULL, $1 ); }
| declaration_list declaration { N2C ($$, DECLARATION_LIST, NULL, $1, $2); }
;
function :
FUNC identifier '(' parameter_list ')' statement
{ N3C ( $$, FUNCTION, NULL, $2, $4, $6 ); }
;
statement :
assignment_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| return_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| print_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| if_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| while_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| null_statement { N1C ( $$, STATEMENT, NULL, $1 ); }
| block { N1C ( $$, STATEMENT, NULL, $1 ); }
;
block :
OPENBLOCK declaration_list statement_list CLOSEBLOCK
{ N2C ($$, BLOCK, NULL, $2, $3); }
| OPENBLOCK statement_list CLOSEBLOCK { N1C ($$, BLOCK, NULL, $2 ); }
;
assignment_statement :
identifier ':' '=' expression
{ N2C ( $$, ASSIGNMENT_STATEMENT, NULL, $1, $4 ); }
| identifier '+' '=' expression
{ N2C ( $$, ADD_STATEMENT, NULL, $1, $4 ); }
| identifier '-' '=' expression
{ N2C ( $$, SUBTRACT_STATEMENT, NULL, $1, $4 ); }
| identifier '*' '=' expression
{ N2C ( $$, MULTIPLY_STATEMENT, NULL, $1, $4 ); }
| identifier '/' '=' expression
{ N2C ( $$, DIVIDE_STATEMENT, NULL, $1, $4 ); }
;
return_statement :
RETURN expression
{ N1C ( $$, RETURN_STATEMENT, NULL, $2 ); }
;
print_statement :
PRINT print_list
{ N1C ( $$, PRINT_STATEMENT, NULL, $2 ); }
;
null_statement :
CONTINUE
{ N0C ( $$, NULL_STATEMENT, NULL ); }
;
if_statement :
IF relation THEN statement
{ N2C ( $$, IF_STATEMENT, NULL, $2, $4 ); }
| IF relation THEN statement ELSE statement
{ N3C ( $$, IF_STATEMENT, NULL, $2, $4, $6 ); }
;
while_statement :
WHILE relation DO statement
{ N2C ( $$, WHILE_STATEMENT, NULL, $2, $4 ); }
;
relation:
expression '=' expression
{ N2C ( $$, RELATION, strdup("="), $1, $3 ); }
| expression '<' expression
{ N2C ( $$, RELATION, strdup("<"), $1, $3 ); }
| expression '>' expression
{ N2C ( $$, RELATION, strdup(">"), $1, $3 ); }
;
expression :
expression '|' expression
{ N2C ( $$, EXPRESSION, strdup("|"), $1, $3 ); }
| expression '^' expression
{ N2C ( $$, EXPRESSION, strdup("^"), $1, $3 ); }
| expression '&' expression
{ N2C ( $$, EXPRESSION, strdup("&"), $1, $3 ); }
| expression '+' expression
{ N2C ( $$, EXPRESSION, strdup("+"), $1, $3 ); }
| expression '-' expression
{ N2C ( $$, EXPRESSION, strdup("-"), $1, $3 ); }
| expression '*' expression
{ N2C ( $$, EXPRESSION, strdup("*"), $1, $3 ); }
| expression '/' expression
{ N2C ( $$, EXPRESSION, strdup("/"), $1, $3 ); }
| '-' expression %prec UMINUS
{ N1C ( $$, EXPRESSION, strdup("-"), $2 ); }
| '~' expression %prec UMINUS
{ N1C ( $$, EXPRESSION, strdup("~"), $2 ); }
| '(' expression ')' { $$ = $2; }
| number { N1C ( $$, EXPRESSION, NULL, $1 ); }
| identifier
{ N1C ( $$, EXPRESSION, NULL, $1 ); }
| identifier '(' argument_list ')'
{ N2C ( $$, EXPRESSION, NULL, $1, $3 ); }
;
declaration :
VAR variable_list { N1C ( $$, DECLARATION, NULL, $2 ); }
;
print_item :
expression
{ N1C ( $$, PRINT_ITEM, NULL, $1 ); }
| string
{ N1C ( $$, PRINT_ITEM, NULL, $1 ); }
;
identifier: IDENTIFIER { N0C($$, IDENTIFIER_DATA, strdup(yytext) ); }
number: NUMBER
{
int64_t *value = malloc ( sizeof(int64_t) );
*value = strtol ( yytext, NULL, 10 );
N0C($$, NUMBER_DATA, value );
}
string: STRING { N0C($$, STRING_DATA, strdup(yytext) ); }
%%
int
yyerror ( const char *error )
{
fprintf ( stderr, "%s on line %d\n", error, yylineno );
exit ( EXIT_FAILURE );
}

30
exercises/04/vslc/src/scanner.l Normal file
View File

@@ -0,0 +1,30 @@
%{
#include <vslc.h>
%}
%option noyywrap
%option array
%option yylineno
WHITESPACE [\ \t\v\r\n]
COMMENT \/\/[^\n]+
QUOTED \"([^\"\n]|\\\")*\"
%%
{WHITESPACE}+ { /* Eliminate whitespace */ }
{COMMENT} { /* Eliminate comments */ }
func { return FUNC; }
print { return PRINT; }
return { return RETURN; }
continue { return CONTINUE; }
if { return IF; }
then { return THEN; }
else { return ELSE; }
while { return WHILE; }
do { return DO; }
begin { return OPENBLOCK; }
end { return CLOSEBLOCK; }
var { return VAR; }
[0-9]+ { return NUMBER; }
[A-Za-z_][0-9A-Za-z_]* { return IDENTIFIER; }
{QUOTED} { return STRING; }
. { return yytext[0]; }
%%

281
exercises/04/vslc/src/tlhash.c Normal file
View File

@@ -0,0 +1,281 @@
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <tlhash.h>
/*********************************************************************
* Declarations of the utility functions for obtaining hashes, found *
* at the bottom of this file. *
*********************************************************************/
/* Little-endian, for x86-s */
#define CRC32_IEEE802_3 (0xedb88320)
static const uint32_t crc32_ieee802_3[256];
static const uint32_t *crc_table = (uint32_t *)crc32_ieee802_3;
static uint32_t crc32 ( void *input, size_t length );
/********************************
* External interface functions *
********************************/
/* Initializer
* Returns
* ENOMEM - if allocation of table entries fails.
*/
int
tlhash_init ( tlhash_t *tab, size_t n_buckets )
{
size_t i;
tab->n_buckets = n_buckets;
tab->size = 0;
tab->buckets = (tlhash_element_t **) calloc (
n_buckets, sizeof(tlhash_element_t *)
);
if ( tab->buckets == NULL )
return TLHASH_ENOMEM;
for ( i=0; i<n_buckets; i++ )
tab->buckets[i] = NULL;
return TLHASH_SUCCESS;
}
/* Finalizer
* Returns
* ENOENT - if there is no table to free.
*/
int
tlhash_finalize ( tlhash_t *tab )
{
size_t i;
if ( tab == NULL )
return TLHASH_ENOENT;
for ( i=0; i<tab->n_buckets; i++ )
{
tlhash_element_t *element = tab->buckets[i], *next;
while ( element != NULL )
{
next = element->next;
free ( element->key );
free ( element );
tab->size -= 1;
element = next;
}
}
free ( tab->buckets );
return TLHASH_SUCCESS;
}
/* Insert - find hash value, modulate over buckets, append to linked list
* Returns
* EEXIST - if an element is already indexed by this key
* ENOMEM - if allocation of element or key copy fails
*/
int
tlhash_insert (
tlhash_t *tab, void *key, size_t key_length, void *value
)
{
void *test_entry;
int test = tlhash_lookup ( tab, key, key_length, &test_entry );
if ( test != TLHASH_ENOENT )
return TLHASH_EEXIST;
uint32_t hash = crc32 ( key, key_length );
size_t bucket = hash % tab->n_buckets;
tlhash_element_t *element = malloc ( sizeof(tlhash_element_t) );
if ( element == NULL )
return TLHASH_ENOMEM;
void *key_copy = malloc ( key_length );
if ( key_copy == NULL )
{
free ( element );
return TLHASH_ENOMEM;
}
memcpy ( key_copy, key, key_length );
element->key = key_copy;
element->key_length = key_length;
element->value = value;
element->next = tab->buckets[bucket];
tab->buckets[bucket] = element;
tab->size += 1;
return TLHASH_SUCCESS;
}
/* Lookup - find hash value, modulate over buckets, search linked list
* Returns
* ENOENT - if no element is indexed by this key
*/
int
tlhash_lookup (
tlhash_t *tab, void *key, size_t key_length, void **value
)
{
uint32_t hash = crc32 ( key, key_length );
size_t bucket = hash % tab->n_buckets;
tlhash_element_t *el = tab->buckets[bucket];
*value = NULL;
while ( el != NULL )
{
if ( el->key_length == key_length && ! memcmp(el->key,key,key_length) )
{
*value = el->value;
break;
}
el = el->next;
}
if ( el != NULL )
return TLHASH_SUCCESS;
else
return TLHASH_ENOENT;
}
/* Removal - find hash value, modulate over buckets, delete entry
* Returns
* ENOENT - no such element to remove was found.
*/
int
tlhash_remove ( tlhash_t *tab, void *key, size_t key_length )
{
uint32_t hash = crc32 ( key, key_length );
size_t bucket = hash % tab->n_buckets;
tlhash_element_t *el = tab->buckets[bucket], *prev = NULL;
while ( el != NULL )
{
if ( el->key_length == key_length && ! memcmp(el->key,key,key_length) )
{
/* We have a match. */
if ( prev != NULL ) /* Remove from list if it's not the head */
prev->next = (void *)el->next;
else /* Substitute it if it IS the head */
tab->buckets[bucket] = el->next;
/* Free the container and key copy allocated by this lib */
free ( el->key );
free ( el );
break;
}
prev = el;
el = el->next;
}
if ( el == NULL )
return TLHASH_ENOENT;
else
{
tab->size -= 1;
return TLHASH_SUCCESS;
}
}
size_t
tlhash_size ( tlhash_t *tab )
{
return tab->size;
}
void
tlhash_keys ( tlhash_t *tab, void **keys )
{
size_t b, i = 0;
for ( b=0; b<tab->n_buckets; b++ )
{
tlhash_element_t *el = tab->buckets[b];
while ( el != NULL )
{
keys[i] = el->key;
i += 1;
el = el->next;
}
}
}
void
tlhash_values ( tlhash_t *tab, void **values )
{
size_t b, i = 0;
for ( b=0; b<tab->n_buckets; b++ )
{
tlhash_element_t *el = tab->buckets[b];
while ( el != NULL )
{
values[i] = el->value;
i += 1;
el = el->next;
}
}
}
/***************************************
* Hashing function and IEEE data blob *
***************************************/
static uint32_t
crc32 ( void *input, size_t length )
{
const uint8_t *data = (uint8_t *)input;
size_t i = 0;
uint32_t hash = 0xFFFFFFFF;
for ( i = 0; i<length; i++ )
hash = (hash>>8) ^ crc_table [ data[i] ^ (uint8_t)hash ];
return (hash^0xFFFFFFFF);
}
static const uint32_t
crc32_ieee802_3[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

232
exercises/04/vslc/src/tree.c Normal file
View File

@@ -0,0 +1,232 @@
#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 );
typedef struct stem_t *stem;
struct stem_t { const char *str; stem next; };
static void
tree_print(node_t* root, stem head);
static void destroy_subtree ( node_t *discard );
/* External interface */
void
destroy_syntax_tree ( void )
{
destroy_subtree ( root );
}
void
simplify_syntax_tree ( void )
{
simplify_tree ( &root, root );
}
extern bool new_print_style;
void
print_syntax_tree ( void )
{
if (new_print_style)
tree_print ( root, 0 );
// Old tree printing
else
node_print ( root, 0 );
}
void
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 );
}
static void
tree_print(node_t* root, stem head)
{
static const char *sdown = " │", *slast = " └", *snone = " ";
struct stem_t col = {0, 0}, *tail;
// Print stems of branches coming further down
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);
}
if (root == NULL) {
// Secure against null pointers sent as root
printf("─(nil)\n");
return;
}
printf("─%s", 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');
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;
}
/* 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
simplify_tree ( node_t **simplified, node_t *root )
{
if ( root == NULL )
return;
/* Simplify subtrees before examining this node */
for ( uint64_t i=0; i<root->n_children; i++ )
simplify_tree ( &root->children[i], root->children[i] );
node_t *discard, *result = root;
switch ( root->type )
{
/* Structures of purely syntactic function */
case PARAMETER_LIST: case ARGUMENT_LIST:
case STATEMENT: case PRINT_ITEM: case GLOBAL:
result = root->children[0];
node_finalize ( root );
break;
case PRINT_STATEMENT:
result = root->children[0];
result->type = PRINT_STATEMENT;
node_finalize(root);
/* Flatten lists:
* Take left child, append right child, substitute left for root.
*/
case STATEMENT_LIST: case DECLARATION_LIST: case GLOBAL_LIST:
case PRINT_LIST: case EXPRESSION_LIST: case VARIABLE_LIST:
if ( root->n_children >= 2 )
{
result = root->children[0];
result->n_children += 1;
result->children = realloc (
result->children, result->n_children * sizeof(node_t *)
);
result->children[result->n_children-1] = root->children[1];
node_finalize ( root );
}
break;
case EXPRESSION:
switch ( root->n_children )
{
case 1:
if ( root->children[0]->type == NUMBER_DATA )
{
result = root->children[0];
if ( root->data != NULL )
*((int64_t *)result->data) *= -1;
node_finalize (root);
}
else if ( root->data == NULL )
{
result = root->children[0];
node_finalize (root);
}
break;
case 2:
if ( root->children[0]->type == NUMBER_DATA &&
root->children[1]->type == NUMBER_DATA
) {
result = root->children[0];
int64_t
*x = result->data,
*y = root->children[1]->data;
switch ( *((char *)root->data) )
{
case '+': *x += *y; break;
case '-': *x -= *y; break;
case '*': *x *= *y; break;
case '/': *x /= *y; break;
}
node_finalize ( root->children[1] );
node_finalize ( root );
}
break;
}
}
*simplified = result;
}

75
exercises/04/vslc/src/vslc.c Normal file
View File

@@ -0,0 +1,75 @@
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <vslc.h>
/* Global state */
node_t *root; // Syntax tree
tlhash_t *global_names; // Symbol table
char **string_list; // List of strings in the source
size_t n_string_list = 8; // Initial string list capacity (grow on demand)
size_t stringc = 0; // Initial string count
/* Command line option parsing for the main function */
static void options ( int argc, char **argv );
bool
print_full_tree = false,
print_simplified_tree = false,
print_symbol_table_contents = false,
new_print_style = true;
/* Entry point */
int
main ( int argc, char **argv )
{
options ( argc, argv );
yyparse(); // Generated from grammar/bison, constructs syntax tree
if ( print_full_tree )
print_syntax_tree ();
simplify_syntax_tree (); // In tree.c
if ( print_simplified_tree )
print_syntax_tree ();
create_symbol_table (); // In ir.c
if ( print_symbol_table_contents )
print_symbol_table();
destroy_syntax_tree (); // In tree.c
destroy_symbol_table (); // In ir.c
}
static const char *usage =
"Command line options\n"
"\t-h\tOutput this text and halt\n"
"\t-t\tOutput the full syntax tree\n"
"\t-T\tOutput the simplified syntax tree\n"
"\t-s\tOutput the symbol table contents\n"
"\t-u\tDo not use print style more like the tree command\n";
static void
options ( int argc, char **argv )
{
int o;
while ( (o=getopt(argc,argv,"htTsu")) != -1 )
{
switch ( o )
{
case 'h':
printf ( "%s:\n%s", argv[0], usage );
exit ( EXIT_FAILURE );
break;
case 't': print_full_tree = true; break;
case 'T': print_simplified_tree = true; break;
case 's': print_symbol_table_contents = true; break;
case 'u': new_print_style = false; break;
}
}
}