InstallWorkerThread::~InstallWorkerThread()
{
strFree(m_strPrinterName);
strFree(m_strSourceDir);
this->PeekMessagesUntilTerminate();
}
/**
* Funkce vycisti seznam do nejblizsiho navesti S_LAB.
* @param L je seznam.
*/
void hListClearToLab(tListOfCall *L)
{
if(L->last != NULL)
{
// uvolni prvni polozku protoze je vzdy S_LAB
HtItemData *item = L->last;
L->last = item->prevItem;
L->last->nextItem = NULL;
free(item);
// uvolnuj az kym neprijdes na dalsi S_LAB
while(L->last != NULL)
{
item = L->last;
// jestlize je S_LAB prerus uvolnovani jinak uvolni retezce
if(item->type == S_LAB)
return;
else
{
strFree(&item->data.varKey);
if(item->data.varType == T_STRING)
strFree(&item->data.value.sValue);
}
// posun prvky seznamu
L->last = item->prevItem;
L->last->nextItem = NULL;
free(item);
}
}
}
int main (int argc, char *argv[])
{
if (argc != 3) {
printf("Really? Even in test?\n");
return 1;
}
mmuInit();
tString text = strCreate(argv[1]);
tString search = strCreate(argv[2]);
printf("Text: %s\n"
"Text len: %u\n", text.data, text.len);
printf("Hledany string: %s\n"
"Hledany len: %u\n", search.data, search.len);
int position = kmpSearch(text, search);
printf("Pozice je: %d\n", position);
strFree(&text);
strFree(&search);
mmuGlobalFree();
return 0;
}
/**
* Funkce uvolni seznam.
* @param L je seznam/
*/
void hListDispose(tListOfCall *L)
{
// ak je seznam prazdny
if(L->first !=NULL)
{
HtItemData *item;
// projdi seznamem kym neni NULL
while(L->first != NULL)
{
item = L->first;
L->first = item->nextItem;
// ak je prvek seznamu promenna data tak uvolni retezce v data
if(item->type == S_VAR)
{
strFree(&item->data.varKey);
if(item->data.varType == T_STRING)
strFree(&item->data.value.sValue);
}
// uvolni
free(item);
item = NULL;
}
}
// nastav ukazatele na NULL
L->first = NULL;
L->last = NULL;
}
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 vstring::strReflow (char * & target, strSizeType width, const char * preString, const char * postString, int align)
{
strRemoveWhiteSpace (target); // zunaechst mal alle vorhandenen CR und LF loeschen, um dann neue einzufuegen
strTrim (target);
strSizeType n = strLength (target);
char * result = 0x0000; // hierin speichern wir den ganzen neu gestalteten Absatz zwischen
if (n > width && width > 0) // nur dann was tun, wenn der ganze String nicht in eine Zeile passt
{
char * line = 0x0000; // hierin speichern wir eine einzelne Zeile zwischen
strSizeType a = 0; // Position, bis zu der bisher der absatz abgearbeitet wurde
strSizeType b = 0; // Position bis zu der die neue naechste Zeile geht
while (b < n) // Den ganzen String abarbeiten, bis alles in einzelne Zeilen aufgeteilt wurde
{
b = a + width; // zunaechst das optimale Ende der naechsten Zeile setzen
if (b < n) // Feststellen, ob der ganze reststring ueberhaupt noch aufgeteilt werden muss
{
while (b > a && target[b] != ' ') // nach vorne suchen, bis wir eine Trennstelle finden
{
b--;
}
if (b == a) // Wenn keine Trennstelle gefunden, dann muessen wir doch nach hinten suchen
{
b = a + width; // Wieder den ausgangswert setzen
while (b < n && target[b] != ' ') // und erstes leerzeichen nach hinten suchen
{
b++;
}
}
}
else
{
b = n; // Eine weitere Aufteilung ist nicht notwendig, also den ganzen reststring einfach nehmen
}
strCopy (line, target, a, b); // Kopiere jetzt die Zeile aus dem ganzen String heraus
if (!(align == 3 && b == n)) // die letze Zeile wird beim Blocksatz nicht mehr formatiert
{
strReflowLine (line, width, align); // fuege jetzt je nach ausrichtung vorne oder zwischen drin Leerzeichen ein
}
strCopy (result, result, preString); // kopiere prefix dran
strCopy (result, result, line); // kopiere nun die eigentliche Zeile an
strCopy (result, result, postString); // kopiere nun den Suffix hinten dran (das LF)
a = b + 1; // und setze nun den beginn des reststring hinter das leerzeichen, an dem wir grade getrennt haben
}
strFree (line); // und loesche die temporaeren zwiscehnspeicher
}
else
{
strCopy (result, result, preString); // kopiere prefix dran
strCopy (result, result, target); // kopiere nun die eigentliche Zeile an
strCopy (result, result, postString); // kopiere nun den Suffix hinten dran (das LF)
}
strCopy (target, result); // kopiere nun das gesamtergebnis in den uebergebenen String
strFree (result);
}
void ItemFreeAktu(sGlobTableItem *pomg,sLokTableItem *poml){/*mazani alokovaneho prvku pri chybe*/
if (pomg!=NULL){/*pokud mazu globalni prvek*/
strFree(&(pomg->data.nazev));/*smaz*/
strFree(&(pomg->arg));
free(pomg);
}else
if (poml!=NULL){/*pokud mazu lokalni prvek*/
strFree(&(poml->data.nazev));/*smaz*/
free(poml);
}
}
void
DestroyIList( ptr_IList ilist_ptr)
//pri ruseni treba kontrolovat ci polozkou instrukcie nebola retazcova konstanta
{
ptr_InstEntry next, temp = ilist_ptr->head;
while ( temp != NULL )
{
next = temp->next;
if ( temp->cont.op1type == STR_OP_TYPE )
{
if ( temp->cont.op1.str != NULL ){
strFree(temp->cont.op1.str);
free(temp->cont.op1.str);
temp->cont.op1.str = NULL;
}
}
if ( temp->cont.op2type == STR_OP_TYPE )
{
if ( temp->cont.op2.str != NULL ){
strFree(temp->cont.op2.str);
free(temp->cont.op2.str);
temp->cont.op2.str = NULL;
}
}
if ( temp->cont.op3type == STR_OP_TYPE )
{
if ( temp->cont.op3.str != NULL ){
strFree(temp->cont.op3.str);
free(temp->cont.op3.str);
temp->cont.op3.str = NULL;
}
}
free(temp) ;
temp = next;
}
InitIList( ilist_ptr );
}
String
strNConcat(String s1, String s2)
{
String s3 = strConcat(s1, s2);
strFree(s1);
return s3;
}
void vstring::strReplace (char * & target, const char * replace, const char * by)
{
char * tmptarget = 0x0000; // Zunaechst einen temporaeren Speicher deklarieren
strSizeType n = strLength (target);
strSizeType k = strLength (replace);
if (k > 0) // ist ueberhaupt ein String angegeben, nach dem gesucht werden soll ?
{
strSizeType l = strLength (by);
char strBuffer[256]; // Lege nun eine Zwischenpuffer an, der eine Feste groesse hat, und immer bei vollstaendiger Fuellung and den Zielstring angefuegt wird
strSizeType strBufferCounter = 0;
if (n > 0)
{
strSizeType i = 0, j; // Schleifenzaehler
while (i + k <= n)
{
j = 0;
while (j < k && target[i + j] == replace[j])
{
j++;
}
if (j == k) // der 'replace' string wurde gefunden, also den 'by' string in den puffer einfuegen
{
j = 0;
while (j < l)
{
// Kopiere den string Zeichen fuer Zeichen in unseren Zwischenpuffer
strBuffer[strBufferCounter++] = by[j];
if (strBufferCounter == 256 - 1)
{
strBuffer[strBufferCounter] = 0;
strCopy (tmptarget, tmptarget, strBuffer);
strBufferCounter = 0;
}
j++;
}
i += k; // dann muessen wir erst wieder hinter dem gefundenen String weiter arbeiten
}
else
{
// der 'replace' string wurde nicht gefunden , also nur den einen character in den puffer einfuegen
strBuffer[strBufferCounter++] = target[i];
if (strBufferCounter == 256 - 1)
{
strBuffer[strBufferCounter] = 0;
strCopy (tmptarget, tmptarget, strBuffer);
strBufferCounter = 0;
}
i++;
}
}
// schliesslich noch den rest des puffers an unseren target string anfuegen
strBuffer[strBufferCounter] = 0;
strCopy (tmptarget, tmptarget, strBuffer);
strBufferCounter = 0;
}
strFree (target); // Nun den Zielstring freigeben, falls er belegt war
target = tmptarget; // Nun den Zeiger einfach umsetzten. Hier muss nicht mehr kopiert werden....
tmptarget = 0x0000; // weil wir hier den temporaeren string als frei markieren, ohne den Speicher wieder freizugeben.
}
}
void vstring::strCopy (char * & target, const char * source, strSizeType startindex, strSizeType endindex)
{
char * tmptarget = 0x0000; // Zunaechst einen Temporaeren Speicher deklarieren, weil diese Routine auch arbeiten soll, wenn der SourceString identisch mit dem Target sind. Also darf dieser erst geloescht werden, wenn alles fertig kopiert ist
if (startindex >= 0 && endindex >= 0 && startindex <= endindex) // sicherstellen, dass im Falle von Ende vor Start-Index (Negative Laenge) nichts kopiert wird
{
strSizeType i = endindex - startindex; // berechne nun die Laenge des Ergebnisstrings
strAlloc (tmptarget, i); // Speicher fuer den Ergebnisstring allokieren
if (tmptarget != 0x0000) // Hat allokation funktioniert ?
{
if (source != 0x0000) // Ist ueberhaupt ein Quellstring vorhanden
{
i = 0;
while (source[i] != 0 && i < startindex) // pruefe jetzt, ob der Source-String vielleicht schon vor dem Startindex terminiert ist
{
++i;
}
if (i == startindex)
{
i = 0;
while (startindex + i < endindex && source[startindex + i] != 0) // nun den angebenen Speicherbereich ablaufen
{
tmptarget[i] = source[startindex + i]; // und Zeichen fuer Zeichen kopieren
++i;
}
tmptarget[i] = 0; // nun das Null-Terminierungsbyte nicht vergessen
}
}
}
}
strFree (target); // Nun den Zielstring freigeben, falls er belegt war
target = tmptarget; // Nun den Zeiger einfach umsetzten. Hier muss nicht mehr kopiert werden....
tmptarget = 0x0000; // weil wir hier den temporaeren string als frei markieren, ohne den Speicher wieder freizugeben.
}
void vstring::strCopy (char * & target, const char * source1, const char * source2)
{
char * tmptarget = 0x0000; // Zunaechst einen Temporaeren Speicher deklarieren, weil diese Routine auch arbeiten soll, wenn einer oder beide SourceString identisch mit dem Target sind. Also darf dieser erst geloescht werden, wenn alles fertig kopiert ist
strSizeType i = strLength (source1) + strLength (source2); // Anzahl der zu kopierenden Zeichen holen
strAlloc (tmptarget, i); // dann fuer den temporaeren String den Speicher belegen
if (tmptarget != 0x0000) // War die gesamtlaenge groesser als 0 ?
{
strSizeType j = 0; // Offset es aktuellen Quellstring in den Zielstring
if (source1 != 0x0000) // ist der betreffende Quellstring ueberhaupt vorhanden
{
i = 0; // Zaehlvariable im Quellstring
while (source1[i] != 0) // bis zum Null-Terminierungsbyte durchlaufen..
{
tmptarget[j + i] = source1[i]; // und Zeichen fuer Zeichen kopieren
i++;
}
j += i; // nun den Offset im Zielstring entsprechend der Eben kopierten Anzahl weitersetzen fuer den naechsten String
}
if (source2 != 0x0000) // ist der zweite String vorhanden ?
{
i = 0; // genau das selbe vorgehen, wie im ersten Sring. Dieser Teil koennte fuer weitere Funktionen beliebig oft hintereinander kopiert werden
while (source2[i] != 0)
{
tmptarget[j + i] = source2[i];
i++;
}
j += i;
}
tmptarget[j] = 0; // Und schliesslich das Null-Terminierungs-Byte am ende des Zielstrings setzen
}
strFree (target); // Nun den Zielstring freigeben, falls er belegt war
target = tmptarget; // Nun den Zeiger einfach umsetzten. Hier muss nicht mehr kopiert werden....
tmptarget = 0x0000; // weil wir hier den temporaeren string als frei markieren, ohne den Speicher wieder freizugeben.
}
void AsmCodeFree(AsmCode *code) {
strFree(code->line);
ArrayFree(code->tokens, strFree);
if (code->objCode != NULL)
ObjFree(code->objCode);
ObjFree(code);
}
static StringList
uclConstructOptList(String name, StringList given)
{
StringList res;
String flag;
String tmp;
Bool sep;
flag = cfgLookupString(name, uclOptions);
tmp = strConcat(name, "-sep");
sep = cfgLookupBoolean(tmp, uclOptions);
strFree(tmp);
res = listNil(String);
while (given) {
if (sep) {
res = listCons(String)(flag, res);
res = listCons(String)(car(given), res);
}
else {
tmp = strConcat(flag, car(given));
res = listCons(String)(tmp, res);
}
given = cdr(given);
}
return listNReverse(String)(res);
}
String
strNReplace(String txt, String orig, String repl)
{
String s = strReplace(txt, orig, repl);
strFree(txt);
return s;
}
int main(int argc, char** argv)
{
FILE *f;
if (argc != 2)
{
fprintf(stderr, "Spatny pocet parametru\n");
return INTERN_ERROR;
}
if (argc == 1)
{
fprintf(stderr, "Neni zadan vstupni soubor\n");
return INTERN_ERROR;
}
if ((f = fopen(argv[1], "r")) == NULL)
{
fprintf(stderr, "Soubor se nepodarilo otevrit\n");
return INTERN_ERROR;
}
setSourceFile(f);
int tokenn=0;
do
{
tokenn = getNextToken(); //TOHLE SE VOLA V PARSERU
printf("token je: %d\n",tokenn);
} while(tokenn != 101);
/////////////////////////////////////////////////
////////////TADY PO SOBĚ UKLÍZÍME////////////////
////////////////////////////////////////////////
strFree(&token.data); //uvolním řetezec
fclose(f); //zavřeme soubor
return 0;
}
/**
* Funkce pri chybe uvolni vsechny dynamicky vytvorene promenne v interpret.c
*/
void errorFree()
{
hListDispose(g_list);
jStackDispose(g_jStack);
if(g_retData->varType == T_STRING)
strFree(&g_retData->varKey);
}
void TableFree(tGlobSymbolTable *T,Tridic *ridic,sGlobTableItem *koren,int *in){/*rekurzivni mazani tabulek*/
if((koren)!= NULL) {/*pokud neni globalni tabulka prazdna*/
if(koren->data.typ == FUNCTION_HEADER){/*pokud je glob. prvek funkce*/
if(koren->data.def == 0 ) *in=0;/*pokud neni definovana*/
TableFreeLok(T,ridic,(koren->link));/*zavolam mazani lokalni tabulky*/
}
TableFree(T,ridic,(koren->lptr),in);/*posouvam se vlevo*/
TableFree(T,ridic,(koren->rptr),in);/*posouvam se vpravo*/
//strFree(&(koren->hodnota->stringh));
strFree(&(koren->data.nazev));/*mazu*/
strFree(&(koren->arg));
free(koren);
koren = NULL;
}
return ;
}
/*
* Return a processed source line list of the file contents.
*/
SrcLineList
includeFile(FileName fname)
{
String fnameString;
SrcLineList r;
inclSerialLineNo = 0;
fnameString = strCopy(fnameUnparseStatic(fname));
inclBuffer = bufNew();
includedFileCodes = 0;
localAssertList = listCopy(String)(globalAssertList);
fileState.curDir = osCurDirName();
fileState.fileCodes = 0;
fileState.fileNames = 0;
r = listNReverse(SrcLine)(
inclFile(fnameString, false, true, &inclFileLineNo));
strFree(fnameString);
bufFree(inclBuffer);
listFree(String)(localAssertList);
listFree(Hash)(includedFileCodes);
return r;
}
static String
uclGetKeyName(String s)
{
String r = strCopy(s);
String mode, std;
String tmp;
mode = uclIsCompileOnly ? "cc-" : "link-";
std = uclStdc ? "std-" : "";
tmp = r;
r = strConcat(mode, r);
strFree(tmp); tmp = r;
r = strConcat(std, r);
strFree(tmp);
return r;
}
void
destroyNode(node_ptr ptr)
{
strFree(ptr->data.id_name); //uvolnime retazec meno
free(ptr->data.id_name); //uvolnime ukazatel nanho
ptr->data.id_name = NULL;
if ( ptr->data.type == STR_TYPE ) //ak je obshom retazec uvolnime a zrusime aj ten....
if ( (ptr->data).value.str != NULL )
{
strFree((ptr->data).value.str);
free((ptr->data).value.str);
(ptr->data).value.str = NULL;
}
}
void FreeRamec(sRamec *ramec){
if(ramec != NULL){
FreeRamec(ramec->lptr);
FreeRamec(ramec->rptr);
strFree(&(ramec->nazev));
free(ramec);
ramec = NULL;
}
}
E_CODE functionInsertSymbol(tFunction* function,tString symbolname){
tSymbol *symb=mmuMalloc(sizeof(tSymbol));
strCopyString(&symbolname,&(symb->key));
//symb->type=DT_UNKNOWN;
symb->data=NULL;
E_CODE err=BTInsert(&(function->symbols),&(symb->key),symb);
if (err!=ERROR_OK){strFree(&(symb->key));mmuFree(symb);}
return err;
}
void freeTokenMem(tToken* t) {
if (t == NULL) return;
if (*t == NULL) return;
if ((*t)->typ == TYPE_STRING || (*t)->typ == TYPE_IDENTIFICATOR) {
strFree(&(*t)->value.stringVal);
}
free(*t);
*t = NULL;
}
/**
* Uvolni tConstantInfo z pameti.
* @param constant[in]
*/
void freeConstantInfo(tConstantInfo * constant) {
if (constant->dataType == TAB_SYM_VAR_NO_AUTO_STRING) {
//free stringu
strFree(constant->value.stringVal);
free(constant->value.stringVal);
}
//smazeme strukturu ke konstante
free(constant);
}
void TableFreeLok(tGlobSymbolTable *T,Tridic *ridic,sLokTableItem *koren){/*uvolneni lokalni tabulky*/
if(koren != NULL){/*pokud neni lokalni prazdna*/
TableFreeLok(T,ridic,(koren->lptr));/*posouvam se vlevo*/
TableFreeLok(T,ridic,(koren->rptr));/*posouvam se vpravo*/
strFree(&(koren->data.nazev));/*mazu*/
free(koren);
koren = NULL;
}
}
E_CODE symbolTableInsertFunction(tSymbolTable* symbolTable, tString functionName){
tFunction *func=mmuMalloc(sizeof(tFunction));
strCopyString(&functionName,&(func->name)); // jmeno fce
btInit(&(func->symbols)); // symboly
initList(&(func->instructions)); // instrukce
initList(&(func->constants));
func->called=1;
E_CODE err=BTInsert(&(symbolTable->functions),&(func->name),func);
if (err!=ERROR_OK){strFree(&(func->name));mmuFree(func);}
return err;
}
local void
checkPrintfCase(int w, const char *txt)
{
String name = strPrintf("%d-[%s]", w, txt);
char buf[20];
sprintf(buf, "%*s", w, txt);
String s2 = strPrintf("%*s", w, txt);
testStringEqual(name, buf, s2);
strFree(name);
}
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 clean_scanner()
{
strFree(buffer);
if (fclose(in) != EOF)
{
return OK;
}
else
{
fprintf(stderr, "Input file couldn't be closed!\n");
return EOF;
}
}