V. 1.1.0 Acse.lex Page 1/1 V. 1.1.0 Acse.y Page 1/4 V. 1.1.0 Acse.

y Page 2/4
/*************************************************************************** /*****************************************************************************
Scanner ******************************** PARSER ************************************* var_declarations : var_declarations var_declaration
***************************************************************************/ *****************************************************************************/ | /* empty */
%option noyywrap ;
%{
%{ #include "axe_struct.h" var_declaration : TYPE declaration_list SEMI
#include <string.h> #include "axe_engine.h" { set_new_variables(program, $1, $2); }
#include "axe_struct.h" #include "symbol_table.h" ;
#include "collections.h" #include "axe_errors.h"
#include "Acse.tab.h" #include "collections.h" declaration_list : declaration_list COMMA declaration
#include "axe_constants.h" #include "axe_expressions.h" { $$ = addElement($1, $3, −1); }
#include "axe_gencode.h" | declaration
extern int line_num; #include "axe_utils.h" { $$ = addElement(NULL, $1, −1); }
extern int num_error; #include "axe_array.h" ;
#include "axe_io_manager.h"
extern int yyerror(const char* errmsg); declaration : IDENTIFIER ASSIGN NUMBER
{ $$ = alloc_declaration($1, 0, 0, $3);
%} if ($$ == NULL)
/*========================================================================= int line_num; notifyError(AXE_OUT_OF_MEMORY);
TOKEN DEFINITIONS int num_error; /* number of errors */ }
=========================================================================*/ int num_warning; /* number of warnings */ | IDENTIFIER LSQUARE NUMBER RSQUARE
DIGIT [0−9] t_program_infos *program; /* ALL PROGRAM INFORMATION */ { $$ = alloc_declaration($1, 1, $3, 0);
ID [a−zA−Z_][a−zA−Z0−9_]* if ($$ == NULL)
%} notifyError(AXE_OUT_OF_MEMORY);
}
/*========================================================================= /*========================================================================= | IDENTIFIER
TOKENS SEMANTIC RECORDS {
=========================================================================*/ =========================================================================*/ $$ = alloc_declaration($1, 0, 0, 0);
%option noyywrap if ($$ == NULL)
%x comment %union { notifyError(AXE_OUT_OF_MEMORY);
int intval; }
%% char *svalue; ;
t_axe_expression expr;
"\r\n" { ++line_num; } t_axe_declaration *decl; code_block : statement
"\n" { ++line_num; } t_list *list; | LBRACE statements RBRACE
t_axe_label *label; ;
[ \t\f\v]+ { /* Ignore whitespace. */ } t_while_statement while_stmt;
} statements : statements statement
"//"[^\n]* { ++line_num; /* ignore comment lines */ } /*========================================================================= | statement
"/*" BEGIN(comment); TOKENS ;
=========================================================================*/
<comment>[^*\n]* %start program statement : assign_statement SEMI
<comment>[^*\n]*\n { ++line_num; } | control_statement
<comment>"*"+[^*/\n]* %token LBRACE RBRACE LPAR RPAR LSQUARE RSQUARE | read_write_statement SEMI
<comment>"*"+[^*/\n]*\n { ++line_num; } %token SEMI COLON PLUS MINUS MUL_OP DIV_OP MOD_OP | SEMI
<comment>"*"+"/" BEGIN(INITIAL); %token AND_OP OR_OP NOT_OP { gen_nop_instruction(program); }
%token ASSIGN LT GT SHL_OP SHR_OP EQ NOTEQ LTEQ GTEQ ;
"{" { return LBRACE; } %token ANDAND OROR
"}" { return RBRACE; } %token COMMA control_statement : if_statement
"[" { return LSQUARE; } %token FOR | while_statement
"]" { return RSQUARE; } %token RETURN | do_while_statement SEMI
"(" { return LPAR; } %token READ | return_statement SEMI
")" { return RPAR; } %token WRITE ;
";" { return SEMI; }
":" { return COLON; } %token <label> DO read_write_statement : read_statement
"+" { return PLUS; } %token <while_stmt> WHILE | write_statement
"−" { return MINUS; } %token <label> IF ;
"*" { return MUL_OP; } %token <label> ELSE
"/" { return DIV_OP; } %token <intval> TYPE assign_statement : IDENTIFIER LSQUARE exp RSQUARE ASSIGN exp
"%" { return MOD_OP; } %token <svalue> IDENTIFIER {
"&" { return AND_OP; } %token <intval> NUMBER storeArrayElement(program, $1, $3, $6);
"|" { return OR_OP; } free($1);
"!" { return NOT_OP; } %type <expr> exp }
"=" { return ASSIGN; } %type <decl> declaration | IDENTIFIER ASSIGN exp
"<" { return LT; } %type <list> declaration_list {
">" { return GT; } %type <label> if_stmt int location;
"<<" { return SHL_OP; } t_axe_instruction *instr;
">>" { return SHR_OP; } /*========================================================================= location = get_symbol_location(program, $1, 0);
"==" { return EQ; } OPERATOR PRECEDENCES
"!=" { return NOTEQ; } =========================================================================*/ if ($3.expression_type == IMMEDIATE)
"<=" { return LTEQ; } instr = gen_addi_instruction
">=" { return GTEQ; } %left COMMA (program, location, REG_0, $3.value);
"&&" { return ANDAND; } %left ASSIGN else
"||" { return OROR; } %left OROR instr = gen_add_instruction
"," { return COMMA; } %left ANDAND (program, location, REG_0, $3.value, CG_DIRECT_ALL);
%left OR_OP
"do" { return DO; } %left AND_OP free($1);
"else" { return ELSE; } %left EQ NOTEQ }
"for" { return FOR; } %left LT GT LTEQ GTEQ ;
"if" { return IF; } %left SHL_OP SHR_OP
"int" { yylval.intval = INTEGER_TYPE; return TYPE; } %left MINUS PLUS if_statement : if_stmt
"while" { return WHILE; } %left MUL_OP DIV_OP {
"return" { return RETURN; } %right NOT assignLabel(program, $1);
"read" { return READ; } }
"write" { return WRITE; } /*========================================================================= | if_stmt ELSE
BISON GRAMMAR {
{ID} { yylval.svalue=strdup(yytext); return IDENTIFIER; } =========================================================================*/ $2 = newLabel(program);
{DIGIT}+ { yylval.intval = atoi( yytext ); %% gen_bt_instruction (program, $2, 0);
return(NUMBER); } assignLabel(program, $1);
program : var_declarations statements }
. { yyerror("Error: unexpected token"); { code_block
num_error++; /* Notify the end of program and generates HALT */ {
return (−1); /* invalid token */ set_end_Program(program); assignLabel(program, $2);
} YYACCEPT; }
} ;
;

