//-------------------------------------------------------------------
// VYHODNOCENI LISTU PRO > , >= ,<= < , != ,==
//-------------------------------------------------------------------
int FOURTH_eval(Expr_list**first, Expr_list** last)
{
Expr_list *pom;
Expr_list *del;
T_Var *var;
pom = *first;
if (debug) printf("\n > , >= , <= < , != , == ");
while ((pom != NULL) && (pom != *last)) {
// mozne plynule vyhodnocovat prioritne na nejnizi urovni
// v dane useku zbyly pouze operace relace
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = NID_BOOL;
switch (pom->operace) {
case TOKEN_BIGGER : T_InstrSet(&instr, IID_BIGGER, var, pom->value, pom->next->value); break;
case TOKEN_SMALLER : T_InstrSet(&instr, IID_SMALLER, var, pom->value, pom->next->value); break;
case TOKEN_BEQUAL : T_InstrSet(&instr, IID_BEQUAL, var, pom->value, pom->next->value); break;
case TOKEN_SMEQUAL : T_InstrSet(&instr, IID_SMEQUAL, var, pom->value, pom->next->value); break;
case TOKEN_EQUAL : T_InstrSet(&instr, IID_EQUAL, var, pom->value, pom->next->value); break;
case TOKEN_UNEQUAL : T_InstrSet(&instr, IID_UNEQUAL, var, pom->value, pom->next->value); break;
default : free(var); var = NULL;
}
if (var!=NULL) {
T_ListAppend(inst_list, &instr);
pom->value=var;
MYSHORTCUT;
}
}
return EXIT_SUCCESS;
}
int FIRST_eval(Expr_list**first, Expr_list** last)
{
Expr_list *pom;
Expr_list *del;
T_Var *var;
//1. **
if (debug) printf("\n-----* /----\n");
pom = *first;
while ((pom != NULL) && (pom != *last)) {
if (pom->operace==TOKEN_DSTAR)
if (((pom->value->NID == NID_NUMBER) || (pom->value->NID == NID_UNDEF))
&&((pom->next->value->NID == NID_NUMBER) || (pom->next->value->NID == NID_UNDEF)))
{
if (debug) printf("%f - %f ** \n",pom->value->vals.d_val ,pom->next->value->vals.d_val );
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID=NID_NUMBER;
GenerateInstruction(IID_PWR, var, pom->value, pom->next->value);
pom->value=var;
MYSHORTCUT;
}
else { errno = SEMANTIC_ERROR; if (debug) printf("semantika ** \n"); return EXIT_FAILURE; }
else pom = pom->next;
}
return EXIT_SUCCESS;
}
//-------------------------------------------------------------------
// VYHODNOCENI LISTU PRO + -
//-------------------------------------------------------------------
int THIRT_eval(Expr_list** first, Expr_list** last)
{
Expr_list *pom;
Expr_list *del;
T_Var *var;
pom=*first;
if (debug) printf("\n-----+ - ----");
while ((pom != NULL) && (pom != *last)) {
if (pom->operace == TOKEN_MINUS)
//------------------------NUM - NUM --------------------------
if (((pom->value->NID == NID_NUMBER) || (pom->value->NID == NID_UNDEF))
&&((pom->next->value->NID == NID_NUMBER) || (pom->next->value->NID == NID_UNDEF)))
{
if (debug) printf("%f - %f - \n", pom->value->vals.d_val, pom->next->value->vals.d_val);
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = NID_NUMBER;
GenerateInstruction(IID_DIFF, var, pom->value, pom->next->value);
pom->value=var;
MYSHORTCUT;
}
else { errno = SEMANTIC_ERROR; if (debug) printf("semantika -\n"); return EXIT_FAILURE; }
else if (pom->operace == TOKEN_PLUS)
//------------------------NUM - NUM --------------------------
if ((pom->value->NID == NID_NUMBER) || (pom->value->NID == NID_UNDEF) || (pom->value->NID == NID_STRING)) {
if (debug) printf("%f - %f + \n", pom->value->vals.d_val, pom->next->value->vals.d_val);
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = pom->value->NID;
GenerateInstruction(IID_PLUS, var, pom->value, pom->next->value);
pom->value = var;
MYSHORTCUT;
}
else { errno = SEMANTIC_ERROR; if (debug) printf("semantika + \n"); return EXIT_FAILURE; }
else pom = pom->next;
}
return EXIT_SUCCESS;
}
void Generate (AST* ast, int i,char* str)
{
switch(ast->type){
case tok_plus:case tok_mul:case tok_minus:case tok_div:
case tok_gt:case tok_gte:case tok_lt:case tok_lte:
case tok_eq:
GenerateOperation(ast, i);
break;
case tok_number:
GenerateNumber(ast);
break;
case tok_if:
GenerateIf (ast, i, str);
break;
case tok_setq:
GenerateSetq (ast, i);
break;
case tok_valiable:
GenerateVariable (ast);
break;
case tok_defun:
GenerateDefun (ast);
break;
case tok_arg:
GenerateArg (ast);
break;
case tok_func:
GenerateFunc (ast, i);
break;
default:
printf("default\n");
break;
}
free(ast);
}
int if_state(int mode, T_Var *jmp)
{
DEBUG_IF;
lex_rc = GetToken(&token);
TOKEN_CHECK;
if (lex_rc == TOKEN_IDENTIFICATOR) {
if (mode == MODE_OUTSIDE && strcmp(token.data, "else") == 0) {
DEBUG_IF_ELSE;
// Expression is true -- jump behind else
GenerateVariable(TRUE, &write_var);
GenerateInstruction(IID_JUMP, write_var, NULL, NULL);
// Expression is false -- else follows
GenerateInstruction(IID_LABEL, jmp, NULL, NULL);
T_LabelListAppend(lbl_list, inst_list->last);
return if_state(MODE_INSIDE, write_var);
}
else if (strcmp(token.data, "end") == 0) {
DEBUG_IF_END;
// Once end is found, places its label
GenerateInstruction(IID_LABEL, jmp, NULL, NULL);
T_LabelListAppend(lbl_list, inst_list->last);
return EXIT_SUCCESS;
}
}
CALL_CHECK(stat(MODE_INSIDE));
CALL_CHECK(if_state(mode, jmp));
DEBUG_IF_END;
return EXIT_SUCCESS;
}
// generator listu z tokenu - vlastnost operace,zavorek,hodnoty/NID
int gener_list(Expr_list **L)
{
T_Var *var;
int waitfor=HODNOTA;
int err;
parentheses = 0;
int par = 0;
Expr_list *pom = NULL;
Expr_list *last = NULL;
*L = NULL; //inic listu
if (debug) printf("list %d\n", *L);
lex_rc = GetToken(&token);
TOKEN_CHECK;
while ((lex_rc != TOKEN_EOF) && (lex_rc != TOKEN_EOL)) {
switch (lex_rc) {
//-------------------op == HODNOTA---------------
//--------------------CISLO---------------------
case TOKEN_NUMBER:
if (waitfor == HODNOTA) {
if (debug) printf("%d cislo\n",lex_rc);
CALL_CHECK(GenerateVariable(FALSE, &var));
CDoubleToT_Var(atof(token.data),var);
GENERSHORT; //viz synan.h
waitfor=OPERACE;
}
else { errno=SYNTACTIC_ERROR; if (debug) printf("cekam operaci"); return EXIT_FAILURE; }
break;
//--------------------STRING---------------------
case TOKEN_STRING:
if (waitfor == HODNOTA) {
if (debug) printf("%d string\n",lex_rc);
CALL_CHECK(GenerateVariable(FALSE, &var));
T_StringToT_Var(&token,var);
GENERSHORT;
waitfor=OPERACE;
}
else { errno=SYNTACTIC_ERROR; if (debug) printf("cekam operaci"); return EXIT_FAILURE; }
break;
//--------------------ID---------------------
case TOKEN_IDENTIFICATOR:
// 1 . nil , false , true
if (waitfor == HODNOTA) {
waitfor = OPERACE;
if (strcmp(token.data, "nil") == 0) {
if (debug) printf("%d nil\n", lex_rc);
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = NID_NIL;
GENERSHORT;
}
else if (strcmp(token.data, "false") == 0) {
if (debug) printf("%d false\n", lex_rc);
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = NID_BOOL;
var->vals.b_val = FALSE;
GENERSHORT;
}
else if (strcmp(token.data, "true") == 0) {
if (debug) printf("%d true\n", lex_rc);
CALL_CHECK(GenerateVariable(FALSE, &var));
var->NID = NID_BOOL;
var->vals.b_val = TRUE;
GENERSHORT;
}
// 2. identifikatory - pouze ukladame ukaz na tabulku
else if (T_HTableExport(id_table, token.data, &var) == HASH_FOUND) {
if (debug) printf ("%s identifikator\n", token.data);
if (var->NID == NID_FUNCTION) { if (debug) printf("funkceeeeeeeeeeeeee");}
//CALL_CHECK(CallFunction());
//lex_rc=GetToken(&token);
//if ((lex_rc==EOL) || (lex_rc==EOF))
//(*L)->value = nularet;
GENERSHORT;
}
else { errno = UNDEFINED_VARIABLE; if (debug) printf("id neexistuje"); return EXIT_FAILURE; }
}
else { errno = SYNTACTIC_ERROR; if (debug) printf("cekam operaci"); return EXIT_FAILURE; }
break;
//--------------------zavorka---------------------
//vaze se k hodnote v pravo - ceka se stale na hodnotu
case TOKEN_LBRACKET :
if (waitfor == HODNOTA) {
par--;
parentheses--;
if (debug) printf("%d levaz\n", lex_rc);
}
else { errno = SYNTACTIC_ERROR; if (debug) printf("cekam operaci"); return EXIT_FAILURE; }
break;
//--------------------op == OPERACE ---------------------
//--------------------zavorka---------------------
case TOKEN_RBRACKET :
if (waitfor == OPERACE) {
last->zavorka++;
parentheses++;
if (debug) printf("%d pravaz\n", lex_rc);
}
else { errno = SYNTACTIC_ERROR; if (debug) printf("cekam hodnotu"); return EXIT_FAILURE; }
if (parentheses > 0) { errno=SYNTACTIC_ERROR; if (debug) printf("cekam hodnotu"); return EXIT_FAILURE; }
break;
//--------------------operace ---------------------
case TOKEN_DSTAR:
case TOKEN_STAR: case TOKEN_SLASH:
case TOKEN_PLUS: case TOKEN_MINUS:
case TOKEN_EQUAL: case TOKEN_UNEQUAL: case TOKEN_BEQUAL:
case TOKEN_SMEQUAL:case TOKEN_SMALLER: case TOKEN_BIGGER:
if (waitfor==OPERACE) {
if (debug) printf("%d operace\n", lex_rc);
last->operace = lex_rc;
waitfor = HODNOTA;
}
else { errno=SYNTACTIC_ERROR; if (debug) printf("cekam hodnotu"); return EXIT_FAILURE; }
break;
//------------------------PRAVAZAVORKA----------------------------
case TOKEN_LSBRACKET:
if (waitfor==OPERACE) {
if (debug) printf("%d leva hranata zavorka\n",lex_rc);
if ((*L!=NULL)&&((*L)->next==NULL)) {
T_Var *svar;
T_Var *svar2;
if ((err = expr_string(&svar ,&svar2)) != EXIT_SUCCESS) return EXIT_FAILURE;
else {
if ((svar!=NULL)||(svar2!=NULL)) {
CALL_CHECK(GenerateVariable(FALSE, &read_var));
read_var->NID=NID_STRING;
GenerateInstruction(IID_COPY, read_var, (*L)->value, NULL);
GenerateInstruction(IID_CUT, read_var, svar, svar2);
(*L)->value=read_var;
}
if ((lex_rc == TOKEN_EOL) || (lex_rc == TOKEN_EOF)) return EXIT_SUCCESS;
}
}
}
else { errno=SYNTACTIC_ERROR; if (debug) printf("cekam hodnotu"); return EXIT_FAILURE;}
break;
case TOKEN_BROKEN : if (debug) printf("%d lex chyba kdyz token brken chyba\n",lex_rc); return EXIT_FAILURE;
default : { errno = SYNTACTIC_ERROR; if (debug) printf("%d syn chyba kdyz token brken chyba\n", lex_rc); return EXIT_FAILURE;} break;
}
lex_rc = GetToken(&token);
TOKEN_CHECK;
}
if (*L == NULL) { errno = SYNTACTIC_ERROR; if (debug) printf("prazdno"); return EXIT_FAILURE;}
if (parentheses != 0) { errno = SYNTACTIC_ERROR; if (debug) printf("spatne zavorky"); return EXIT_FAILURE;}
return EXIT_SUCCESS;
}
int item()
{
DEBUG_ITEM;
double tmp;
switch (lex_rc) {
case TOKEN_STRING:
DEBUG_ITEM_STR;
CALL_CHECK(GenerateVariable(FALSE, &read_var));
T_StringToT_Var(&token, read_var);
DEBUG_ITEM_END;
return EXIT_SUCCESS;
break;
case TOKEN_NUMBER:
DEBUG_ITEM_NUM;
CALL_CHECK(GenerateVariable(FALSE, &read_var));
tmp = strtod(token.data, NULL);
CDoubleToT_Var(tmp, read_var);
DEBUG_ITEM_END;
return EXIT_SUCCESS;
break;
case TOKEN_IDENTIFICATOR:
if (strcmp(token.data, "true") == 0) {
DEBUG_ITEM_TRUE;
CALL_CHECK(GenerateVariable(FALSE, &read_var));
read_var->NID = NID_BOOL;
read_var->vals.b_val = 1;
DEBUG_ITEM_END;
return EXIT_SUCCESS;
}
else if (strcmp(token.data, "false") == 0) {
DEBUG_ITEM_FALSE;
CALL_CHECK(GenerateVariable(FALSE, &read_var));
read_var->NID = NID_BOOL;
read_var->vals.b_val = 0;
DEBUG_ITEM_END;
return EXIT_SUCCESS;
}
else if (strcmp(token.data, "nil") == 0) {
DEBUG_ITEM_NIL;
CALL_CHECK(GenerateVariable(FALSE, &read_var));
read_var->NID = NID_NIL;
DEBUG_ITEM_END;
return EXIT_SUCCESS;
}
else if (T_HTableExport(id_table, token.data, &read_var) == HASH_FOUND) {
DEBUG_ITEM_ID;
return EXIT_SUCCESS;
}
break;
}
errno = SYNTACTIC_ERROR;
return EXIT_FAILURE;
}
int keyword(int mode)
{
DEBUG_KW;
if (lex_rc == TOKEN_IDENTIFICATOR) {
if (strcmp(token.data,"if") == 0 ) {
DEBUG_KW_IF;
CALL_CHECK(expr());
GenerateVariable(TRUE, &write_var);
GenerateInstruction(IID_BRAFAL, read_var, write_var, NULL);
CALL_CHECK(if_state(MODE_OUTSIDE, write_var));
DEBUG_KW_END;
return EXIT_SUCCESS;
}
else if (strcmp(token.data,"while") == 0 ) {
DEBUG_KW_WHILE;
T_Var *start_lbl;
GenerateVariable(TRUE, &start_lbl);
GenerateInstruction(IID_LABEL, start_lbl, NULL, NULL);
T_LabelListAppend(lbl_list, inst_list->last);
CALL_CHECK(expr());
GenerateVariable(TRUE, &write_var);
GenerateInstruction(IID_BRAFAL, read_var, write_var, NULL);
CALL_CHECK(while_state(start_lbl, write_var));
DEBUG_KW_END;
return EXIT_SUCCESS;
}
else if (strcmp(token.data,"function") == 0 && (mode == MODE_OUTSIDE)) {
DEBUG_KW_FUNCTION;
lex_rc = GetToken(&token);
// TOKEN_CHECK;
// if (lex_rc == TOKEN_IDENTIFICATOR) {
// lex_rc = GetToken(&token);
// TOKEN_CHECK;
// if (lex_rc == TOKEN_LBRACKET) {
//
// f_item();
// CALL_CHECK(f_());
//
// lex_rc = GetToken(&token);
// TOKEN_CHECK;
//
// DEBUG_KW_END;
// return EXIT_SUCCESS;
// }
// }
}
}
errno = SYNTACTIC_ERROR;
return EXIT_FAILURE;
}
int CallFunction()
{
// Saves a name of called function, currently located in token
T_String f_name;
T_StringInit(&f_name);
T_StringCopy(&f_name, &token);
// Opening bracket must follow
lex_rc = GetToken(&token);
TOKEN_CHECK;
if (lex_rc == TOKEN_LBRACKET) {
T_HashTable *tmp_table = malloc(sizeof(T_HashTable));
T_Var *f_var = malloc(sizeof(T_Var));
if (tmp_table == NULL || f_var == NULL) {
free(tmp_table);
free(f_var);
errno = INTERNAL_ERROR;
return EXIT_FAILURE;
}
T_HTableInit(tmp_table);
T_VarInit(f_var);
// Adds current id_table to table list and change its pointer
T_IdListAppend(table_list, id_table);
id_table = tmp_table;
T_Var *var = malloc(sizeof(T_Var));
PTR_CHECK(var);
T_VarInit(var);
var->NID = NID_CONST;
char *reserved[] = {"as", "def", "directive", "export", "from", "import", "launch", "load", "macro", "input", "print", "numeric", "typeOf", "len", ""};
T_HTableInit(id_table);
for (int i = 0; strcmp(reserved[i], "") != 0; i++)
T_HTableInsert(id_table, reserved[i], var);
free(var);
// Gets all function parameters into hash table
if (write_var->vals.args.size > 0) {
lex_rc = GetToken(&token);
TOKEN_CHECK;
CALL_CHECK(item());
CALL_CHECK(T_HTableInsert(id_table, write_var->vals.args.first->data.data, read_var));
CALL_CHECK(it_list(write_var->vals.args.first->next));
}
else {
lex_rc = GetToken(&token);
TOKEN_CHECK;
if (lex_rc != TOKEN_RBRACKET) {
errno = SYNTACTIC_ERROR;
return EXIT_FAILURE;
}
}
// Calls the function with the saved name
T_StringToT_Var(&f_name, f_var);
GenerateInstruction(IID_JUMP, f_var, NULL, NULL);
// Generates a lable as a return point
GenerateVariable(TRUE, &write_var);
GenerateInstruction(IID_LABEL, write_var, NULL, NULL);
T_LabelListAppend(cal_list, inst_list->last);
free(f_var);
return EXIT_SUCCESS;
}
errno = SYNTACTIC_ERROR;
return EXIT_FAILURE;
}