Start PS4
parent
7a3af1c302
commit
4717d45e30
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,12 @@
|
|||
LEX=flex
|
||||
YACC=bison
|
||||
YFLAGS+=--defines=src/y.tab.h -o y.tab.c
|
||||
CFLAGS+=-std=c99 -g -Isrc -Iinclude -D_POSIX_C_SOURCE=200809L -DYYSTYPE="node_t *"
|
||||
|
||||
src/vslc: src/vslc.c src/parser.o src/scanner.o src/nodetypes.o src/tree.o src/ir.o src/tlhash.c
|
||||
src/y.tab.h: src/parser.c
|
||||
src/scanner.c: src/y.tab.h src/scanner.l
|
||||
clean:
|
||||
-rm -f src/parser.c src/scanner.c src/*.tab.* src/*.o
|
||||
purge: clean
|
||||
-rm -f src/vslc
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#ifndef IR_H
|
||||
#define IR_H
|
||||
|
||||
/* This is the tree node structure */
|
||||
typedef struct n {
|
||||
node_index_t type;
|
||||
void *data;
|
||||
struct s *entry;
|
||||
uint64_t n_children;
|
||||
struct n **children;
|
||||
} node_t;
|
||||
|
||||
// Export the initializer function, it is needed by the parser
|
||||
void node_init (
|
||||
node_t *nd, node_index_t type, void *data, uint64_t n_children, ...
|
||||
);
|
||||
|
||||
typedef enum {
|
||||
SYM_GLOBAL_VAR, SYM_FUNCTION, SYM_PARAMETER, SYM_LOCAL_VAR
|
||||
} symtype_t;
|
||||
|
||||
typedef struct s {
|
||||
char *name;
|
||||
symtype_t type;
|
||||
node_t *node;
|
||||
size_t seq;
|
||||
size_t nparms;
|
||||
tlhash_t *locals;
|
||||
} symbol_t;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#ifndef NODETYPES_H
|
||||
#define NODETYPES_H
|
||||
typedef enum {
|
||||
PROGRAM,
|
||||
GLOBAL_LIST,
|
||||
GLOBAL,
|
||||
STATEMENT_LIST,
|
||||
PRINT_LIST,
|
||||
EXPRESSION_LIST,
|
||||
VARIABLE_LIST,
|
||||
ARGUMENT_LIST,
|
||||
PARAMETER_LIST,
|
||||
DECLARATION_LIST,
|
||||
FUNCTION,
|
||||
STATEMENT,
|
||||
BLOCK,
|
||||
ASSIGNMENT_STATEMENT,
|
||||
ADD_STATEMENT,
|
||||
SUBTRACT_STATEMENT,
|
||||
MULTIPLY_STATEMENT,
|
||||
DIVIDE_STATEMENT,
|
||||
RETURN_STATEMENT,
|
||||
PRINT_STATEMENT,
|
||||
NULL_STATEMENT,
|
||||
IF_STATEMENT,
|
||||
WHILE_STATEMENT,
|
||||
EXPRESSION,
|
||||
RELATION,
|
||||
DECLARATION,
|
||||
PRINT_ITEM,
|
||||
IDENTIFIER_DATA,
|
||||
NUMBER_DATA,
|
||||
STRING_DATA
|
||||
} node_index_t;
|
||||
|
||||
extern char *node_string[26];
|
||||
#endif
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#ifndef TLHASH_H
|
||||
#define TLHASH_H
|
||||
#include <stddef.h>
|
||||
typedef struct el {
|
||||
void *key, *value;
|
||||
size_t key_length;
|
||||
struct el *next;
|
||||
} tlhash_element_t;
|
||||
|
||||
typedef struct {
|
||||
size_t n_buckets, size;
|
||||
tlhash_element_t **buckets;
|
||||
} tlhash_t;
|
||||
|
||||
int tlhash_init ( tlhash_t *tab, size_t n_buckets );
|
||||
int tlhash_finalize ( tlhash_t *tab );
|
||||
int tlhash_insert ( tlhash_t *tab, void *key, size_t keylen, void *val );
|
||||
int tlhash_lookup ( tlhash_t *tab, void *key, size_t keylen, void **val );
|
||||
int tlhash_remove ( tlhash_t *tab, void *key, size_t key_length );
|
||||
size_t tlhash_size ( tlhash_t *tab );
|
||||
void tlhash_keys ( tlhash_t *tab, void **keys );
|
||||
void tlhash_values ( tlhash_t *tab, void **values );
|
||||
|
||||
#define TLHASH_SUCCESS 0 /* Success */
|
||||
#define TLHASH_ENOMEM 1 /* No memory available */
|
||||
#define TLHASH_ENOENT 2 /* No such table entry */
|
||||
#define TLHASH_EEXIST 3 /* Table entry already exists */
|
||||
#endif
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef VSLC_H
|
||||
#define VSLC_H
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
// Prototypes for the hash table functions
|
||||
#include "tlhash.h"
|
||||
|
||||
// Numbers and names for the types of syntax tree nodes
|
||||
#include "nodetypes.h"
|
||||
|
||||
// Definition of the tree node type
|
||||
#include "ir.h"
|
||||
|
||||
// Token definitions and other things from bison, needs def. of node type
|
||||
#include "y.tab.h"
|
||||
|
||||
/* This is generated from the bison grammar, calls on the flex specification */
|
||||
int yyerror ( const char *error );
|
||||
|
||||
/* These are defined in the parser generated by bison */
|
||||
extern int yylineno;
|
||||
extern int yylex ( void );
|
||||
extern char yytext[];
|
||||
|
||||
/* Global state */
|
||||
extern node_t *root;
|
||||
|
||||
// Moving global defs to global header
|
||||
|
||||
extern tlhash_t *global_names; // Defined in ir.c, used by generator.c
|
||||
extern char **string_list; // Defined in ir.c, used by generator.c
|
||||
extern size_t stringc; // Defined in ir.c, used by generator.c
|
||||
|
||||
/* Global routines, called from main in vslc.c */
|
||||
void simplify_syntax_tree ( void );
|
||||
void print_syntax_tree ( void );
|
||||
void destroy_syntax_tree ( void );
|
||||
|
||||
void create_symbol_table ( void );
|
||||
void print_symbol_table ( void );
|
||||
void destroy_symbol_table ( void );
|
||||
|
||||
#endif
|
||||
|
|
@ -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 */
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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 );
|
||||
}
|
||||
|
|
@ -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]; }
|
||||
%%
|
||||
|
|
@ -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
|
||||
};
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
VSLC := ../src/vslc
|
||||
|
||||
PS2_EXAMPLES := $(patsubst ps2-parser/%.vsl, ps2-parser/%.ast, $(wildcard ps2-parser/*.vsl))
|
||||
PS3_EXAMPLES := $(patsubst ps3-simplify/%.vsl, ps3-simplify/%.ast, $(wildcard ps3-simplify/*.vsl))
|
||||
PS4_EXAMPLES := $(patsubst ps4-symtab/%.vsl, ps4-symtab/%.ast, $(wildcard ps4-symtab/*.vsl))
|
||||
|
||||
all: $(PS2_EXAMPLES) $(PS3_EXAMPLES) $(PS4_EXAMPLES)
|
||||
ps2: $(PS2_EXAMPLES)
|
||||
ps3: $(PS3_EXAMPLES)
|
||||
ps4: $(PS4_EXAMPLES)
|
||||
|
||||
%.ast: %.vsl
|
||||
$(VSLC) -t < $^ > $@
|
||||
|
||||
clean:
|
||||
-rm -r */*.ast
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
// checking that comments are ignored
|
||||
|
||||
// This program checks the assignment operators
|
||||
|
||||
func main()
|
||||
begin
|
||||
var a
|
||||
a := 3
|
||||
a += 1
|
||||
a /= 2
|
||||
a *= 32
|
||||
a -= 2
|
||||
print a
|
||||
end
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
func add(a, b) begin
|
||||
return a + b
|
||||
end
|
||||
|
||||
func main()
|
||||
begin
|
||||
print add(40, 2)
|
||||
end
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
func main() begin
|
||||
print "Hello, World!"
|
||||
end
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
func main()
|
||||
begin
|
||||
var a, b, c, d
|
||||
c := 1
|
||||
a := 3
|
||||
b := a + c // 4
|
||||
d := a * 100 + 50
|
||||
print "a", a
|
||||
print "b", b
|
||||
print "c", c
|
||||
print "d", d
|
||||
if a = 14 then
|
||||
print 1, "N", d / 5 + a, "RPR", a, "TERS "
|
||||
else
|
||||
print "COMP", c, "L", "ERS "
|
||||
|
||||
print b, "R", a, " "
|
||||
|
||||
if a < b then
|
||||
if d > 42 then
|
||||
print b, "W", d, "ME"
|
||||
else
|
||||
print "L", b, "M", c
|
||||
// A dangling else, what could go wrong?
|
||||
end
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
|
||||
var global_var
|
||||
|
||||
func my_func(param)
|
||||
begin
|
||||
var local_var, local_var2
|
||||
local_var := 1
|
||||
end
|
||||
|
||||
var glob1, glob2
|
||||
|
||||
func main()
|
||||
begin
|
||||
var main_local_var
|
||||
begin
|
||||
var main_local_nested_var
|
||||
main_local_nested_var := main_local_var
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
// check parsing of do-while loop
|
||||
|
||||
func main()
|
||||
begin
|
||||
var i
|
||||
i := 2
|
||||
while i < 9000 do
|
||||
i := i * i
|
||||
print i
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
|
||||
func main() begin
|
||||
var a
|
||||
a := 1 + 2 + 4 + 5 + 6 + 7 + 8 + 9
|
||||
b := (10 + 10 * 4) * (2 + 2 * (1 + 1)) / 10 + 2 * 5 + 6 / 3
|
||||
|
||||
if a = b then
|
||||
print "The answer is", b
|
||||
end
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
|
||||
func my_fun(a, b, c, d, e, f, g, h) begin
|
||||
var i, j, k, l, m
|
||||
|
||||
i := a + b + d
|
||||
|
||||
if i = f then begin
|
||||
print "hmmm"
|
||||
end
|
||||
end
|
||||
|
||||
func main() begin
|
||||
var n, o, p, q, r, s, t, u, v, w
|
||||
n := 5
|
||||
n += my_func(1, 2, 3, 5, 8, 13, 21, 34)
|
||||
end
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
var global_var0, global_var1
|
||||
|
||||
func my_func(param0, param1) begin
|
||||
var a
|
||||
return 0
|
||||
end
|
||||
|
||||
func main() begin
|
||||
var a
|
||||
print "a string"
|
||||
end
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
|
||||
func main() begin
|
||||
var a, b
|
||||
a := 1
|
||||
begin
|
||||
var a
|
||||
a := 2
|
||||
b := 40
|
||||
begin
|
||||
var a
|
||||
a := b + 2
|
||||
print a, b
|
||||
end
|
||||
print a
|
||||
end
|
||||
print b
|
||||
end
|
||||
Loading…
Reference in New Issue