ERROR BT_Insert(struct_BTree* tree, STRING_PTR key, void* data)
{
if (tree->root == NULL)
{
tree->root = gcMalloc(sizeof(struct struct_BTree_Node));
tree->root->key = key;
tree->root->left = NULL;
tree->root->right = NULL;
tree->root->data = data;
tree->last = tree->root;
return E_OK;
}
struct_BTree_Node temp_node = tree->root;
while(temp_node != NULL)
{
if ( strSize(key) < strSize(temp_node->key))
{
if(temp_node->left == NULL)
{
temp_node->left = gcMalloc(sizeof(struct struct_BTree_Node));
temp_node->left->key = key;
temp_node->left->left = NULL;
temp_node->left->right = NULL;
temp_node->left->data = data;
tree->last = temp_node->left;
return E_OK;
}
else temp_node=temp_node->left;
}
else if (strSize(key) >= strSize(temp_node->key))
{
if (temp_node->right == NULL)
{
temp_node->right = gcMalloc(sizeof(struct struct_BTree_Node));
temp_node->right->key = key;
temp_node->right->left = NULL;
temp_node->right->right = NULL;
temp_node->right->data = data;
tree->last = temp_node->right;
return E_OK;
}
else temp_node = temp_node->right;
}
else
{
tree->last = temp_node;
return E_OK;
}
}
return E_OK;
}
void * igenerateNoAppend(tInstrType type, void * op1, void * op2, void * op3){
tInstr * i = gcMalloc(sizeof(tInstr));
if( i == NULL ) return NULL;
i->type = type;
i->op1 = op1;
i->op2 = op2;
i->op3 = op3;
tListItem * item = gcMalloc(sizeof(tListItem));
if( item == NULL ) return NULL;
item->instr = *i;
item->nextItem = NULL;
return item;
}
INSTRUCTION_PTR makeInstruction(INSTRUCTION_TYPE type, PTR operand1, PTR operand2, PTR destionation){
INSTRUCTION_PTR i = gcMalloc(sizeof(INSTRUCTION));
fprintf(stderr, "Creating instruction: %s\n", debugInstruction(type));
i->type = type;
i->operand1 = operand1;
i->operand2 = operand2;
i->destionation = destionation;
return i;
}
int main(int argc, char** argv) {
if (argc != 2) { // ocekavame PRAVE JEDEN argument (+ nazev souboru)
fprintf(stderr, "Nespravny pocet argumentu testovaciho programu.\n");
return -1; //!! predelat na spravnou konstantu
}
FILE * f = fopen(argv[1], "r");
if (f == NULL ) {
fprintf(stderr, "Testovacimu souboru se nepodarilo otevrit soubor s aplikaci.\n");
return internalError();
}
initGarbageCollector();
//nastav soubor, ze ktereho scanner cte
setSourceFile(f);
htable_t* fT;
tIlist iL;
listInit(&iL);
fT = htable_init(HTABLE_SIZE);
htableStack *sS = gcMalloc(sizeof(htableStack));
if (sS == NULL) return internalError();
sS = htable_stack_init();
htable_t *mainTable ;
mainTable = htable_init(HTABLE_SIZE);
htable_stack_push(sS,mainTable);
int result = parse(fT, &iL,sS);
if (result != EOK)
{
fclose(f);
freeGarbage();
return result;
// jinak probehlo vse v poradku, muzeme provadet kod
}
result = (interpret(&iL,fT,sS));
freeGarbage();
fclose(f);
if(result != EOK){
return result;
}
return EOK;
}
static void growAttrList(int idx, size_t newSize){
int *tmpData = NULL;
String *tmpKeys = NULL;
if(idx < 0 || attrListPool[idx].size > newSize) return;
if(attrListPool[idx].data == NULL){
tmpData = (int *)gcMalloc(newSize * sizeof(int));
}
else{
tmpData = (int *)gcRealloc(attrListPool[idx].data, newSize * sizeof(int));
}
if(attrListPool[idx].keys == NULL){
tmpKeys = (String *)gcMalloc(newSize * sizeof(String));
}
else{
tmpKeys = (String *)gcRealloc(attrListPool[idx].keys, newSize * sizeof(String));
}
attrListPool[idx].data = tmpData;
attrListPool[idx].keys = tmpKeys;
attrListPool[idx].size = newSize;
}
int tokenInit(tToken * tk){
tk->data = gcMalloc(sizeof(TString));
if( tk-> data == NULL){
//clean()
return internalError();
}
tk->line = 0;
tk->state = S_START;
return EOK;
}
SYMBOL_PTR stInsertStaticValueEmpty(FUNCTION_PTR function){
SYMBOL_PTR symbol = gcMalloc(sizeof(SYMBOL));
symbol->id.data = NULL;
symbol->type = TTYPE_CONSTANT;
symbol->items = NULL;
symbol->filgy = false;
listInsertEnd(&function->staticValues, symbol);
return symbol;
}
ERROR interpret(SYMBOL_TABLE* table)
{
STACK_PTR stack;
ERROR err;
stack = gcMalloc(sizeof(struct STACK));
stackInit(stack);
/// ----- POZNAMKA -----
err = recursive_interpret(table->curr,stack);
stackFree(stack);
gcFree(stack);
return err;
}
int listInsertLast(tIlist *L, tInstr i) {
tListItem *newItem;
newItem = gcMalloc(sizeof (tListItem));
if(newItem == NULL) return internalError();
newItem->instr = i;
newItem->nextItem = NULL;
if (L->first == NULL)
L->first = newItem;
else
L->last->nextItem=newItem;
L->last=newItem;
return EOK;
}
ERROR stInsertSymbol(FUNCTION_PTR function, STRING id){
SYMBOL_PTR symbol = gcMalloc(sizeof(SYMBOL));
strCopy(&id, &symbol->id);
symbol->type = TYPE_OTHER;
symbol->items = NULL;
symbol->filgy = false;
ERROR err = BT_Insert(&function->symbols, &symbol->id, symbol);
if(err != E_OK){
fprintf(stderr, "Are you Chuck? insert symbol\n");
}
return err;
}
static void initPool(){
const int initialSize = 32;
int i;
struct attrListRec *tmp = NULL;
if(poolInitialized)return;
/* Register garbage-collection function */
gcRegister(shrinkPool, deletePool);
/* Set up pool */
tmp = (struct attrListRec *)gcMalloc((size_t)(initialSize * sizeof(struct attrListRec)));
for(i = 0; i < initialSize; ++i){
tmp[i].id = INVALID_ATTRLIST;
tmp[i].size = 0;
tmp[i].data = NULL;
}
attrListPool = tmp;
poolSize = initialSize;
poolInitialized = true;
}
ERROR stInsertFunction(SYMBOL_TABLE_PTR st, STRING id){
FUNCTION_PTR function = gcMalloc(sizeof(FUNCTION));
BT_Init(&function->symbols);
listInit(&function->staticValues);
listInit(&function->instructions);
function->calledCount = 0;
function->argumentsCount = 0;
function->argumentsCalled = 0;
strCopy(&id, &function->id);
ERROR err = BT_Insert(&st->functions, &function->id, function);
if(err != E_OK){
fprintf(stderr, "Are you Chuck? insert function\n");
}
return err;
}
SYMBOL_PTR stInsertStaticValue(FUNCTION_PTR function, STRING id, enum_RetVal retval, SYMBOL_PTR* symbol){
fprintf(stderr, "|| Static val in %s : %s\n", id.data, debugRetval(retval));
bool wasEmpty = false;
if(!(*symbol)){
*symbol = gcMalloc(sizeof(SYMBOL));
wasEmpty = true;
}
if(wasEmpty || !(*symbol)->items)
(*symbol)->items = gcMalloc(sizeof(ITEM));
//strCopy(&id, &(*symbol)->id); //mozno ne?
switch(retval){
case TTYPE_NULL:
(*symbol)->items->type = TYPE_NULL;
(*symbol)->filgy = true;
break;
case TTYPE_TRUE:
(*symbol)->items->type = TYPE_BOOL;
(*symbol)->items->value.valBool = true;
(*symbol)->filgy = true;
break;
case TTYPE_FALSE:
(*symbol)->items->type = TYPE_BOOL;
(*symbol)->items->value.valBool = false;
(*symbol)->filgy = true;
break;
case TTYPE_STRING:
(*symbol)->items->type = TYPE_STRING;
strCopy(&id, &((*symbol)->items->value.valString));
(*symbol)->filgy = true;
break;
case TTYPE_NUMBER:
(*symbol)->items->type = TYPE_DIGIT_INT;
sscanf(id.data, "%d", &((*symbol)->items->value.valInt));
(*symbol)->filgy = true;
break;
case TTYPE_DEC_NUMBER:
(*symbol)->items->type = TYPE_DIGIT_DOUBLE;
sscanf(id.data, "%lf", &((*symbol)->items->value.valDouble));
(*symbol)->filgy = true;
break;
case TTYPE_VARIABLE:
(*symbol)->items->type = TYPE_CALLABLE;
(*symbol)->filgy = true;
break;
default:
(*symbol)->items->type = TYPE_OTHER;
break;
}
listInsertEnd(&function->staticValues, (*symbol));
return (*symbol);
}
ERROR op_check(SYMBOL_PTR smb, char IO)
{
if(smb == NULL)
return E_COMPILATOR;
else
{
if(smb->id.data == NULL)
{
if(smb->items == NULL)
if(IO == 'o' || IO == 'O')
{
smb->items = gcMalloc(sizeof(struct ITEM));
return E_OK;
}
else
return E_COMPILATOR;
else
{
if(IO == 'i' || IO == 'I')
{
if(smb->filgy == false)
return E_SEMANTIC_UNDECLARED;
else
return E_OK;
}
else
return E_OK;
}
}
else
{
if(smb->items == NULL)
{
if(IO == 'o' || IO == 'O')
{
smb->items = gcMalloc(sizeof(struct ITEM));
return E_OK;
}
else
return E_COMPILATOR;
}
else
{
if(IO == 'i' || IO == 'I')
{
if(smb->filgy == false)
return E_SEMANTIC_UNDECLARED;
else
return E_OK;
}
else
return E_OK;
}
}
}
if(IO == 'i' || IO == 'I')
{
if(smb->filgy == false)
return E_SEMANTIC_UNDECLARED;
else
return E_OK;
}
else
return E_OK;
}
ERROR recursive_interpret(FUNCTION_PTR function, STACK_PTR stack)
{
// fprintf(stderr,"Zavolana funkce: %d\n",function);
LIST_NODE_PTR instr_node = function->instructions.begin;
ERROR err = E_OK;
// ----- Priprava promenych ------
INSTRUCTION_PTR instruction = NULL;
int str_from,str_to,tmp_count;
STRING tmp_string;
STACK_PTR tmp_stack;
tmp_stack = gcMalloc(sizeof(struct STACK));
stackInit(tmp_stack);
// NULL SYMBOL
ITEMPTR null_item;
null_item = gcMalloc(sizeof(struct ITEM));
null_item->type = TYPE_NULL;
SYMBOL* null_symbol;
null_symbol = gcMalloc(sizeof(struct SYMBOL));
null_symbol->type = TYPE_NULL;
null_symbol->items = null_item;
// TMP SYMBOL
ITEMPTR tmp_item;
SYMBOL* tmp_symbol;
SYMBOL* op1 = NULL;
SYMBOL* op2 = NULL;
SYMBOL* op3 = NULL;
FUNCTION_PTR tmp_function = NULL;
while(instr_node != NULL && err == E_OK)
{
instruction = instr_node->value;
tmp_item = gcMalloc(sizeof(struct ITEM));
tmp_symbol = gcMalloc(sizeof(struct SYMBOL));
tmp_symbol->items = tmp_item;
op1 = (SYMBOL*) instruction->operand1;
op2 = (SYMBOL*) instruction->operand2;
op3 = (SYMBOL*) instruction->destionation;
fprintf(stderr,"while interpret : %d (%s)\n",instruction->type, debugInstruction(instruction->type));
switch(instruction->type)
{
case INSTRUCTION_NOP:
break;
case INSTRUCTION_MOV:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
data_copy(op2, op1);
op1->filgy = true;
break;
case INSTRUCTION_LOAD_NULL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'O')) != E_OK)
return err;
if ((err = op_check(op3,'O')) != E_OK)
return err;
data_copy(null_symbol,op1);
data_copy(null_symbol,op2);
data_copy(null_symbol,op3);
op1->filgy = true;
op2->filgy = true;
op3->filgy = true;
break;
case INSTRUCTION_ADDITION:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = op2->items->value.valInt + op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valInt + op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble + op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble + op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->type = TYPE_STRING;
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_DIGIT_INT)
{
STRING new_string;
char* new_char_string = gcMalloc(sizeof(char*));;
sprintf(new_char_string, "%d", op3->items->value.valInt);
strInitRaw(&new_string, new_char_string);
tmp_symbol->items->type = TYPE_STRING;
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_DIGIT_DOUBLE)
{
STRING new_string;
char* new_char_string = gcMalloc(sizeof(char*));
sprintf(new_char_string, "%lf", op3->items->value.valDouble);
strInitRaw(&new_string, new_char_string);
tmp_symbol->items->type = TYPE_STRING;
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else
return E_SEMANTIC_TYPE_MISMATCH;
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_SUBSTRACTION:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = op2->items->value.valInt - op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valInt - op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble - op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble - op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else
return E_SEMANTIC_TYPE_MISMATCH;
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_MULTIPLICATION:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = op2->items->value.valInt * op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = ((double)op2->items->value.valInt) * op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble * ((double)op3->items->value.valInt);
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble * op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else
return E_SEMANTIC_TYPE_MISMATCH;
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_DIVISION:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
if(op3->items->value.valInt == 0)
return E_SEMANTIC_ZERO_DIV;
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = op2->items->value.valInt / op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_DOUBLE)
{
if(op3->items->value.valDouble == 0.0)
return E_SEMANTIC_ZERO_DIV;
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valInt / op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_INT)
{
if(op3->items->value.valInt == 0)
return E_SEMANTIC_ZERO_DIV;
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble / op3->items->value.valInt;
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
if(op3->items->value.valDouble == 0.0)
return E_SEMANTIC_ZERO_DIV;
tmp_symbol->items->type = TYPE_DIGIT_DOUBLE;
tmp_symbol->items->value.valDouble = op2->items->value.valDouble / op3->items->value.valDouble;
data_copy(tmp_symbol,op1); // from, to
}
else
return E_SEMANTIC_TYPE_MISMATCH;
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_LESS:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt < op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble < op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used < op3->items->value.valString.used;
}
else
return E_SEMANTIC_TYPE_MISMATCH;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_GREATER:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt > op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble > op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used > op3->items->value.valString.used;
}
else
return E_SEMANTIC_TYPE_MISMATCH;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_LESS_EQUAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt <= op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble <= op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used <= op3->items->value.valString.used;
}
else
return E_SEMANTIC_TYPE_MISMATCH;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_GREATER_EQUAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt >= op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble >= op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used >= op3->items->value.valString.used;
}
else
return E_SEMANTIC_TYPE_MISMATCH;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_EQUAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt == op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble == op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used == op3->items->value.valString.used;
}
else
tmp_symbol->items->value.valBool = false;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_NOT_EQUAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_BOOL;
if(op2->items->type == TYPE_DIGIT_INT && op3->items->type == TYPE_DIGIT_INT)
{
tmp_symbol->items->value.valBool = op2->items->value.valInt != op3->items->value.valInt;
}
else if(op2->items->type == TYPE_DIGIT_DOUBLE && op3->items->type == TYPE_DIGIT_DOUBLE)
{
tmp_symbol->items->value.valBool = op2->items->value.valDouble != op3->items->value.valDouble;
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->value.valBool = op2->items->value.valString.used != op3->items->value.valString.used;
if(!tmp_symbol->items->value.valBool)
{
tmp_symbol->items->value.valBool = !strCompare(op2->items->value.valString, op3->items->value.valString.data);
}
}
else
tmp_symbol->items->value.valBool = false;
data_copy(tmp_symbol,op1);
tmp_symbol = NULL;
break;
case INSTRUCTION_PUSH:
// printf("ahoj %d\n",op1->filgy);
if ((err = op_check(op1,'I')) != E_OK)
return err;
stackPush(stack,op1);
break;
case INSTRUCTION_POP:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_symbol = stackPop(stack);
if(tmp_symbol == NULL){
tmp_symbol = gcMalloc(sizeof(SYMBOL));
tmp_symbol->items = gcMalloc(sizeof(ITEM));
tmp_symbol->items->type = TYPE_NULL;
tmp_symbol->filgy = true;
}
data_copy(tmp_symbol,op1);
op1->filgy = true;
break;
case INSTRUCTION_CALL:
if(op1 == NULL)
return E_COMPILATOR;
tmp_function = function;
function = (FUNCTION_PTR)op1;
err=recursive_interpret(function,stack);
if (err != E_OK)
return err;
function = tmp_function;
break;
case INSTRUCTION_RETURN:
return err;
break;
case INSTRUCTION_JUMP:
if(op3 == NULL)
return E_COMPILATOR;
instr_node = function->instructions.begin;
while(instr_node != (LIST_NODE_PTR)op3)
{
if(instr_node->next == NULL)
{
fprintf(stderr,"NENALEZENO!!!\n");
fprintf(stderr,"NENALEZENO!!!\n");
fprintf(stderr,"NENALEZENO!!!\n");
break;
}
instr_node = instr_node->next;
}
continue;
break;
case INSTRUCTION_IF_JUMP:
// if ((err = op_check(op2,'I')) != E_OK)
// return err;
if(op3 == NULL)
return E_COMPILATOR;
if(op2->items->type == TYPE_BOOL)
{
if(!op2->items->value.valBool)
{
instr_node = function->instructions.begin;
while(instr_node != (LIST_NODE_PTR)op3)
{
if(instr_node->next == NULL)
break;
instr_node = instr_node->next;
}
continue;
}
}
// if(op2->items->type == TYPE_DIGIT_INT)
// {
// printf("AHOJ\n");
// if(!op2->items->value.valInt)
// {
// instr_node = function->instructions.begin;
// while(instr_node != (LIST_NODE_PTR)op3)
// {
// if(instr_node->next == NULL)
// break;
// instr_node = instr_node->next;
// }
// continue;
// }
// }
break;
case INSTRUCTION_LABEL:
break;
case INSTRUCTION_BOOLVAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_symbol = stackPop(stack);
tmp_symbol->items = boolval(*tmp_symbol->items);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_DOUBLEVAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_symbol = stackPop(stack);
tmp_symbol->items = doubleval(*tmp_symbol->items);
if(tmp_symbol->items == NULL)
return E_SEMANTIC_DOUBLEVAL;
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_INTVAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
op1 = stackPop(stack);
if ((err = op_check(op1,'I')) != E_OK)
return err;
tmp_symbol->items = intval(*op1->items);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_STRVAL:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_symbol = stackPop(stack);
tmp_symbol->items = strval(*tmp_symbol->items);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_GET_STRING:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_string = get_string();
tmp_symbol->items->type = TYPE_STRING;
strInit(&tmp_symbol->items->value.valString);
strCopy(&tmp_string, &tmp_symbol->items->value.valString);
data_copy(tmp_symbol, op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_CONCATE:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if ((err = op_check(op2,'I')) != E_OK)
return err;
if ((err = op_check(op3,'I')) != E_OK)
return err;
if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_STRING)
{
tmp_symbol->items->type = TYPE_STRING;
strInit(&tmp_symbol->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_DIGIT_INT)
{
STRING new_string;
char* new_char_string = gcMalloc(sizeof(char*));
sprintf(new_char_string, "%d", op3->items->value.valInt);
strInitRaw(&new_string, new_char_string);
tmp_symbol->items->type = TYPE_STRING;
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else if(op2->items->type == TYPE_STRING && op3->items->type == TYPE_DIGIT_DOUBLE)
{
STRING new_string;
char* new_char_string = gcMalloc(sizeof(char*));
sprintf(new_char_string, "%lf", op3->items->value.valDouble);
strInitRaw(&new_string, new_char_string);
tmp_symbol->items->type = TYPE_STRING;
strConcatenate(&tmp_symbol->items->value.valString, &op2->items->value.valString);
strConcatenate(&tmp_symbol->items->value.valString, &op3->items->value.valString);
data_copy(tmp_symbol,op1); // from, to
}
else
return E_SEMANTIC_TYPE_MISMATCH;
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_PUT_STRING:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if (op2 == NULL)
return E_COMPILATOR;
// DODELAT VRACENI POCTU VYPSANYCH! DO OP1
tmp_count = *((int*)op2);
for(int i=0;i<tmp_count;i++)
{
tmp_symbol = stackPop(stack);
if ((err = op_check(tmp_symbol,'I')) != E_OK)
return err;
stackPush(tmp_stack,tmp_symbol);
}
for(int i=0;i<tmp_count;i++)
{
tmp_symbol = stackPop(tmp_stack);
if(tmp_symbol->items->type == 2)
printf("%d",tmp_symbol->items->value.valInt);
else if(tmp_symbol->items->type == 3)
printf("%lf",tmp_symbol->items->value.valDouble);
else if(tmp_symbol->items->type == 4)
printf("%s",tmp_symbol->items->value.valString.data);
}
tmp_symbol = NULL;
break;
case INSTRUCTION_STRLEN:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if (op2 == NULL)
return E_COMPILATOR;
tmp_count = *((int*)op2);
if (tmp_count != 1)
return E_COMPILATOR;
op1 = stackPop(stack);
if ((err = op_check(op1,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = my_strlen(op1->items->value.valString);
data_copy(tmp_symbol, op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_GET_SUBSTRING:
if ((err = op_check(op1,'O')) != E_OK)
return err;
if (op2 == NULL)
return E_COMPILATOR;
tmp_count = *((int*)op2);
if (tmp_count != 3)
return E_COMPILATOR;
// TO
tmp_symbol = stackPop(stack);
if ((err = op_check(tmp_symbol,'I')) != E_OK)
return err;
str_to = tmp_symbol->items->value.valInt;
// FROM
tmp_symbol = stackPop(stack);
if ((err = op_check(tmp_symbol,'I')) != E_OK)
return err;
str_from = tmp_symbol->items->value.valInt;
// STRING
tmp_symbol = stackPop(stack);
if ((err = op_check(tmp_symbol,'I')) != E_OK)
return err;
tmp_string = get_substring(tmp_symbol->items->value.valString,str_from,str_to,&err);
if(err != E_OK)
return err;
tmp_symbol->items->type = TYPE_STRING;
strCopy(&tmp_symbol->items->value.valString,&tmp_string);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_FIND_STRING:
if ((err = op_check(op1,'O')) != E_OK)
return err;
op2 = stackPop(stack);
if ((err = op_check(op2,'I')) != E_OK)
return err;
op3 = stackPop(stack);
if ((err = op_check(op1,'I')) != E_OK)
return err;
tmp_symbol->items->type = TYPE_DIGIT_INT;
tmp_symbol->items->value.valInt = find_string(op3->items->value.valString, op2->items->value.valString);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
case INSTRUCTION_SORT_STRING:
if ((err = op_check(op1,'O')) != E_OK)
return err;
tmp_symbol = stackPop(stack);
if ((err = op_check(tmp_symbol,'I')) != E_OK)
return err;
sort_string(tmp_symbol->items->value.valString);
data_copy(tmp_symbol,op1);
op1->filgy = true;
tmp_symbol = NULL;
break;
default:
return E_OK;
break;
}
instr_node = instr_node->next;
}
return err;
}