Sheet 1/6
 V. 1.1.0 Acse.y Page 3/4 V. 1.1.0 Acse.y Page 4/4 V. 1.1.0 jumpnote.txt Page 1/1
if_stmt : IF } ********************************************************************************
{ | NOT_OP NUMBER { if ($2 == 0) HOW TO GENERATE JUMPS
$1 = newLabel(program); $$ = create_expression (1, IMMEDIATE); ********************************************************************************
} else This is an example:
LPAR exp RPAR $$ = create_expression (0, IMMEDIATE);
{ } gen_beq_instruction( ... label ... )
if ($4.expression_type == IMMEDIATE) | NOT_OP IDENTIFIER { Generates a jump−if−equal instruction (i.e., jump if flag zero is set)
gen_load_immediate(program, $4.value); int identifier_location; to ‘label’.
else int output_register; That means a jump to ‘label’ if the preceding expression is FALSE.
gen_andb_instruction(program, $4.value, identifier_location =
$4.value, $4.value, CG_DIRECT_ALL); get_symbol_location(program, $2, 0);
gen_beq_instruction (program, $1, 0); output_register =
} getNewRegister(program);
code_block { $$ = $1; } gen_notl_instruction (program, output_register
; , identifier_location);
$$ = create_expression (output_register, REGISTER);
while_statement : WHILE free($2);
{ $1 = create_while_statement(); }
$1.label_condition | exp AND_OP exp {
= assignNewLabel(program); $$ = handle_bin_numeric_op(program, $1, $3, ANDB); }
} | exp OR_OP exp {
LPAR exp RPAR $$ = handle_bin_numeric_op(program, $1, $3, ORB); }
{ | exp PLUS exp {
if ($4.expression_type == IMMEDIATE) $$ = handle_bin_numeric_op(program, $1, $3, ADD); }
gen_load_immediate(program, $4.value); | exp MINUS exp {
else $$ = handle_bin_numeric_op(program, $1, $3, SUB); }
gen_andb_instruction(program, $4.value, | exp MUL_OP exp {
$4.value, $4.value, CG_DIRECT_ALL); $$ = handle_bin_numeric_op(program, $1, $3, MUL); }
$1.label_end = newLabel(program); | exp DIV_OP exp {
gen_beq_instruction (program, $1.label_end, 0); $$ = handle_bin_numeric_op(program, $1, $3, DIV); }
} | exp LT exp {
code_block $$ = handle_binary_comparison (program, $1, $3, _LT_); }
{ | exp GT exp {
/* jump to the beginning of the loop */ $$ = handle_binary_comparison (program, $1, $3, _GT_); }
gen_bt_instruction | exp EQ exp {
(program, $1.label_condition, 0); $$ = handle_binary_comparison (program, $1, $3, _EQ_); }
| exp NOTEQ exp {
/* fix the label ‘label_end’ */ $$ = handle_binary_comparison (program, $1, $3, _NOTEQ_); }
assignLabel(program, $1.label_end); | exp LTEQ exp {
} $$ = handle_binary_comparison (program, $1, $3, _LTEQ_); }
; | exp GTEQ exp {
$$ = handle_binary_comparison (program, $1, $3, _GTEQ_); }
do_while_statement : DO | exp SHL_OP exp {
{ $$ = handle_bin_numeric_op(program, $1, $3, SHL); }
$1 = newLabel(program); | exp SHR_OP exp {
assignLabel(program, $1); $$ = handle_bin_numeric_op(program, $1, $3, SHR); }
} | exp ANDAND exp {
code_block WHILE LPAR exp RPAR $$ = handle_bin_numeric_op(program, $1, $3, ANDL); }
{ | exp OROR exp {
if ($6.expression_type == IMMEDIATE) $$ = handle_bin_numeric_op(program, $1, $3, ORL); }
gen_load_immediate(program, $6.value); | LPAR exp RPAR { $$ = $2; }
else | MINUS exp { if ($2.expression_type == IMMEDIATE)
gen_andb_instruction(program, $6.value, {
$6.value, $6.value, CG_DIRECT_ALL); $$ = $2;
gen_bne_instruction (program, $1, 0); $$.value = − ($$.value);
} }
; else
{
return_statement : RETURN t_axe_expression exp_r0;
{ exp_r0.value = REG_0;
; exp_r0.expression_type = REGISTER;
$$ = handle_bin_numeric_op
read_statement : READ LPAR IDENTIFIER RPAR (program, exp_r0, $2, SUB);
{ }
int location; }
location = get_symbol_location(program, $3, 0); ;
gen_read_instruction (program, location);
free($3); %%
} /*=========================================================================
; MAIN
=========================================================================*/
write_statement : WRITE LPAR exp RPAR int main (int argc, char **argv)
{ {
int location; /* initialize all the compiler data structures and global variables */
if ($3.expression_type == IMMEDIATE) init_compiler(argc, argv);
{
location = gen_load_immediate(program, $3.value); yyparse();
}
else return 0;
location = $3.value; }
gen_write_instruction (program, location);
} /*=========================================================================
; YYERROR
=========================================================================*/
exp: NUMBER { $$ = create_expression ($1, IMMEDIATE); } int yyerror(const char* errmsg)
| IDENTIFIER { {
int location; errorcode = AXE_SYNTAX_ERROR;
location = get_symbol_location(program, $1, 0);
$$ = create_expression (location, REGISTER); return 0;
free($1); }
}
| IDENTIFIER LSQUARE exp RSQUARE {
int reg;
reg = loadArrayElement(program, $1, $3);
$$ = create_expression (reg, REGISTER);
free($1);

Sheet 2/6
 V. 1.1.0 axe_array.h Page 1/1 V. 1.1.0 axe_engine.h Page 1/1 V. 1.1.0 axe_expressions.h Page 1/1
/* ********************************************************************* /****************************************************************************** /******************************************************************************
* axe_array.h * axe_engine.h * axe_expressions.h
* CODE GENERATION FOR ARRAY MANAGEMENT (LOAD/STORE) * * ****************************************************************************/
* *********************************************************************/ * Contains t_program_infos and some functions for LABEL MANAGEMENT
* (reserve, fix, assign)
/* Generates the instructions for loading the content of an * ****************************************************************************/ /* This function generates instructions for binary numeric
* array element ino a register. typedef struct t_program_infos * operations. It takes as input two expressions and a binary
* ID: array name { * operation identifier, and it returns a new expression that
* index: index of the array cell t_list *variables; * represents the result of the specified binary operation
* Returns the register number t_list *instructions; * applied to ‘exp1’ and ‘exp2’.
* */ t_list *data; *
extern int loadArrayElement(t_program_infos *program t_axe_label_manager *lmanager; * Valid values for ‘binop’ are:
, char *ID, t_axe_expression index); t_symbol_table *sy_table; * ADD
int current_register; * ANDB
/* Generetas the instructions for loading an array cell } t_program_infos; * ORB
* address into a register. * SUB
* */ * MUL
extern int loadArrayAddress(t_program_infos *program /* initialize the informations associated with the program. */ * DIV */
, char *ID, t_axe_expression index); extern t_program_infos * allocProgramInfos(); extern t_axe_expression handle_bin_numeric_op (t_program_infos *program
, t_axe_expression exp1, t_axe_expression exp2, int binop);
/* Generates the instructions for storing data into the array /* add a new instruction to the current program. This function is directly
* cell indexed by ID and index*/ * called by all the functions defined in ‘axe_gencode.h’ */ /* This function generates instructions that perform a
extern void storeArrayElement(t_program_infos *program, char *ID extern void addInstruction(t_program_infos *program, t_axe_instruction *instr); * comparison between two values. It takes as input two
, t_axe_expression index, t_axe_expression data); * expressions and a binary comparison identifier, and it
/* reserve a new label identifier and return the identifier to the caller */ * returns a new expression that represents the result of the
extern t_axe_label * newLabel(t_program_infos *program); * specified binary comparison between ‘exp1’ and ‘exp2’.
*
/* assign the given label identifier to the next instruction. Returns * Valid values for ‘condition’ are:
* the label assigned; otherwise (an error occurred) LABEL_UNSPECIFIED */ * _LT_ (used when is needed to test if the value of ‘exp1’ is less than
extern t_axe_label * assignLabel(t_program_infos *program, t_axe_label *label); * the value of ‘exp2’)
* _GT_ (used when is needed to test if the value of ‘exp1’ is greater than
/* reserve and fix a new label. It returns either the label assigned or the * the value of ‘exp2’)
* value LABEL_UNSPECIFIED if an error occurred */ * _EQ_ (used when is needed to test if the value of ‘exp1’ is equal to
extern t_axe_label * assignNewLabel(t_program_infos *program); * the value of ‘exp2’)
* _NOTEQ_ (used when is needed to test if the value of ‘exp1’ is not equal to
/* add a variable to the program */ * the value of ‘exp2’)
extern void createVariable(t_program_infos *program * _LTEQ_ (used when is needed to test if the value of ‘exp1’ is less than
, char *ID, int type, int isArray, int arraySize, int init_val); * or equal to the value of ‘exp2’)
* _GTEQ_ (used when is needed to test if the value of ‘exp1’ is greater tha
/* get a previously allocated variable */ n
extern t_axe_variable * getVariable * the value of ‘exp2’) */
(t_program_infos *program, char *ID); extern t_axe_expression handle_binary_comparison (t_program_infos *program
, t_axe_expression exp1, t_axe_expression exp2, int condition);
/* get the label that marks the starting address of the variable
* with name "ID" */
extern t_axe_label * getLabelFromVariableID
(t_program_infos *program, char *ID);

/* get a register still not used. This function returns

* the ID of the register found*/
extern int getNewRegister(t_program_infos *program);

Sheet 3/6
 V. 1.1.0 axe_gencode.h Page 1/3 V. 1.1.0 axe_gencode.h Page 2/3 V. 1.1.0 axe_gencode.h Page 3/3
/* *************************************************************************** (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
* axe_gencode.h
* CODE GENERATION extern t_axe_instruction * gen_orli_instruction extern t_axe_instruction * gen_bls_instruction
* ****************************************************************************/ (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− extern t_axe_instruction * gen_eorli_instruction extern t_axe_instruction * gen_bcc_instruction
* NOP & HALT (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/
extern t_axe_instruction * gen_nop_instruction extern t_axe_instruction * gen_andbi_instruction extern t_axe_instruction * gen_bcs_instruction
(t_program_infos *program); (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);

extern t_axe_instruction * gen_halt_instruction extern t_axe_instruction * gen_muli_instruction extern t_axe_instruction * gen_bne_instruction

(t_program_infos *program); (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);

/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− extern t_axe_instruction * gen_orbi_instruction extern t_axe_instruction * gen_beq_instruction

* UNARY OPERATIONS (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/
extern t_axe_instruction * gen_eorbi_instruction extern t_axe_instruction * gen_bvc_instruction
/* A LOAD instruction requires the following parameters: (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
* 1. A destination register (where will be loaded the requested value)
* 2. A label information (can be a NULL pointer. If so, the addess extern t_axe_instruction * gen_divi_instruction extern t_axe_instruction * gen_bvs_instruction
* value will be taken into consideration) (t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);
* 3. A direct address (if label is different from NULL) */
extern t_axe_instruction * gen_load_instruction // SHL = shift left extern t_axe_instruction * gen_bpl_instruction
(t_program_infos *program, int r_dest, t_axe_label *label, int address); extern t_axe_instruction * gen_shli_instruction (t_program_infos *program, t_axe_label *label, int addr);
(t_program_infos *program, int r_dest, int r_source1, int immediate);
extern t_axe_instruction * gen_read_instruction extern t_axe_instruction * gen_bmi_instruction
(t_program_infos *program, int r_dest); extern t_axe_instruction * gen_shri_instruction (t_program_infos *program, t_axe_label *label, int addr);
(t_program_infos *program, int r_dest, int r_source1, int immediate);
extern t_axe_instruction * gen_write_instruction extern t_axe_instruction * gen_bge_instruction
(t_program_infos *program, int r_dest); extern t_axe_instruction * gen_notl_instruction (t_program_infos *program, t_axe_label *label, int addr);
(t_program_infos *program, int r_dest, int r_source1);
/* A STORE instruction copies a value from a register to a extern t_axe_instruction * gen_blt_instruction
* specific memory location. The memory location can be extern t_axe_instruction * gen_notb_instruction (t_program_infos *program, t_axe_label *label, int addr);
* either a label identifier or a address reference. (t_program_infos *program, int r_dest, int r_source1);
* In order to create a STORE instruction the caller must extern t_axe_instruction * gen_bgt_instruction
* privide a valid register location (‘r_dest’) and an /*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− (t_program_infos *program, t_axe_label *label, int addr);
* instance of ‘t_axe_label’ or a numeric address */ * TERNARY OPERATIONS
extern t_axe_instruction * gen_store_instruction * REGISTER = REGISTER OP REGISTER extern t_axe_instruction * gen_ble_instruction
(t_program_infos *program, int r_dest, t_axe_label *label, int address); * Suffix "l" means logical (t_program_infos *program, t_axe_label *label, int addr);
* Suffic "b" means bitwise
/* A MOVA instruction copies an address value into a register. *−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/
* An address can be either an instance of ‘t_axe_label’ /*
* or a number (numeric address) */ extern t_axe_instruction * gen_add_instruction (t_program_infos *program See also:
extern t_axe_instruction * gen_mova_instruction , int r_dest, int r_source1, int r_source2, int flags); axe_utils.h for gen_load_immediate()
(t_program_infos *program, int r_dest, t_axe_label *label, int address); */
extern t_axe_instruction * gen_sub_instruction (t_program_infos *program
, int r_dest, int r_source1, int r_source2, int flags);
/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
* STATUS REGISTER TEST INSTRUCTIONS extern t_axe_instruction * gen_andl_instruction (t_program_infos *program
* −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/ , int r_dest, int r_source1, int r_source2, int flags);

/* rdest = 1 if the last numeric operation is gte 0 extern t_axe_instruction * gen_orl_instruction (t_program_infos *program
* rdest = 0 otherwise */ , int r_dest, int r_source1, int r_source2, int flags);
extern t_axe_instruction * gen_sge_instruction
(t_program_infos *program, int r_dest); extern t_axe_instruction * gen_eorl_instruction (t_program_infos *program
, int r_dest, int r_source1, int r_source2, int flags);
/* EQ */
extern t_axe_instruction * gen_seq_instruction extern t_axe_instruction * gen_andb_instruction (t_program_infos *program
(t_program_infos *program, int r_dest); , int r_dest, int r_source1, int r_source2, int flags);

/* GT */ extern t_axe_instruction * gen_orb_instruction (t_program_infos *program

extern t_axe_instruction * gen_sgt_instruction , int r_dest, int r_source1, int r_source2, int flags);
(t_program_infos *program, int r_dest);
extern t_axe_instruction * gen_eorb_instruction (t_program_infos *program
/* LE */ , int r_dest, int r_source1, int r_source2, int flags);
extern t_axe_instruction * gen_sle_instruction
(t_program_infos *program, int r_dest); extern t_axe_instruction * gen_mul_instruction (t_program_infos *program
, int r_dest, int r_source1, int r_source2, int flags);
/* LT */
extern t_axe_instruction * gen_slt_instruction extern t_axe_instruction * gen_div_instruction (t_program_infos *program
(t_program_infos *program, int r_dest); , int r_dest, int r_source1, int r_source2, int flags);

/* NE */ extern t_axe_instruction * gen_shl_instruction (t_program_infos *program

extern t_axe_instruction * gen_sne_instruction , int r_dest, int r_source1, int r_source2, int flags);
(t_program_infos *program, int r_dest);
extern t_axe_instruction * gen_shr_instruction (t_program_infos *program
/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− , int r_dest, int r_source1, int r_source2, int flags);
* BINARY OPERATIONS
*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/ extern t_axe_instruction * gen_neg_instruction (t_program_infos *program
, int r_dest, int r_source, int flags);

/*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− extern t_axe_instruction * gen_spcl_instruction (t_program_infos *program

* REGISTER = REGISTER OP IMMEDIATE , int r_dest, int r_source1, int r_source2, int flags);
*
* Suffix "li" means logical /*−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
* Suffix "bi" means bitwise * JUMP INSTRUCTIONS
* Prefix "e" means exclusive *−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/
* −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−*/
extern t_axe_instruction * gen_addi_instruction extern t_axe_instruction * gen_bt_instruction
(t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);

extern t_axe_instruction * gen_subi_instruction extern t_axe_instruction * gen_bf_instruction

(t_program_infos *program, int r_dest, int r_source1, int immediate); (t_program_infos *program, t_axe_label *label, int addr);

extern t_axe_instruction * gen_andli_instruction extern t_axe_instruction * gen_bhi_instruction

Sheet 4/6
 V. 1.1.0 axe_labels.h Page 1/1 V. 1.1.0 axe_struct.h Page 1/2 V. 1.1.0 axe_struct.h Page 2/2
/* **************************************************************************** /****************************************************************************** t_axe_label *label_end; /* this label points to the instruction
* axe_labels.h * axe_struct.h * that follows the while construct */
* AUXILIARY FUNCTIONS FOR LABEL MANAGEMENT * FUNDAMENTAL DATA STRUCTURES } t_while_statement;
* ****************************************************************************/ * ****************************************************************************/
/* create a label */
extern t_axe_label * alloc_label(int value);
/* get the number of labels inside the list of labels */ typedef struct t_axe_label
extern int get_number_of_labels(t_axe_label_manager *lmanager); { /* create an expression */
int labelID; /* label identifier */ extern t_axe_expression create_expression (int value, int type);
/* return TRUE if the two labels hold the same identifier */ } t_axe_label;
extern int compareLabels(t_axe_label *labelA, t_axe_label *labelB); /* create an instance that will mantain infos about a while statement */
typedef struct t_axe_register extern t_while_statement create_while_statement();
/* test if a label will be assigned to the next instruction */ {
extern int isAssignedLabel(t_axe_label_manager *lmanager); int ID; /* an identifier of the register */ /* create an instance of ‘t_axe_register’ */
int indirect; /* a boolean value: 1 if the register value is a pointer */ extern t_axe_register * alloc_register(int ID, int indirect);
}t_axe_register;
/* /* create an instance of ‘t_axe_instruction’ */
See also: typedef struct t_axe_address extern t_axe_instruction * alloc_instruction(int opcode);
axe_engine.h for the main label−related functions {
*/ int addr; /* a Program Counter */ /* create an instance of ‘t_axe_address’ */
t_axe_label *labelID; /* a label identifier */ extern t_axe_address * alloc_address(int type, int address, t_axe_label *label);
int type; /* one of ADDRESS_TYPE or LABEL_TYPE */
}t_axe_address; /* create an instance of ‘t_axe_data’ */
extern t_axe_data * alloc_data(int directiveType, int value, t_axe_label *label)
/* A structure that defines the internal data of a ‘Acse variable’ */ ;
typedef struct t_axe_variable
{ /* create an instance of ‘t_axe_variable’ */
int type; /* a valid data type @see ‘axe_constants.h’ */ extern t_axe_variable * alloc_variable
int isArray; /* must be TRUE if the current variable is an array */ (char *ID, int type, int isArray, int arraySize, int init_val);
int arraySize; /* the size of the array. This information is useful only
* if the field ‘isArray’ is TRUE */ /* finalize an instance of ‘t_axe_variable’ */
int init_val; /* initial value of the current variable. Actually it is extern void free_variable (t_axe_variable *variable);
* implemented as a integer value. ‘int’ is
* the only supported type at the moment, /* create an instance of ‘t_axe_variable’ */
* future developments could consist of a modification of extern t_axe_declaration * alloc_declaration
* the supported type system. Thus, maybe init_val will be (char *ID, int isArray, int arraySize, int init_val);
* modified in future. */
char *ID; /* variable identifier (should never be a NULL /* finalize an instruction info. */
* pointer or an empty string "") */ extern void free_Instruction(t_axe_instruction *inst);
t_axe_label *labelID; /* a label that refers to the location
* of the variable inside the data segment */ /* finalize a data info. */
} t_axe_variable; extern void free_Data(t_axe_data *data);

/* a simbolic assembly instruction */

typedef struct t_axe_instruction
{
int opcode; /* instruction opcode (for example: AXE_ADD ) *
/
t_axe_register *reg_1; /* destination register */
t_axe_register *reg_2; /* first source register */
t_axe_register *reg_3; /* second source register */
int immediate; /* immediate value */
t_axe_address *address; /* an address operand */
char *user_comment; /* if defined it is set to the source code
* instruction that generated the current
* assembly. This string will be written
* into the output code as a comment */
t_axe_label *labelID; /* a label associated with the current
* instruction */
}t_axe_instruction;
/* this structure is used in order to define assembler directives.
* Directives are used in many cases such the definition of variables
* inside the data segment. Every instance ‘t_axe_data’ contains
* all the informations about a single directive.
* An example is the directive .word that is required when the assembler
* must reserve a word of data inside the data segment. */
typedef struct t_axe_data
{
int directiveType; /* the type of the current directive
* (for example: DIR_WORD) */
int value; /* the value associated with the directive */
t_axe_label *labelID; /* label associated with the current data */
}t_axe_data;
typedef struct t_axe_expression
{
int value; /* an immediate value or a register identifier */
int expression_type; /* actually only integer values are supported */
} t_axe_expression;
typedef struct t_axe_declaration
{
int isArray; /* must be TRUE if the current variable is an array */
int arraySize; /* the size of the array. This information is useful o
nly
* if the field ‘isArray’ is TRUE */
int init_val; /* initial value of the current variable. */
char *ID; /* variable identifier (should never be a NULL pointer
* or an empty string "") */
} t_axe_declaration;
typedef struct t_while_statement
{
t_axe_label *label_condition; /* this label points to the expression
* that is used as loop condition */

Sheet 5/6
 V. 1.1.0 axe_utils.h Page 1/1 V. 1.1.0 collections.h Page 1/1 V. 1.1.0 symbol_table.h Page 1/1
/* **************************************************************************** /* **************************************************************************** /******************************************************************************
* axe_utils.h * collections.h * symbol_table.h
* Some important functions to access the list of symbols * A double linked list * Some important functions to manage the symbol table
* ****************************************************************************/ * ****************************************************************************/ * ****************************************************************************/
/* a list element */
/* create a variable for each ‘t_axe_declaration’ inside typedef struct t_list /* a symbol inside the sy_table. An element of the symbol table is composed by
* the list ‘variables’. Each new variable will be of type { * three fields: <ID>, <type> and <Location>.
* ‘varType’. */ void *data; * ‘ID’ is a not−NULL string that is used as key identifier for a symbol
extern void set_new_variables(t_program_infos *program struct t_list *next; * inside the table.
, int varType, t_list *variables); struct t_list *prev; * ‘type’ is an integer value that is used to determine the correct type
}t_list; * of a symbol. Valid values for ‘type’ are defined into "sy_table_constants.h".
/* Given a variable/symbol identifier (ID) this function * ‘reg_location’ refers to a register location (i.e. which register contains
* returns a register location where the value is stored * the value of ‘ID’). */
* (the value of the variable identified by ‘ID’). /* add an element ‘data’ to the list ‘list’ at position ‘pos’.*/ typedef struct
* If the variable/symbol has never been loaded from memory extern t_list * addElement(t_list *list, void * data, int pos); {
* to a register, first this function searches char *ID; /* symbol identifier */
* for a free register, then it assign the variable with the given /* add sorted */ int type; /* type associated with the symbol */
* ID to the register just found. extern t_list * addSorted(t_list *list, void * data int reg_location; /* a register location */
* Once computed, the location (a register identifier) is returned , int (*compareFunc)(void *a, void *b)); }t_symbol;
* as output to the caller.
* This function generates a LOAD instruction /* add an element to the end of the list */ /* put a symbol into the symbol table */
* only if the flag ‘genLoad’ is set to 1; otherwise it simply reserve extern t_list * addLast(t_list *list, void * data); extern int putSym(t_symbol_table *table, char *ID, int type);
* a register location for a new variable in the symbol table.
* If an error occurs, get_symbol_location returns a REG_INVALID errorcode */ /* add an element at the beginning of the list */ /* set the location of the symbol with ID as identifier */
extern int get_symbol_location(t_program_infos *program extern t_list * addFirst(t_list *list, void * data); extern int setLocation(t_symbol_table *table, char *ID, int reg);
, char *ID, int genLoad);
/* remove an element at the beginning of the list */ /* get the location of the symbol with the given ID */
/* Generate the instruction to load an ‘immediate’ value into a new register. extern t_list * removeFirst(t_list *list); extern int getLocation(t_symbol_table *table, char *ID, int *errorcode);
* It returns the new register identifier or REG_INVALID if an error occurs */
extern int gen_load_immediate(t_program_infos *program, int immediate); /* remove an element from the list */ /* get the type associated with the symbol with ID as identifier */
extern t_list * removeElement(t_list *list, void * data); extern int getTypeFromID(t_symbol_table *table, char *ID, int type);
/* Notify the end of the program. This function is directly called
* from the parser when the parsing process is ended */ /* remove a link from the list ‘list’ */ /* given a register identifier (location), it returns the ID of the variable
extern void set_end_Program(t_program_infos *program); extern t_list * removeElementLink(t_list *list, t_list *element); * stored inside the register ‘location’. This function returns NULL
* if the location is an invalid location. */
/* find an element inside the list ‘list’. The current implementation calls the extern char * getIDfromLocation(t_symbol_table *table
* CustomfindElement’ passing a NULL reference as ‘func’ */ , int location, int *errorcode);
extern t_list * findElement(t_list *list, void *data);

/* find an element inside the list ‘list’. */ /*

extern t_list * CustomfindElement(t_list *list, void *data See also:
, int (*compareFunc)(void *a, void *b)); axe_utils.h for wrapper functions related to variables
axe_array.h for wrapper functions related to array variables
/* find the position of an ‘element’ inside the ‘list’. −1 if not found */ */
extern int getPosition(t_list *list, t_list *element);

/* find the length of ‘list’ */

extern int getLength(t_list *list);
/* remove all the elements of a list */
extern void freeList(t_list *list);
/* get the last element of the list. Returns NULL if the list is empty
* or list is a NULL pointer */
extern t_list * getLastElement(t_list *list);
/* retrieve the list element at position ‘position’ inside the ‘list’.
* Returns NULL if: the list is empty, the list is a NULL pointer or
* the list holds less than ‘position’ elements. */
extern t_list * getElementAt(t_list *list, unsigned int position);
/* create a new list with the same elements */
extern t_list * cloneList(t_list *list);
/* add a list of elements to another list */
extern t_list * addList(t_list *list, t_list *elements);
/* add a list of elements to a set */
extern t_list * addListToSet(t_list *list, t_list *elements
, int (*compareFunc)(void *a, void *b), int *modified);

Sheet 6/6