static void sort_string(char *s, int l) {
int i = 0, j = 1;
char tmp;
if (l < 2)
return;
for (j = 1; j < l; j++)
if (s[j] < s[0]) {
i++;
if (j > i) {
tmp = s[j];
s[j] = s[i];
s[i] = tmp;
}
}
if (i > 0) {
tmp = s[i];
s[i] = s[0];
s[0] = tmp;
}
sort_string(s, i);
sort_string(s+i+1, l-i-1);
}
ItemSetNode *get_frequent_k_plus_one_itemsets(ItemSetNode *frequent_k, ItemSetNode *frequent_1, int k_plus_one)
{
TreeNode *root = NULL;
ItemSetNode *l, *i;
for (l = frequent_k; l != NULL; l = l->next)
{
for (i = frequent_1; i != NULL; i = i->next)
{
if (*(i->data->item_set) > *(l->data->item_set + strlen(l->data->item_set) - 1))
{
char *old_item_set = l->data->item_set;
char *item_set = malloc(sizeof(char) * (strlen(old_item_set) + 2));
strcpy(item_set, old_item_set);
strcat(item_set, i->data->item_set);
sort_string(item_set);
ItemSet *tmp = new_item_set(item_set, 0);
insert_itemset_into_tree(&root, tmp, 0, k_plus_one);
}
}
}
ItemSetNode *frequent_k_plus_1 = get_frequent_itemsets(root);
return frequent_k_plus_1;
}
static int permutation_check_sort(char *s1, char *s2) {
int i;
int l1 = strlen(s1);
int l2 = strlen(s2);
if (l1 != l2)
return 0;
sort_string(s1, l1);
sort_string(s2, l2);
for (i = 0; i < l1; i++)
if (s1[i] != s2[i])
return 0;
return 1;
}
main()
{
char string[100];
printf("Enter some text\n");
gets(string);
sort_string(string);
printf("%s\n", string);
return 0;
}
int main(){
typedef struct emp_struct{
char* name;
int employee_no;
float salary, tax_to_date;
}Employee;
Employee data[3];
printf("Enter the emp data:\n 1.Name, \t 2. emp_no, \n 3.salary \t 4. tax_to_date\n");
int i;
for(i = 0; i < 3; i++){
data[i].name = (char*) malloc(255);
scanf("%s%d%f%f", data[i].name, &data[i].employee_no, &data[i].salary, &data[i].tax_to_date);
}
for(i = 0; i < 3; i++)
printf("%s, %d, %f, %f\n", data[i].name, data[i].employee_no, data[i].salary, data[i].tax_to_date);
sort_string(data, 3);
for(i = 0; i < 3; i++)
printf("%s, %d, %f, %f\n", data[i].name, data[i].employee_no, data[i].salary, data[i].tax_to_date);
return 0;
}
int main() {
char read_in[1000000];
int preceding_matches[1000000];
int count[256];
int sorted_start_index[256];
for (int i = 0; i < 256; i++) {
count[i] = 0;
sorted_start_index[i] = -1;
}
int bwt_length = read_in_with_char_counts(read_in, count, preceding_matches);
char bwt[bwt_length + 1];
char sorted[bwt_length + 1];
char answer[bwt_length + 1];
bwt[bwt_length] = '\0';
sorted[bwt_length] = '\0';
answer[bwt_length] = '\0';
for (int i = bwt_length; i > -1; --i) {
bwt[i] = read_in[i];
}
sort_string(sorted, count, sorted_start_index);
answer[bwt_length - 1] = '$';
int pos = 0;
for (int i = 1; i < bwt_length; i++) {
answer[bwt_length - 1 - i] = bwt[pos];
unsigned char c = bwt[pos];
pos = sorted_start_index[c] + preceding_matches[pos];
}
printf("%s\n", answer);
}
void process_words(FILE *instream) {
char word[MAX_STR_LEN+1], buf[MAX_STR_LEN+1];
word_ptr wptr;
while (fscanf(instream, "%s", word) == 1 ) {
strcpy(buf, word);
if (sort_string(buf) == NULL) {
err_status = 2;
continue;
}
len_ptr ref;
int length = strlen(buf);
ref = lengthList;
while (ref != NULL) {
if (length == ref->len) {
break;
}
ref = ref->nextLength;
}
if ( (wptr = wordLookup(buf, ref)) == NULL) {
if (ref == NULL) {
//printf("New Length: %d\n", length);
len_ptr temp;
temp = newlen(length);
temp->nextLength = lengthList;
lengthList = temp;
wordInsert(word, buf, lengthList); /* start a new group */
}
else {
wordInsert(word, buf, ref);
}
}
else {
wordAppend(word, wptr); /* add to the appropriate existing group */
}
}
}
/*--------------------------------------------------------------------*/
string_t *
intersect_strings (const string_t * p_left, const string_t * p_right, Bool bSubtract)
/* !bSubtract: Intersect string <left> with string <right> and return
* a newly allocated string with all those characters which are in
* both strings.
* bSubtract: Subtract string <right> from string <left> and return
* a newly allocated string with all those characters which are in
* <left> but not in <right>.
* The order of the characters returned is their order of appearance
* in <left>.
*/
{
size_t len_left, len_right, len_out;
size_t ix_left, ix_right;
long * pos;
CBool * matches;
const char * left_txt;
char * left, * right, * result_txt;
string_t *result;
len_left = mstrsize(p_left);
len_right = mstrsize(p_right);
xallocate(matches, len_left+1, "intersection matches");
/* +1 so that smalloc won't complain when given an empty left string */
for (ix_left = 0; ix_left < len_left; ix_left++)
matches[ix_left] = bSubtract ? MY_TRUE : MY_FALSE;
/* Sort the two strings */
left = sort_string(p_left, len_left, &pos);
right = sort_string(p_right, len_right, NULL);
/* Intersect the two strings by mutual comparison.
* Each non-matched character in left gets is pos[] set to -1.
*/
len_out = bSubtract ? len_left : 0;
for ( ix_left = 0, ix_right = 0
; ix_left < len_left && ix_right < len_right
; )
{
if (left[ix_left] < right[ix_right])
ix_left++;
else if (left[ix_left] > right[ix_right])
ix_right++;
else /* left[ix_left] == right[ix_right]) */
{
if (!bSubtract)
{
matches[pos[ix_left]] = MY_TRUE;
len_out++;
}
else
{
matches[pos[ix_left]] = MY_FALSE;
len_out--;
}
ix_left++;
}
}
/* Create the result: copy all flagged characters */
memsafe(result = alloc_mstring(len_out), len_out, "intersection result");
left_txt = get_txt((string_t *const)p_left);
result_txt = get_txt(result);
for (ix_left = 0, ix_right = 0; ix_left < len_left; ix_left++)
if (matches[ix_left])
result_txt[ix_right++] = left_txt[ix_left];
/* Free intermediate results */
xfree(pos);
xfree(matches);
xfree(left);
xfree(right);
return result;
} /* intersect_strings() */
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;
}
