int globalDecl() { //za decl nebrat token
if ((error = testToken(T_ID)) != E_OK) return error; //ID
if(BSTSearch(TempTree, T.s) != NULL){
return E_SEMA;
}
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error;
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error;
/******************************************INSERT***************************************************************/
if(!(strCmpConstStr(&(T.s), "boolean"))) TempVar->type = O_BOOL;
if(!(strCmpConstStr(&(T.s), "integer"))) TempVar->type = O_INT;
if(!(strCmpConstStr(&(T.s), "real"))) TempVar->type = O_REAL;
if(!(strCmpConstStr(&(T.s), "string"))){
TempVar->type = O_STRING;
strInit(&TempVar->value.sval);
}
BSTInsert (&TempTree, IDstr, TempVar);
/******************************************INSERT***************************************************************/
gettoken();
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // ";"
gettoken();
//strFree(&IDstr);
if (testToken(T_ID) == E_OK)
if ((error = globalDecl()) != E_OK) return error; //dalsia promena?
return E_OK;
}
void GlobItemInsert(tGlobSymbolTable *T,string *nazev, int typ,Tridic *ridic, sGlobTableItem **novy){
int koren=0;
if (((*novy) = (sGlobTableItem*) malloc(sizeof(sGlobTableItem)))==NULL) error(T,OTHER_RUNN_ERR,ridic);/*alokovani mista pro novy globálni uzel*/
sGlobTableItem *pomglob;
strInit(&((*novy)->data.nazev));/*plneni uzlu*/
strCopyString(&((*novy)->data.nazev), nazev);
(*novy)->data.typ = typ;
(*novy)->lptr=NULL;
(*novy)->rptr=NULL;
(*novy)->data.def=1;
strInit(&((*novy)->arg));
//strInit(&((*novy)->hodnota->stringh));
ridic->aktivG=(*novy);
ridic->aktivG->link=NULL;
if (T->first==NULL){/*pokud je strom prazdny*/
T->first=(*novy);/*pridame novy uzel na vrchol stromu*/
}else{
pomglob=T->first;/*nastavime pomocny ukazatel na vrchol stromu*/
koren=tableSearchGlob(ridic,&pomglob,&((*novy)->data.nazev));/*projdeme strom*/
}
if (koren==1){
pomglob->lptr=(*novy);/*uzel vlozime nalevo*/
}else if (koren==2) {
pomglob->rptr=(*novy);/*uzel vlozime napravo*/
}
}
void PridatPom(sRamec *ramec, string *nazev, int typ, double cisloh, string *stringh){
int koren=0;
sRamec *novy;
while (!koren){/*dokud nezjistime kam podle nazvu novou pomocnou zaradit, tak cyklime*/
if( key(nazev, &ramec->nazev) == 2) {/*rozhodne, zda mame jit do praveho podstromu*/
if(ramec->rptr != NULL) ramec = ramec->rptr;/*kdyz neni pravy podstrom prazdny, tak opakujeme dalsi cyklus pro novy ramec*/
else {
if((novy = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL);/*kdyz je pravy podstrom prazdny, tak malokujeme novy prvek a nastavime pravy ukazatel aktualniho prvku na novy*/
strInit(&novy->nazev);
strCopyString(&(novy->nazev),nazev);
ramec->rptr = novy;
PridatHodnotu(novy, typ, cisloh, stringh); /*pomoci funkce PridatHodnotu vyplnime hodnotu prvku*/
return; /*ukoncime funkci*/
}
}
if( key(nazev, &ramec->nazev) == 1){/*rozhodne, zda mame jit do leveho podstromu*/
if(ramec->lptr != NULL) ramec = ramec->lptr; /*kdyz neni levy podstrom prazdny, tak opakujeme dalsi cyklus pro novy ramec*/
else {
if((novy = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL);/*kdyz je levy podstrom prazdny, tak malokujeme novy prvek a nastavime levy ukazatel aktualniho prvku na novy*/
strInit(&novy->nazev);
strCopyString(&(novy->nazev),nazev);
ramec->lptr = novy;
PridatHodnotu(novy, typ, cisloh, stringh); /*pomoci funkce PridatHodnotu vyplnime hodnotu prvku*/
return; /*ukoncime funkci*/
}
}
if( key(nazev, &ramec->nazev) == 0){ /*v pripade, ze se prvek shoduje, tak pouze nahradime jeho hodnotu volanim funkce PridatHodnotu*/
PridatHodnotu(ramec, typ, cisloh, stringh);
return; /*ukoncime funkci*/
}
}
}
tErrors printTape(tTape *tape) {
if(tape == NULL) return E_INTERN;
if(tape->first == NULL) return E_INTERN;
tTapeItem *iter = tape->first;
string inst;
string op1;
string op2;
string result;
if(strInit(&inst) != STR_SUCCESS) return E_INTERN;
if(strInit(&op1) != STR_SUCCESS) return E_INTERN;
if(strInit(&op2) != STR_SUCCESS) return E_INTERN;
if(strInit(&result) != STR_SUCCESS) return E_INTERN;
printf("||======================================================================||\n");
printf("||\tINST\t|\tOP1\t|\tOP2\t|\tRESULT\t||\n");
printf("||======================================================================||\n");
while(iter != NULL) {
// Line 1
strClear(&inst);
strClear(&op1);
strClear(&op2);
strClear(&result);
constructInstStringLine1(&inst, iter->instruction);
if(iter->op1 != NULL) constructOpStringLine1(&op1, iter->op1);
if(iter->op2 != NULL) constructOpStringLine1(&op2, iter->op2);
if(iter->result != NULL) constructOpStringLine1(&result, iter->result);
printf("||\t%s\t|\t%s\t|\t%s\t|\t%s\t\t||\n", inst.str, op1.str, op2.str, result.str);
// Line 2
strClear(&inst);
strClear(&op1);
strClear(&op2);
strClear(&result);
constructInstStringLine2(&inst, iter);
if(iter->op1 != NULL) constructOpStringLine2(&op1, iter->op1);
if(iter->op2 != NULL) constructOpStringLine2(&op2, iter->op2);
if(iter->result != NULL) constructOpStringLine2(&result, iter->result);
printf("||\t%s\t|\t%s\t|\t%s\t|\t%s\t\t||\n", inst.str, op1.str, op2.str, result.str);
printf("||======================================================================||\n");
iter = iter->next;
}
strFree(&inst);
strFree(&op1);
strFree(&op2);
strFree(&result);
return E_OK;
}
void VytvorRamec(sLokTableItem *koren, sRamec *novy){
if(koren != NULL){
novy->lptr = NULL; /*nastavi defaultne kazdemu novemu prvku ukazatele na NULL*/
novy->rptr = NULL;
sRamec *pom;/*vytvori si pomocnou promenou*/
strInit(&(novy->nazev));
strCopyString((&novy->nazev), (&koren->data.nazev));/*kopiruje informace z tabulky symbolu*/
novy->typ = koren->data.typ;
novy->hodnota.def = 0; /*nastavi definovanost prvku na 0 (tzn. neobsahuje hodnotu)*/
novy->hodnota.porarg = koren->poradi_argumentu;
if(koren->lptr != NULL){ /*kdyz ma ukazatel na levy podstrom, tak:*/
if((pom = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL); /*malokuje misto pro novy prvek ramce*/
novy->lptr = pom; /*a aktualnimu prvku nastavi ukazatel na novy levy podstrom*/
VytvorRamec(koren->lptr, novy->lptr); /*a dale rekurzivne vola funkci VytvorRamec*/
} else novy->lptr = NULL; /*kdyz nema levy podstrom, pta se na pravy podstrom u ktereho postupuje obdobne jako u leveho*/
if(koren->rptr != NULL){
if((pom = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL);
novy->rptr = pom;
VytvorRamec(koren->rptr, novy->rptr);
} else novy->rptr = NULL;
} /*v pripade, ze nema ani jeden podstrom, tak se funkce ukonci a vraci se do rekurzivni funkce, v ktere byla predtim volana*/
}
void GlobTableInit(tGlobSymbolTable *T,Tridic *ridic)/*inicializace globalni tabilky*/
{
string pom;
sGlobTableItem *novy;
Rfirst=NULL;/* zasobnik ramcu je prazdny*/
T->first = NULL;/*globalni tabulka je prazdna*/
ridic->aktiv= NULL;/*ukazatel na aktivni uzel globalni tabulky*/
ridic->pomlog = 0;/*pomocna promenna*/
ridic->pocet_argumentu=0;/*pocet argumentu fce je nula*/
ridic->deklaration=0;/*pomocna promenna pro definici funkci*/
strInit(&pom);
strAddStr(&pom,"length");
GlobItemInsert(T,&pom,FUNCTION_HEADER,ridic,&novy);
strAddStr(&(novy->arg),"si");
strClear(&pom);
strAddStr(&pom,"copy");
GlobItemInsert(T,&pom,FUNCTION_HEADER,ridic,&novy);
strAddStr(&(novy->arg),"siis");
strClear(&pom);
strAddStr(&pom,"find");
GlobItemInsert(T,&pom,FUNCTION_HEADER,ridic,&novy);
strAddStr(&(novy->arg),"ssi");
strClear(&pom);
strAddStr(&pom,"sort");
GlobItemInsert(T,&pom,FUNCTION_HEADER,ridic,&novy);
strAddStr(&(novy->arg),"ss");
}
void ungetToken(tToken* token) {
if (token == NULL) {
return;
}
if (!TQueue) {
TQInit();
}
tToken newTok = (tToken)malloc(sizeof(struct stToken));
tTokenQueueElem elm = (tTokenQueueElem)malloc(sizeof(struct tTQelem));
if (!newTok || !elm) {
FatalError(99, ERR_MESSAGES[ERR_ALLOC]);
}
newTok->typ = (*token)->typ;
if ((*token)->typ == TYPE_IDENTIFICATOR || (*token)->typ == TYPE_STRING) {
strInit(&newTok->value.stringVal);
strCopyString(&newTok->value.stringVal, &(*token)->value.stringVal);
}
else {
newTok->value = (*token)->value;
}
freeTokenMem(token);
elm->token = newTok;
elm->rptr = elm->lptr= NULL;
if (!TQueue->First) {//ve fronte nikdo neni
TQueue->First = TQueue->Last = elm;
}
else {//nekdo ceka
TQueue->Last->rptr = elm;
elm->lptr = TQueue->Last;
TQueue->Last = elm;
}
}
void TQDequeue(tToken* token) {
if (token == NULL) {
return;
}
if (!TQueue || !TQueue->First) {//neexistuje fronta nebo je prazdna
token = NULL;
return;
}
(*token) = (tToken)malloc(sizeof(struct stToken));
(*token)->typ = TQueue->First->token->typ;
if ((*token)->typ == TYPE_IDENTIFICATOR || (*token)->typ == TYPE_STRING) {
strInit(&(*token)->value.stringVal);
strCopyString(&(*token)->value.stringVal, &TQueue->First->token->value.stringVal);
}
else {
(*token)->value = TQueue->First->token->value;
}
//navazu odkazy
tTokenQueueElem elm = TQueue->First;
if (TQueue->First == TQueue->Last) {//toto byl posledni prvek fronty
TQueue->First = TQueue->Last = NULL;
freeTokenQueue();
}
else {
TQueue->First = elm->rptr;
TQueue->First->lptr = NULL;
}
//uvolnime po sobe pamet
freeTokenMem(&elm->token);
free(elm);
}
int init_scanner(char *filename)
{
if (filename != NULL)
{
if ((in = fopen(filename, "r")) == NULL)
{
fprintf(stderr, "Input file '%s' cannot be open!\n", filename);
return EOF;
}
}
else
{
in = stdin;
}
buffer = &buff_struct;
if (!strInit(buffer))
{
fprintf(stderr, "Malloc error.\n");
return ERR_INTERPRET;
}
else
{
return OK;
}
}
int params() {
int enumerator;
if ((error = testToken(T_ID)) != E_OK) return error; // "ID_parametru" - mozna specifikovat
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error; // ":"
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error;
if(!(strCmpConstStr(&(T.s), "boolean"))) enumerator = O_BOOL;
else if(!(strCmpConstStr(&(T.s), "integer"))) enumerator = O_INT;
else if(!(strCmpConstStr(&(T.s), "real"))) enumerator = O_REAL;
else if(!(strCmpConstStr(&(T.s), "string"))) enumerator = O_STRING;
else return E_SEMA;
gettoken();
pc++;
if(strCmpstring(&IDstr, &ActFun) == 0) return E_SEMA; //ADDED
if (searchParam(paramlist, &IDstr) != NULL) return E_SEMA;
if ((error = insertParam(paramlist,&IDstr, enumerator)) != E_OK) return error;;
//strFree(&IDstr);
if (testToken(T_SEMICOLON) == E_OK) {
gettoken();
if((error = params()) != E_OK) return error; //vice parametru - rekurze
}
return E_OK;
}
void PridatHodnotu(sRamec *ramec, int typ, double cisloh, string *stringh){
ramec->typ = typ; /*priradi prvku v ramci typ*/
if(typ == TP_STRING) { /*kdyz je typ string, tak preda retezec*/
strInit(&ramec->hodnota.stringh);/*kdyz je bool, int, nebo real, tak pouze priradi double*/
strCopyString(&(ramec->hodnota.stringh),stringh);/*nastavi definovanost prvku na 1*/
}
else {
ramec->hodnota.cisloh = cisloh;
}
ramec->hodnota.def = 1;
return;
}
/**
* @info Fce ziska vstup od uzivatele
* @param E_CODE - odkaz na chybovy kod
* @return tSymbolData - nacteny retezec
*/
E_CODE input (tSymbolData *dest)
{
int c;
tString save;
E_CODE err = strInit(&save);
while ((c = fgetc(stdin)) != EOF && c != '\n' && err == ERROR_OK)
err = strAdd(&save, (char) c);
dest->type = DT_STRING;
dest->data.sData = save;
return err;
}
string substr(string s, int i, int n)
{
string temp;
if (strInit(&temp) != E_SUCCESS)
return temp;
for (int j = i; j < n; j++)
if (strAppend(&temp, s.str[j]) != E_SUCCESS)
return temp;
return temp;
}
string* tabSymListCreateTmpSymbol(tTabSymListElemPtr generateFor, tTabSym* locTable) {
char buffer[BUFFER_SIZE];
int flag;
unsigned int index=0;
if(locTable==NULL) return NULL; //chyba
unsigned int* chooseCounter;
//vybereme counter
if(generateFor==NULL){
chooseCounter=&locTable->tmpCounter;
}else{
chooseCounter=&generateFor->table->tmpCounter;
}
if(sumCounters(generateFor, &index)==0){
//chyba overflow
return NULL;
}
//zkontrolujeme overflow
if (locTable->tmpCounter > UINT_MAX - index){
//chyba overflow
return 0;
}
index+=locTable->tmpCounter;
//Notice that only when this returned value is non-negative and less than n, the string has been completely written.
flag = snprintf(buffer, BUFFER_SIZE, "%u", index);//vytvoreni nazvu docasne promenne
if (flag < 0 || flag >= BUFFER_SIZE) {
//chyba pri vytvareni nazvu
return NULL;
}
string* newString = malloc(sizeof(string));
if (newString == NULL) {
//chyba pri alokaci
return NULL;
}
if(strInit(newString)){
free(newString);
return NULL;
}
if(strConConstString(newString, buffer)){
strFree(newString);
free(newString);
return NULL;
}
//zvysime counter u tabulky symbolu
(*chooseCounter)++;
return newString;
}
int localDecl() { //za decl nebrat token
if ((error = testToken(T_ID)) != E_OK) return error; //ID
if (searchParam(paramlist, &(T.s)) != NULL){ //zde budu muset nejspis dat jen jmenu aktualni fkce
return E_SEMA;
}
if(strCmpstring(&(T.s), &ActFun) == 0){ //ADDED
return E_SEMA;
}
if(BSTSearch (TempTreeL, T.s) != NULL){
return E_SEMA;
}
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error;
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error; // typ
/******************************************INSERT***************************************************************/
if(!(strCmpConstStr(&(T.s), "boolean"))) TempVar->type = O_BOOL;
if(!(strCmpConstStr(&(T.s), "integer"))) TempVar->type = O_INT;
if(!(strCmpConstStr(&(T.s), "real"))) TempVar->type = O_REAL;
if(!(strCmpConstStr(&(T.s), "string"))){
TempVar->type = O_STRING;
strInit(&TempVar->value.sval);
}
BSTInsert (&TempTreeL, IDstr, TempVar);
/******************************************INSERT***************************************************************/
gettoken();
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // ";"
gettoken();
//strFree(&IDstr);
if (testToken(T_ID) == E_OK)
if ((error = localDecl()) != E_OK) return error; //dalsia promena?
return E_OK;
}
/**
* @info Vytvori strukturu a prida do ni *char z parametru
* @param char* - pole znaku, nad kterym vytvorime novou strukturu string
* @return tString - Struktura s polem a jeho rozmery
*/
tString strCreate (const char *array)
{
tString str = {NULL, 0, 0};
if (strInit(&str) == ERROR_COMPILATOR)
return str;
int i = 0;
while (array[i] != '\0')
if (strAdd(&str, array[i++]) == ERROR_COMPILATOR) {
strFree(&str);
return str;
}
return str;
}
string concat(string s1, string s2)
{
string temp;
if (strInit(&temp) != E_SUCCESS)
return temp;
if (strCopy(&s1, &temp) != E_SUCCESS)
return temp;
for (int i = 0, j = length(temp); i < length(s2); i++, j++)
if (strAppend(&temp, s2.str[j]) != E_SUCCESS)
return temp;
return temp;
}
int main() {
TTable mujTable;
table = &mujTable;
tableInit(table);
tableInsertFunction(table, strCreateString("fce"));
functionInsertVar(table->lastAddedFunc, strCreateString("x"));
functionInsertVar(table->lastAddedFunc, strCreateString("y"));
functionInsertVar(table->lastAddedFunc, strCreateString("z"));
printf("\nJedna funkce: \n");
tablePrintOrder(*table);
printf("\n----------------------------\n");
//tiskniPrecTab();
FILE *f = fopen("testy/test-expr2.txt","r");
setSourceFile(f);
strInit(&attr);
listInit(&table->lastAddedFunc->tmpVar);
int err = EOK;
TVar *x = NULL;
int test = 1;
token = 1;
while(token != END_OF_FILE) {
token = getNextToken(&attr);
x = NULL;
err = parseExpression(table, &x);
printf("Test %d skoncil s chybou: %d a vysledkem: %d \n", test,err, (int)x);
test++;
while (token != END_OF_FILE && token != L_SEMICOLON) {
token = getNextToken(&attr);
}
}
tiskniList(&table->lastAddedFunc->instructions);
listDataDelete(&table->lastAddedFunc->tmpVar);
listDispose(&table->lastAddedFunc->tmpVar);
fclose(f);
tableClear(table);
strFree(&attr);
return EXIT_SUCCESS;
}
/*
* @depractated
* @bug this whole function is one big bug, do not use
*/
int unescapeStr(string* s) {
string ret;
//string help;
//strInit(&help);
strInit(&ret);
int i = 0;
while (s->str[i++]!='\0') {
if (s->str[i] == '\\') {
i++;
}
else {
if (strAddChar(&ret, s->str[i])) {
strFree(s);
FatalError(99, ERR_MESSAGES[ERR_ALLOC]);
}
}
}
return 1;
}
int mara()
{
string stri;
int type;
double num;
int error;
type=-1;
//*num=0;
//*line=1;
FILE *soubor;
//stri=malloc(sizeof(string));
printf("*******************\n");
soubor = fopen(TEXT, "r");
while (type != 3)
{
if ((strInit(&stri))==1)
{
printf("nepovedlo se vytvořit řetězec\n");
}
//int get_token(FILE *F, double *num, int *line, string *stri, int *error )
type=get_token(soubor,&num,&stri,&error);
printf("\nJe to typ: %i\n",type);
printf("Charnum je: %f a radek je:%i\n",num,line);
printf("String je: %s\n",strGetStr(&stri));
printf("**************************************\n");
strFree(&stri);
}
fclose(soubor);
}
string* tabSymCreateTmpSymbol(tTabSym* table) {
char buffer[BUFFER_SIZE];
int flag;
//Notice that only when this returned value is non-negative and less than n, the string has been completely written.
flag = snprintf(buffer, BUFFER_SIZE, "%u", table->tmpCounter++);//vytvoreni nazvu docasne promenne
if (flag < 0 || flag >= BUFFER_SIZE) {
//chyba pri vytvareni nazvu
return NULL;
}
string* newString = (string*)malloc(sizeof(string));
if (newString == NULL) {
//chyba pri alokaci
return NULL;
}
if(strInit(newString)){
return NULL;
}
strCmpConstStr(newString, buffer);
return newString;
}
string copy(string *str, int i, int j) //Funkce vrací podřetězec z řetězce str od i o délce j.
{
string strback; //Pomocná proměnná typu string.
int p; //Řídící proměnná for cyklu.
if (i < 1) //Pokud je i menší než 1, přiřadíme mu hodnotu 1, aby jsme nepřistupovali mimo string.
{
i=1;
}
if ((i+j-1) > str->length) //Pokud je j větší než délka řetězce, upravíme jej, aby jsme nekopírovali prvky za rozsahem stringu.
{
j=str->length-i+1;
}
strInit(&strback); //Inicializace stringu.
for (p = 0; p < j; p++) //For cyklus o j opakováních.
{
strAddChar(&strback,str->str[i+p-1]); //Jednotlivé znaky přidáváme do strback.
}
return strback; //Vracíme string.
}
void VytvorRamecGlob(sGlobTableItem *koren, sRamec *novy){
if(koren != NULL){/*postup je zde obdobny, jako u funkce VytvorRamec pro lokalni tabulky symbolu, ktera se nachazi nad touto funkci*/
novy->lptr = NULL;
novy->rptr = NULL;
sRamec *pom;
strInit(&(novy->nazev));
strCopyString((&novy->nazev), (&koren->data.nazev));
novy->typ = koren->data.typ;
novy->hodnota.def = 0;
novy->hodnota.porarg = 0;
if(koren->lptr != NULL){
if((pom = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL);
novy->lptr = pom;
VytvorRamecGlob(koren->lptr, novy->lptr);
} else novy->lptr = NULL;
if(koren->rptr != NULL){
if((pom = (sRamec*) malloc(sizeof(sRamec)))==NULL) error(NULL,OTHER_RUNN_ERR,NULL);
novy->rptr = pom;
VytvorRamecGlob(koren->rptr, novy->rptr);
} else novy->rptr = NULL;
}
}
void stInitLibFunctions(SYMBOL_TABLE_PTR st){
STRING id;
strInit(&id);
strInitRaw(&id, "boolval");
stInsertFunction(st, id);
strInitRaw(&id, "doubleval");
stInsertFunction(st, id);
strInitRaw(&id, "intval");
stInsertFunction(st, id);
strInitRaw(&id, "strval");
stInsertFunction(st, id);
strInitRaw(&id, "get_string");
stInsertFunction(st, id);
strInitRaw(&id, "put_string");
stInsertFunction(st, id);
strInitRaw(&id, "strlen");
stInsertFunction(st, id);
strInitRaw(&id, "get_substring");
stInsertFunction(st, id);
strInitRaw(&id, "find_string");
stInsertFunction(st, id);
strInitRaw(&id, "sort_string");
stInsertFunction(st, id);
}
int LokTableInsert(tGlobSymbolTable *T, string *nazev, int typ,Tridic *ridic){/*vlození noveho uzlu do lok table*/
sLokTableItem *novy;
sLokTableItem *pomloka;
int koren=0;
if ((novy = (sLokTableItem*) malloc(sizeof(sLokTableItem)))==NULL) error(T,OTHER_RUNN_ERR,ridic);/*alokace mista na novy lokalni prvek*/
ridic->aktiv=novy;/*nastaveni aktivity na novy prvek*/
novy->data.def=1;/*plneni prvku*/
strInit(&(novy->data.nazev));
novy->data.typ=typ;
novy->lptr=NULL;
novy->rptr=NULL;
if ( ridic->pomlog || ridic->deklaration){/*pokud se jedna o hlavicku fce*/
ridic->pocet_argumentu++;
novy->data.def=1;/*argument je inicialyzovany*/
novy->poradi_argumentu=ridic->pocet_argumentu;/*poradí argumentu*/
}else {
novy->data.def=0;/*lokalni promenna neni inicializovana*/
novy->poradi_argumentu=0;/*nejedna se o argument funkce*/
}
if (nazev!=NULL){/*pokud se nejedna o navratovy typ*/
strCopyString((&novy->data.nazev), nazev);/*naplnim nazev*/
}else {
strCopyString((&novy->data.nazev), &(ridic->nazev_func));/*jinak ziskam nazev z globalni tabulky z aktualniho prvku*/
novy->data.def=3;
}
sGlobTableItem *pomgl;
koren=0;
pomgl = T->first;/*nastavime koren stromu*/
koren= tableSearchGlob(ridic,&pomgl,&(novy->data.nazev));/*prohledame glob tabulku kvuli shodnym nazvum fci*/
if (koren==0 && nazev!=NULL){/*pokud byl prvek nalezen a lok promenna neni navratovy typ*/
if (pomgl->data.typ==FUNCTION_HEADER){/*pokud byla nalezena glob uzel ktery je funkce*/
ItemFreeAktu(NULL, novy);/*uvolni pridavany prvek*/
error(T,TAB_ERR,ridic);/*chyba v ramci tabulky*/
}
}
if (ridic->deklaration>0){/*pokud jsme v hlavicce funkce*/
sLokTableItem *poml;
sGlobTableItem *pomgl;
pomgl = ridic->aktivG;/*jako pomocný glob uzel nastavime aktivni glob uzel*/
poml=pomgl->link;/*jako pomocnou lok. tabulku nastavime odkaz z aktivniho glob uzlu*/
koren=0;
koren=tableSearchLok(ridic,&poml,&(novy->data.nazev));
if (koren){
ItemFreeAktu(NULL, novy);/*uvolnime pridávany prvek*/
error(T,TAB_ERR,ridic);/*chyba v ramci tabulky*/
}
ridic->deklaration++;/*kontrola poctu argumentu*/
if (ridic->deklaration==strGetLength(&(pomgl->arg))+1) {ridic->deklaration=0;}/*pocet prvku deklrovane a definovane funkce je jiny*/
if (poml->data.typ==typ){/*pokud sedi typ argumentu deklarovane a definovane funkce*/
if (poml->poradi_argumentu==novy->poradi_argumentu){/*pokud je na stejnem miste*/
if (nazev!=NULL){/*pokud se nejedna o navratovy parametr*/
if ((strCmpString(&(poml->data.nazev), nazev)==0)) {/*pokud sedi nazvy*/
ItemFreeAktu(NULL, novy);/*uvolnime vkladany argument*/
return 1;/*agrumnet je totozny*/
}else {
ItemFreeAktu(NULL, novy);/*uvolnime vkladany argument*/
error(T,TAB_ERR,ridic);/*error v ramci tabulky*/
}
}else{/*pokud se jedna o navratovy parametr*/
if (ridic->deklaration==strGetLength(&(ridic->aktivG->arg))) {/*pokud neni stejny pocet argumentu*/
ItemFreeAktu(NULL, novy);/*uvolnime vkladany argument*/
error(T,TAB_ERR,ridic);/*error v ramci tabulky*/
}
ridic->aktivG=pomgl;/*uvolnime vkládaný argument*/
ItemFreeAktu(NULL,novy);/*error v ramci tabulky*/
return 1;/*agrumnet je totozny*/
}
}else {/*nejedna se o stejny typ*/
ItemFreeAktu(NULL, novy);/*uvolníme vkladany argument*/
error(T,TAB_ERR,ridic);/*error v ramci tabulky*/
}
}
}
else{/*pokud pridavame lokalni promennou*/
if (ridic->aktivG->link==NULL){/*pokud je strom prazdny*/
ridic->aktivG->link=novy;/*pridame jako koren*/
}else{
pomloka=ridic->aktivG->link;
koren=0;
koren=tableSearchLok(ridic,&pomloka,&(novy->data.nazev));
if (koren==0){/*pokud j*z prvek se stejnym klicem existuje*/
ItemFreeAktu(NULL, novy);/*uvolnime vkladany argument*/
error(T,TAB_ERR,ridic);/*error v ramci tabulky*/
}
if (koren==1){/*pridame do leveho podstromu*/
pomloka->lptr=novy;
}else if (koren==2) {pomloka->rptr=novy;}/*pridáme do praveho podstromu*/
}
if ( (ridic->pomlog ) || (nazev==NULL) ){/*pokud jsme v hlavicce funkce*/
switch(typ){/*pridame typ argumnetu do glob tabulky*/
case TP_INT:
if (strAddChar(&(ridic->aktivG->arg),'i'));
break;
case TP_REAL:
if (strAddChar(&(ridic->aktivG->arg),'r'));
break;
case TP_STRING:
if (strAddChar(&(ridic->aktivG->arg),'s'));
break;
case BOOLEAN:
if (strAddChar(&(ridic->aktivG->arg),'b'));
break;
}
}
if (nazev==NULL) {/*pokud uz byl predan i navratovy typ*/
ridic->pocet_argumentu=0; /*nasleduji lok promenne*/
ridic->pomlog=0;/*nejsme j*z v hlavicce funkce*/
}
return 1;
}
return 0;
}
//################### HLEDANI A ZPRACOVANI FUNKCE #######################
tErrors SearchFun()
{
tFunListItem *FunPtr; // ukazatel na prvek seznamu funkce
tVariable *pTree; // ukazatel na strukturu tVariable
tParamItem *param; // ukazatel na parametr
tErrors er; // promenna typu tErrors pro ulozeni vysledneho error kodu
tExpType type; // typ prvku na zasobniku
tVariable *temp;
tVariable *temp2;
tParamList *parameterList;
int param_counter = 0;
int param_number = 0;
parameterList = allocate(sizeof(tParamList));
initParamlist(parameterList);
FunPtr = searchFunList(&(T.s)); // pokud najdes funkci v seznamu funkci
param_number = FunPtr->param_count; // ulozeni - pocet parametru funkce do param
param = FunPtr->param_list->first; // ulozeni ukazatele na prvni prvek v seznamu parametru funkci
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
if (type != LB) // pokud nenasleduje leva zavorka, E_SYN
return E_SYN;
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
//printf("P: %d T.TYPE: %d\n",param_number,T.type);
if ((param_number == 0) && (T.type != T_RB))
return E_SEMB;
while((type != RB) && ((strCmpConstStr (&(T.s), "end")!=0) && (T.type != T_SEMICOLON))) // ber novy token dokud neprojdes vsechny parametry funkce
{ //printf("JSEM ve WHILE\n");
//printf("TOKEN 01: %s\n",T.s.str);
if (T.type == T_ID) // pokud je typ ID, vyhledej jej v BVS
{
if (insertParam(parameterList, &(T.s), T.type) != E_OK) return E_INTERN;
if ((SearchDataType(TempTree, TempTreeL)) != NULL) // pokud je token typu ID a je nalezen v BVS
{
pTree = SearchDataType(TempTree, TempTreeL); // uloz mi ukazatel na prvek do stromu
if (pTree->type != param->type) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB; // vraci E_SEMB
}
else
{ // pokud neni prvek nalezen
return E_SEMA; // vraci E_SEMA
}
}
else if (T.type == T_INT)
{
if (param->type != O_INT) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_REAL)
{
if (param->type != O_REAL) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_STRING)
{
if (param->type != O_STRING) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_KONST)
{
if (param->type != O_BOOL) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else // pokud neni parametr ID
{
return E_SYN; // vraci chybu E_SYN
}
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
param_counter++; // pocitadlo paramateru
if (((param_counter == param_number) && (type != RB)) && (type != COMMA)) // pokud neni za ID carka nebo za posledni parametrem neni prava zavorka
return E_SYN; // vrat chybu E_SYN
if (param_counter > param_number) // pokud pocitadlo parametru je vetsi jako hodnota, ktera je udana u funkce v seznamu
return E_SEMB; // vrat chybu E_SEMB
if (param->next != NULL)
param = param->next; // posunuti na dalsi parametr funkce ???????????????????????
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
}
if (param_number != param_counter)
return E_SEMB;
res = FunPtr->ret_type;
if ((temp = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
if ((temp2 = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp2->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->name = FunPtr->name;
temp->value.param_pointer = parameterList->first;
temp->type = PARAM_POINTER;
temp2->type = TAPE_POINTER;
temp2->value.tape_pointer = FunPtr->tape_ptr;
Tape->last->op1 = temp; // ulozeni ukazatele na tVariable polozku, ktera obsahuje ukazatel na funkci na pasce
Tape->last->instruction = CALL; // instrukce je funkce
Tape->last->op2 = temp2;
Tape->last->result->type = FunPtr->ret_type;
if (param_counter == 0)
gettoken();
return E_OK; // pokud to najde funkci E_OK
}
//######################## Redukce zasobniku ############################
tErrors ExpStackReduct(tExpStack *S, tTabSigns sign)
{
tExpType toptype = -1; //promenna typu tExptype a hodnotou -1 pro uchovani typu tokenu
tElemPtr TopOp; //zpracovavany OP2
tElemPtr SecTopOp; //zpracovavany OP1
tElemPtr TopIstruction; //provadena instrukce mezi OP1|OP2
tErrors er; //promenna typu tErrors
tVariable *temp;
ExpStackTop(S, &toptype); //vraci hodnotu prvniho prvku zasobniku
if (toptype == ID) //vstup=ID, pravidlo E->ID
{
S->Top->data = NONTERM; //zmena interniho typu na NONTERM podle pravidla
return E_OK;
}
if (sign == Q) //vstup = ')', pravidlo E->(E) (ale ')' nemam na zasobniku)
{
reduct =1;
if (toptype != NONTERM) //kdyz neni na vrcholu zasobnika NONTERM
return E_SYN; //vraci error E_SYN
ExpStackSecTop(S, &toptype); //vraci hodnotu druheho prvku
if (toptype != LB) //pokud je na druhem miste v zasobniku '('
return E_SYN; //vraci error E_SYN
ExpStackSecPop(S); //odstranim zavorku
return E_OK;
}
else //ostatni pravidla E->EopE (pr. E->E+E, E->E-E,...)
{
if (toptype != NONTERM) //kdyz neni na vrcholu zasobnika neterminal
return E_SYN; //vraci error E_SYN
else //kdyz je na zasobniku nonterm
{
ExpStackTopPoint (S, &TopOp); // druhy operand OP2 (prvni prvek na STACKU)
ExpStackInstructionTopPoint (S, &TopIstruction); // instrukce (druhy prvek na STACKU)
if (TopIstruction->data != DOLAR)
{
ExpStackSecTopPoint (S, &SecTopOp); // prvni operand OP1 (treti prvek na STACKU)
reduct =1;
//printf("OP2: %d OP1:%d \n",TopOp->tempVarPtr->type,SecTopOp->tempVarPtr->type);
er = ExpParserSem(&(TopOp->tempVarPtr->type),&(SecTopOp->tempVarPtr->type),&(TopIstruction->instruction)); // aplikuju semanticka pravidla
if (er == E_SEMB) //pokud je semantika vyrazu nespravana
{
return er; //koncim s chybou
}
Tape->last->op2 = S->Top->tempVarPtr;
ExpStackPop(S);
}
else
{
if (flag == FALSE)
{
// printf("OP2: %d INST:%d \n",TopOp->tempVarPtr->type,TopIstruction->data);
if (TopOp->tempVarPtr->type != O_BOOL)
return E_SEMB;
if (reduct != 1)
{
Tape->last->op1 = S->Top->tempVarPtr;
if ((temp = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->value.bval = TRUE;
temp->valFull = DATA;
temp->type = O_BOOL;
Tape->last->instruction = MORE;
Tape->last->op2 = temp;
er = InsertEmptyItemTape(); //vkladam novy prazdny prvek na pasku
if (er == E_INTERN)
return er;
}
ExpStackPop(S);
return E_OK;
}
else
{
if (reduct != 1)
{
Tape->last->instruction = NOP;
Tape->last->result = S->Top->tempVarPtr;
res = S->Top->tempVarPtr->type;
er = InsertEmptyItemTape(); //vkladam novy prazdny prvek na pasku
if (er == E_INTERN)
return er;
}
ExpStackPop(S);
return E_OK;
}
}
}
ExpStackTop(S, &toptype); //vraci hodnotu prvniho prvku
if (toptype == NONTERM) //kdyz je na vrcholu zasobnika neterminal
return E_SYN; //vraci error E_SYN
else //pokud tam neni neterminal
{
Tape->last->instruction = S->Top->instruction;
ExpStackPop (S); //odstranim dany operand
}
ExpStackTop(S, &toptype); //vraci hodnotu prvniho prvku
if (toptype != NONTERM) //kdyz neni na vrcholu zasobnika neterminal
return E_SYN; //vraci error E_SYN
else
{
Tape->last->op1 = S->Top->tempVarPtr;
ExpStackPop (S); //odstranim dany operand
}
ExpStackPush(S, NONTERM, NULL); //vlozim zpatky na zasobnik novy neterminal
Tape->last->result = S->Top->tempVarPtr; // ukladam vysledek OP1 a OP2 do result na pasku
//printf("exp adreasa resultu v expe : %d \n",S->Top->tempVarPtr);
er = InsertEmptyItemTape(); //vkladam novy prazdny prvek na pasku
if (er == E_INTERN)
return er;
}
return E_OK; //koncim s redukci -> vse OK
}
//############### Vlozeni prvku na zacatek zasobniku ####################
tErrors ExpStackPush (tExpStack *L, tExpType val, tVariable *item)
{
tElemPtr temp; //nova promenna typu tElemPtr
if ((temp = malloc(sizeof(struct tElem))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if ((val == LB) || (val == RB) || (val == DOLAR)) //kdyz davam na zasobnik '(' nebo ')' nebo '$'
{
temp->data = val; //do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; //ukazatel bud ukazovat na vrchol zasobniku
L->Top = temp; //ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
else if (val == NONTERM) //kdyz davam na zasobnik neterminal
{
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = res;
temp->data = val; //do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; //ukazatel bud ukazovat na vrchol zasobniku
L->Top = temp; //ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
else
{
switch(T.type)
{ //###################### INSTRUKCE ###################
case T_ADD : temp->instruction = ADD; break;
case T_SUB : temp->instruction = SUB; break;
case T_MUL : temp->instruction = MUL; break;
case T_DIV : temp->instruction = DIV; break;
case T_LESS : temp->instruction = LESS; break;
case T_MORE : temp->instruction = MORE; break;
case T_LESS_EQ : temp->instruction = EQL; break;
case T_MORE_EQ : temp->instruction = EQM; break;
case T_NOT_EQ : temp->instruction = NEQ; break;
case T_EQUAL : temp->instruction = EQ; break;
//####################### OPERANDY ####################
case T_INT : // push na stack token typu INT, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_INT; //operand typu O_INT
temp->tempVarPtr->value.ival = strtol(T.s.str,NULL, 10);
break;
case T_REAL : // push na stack token typu REAL, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_REAL; //operand typu O_REAL
temp->tempVarPtr->value.rval = strtod(T.s.str, NULL);
break;
case T_STRING : // push na stack token typu STRING, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_STRING;
if (strInit(&(temp->tempVarPtr->value.sval)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
if (strCopystring(&(temp->tempVarPtr->value.sval), &(T.s)) == STR_ERROR)
return E_INTERN;
break;
case T_KONST : // push na stack token typu KONST - BOOL, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu //konstanty ukladam jako true nebo false
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_BOOL; //operand typu O_BOOL - boolean
if (!strCmpConstStr(&(T.s), "true")) //pokud hodnota tokenu true
temp->tempVarPtr->value.bval = true; // uloz hodnotu operandu jako true
else if (!strCmpConstStr(&(T.s), "false")) //pokud hodnota tokenu je false
temp->tempVarPtr->value.bval = false; //uloz hodnotu operandu jako false
else
return E_SYN; //vraci error E_SYN
break;
default : break;
}
}
temp->data = val; // do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; // ukazatel bud ukazovat na vrchol zasobniku
if(T.type == T_ID) // pokud typ tokenu je ID (nejaka promenna)
{
temp->tempVarPtr = item; // uloz mi ukazatel na promennou do stromu LBVS/GBVS
temp->tempVarPtr->valFull = NODATA;
}
L->Top = temp; // ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
/* globally initialze the runtime system
* NOTE: this is NOT thread safe and must not be called concurrently. If that
* ever poses a problem, we may use proper mutex calls - not considered needed yet.
* If ppErrObj is provided, it receives a char pointer to the name of the object that
* caused the problem (if one occured). The caller must never free this pointer. If
* ppErrObj is NULL, no such information will be provided. pObjIF is the pointer to
* the "obj" object interface, which may be used to query any other rsyslog objects.
* rgerhards, 2008-04-16
*/
rsRetVal
rsrtInit(char **ppErrObj, obj_if_t *pObjIF)
{
DEFiRet;
if(iRefCount == 0) {
/* init runtime only if not yet done */
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
CHKiRet(pthread_getschedparam(pthread_self(),
&default_thr_sched_policy,
&default_sched_param));
CHKiRet(pthread_attr_init(&default_thread_attr));
CHKiRet(pthread_attr_setschedpolicy(&default_thread_attr,
default_thr_sched_policy));
CHKiRet(pthread_attr_setschedparam(&default_thread_attr,
&default_sched_param));
CHKiRet(pthread_attr_setinheritsched(&default_thread_attr,
PTHREAD_EXPLICIT_SCHED));
#endif
if(ppErrObj != NULL) *ppErrObj = "obj";
CHKiRet(objClassInit(NULL)); /* *THIS* *MUST* always be the first class initilizer being called! */
CHKiRet(objGetObjInterface(pObjIF)); /* this provides the root pointer for all other queries */
/* initialize core classes. We must be very careful with the order of events. Some
* classes use others and if we do not initialize them in the right order, we may end
* up with an invalid call. The most important thing that can happen is that an error
* is detected and needs to be logged, wich in turn requires a broader number of classes
* to be available. The solution is that we take care in the order of calls AND use a
* class immediately after it is initialized. And, of course, we load those classes
* first that we use ourselfs... -- rgerhards, 2008-03-07
*/
if(ppErrObj != NULL) *ppErrObj = "statsobj";
CHKiRet(statsobjClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "prop";
CHKiRet(propClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "glbl";
CHKiRet(glblClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "msg";
CHKiRet(msgClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "ruleset";
CHKiRet(rulesetClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "wti";
CHKiRet(wtiClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "wtp";
CHKiRet(wtpClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "queue";
CHKiRet(qqueueClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "conf";
CHKiRet(confClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "parser";
CHKiRet(parserClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "strgen";
CHKiRet(strgenClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "rsconf";
CHKiRet(rsconfClassInit(NULL));
if(ppErrObj != NULL) *ppErrObj = "lookup";
CHKiRet(lookupClassInit());
/* dummy "classes" */
if(ppErrObj != NULL) *ppErrObj = "str";
CHKiRet(strInit());
}
++iRefCount;
dbgprintf("rsyslog runtime initialized, version %s, current users %d\n", VERSION, iRefCount);
finalize_it:
RETiRet;
}
int main() {
//obsah souboru nas zajimat nebude
FILE* f = fopen("test-1.txt", "r");
tToken t;
printDescription("Do fronty tlacim bool = true");
t = malloc(sizeof(struct stToken));
t->typ = TYPE_BOOL;
t->value.boolVal = true;
ungetToken(&t);
printDescription("Zkusim zavolat scanner ocekavam bool = true");
getToken(&t, f);
if (t->typ == TYPE_BOOL && t->value.boolVal) {
printDescription("TEST OK");
}
else {
printDescription("TEST FAILED");
}
freeTokenMem(t);
printDescription("Od ted testuji jen pomoci fce void TQDequeue(tToken*);");
printDescription("protoze jestli se vola skrz scanner j*z vime");
printDescription("Do fronty tlacim int = 42");
t = malloc(sizeof(struct stToken));
t->typ = TYPE_INTEGER;
t->value.intVal = 42;
ungetToken(&t);
printDescription("Do fronty tlacim KEYW_RETURN");
t = malloc(sizeof(struct stToken));
t->typ = KEYW_RETURN;
ungetToken(&t);
printDescription("Ocekavam int = 42 fronta by nemela byt deinicializovana");
TQDequeue(&t);
if (t->typ == TYPE_INTEGER && t->value.intVal == 42 && TQueue) {
printDescription("TEST OK");
}
else {
printDescription("TEST FAILED");
}
freeTokenMem(t);
printDescription("Ocekavam return keyword fronta by mela byt deinicializovana");
TQDequeue(&t);
if (t->typ == KEYW_RETURN && !TQueue) {
printDescription("TEST OK");
}
else {
printDescription("TEST FAILED");
}
freeTokenMem(t);
printDescription("Do fronty tlacim string = 'HuaHuaString'");
t = malloc(sizeof(struct stToken));
t->typ = TYPE_STRING;
strInit(&t->value.stringVal);
strConConstString(&t->value.stringVal, "HuaHuaString");
ungetToken(&t);
printDescription("Ocekavam string = 'HuaHuaString' fronta by mela byt deinicializovana");
string s;
strInit(&s);
strConConstString(&s, "HuaHuaString");
TQDequeue(&t);
if (t->typ == TYPE_STRING && !strCmpString(&t->value.stringVal, &s) && !TQueue) {
printDescription("TEST OK");
}
else {
printDescription("TEST FAILED");
}
strFree(&s);
freeTokenMem(t);
printDescription("Zavolam void freeTokenMem(tToken); nad NULL");
printDescription("Nemela by nastat chyba");
printDescription("Test zrusen je to blbost");
//freeTokenMem(t);
printDescription("Mam deinicializovanou frontu zkusim z ni neco vytahnout");
printDescription("behem programu nebude volano, ale pro jistotu");
TQDequeue(&t);
if (!TQueue/* && !t*/) {
printDescription("TEST OK");
}
else {
printDescription("TEST FAILED");
}
//freeTokenMem(t);//pro jistotu
getchar();
fclose(f);
return 0;
}
