// CFileOpenDlg::EnumDirs
//
// Enumerates all subdirectories. Recurses depth-first
//
int CFileOpenDlg::EnumDirs(LPCTSTR pszPath, LPCTSTR pszFilter, HTREEITEM hItemParent)
{
WIN32_FIND_DATA fd;
HANDLE hFind;
BOOL bFind;
HTREEITEM hItem = TVI_LAST;
CString strSearch(pszPath),
strBase(pszPath);
int nCount = 0;
strSearch += pszFilter;
hFind = FindFirstFile(strSearch, &fd);
bFind = (hFind != INVALID_HANDLE_VALUE);
while(bFind)
{
if((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
!(fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
{
TVINSERTSTRUCT tvi;
CString strSub(strBase);
int iIcon;
strSub += fd.cFileName;
iIcon = GetIconIndex(strSub);
tvi.hParent = hItemParent;
tvi.hInsertAfter = TVI_LAST;
tvi.item.mask = TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE |
TVIF_TEXT | TVIF_PARAM;
tvi.item.pszText = fd.cFileName;
tvi.item.iImage = iIcon;
tvi.item.iSelectedImage = iIcon;
tvi.item.cChildren = I_CHILDRENCALLBACK;
tvi.item.lParam = -1;
hItem = m_treeFolder.InsertItem(&tvi);
++nCount;
/*
strSub += _T("\\");
if(hItem)
{
m_treeFolder.SetItemData(hItem, 1);
EnumDirs(strSub, pszFilter, hItem);
}*/
}
bFind = FindNextFile(hFind, &fd);
}
return nCount;
}
LPTSTR get_windows_temp_path()
{
BYTE temp[255], system_root[255];
LPTSTR path;
if (retrieve_machine_var("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment", "TEMP", temp) == EXIT_FAILURE) {
addToLog("No Windows Temp folder");
return ("");
}
if (retrieve_machine_var("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "SystemRoot", system_root) == EXIT_FAILURE) {
addToLog("No Windows Temp folder");
return ("");
}
path = strSub((LPTSTR)temp, "%SystemRoot%", (LPTSTR)system_root);
concatBeforeAddToLog("Windows Temp folder found : ", path);
return (path);
}
/***********************************************************************************************************************************
Test Run
***********************************************************************************************************************************/
void
testRun(void)
{
FUNCTION_HARNESS_VOID();
// *****************************************************************************************************************************
if (testBegin("strNew(), strNewBuf(), strNewN(), strEmpty(), strPtr(), strSize(), and strFree()"))
{
// We don't want this struct to grow since there are generally a lot of strings, so make sure it doesn't grow without us
// knowing about it
TEST_RESULT_UINT(sizeof(StringConst), TEST_64BIT() ? 16 : 12, "check StringConst struct size");
// Test the size macro
TEST_RESULT_VOID(CHECK_SIZE(555), "valid size");
TEST_ERROR(CHECK_SIZE(STRING_SIZE_MAX + 1), AssertError, "string size must be <= 1073741824 bytes");
String *string = strNew("static string");
TEST_RESULT_STR(strPtr(string), "static string", "new with static string");
TEST_RESULT_INT(strSize(string), 13, "check size");
TEST_RESULT_BOOL(strEmpty(string), false, "is not empty");
TEST_RESULT_INT(strlen(strPtr(string)), 13, "check size with strlen()");
TEST_RESULT_CHAR(strPtr(string)[2], 'a', "check character");
TEST_RESULT_VOID(strFree(string), "free string");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_STR(strPtr(strNewN("testmorestring", 4)), "test", "new string with size limit");
// -------------------------------------------------------------------------------------------------------------------------
Buffer *buffer = bufNew(8);
memcpy(bufPtr(buffer), "12345678", 8);
bufUsedSet(buffer, 8);
TEST_RESULT_STR(strPtr(strNewBuf(buffer)), "12345678", "new string from buffer");
// -------------------------------------------------------------------------------------------------------------------------
string = strNewFmt("formatted %s %04d", "string", 1);
TEST_RESULT_STR(strPtr(string), "formatted string 0001", "new with formatted string");
TEST_RESULT_PTR(strPtr(NULL), NULL, "null string pointer");
TEST_RESULT_VOID(strFree(string), "free string");
TEST_RESULT_VOID(strFree(NULL), "free null string");
}
// *****************************************************************************************************************************
if (testBegin("STRING_STATIC()"))
{
TEST_RESULT_STR(strPtr(TEST_STRING), "a very interesting string!", "check static string");
TEST_RESULT_STR(strPtr(strSubN(TEST_STRING, 0, 6)), "a very", "read-only strSub() works");
}
// *****************************************************************************************************************************
if (testBegin("strBase() and strPath()"))
{
TEST_RESULT_STR(strPtr(strBase(STRDEF(""))), "", "empty string");
TEST_RESULT_STR(strPtr(strBase(STRDEF("/"))), "", "/ only");
TEST_RESULT_STR(strPtr(strBase(STRDEF("/file"))), "file", "root file");
TEST_RESULT_STR(strPtr(strBase(STRDEF("/dir1/dir2/file"))), "file", "subdirectory file");
TEST_RESULT_STR(strPtr(strPath(STRDEF(""))), "", "empty string");
TEST_RESULT_STR(strPtr(strPath(STRDEF("/"))), "/", "/ only");
TEST_RESULT_STR(strPtr(strPath(STRDEF("/file"))), "/", "root path");
TEST_RESULT_STR(strPtr(strPath(STRDEF("/dir1/dir2/file"))), "/dir1/dir2", "subdirectory file");
}
// *****************************************************************************************************************************
if (testBegin("strCat(), strCatChr(), and strCatFmt()"))
{
String *string = strNew("XXXX");
String *string2 = strNew("ZZZZ");
TEST_RESULT_STR(strPtr(strCat(string, "YYYY")), "XXXXYYYY", "cat string");
TEST_RESULT_SIZE(string->extra, 4, "check extra");
TEST_RESULT_STR(strPtr(strCatFmt(string, "%05d", 777)), "XXXXYYYY00777", "cat formatted string");
TEST_RESULT_SIZE(string->extra, 6, "check extra");
TEST_RESULT_STR(strPtr(strCatChr(string, '!')), "XXXXYYYY00777!", "cat chr");
TEST_RESULT_SIZE(string->extra, 5, "check extra");
TEST_RESULT_STR(strPtr(string2), "ZZZZ", "check unaltered string");
}
// *****************************************************************************************************************************
if (testBegin("strDup()"))
{
const String *string = STRDEF("duplicated string");
String *stringDup = strDup(string);
TEST_RESULT_STR(strPtr(stringDup), strPtr(string), "duplicated strings match");
TEST_RESULT_PTR(strDup(NULL), NULL, "duplicate null string");
}
// *****************************************************************************************************************************
if (testBegin("strBeginsWith() and strBeginsWithZ()"))
{
TEST_RESULT_BOOL(strBeginsWith(STRDEF(""), STRDEF("aaa")), false, "empty string");
TEST_RESULT_BOOL(strBeginsWith(STRDEF("astring"), STRDEF("")), true, "empty begins with");
TEST_RESULT_BOOL(strBeginsWithZ(STRDEF("astring"), "astr"), true, "partial begins with");
TEST_RESULT_BOOL(strBeginsWithZ(STRDEF("astring"), "astring"), true, "equal strings");
}
// *****************************************************************************************************************************
if (testBegin("strEndsWith() and strEndsWithZ()"))
{
TEST_RESULT_BOOL(strEndsWith(STRDEF(""), STRDEF(".doc")), false, "empty string");
TEST_RESULT_BOOL(strEndsWith(STRDEF("astring"), STRDEF("")), true, "empty ends with");
TEST_RESULT_BOOL(strEndsWithZ(STRDEF("astring"), "ing"), true, "partial ends with");
TEST_RESULT_BOOL(strEndsWithZ(STRDEF("astring"), "astring"), true, "equal strings");
}
// *****************************************************************************************************************************
if (testBegin("strEq(), strEqZ(), strCmp(), strCmpZ()"))
{
TEST_RESULT_BOOL(strEq(STRDEF("equalstring"), STRDEF("equalstring")), true, "strings equal");
TEST_RESULT_BOOL(strEq(STRDEF("astring"), STRDEF("anotherstring")), false, "strings not equal");
TEST_RESULT_BOOL(strEq(STRDEF("astring"), STRDEF("bstring")), false, "equal length strings not equal");
TEST_RESULT_INT(strCmp(STRDEF("equalstring"), STRDEF("equalstring")), 0, "strings equal");
TEST_RESULT_INT(strCmp(STRDEF("a"), STRDEF("b")), -1, "a < b");
TEST_RESULT_INT(strCmp(STRDEF("b"), STRDEF("a")), 1, "b > a");
TEST_RESULT_BOOL(strEqZ(STRDEF("equalstring"), "equalstring"), true, "strings equal");
TEST_RESULT_BOOL(strEqZ(STRDEF("astring"), "anotherstring"), false, "strings not equal");
TEST_RESULT_BOOL(strEqZ(STRDEF("astring"), "bstring"), false, "equal length strings not equal");
TEST_RESULT_INT(strCmpZ(STRDEF("equalstring"), "equalstring"), 0, "strings equal");
TEST_RESULT_INT(strCmpZ(STRDEF("a"), "b"), -1, "a < b");
TEST_RESULT_INT(strCmpZ(STRDEF("b"), "a"), 1, "b > a");
}
// *****************************************************************************************************************************
if (testBegin("strFirstUpper(), strFirstLower(), strUpper(), strLower()"))
{
TEST_RESULT_STR(strPtr(strFirstUpper(strNew(""))), "", "empty first upper");
TEST_RESULT_STR(strPtr(strFirstUpper(strNew("aaa"))), "Aaa", "first upper");
TEST_RESULT_STR(strPtr(strFirstUpper(strNew("Aaa"))), "Aaa", "first already upper");
TEST_RESULT_STR(strPtr(strFirstLower(strNew(""))), "", "empty first lower");
TEST_RESULT_STR(strPtr(strFirstLower(strNew("AAA"))), "aAA", "first lower");
TEST_RESULT_STR(strPtr(strFirstLower(strNew("aAA"))), "aAA", "first already lower");
TEST_RESULT_STR(strPtr(strLower(strNew("K123aBc"))), "k123abc", "all lower");
TEST_RESULT_STR(strPtr(strLower(strNew("k123abc"))), "k123abc", "already lower");
TEST_RESULT_STR(strPtr(strLower(strNew("C"))), "c", "char lower");
TEST_RESULT_STR(strPtr(strLower(strNew(""))), "", "empty lower");
TEST_RESULT_STR(strPtr(strUpper(strNew("K123aBc"))), "K123ABC", "all upper");
TEST_RESULT_STR(strPtr(strUpper(strNew("K123ABC"))), "K123ABC", "already upper");
TEST_RESULT_STR(strPtr(strUpper(strNew("c"))), "C", "char upper");
TEST_RESULT_STR(strPtr(strUpper(strNew(""))), "", "empty upper");
}
// *****************************************************************************************************************************
if (testBegin("strQuote()"))
{
TEST_RESULT_STR(strPtr(strQuote(STRDEF("abcd"), STRDEF("'"))), "'abcd'", "quote string");
}
// *****************************************************************************************************************************
if (testBegin("strReplaceChr()"))
{
TEST_RESULT_STR(strPtr(strReplaceChr(strNew("ABCD"), 'B', 'R')), "ARCD", "replace chr");
}
// *****************************************************************************************************************************
if (testBegin("strSub() and strSubN()"))
{
TEST_RESULT_STR(strPtr(strSub(STRDEF("ABCD"), 2)), "CD", "sub string");
TEST_RESULT_STR(strPtr(strSubN(STRDEF("ABCD"), 1, 2)), "BC", "sub string with length");
}
// *****************************************************************************************************************************
if (testBegin("strTrim()"))
{
TEST_RESULT_STR(strPtr(strTrim(strNew(""))), "", "trim empty");
TEST_RESULT_STR(strPtr(strTrim(strNew("X"))), "X", "no trim (one char)");
TEST_RESULT_STR(strPtr(strTrim(strNew("no-trim"))), "no-trim", "no trim (string)");
TEST_RESULT_STR(strPtr(strTrim(strNew(" \t\r\n"))), "", "all whitespace");
TEST_RESULT_STR(strPtr(strTrim(strNew(" \tbegin-only"))), "begin-only", "trim begin");
TEST_RESULT_STR(strPtr(strTrim(strNew("end-only\t "))), "end-only", "trim end");
TEST_RESULT_STR(strPtr(strTrim(strNew("\n\rboth\r\n"))), "both", "trim both");
TEST_RESULT_STR(strPtr(strTrim(strNew("begin \r\n\tend"))), "begin \r\n\tend", "ignore whitespace in middle");
}
// *****************************************************************************************************************************
if (testBegin("strChr() and strTrunc()"))
{
TEST_RESULT_INT(strChr(STRDEF("abcd"), 'c'), 2, "c found");
TEST_RESULT_INT(strChr(STRDEF("abcd"), 'C'), -1, "capital C not found");
TEST_RESULT_INT(strChr(STRDEF("abcd"), 'i'), -1, "i not found");
TEST_RESULT_INT(strChr(STRDEF(""), 'x'), -1, "empty string - x not found");
String *val = strNew("abcdef");
TEST_ERROR(
strTrunc(val, (int)(strSize(val) + 1)), AssertError,
"assertion 'idx >= 0 && (size_t)idx <= this->size' failed");
TEST_ERROR(strTrunc(val, -1), AssertError, "assertion 'idx >= 0 && (size_t)idx <= this->size' failed");
TEST_RESULT_STR(strPtr(strTrunc(val, strChr(val, 'd'))), "abc", "simple string truncated");
strCat(val, "\r\n to end");
TEST_RESULT_STR(strPtr(strTrunc(val, strChr(val, 'n'))), "abc\r\n to e", "complex string truncated");
TEST_RESULT_STR(strPtr(strTrunc(val, strChr(val, 'a'))), "", "complete string truncated - empty string");
TEST_RESULT_INT(strSize(val), 0, "0 size");
TEST_RESULT_STR(strPtr(strTrunc(val, 0)), "", "test coverage of empty string - no error thrown for index 0");
}
// *****************************************************************************************************************************
if (testBegin("strToLog() and strObjToLog()"))
{
TEST_RESULT_STR(strPtr(strToLog(STRDEF("test"))), "{\"test\"}", "format string");
TEST_RESULT_STR(strPtr(strToLog(NULL)), "null", "format null string");
char buffer[256];
TEST_RESULT_UINT(strObjToLog(NULL, (StrObjToLogFormat)strToLog, buffer, sizeof(buffer)), 4, "format null string");
TEST_RESULT_STR(buffer, "null", "check null string");
TEST_RESULT_UINT(strObjToLog(STRDEF("teststr"), (StrObjToLogFormat)strToLog, buffer, sizeof(buffer)), 11, "format string");
TEST_RESULT_STR(buffer, "{\"teststr\"}", "check string");
}
// *****************************************************************************************************************************
if (testBegin("strSizeFormat()"))
{
TEST_RESULT_STR(strPtr(strSizeFormat(0)), "0B", "zero bytes");
TEST_RESULT_STR(strPtr(strSizeFormat(1023)), "1023B", "1023 bytes");
TEST_RESULT_STR(strPtr(strSizeFormat(1024)), "1KB", "1 KB");
TEST_RESULT_STR(strPtr(strSizeFormat(2200)), "2.1KB", "2.1 KB");
TEST_RESULT_STR(strPtr(strSizeFormat(1048576)), "1MB", "1 MB");
TEST_RESULT_STR(strPtr(strSizeFormat(20162900)), "19.2MB", "19.2 MB");
TEST_RESULT_STR(strPtr(strSizeFormat(1073741824)), "1GB", "1 GB");
TEST_RESULT_STR(strPtr(strSizeFormat(1073741824 + 107374183)), "1.1GB", "1.1 GB");
TEST_RESULT_STR(strPtr(strSizeFormat(UINT64_MAX)), "17179869183GB", "uint64 max");
}
// *****************************************************************************************************************************
if (testBegin("strLstNew(), strLstAdd*(), strLstGet(), strLstMove(), strLstSize(), and strLstFree()"))
{
// Add strings to the list
// -------------------------------------------------------------------------------------------------------------------------
StringList *list = NULL;
MEM_CONTEXT_TEMP_BEGIN()
{
list = strLstNew();
for (int listIdx = 0; listIdx <= LIST_INITIAL_SIZE; listIdx++)
{
if (listIdx == 0)
{
TEST_RESULT_PTR(strLstAdd(list, NULL), list, "add null item");
}
else
TEST_RESULT_PTR(strLstAdd(list, strNewFmt("STR%02d", listIdx)), list, "add item %d", listIdx);
}
strLstMove(list, MEM_CONTEXT_OLD());
}
MEM_CONTEXT_TEMP_END();
TEST_RESULT_INT(strLstSize(list), 9, "list size");
// Read them back and check values
// -------------------------------------------------------------------------------------------------------------------------
for (unsigned int listIdx = 0; listIdx < strLstSize(list); listIdx++)
{
if (listIdx == 0)
{
TEST_RESULT_PTR(strLstGet(list, listIdx), NULL, "check null item");
}
else
TEST_RESULT_STR(strPtr(strLstGet(list, listIdx)), strPtr(strNewFmt("STR%02u", listIdx)), "check item %u", listIdx);
}
TEST_RESULT_VOID(strLstFree(list), "free string list");
TEST_RESULT_VOID(strLstFree(NULL), "free null string list");
}
int CLuaInstMisc::strSub_old(lua_State *L)
{
MISC_FUNC_DEPRECATED(L, "strSub");
return strSub(L);
}
/**
* Funkce interpret projde a vykona zoznam trojadresnyho kodu.
* @param iList Seznam triadresneho kodu.
* @param btree Binarni strom reprezentujici tabulku symbolu.
* @return Uspesnost funkce.
*/
int interpret(tListOfInstr * iList, BNode *btree)
{
// chod na MAIN navesti v seznamu instrukci
listFirst(iList);
listGotoMain(iList);
tInstr *I = listGetData(iList);
g_btree = btree;
int PUSHING = 0;
// tData pre return
tData retData;
retData.varType = T_NOTDEF;
retData.hasValue = 0;
g_retData = &retData;
// tData pre push
tData pushData;
pushData.varType = T_NOTDEF;
pushData.hasValue = 0;
// Data pro 3 adresy instrukci
tData *data1 = NULL;
tData *data2 = NULL;
tData *data3 = NULL;
tData *var = NULL; //pomocni pri prohladavani
tData dataC ; //pomocni pri vyrazech a = a .. b; ....
// Pomocny zasobnik pro skoky
jumpStack jStack;
jStackInit(&jStack);
g_jStack = &jStack;
// Pomocny dvousmerny seznam pro funkce
tListOfCall list2;
hListInit(&list2);
g_list = &list2;
hListInsert(&list2,NULL,S_LAB);
// Sme na main navesti ?
if(I->instType != I_LAB_MAIN)
{
errorFree();
return EINT;
}
// Projdi a vykonej triadresny kod
while (1)
{
// Ziskej instrukci ze seznamu
I = listGetData(iList);
// Prirad adresy do premennych
data1 = I->addr1;
data2 = I->addr2;
data3 = I->addr3;
// pokus se vyhledat polozky ze stromu v pomocnej strukture
if(data1 != NULL && I->instType != I_JUMP && I->instType != I_JMPN)
{
var = hSearchToLab(&list2, data1, PUSHING);
if(var != NULL)
data1 = var;
}
if(data2 != NULL)
{
var = hSearchToLab(&list2, data2, PUSHING);
if(var != NULL)
data2 = var;
}
if(data3 != NULL && I->instType != I_JUMP)
{
var = hSearchToLab(&list2, data3, PUSHING);
if(var != NULL)
data3 = var;
}
// Podle typu instrukce vykonej operaci ////////////////////////////////////
switch (I->instType)
{
// NAVESTI MAIN
case I_LAB_MAIN:
PUSHING = 1;
break;
// NAVESTI
case I_LAB:
break;
// NAVESTI ZACATEK FUNKCE
case I_LAB_S:
PUSHING = 1;
break;
// NAVESTI KONEC PUSH
case I_LAB_F:
PUSHING = 0;
hListInsert(&list2,NULL,S_LAB);
break;
// SOUCET
case I_ADD:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = data2->value.dValue + data3->value.dValue;
}
}
else
{
errorFree();
return EINT;
}
break;
// MODULO
case I_MOD:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
if(data3->value.dValue == 0)
{
errorFree();
return EINT;
}
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = ((int)data2->value.dValue) % ((int)data3->value.dValue);
}
}
else
{
errorFree();
return EINT;
}
break;
// ODECITANI
case I_SUB:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = data2->value.dValue - data3->value.dValue;
}
}
else
{
errorFree();
return EINT;
}
break;
// NASOBENI
case I_MUL:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = data2->value.dValue * data3->value.dValue;
}
}
else
{
errorFree();
return EINT;
}
break;
// DELENI
case I_DIV:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
if(data3->value.dValue == 0)
{
errorFree();
return EINT;
}
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = data2->value.dValue / data3->value.dValue;
}
data1->value.dValue = data2->value.dValue / data3->value.dValue;
}
else
{
errorFree();
return EINT;
}
break;
// KONKATENACE
case I_CONCAT:
if(data2->varType == T_STRING && data3->varType == T_STRING)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->varType = T_STRING;
data1->hasValue = 1;
strInit(&data1->value.sValue);
strConCat(&data2->value.sValue, &data3->value.sValue, &data1->value.sValue);
}
}
else
{
errorFree();
return EINT;
}
break;
// KONKATENACE
case I_SLENGTH:
if(data3->varType == T_STRING)
{
int a = data3->value.sValue.length;
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->hasValue = HAVE_VALUE;
data1->varType = T_NUMBER;
data1->value.dValue = a;
}
else
{
errorFree();
return EINT;
}
break;
// UMOCNENI
case I_POWER:
if(data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->varType = T_NUMBER;
data1->hasValue = 1;
data1->value.dValue = 1;
data1->value.dValue = pow( data2->value.dValue, data3->value.dValue);
}
}
else
{
errorFree();
return EINT;
}
break;
// POROVNANI
case I_EQUAL:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
switch(data2->varType)
{
case T_NUMBER:
if (data2->value.dValue == data3->value.dValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_STRING:
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) == 0)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_BOOLEAN:
if (data2->value.bValue == data3->value.bValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_NIL:
data1->value.bValue = 1;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
data1->value.bValue = 0;
data1->varType = T_BOOLEAN;
}
break;
// NEGACE POROVNANI
case I_NEQUAL:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
switch(data2->varType)
{
case T_NUMBER:
if (data2->value.dValue == data3->value.dValue)
data1->value.bValue = 0;
else
data1->value.bValue = 1;
break;
case T_STRING:
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) == 0)
data1->value.bValue = 0;
else
data1->value.bValue = 1;
break;
case T_BOOLEAN:
if (data2->value.bValue == data3->value.bValue)
data1->value.bValue = 0;
else
data1->value.bValue = 1;
break;
case T_NIL:
data1->value.bValue = 0;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
data1->value.bValue = 0;
data1->varType = T_BOOLEAN;
}
break;
// MENSI NEZ
case I_LCMP:
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
switch (data2->varType)
{
case T_NUMBER:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (data2->value.dValue < data3->value.dValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_STRING:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) < 0)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
break;
// VETSI NEZ
case I_GCMP:
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
data1->hasValue = HAVE_VALUE;
switch (data2->varType)
{
case T_NUMBER:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (data2->value.dValue > data3->value.dValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_STRING:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) > 0)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
break;
// MENSI ROVNO
case I_ELCMP:
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
switch(data2->varType)
{
case T_NUMBER:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (data2->value.dValue <= data3->value.dValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_STRING:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) <= 0)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
break;
// VETSI ROVNO
case I_EGCMP:
if(data2->varType == data3->varType)
{
if(data2->hasValue != 0 && data3->hasValue != 0)
{
switch (data2->varType)
{
case T_NUMBER:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (data2->value.dValue >= data3->value.dValue)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
case T_STRING:
data1->varType = T_BOOLEAN;
data1->hasValue = 1;
if (strcmp(data2->value.sValue.str, data3->value.sValue.str) >= 0)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
break;
default:
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
break;
// JE VYRAZ TRUE ?
case I_STRUE:
if(data1->varType == T_STRING)
{
strFree(&data1->value.sValue);
data1->value.bValue = 1;
}
else if(data1->varType == T_BOOLEAN)
{
if(data1->value.bValue == 1)
data1->value.bValue = 1;
else
data1->value.bValue = 0;
}
else if(data1->varType == T_NIL || data1->varType == T_NOTDEF)
data1->value.bValue = 0;
else
data1->value.bValue = 1;
data1->varType = T_BOOLEAN;
break;
// SKOK POKIAL FALSE
case I_JMPN:
if(data3->varType == T_BOOLEAN)
{
if(data3->value.bValue == 0)
listGoto(iList, I->addr1);
}
break;
// SKOK
case I_JUMP:
if(I->addr3 != NULL)
jStackPush(&jStack,I);
listGoto(iList, I->addr1);
break;
// PRIRAZENI
case I_ASGN:
if(data3->hasValue != 0)
{
dataC.varType = data3->varType;
data1->hasValue = 1;
makeCopy(data3, &dataC);
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->varType = data3->varType;
switch (dataC.varType)
{
case T_NUMBER:
data1->value.dValue = dataC.value.dValue;
break;
case T_STRING:
strInitText(&data1->value.sValue, dataC.value.sValue.str);
break;
case T_BOOLEAN:
data1->value.bValue = dataC.value.bValue;
break;
case T_NIL:
data1->value.bValue = dataC.value.bValue;
break;
default:
if(dataC.varType == T_STRING)
strFree(&dataC.value.sValue);
errorFree();
return EINT;
}
}
else
{
if(dataC.varType == T_STRING)
strFree(&dataC.value.sValue);
errorFree();
return EINT;
}
if(dataC.varType == T_STRING)
strFree(&dataC.value.sValue);
break;
// ZAPAMATOVANA POLOZKA Z POSLEDNIHO VOLANI
case I_ASGNR:
if(retData.hasValue != 0)
{
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->hasValue = 1;
data1->varType = retData.varType;
switch (retData.varType)
{
case T_NUMBER:
data1->value.dValue = retData.value.dValue;
break;
case T_STRING:
strInitText(&data1->value.sValue, retData.value.sValue.str);
break;
case T_BOOLEAN:
data1->value.bValue = retData.value.bValue;
break;
case T_NIL:
data1->value.bValue = retData.value.bValue;
break;
default:
errorFree();
return EINT;
}
if(retData.varType == T_STRING)
strFree(&retData.value.sValue);
retData.varType = T_NOTDEF;
}
else
{
strFree(&retData.varKey);
if(retData.varType == T_STRING)
strFree(&retData.value.sValue);
retData.varType = T_NOTDEF;
errorFree();
return EINT;
}
break;
// READ FUNKCE
// podla fora sa ma pri cisle chovat inak
case I_READ:
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
if(data3->varType == T_NUMBER)
{
if(data3->value.dValue < 0)
{
errorFree();
return ESEM;
}
strInit(&data1->value.sValue);
readStrToNUMB(&data1->value.sValue,data3->value.dValue);
data1->varType = T_STRING;
}
else if(data3->varType == T_STRING)
{
if(data3->value.sValue.length >= 2)
{
if((data3->value.sValue.str[0] == '*') && (data3->value.sValue.str[1] == 'n'))
{
if(scanf("%lf",&data1->value.dValue) != 1)
{
data1->varType = T_NIL;
data1->value.bValue = 0;
}
else
data1->varType = T_NUMBER;
}
else if((data3->value.sValue.str[0] == '*') && (data3->value.sValue.str[1] == 'l'))
{
strInit(&data1->value.sValue);
readStrToNl(&data1->value.sValue);
data1->varType = T_STRING;
}
else if((data3->value.sValue.str[0] == '*') && (data3->value.sValue.str[1] == 'a'))
{
strInit(&data1->value.sValue);
readStrToEOF(&data1->value.sValue);
data1->varType = T_STRING;
}
else
{
errorFree();
return ESEM;
}
}
else
{
errorFree();
return ESEM;
}
}
else
{
errorFree();
return ESYN;
}
data1->hasValue = HAVE_VALUE;
break;
// WRITE FUNKCE
case I_WRITE:
if (data1->hasValue != 0)
{
if(data1->varType == T_NUMBER)
printf("%g", data1->value.dValue);
else if (data1->varType == T_STRING)
{
// KONECNY AUTOMAT PRO VYPIS
int writeState = 0;
for(int i = 0; i < data1->value.sValue.length; i++)
{
switch(writeState)
{
case 0:
if(data1->value.sValue.str[i] == LOMITKO)
writeState = 1;
else
putchar(data1->value.sValue.str[i]);
break;
case 1:
if(data1->value.sValue.str[i] == 'n')
printf("\n");
else if(data1->value.sValue.str[i] == 't')
printf("\t");
else if(data1->value.sValue.str[i] == LOMITKO)
printf("\\");
else if (data1->value.sValue.str[i] == UVOZOVKY)
printf("\"");
else if(data1->value.sValue.str[i] == NOVYRADEK)
break;
else
putchar(data1->value.sValue.str[i]);
writeState = 0;
break;
}
}
}
else
{
errorFree();
return EINT;
}
}
else
{
errorFree();
return EINT;
}
break;
// FUNKCE FTYPE VRACI TYP
case I_FTYPE:
if (data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->hasValue = 1;
switch(data3->varType)
{
case T_NOTDEF:
strInitText(&data1->value.sValue, "nil");
break;
case T_NUMBER:
strInitText(&data1->value.sValue, "number");
break;
case T_STRING:
strInitText(&data1->value.sValue, "string");
break;
case T_BOOLEAN:
strInitText(&data1->value.sValue, "boolean");
break;
case T_NIL:
strInitText(&data1->value.sValue, "nil");
break;
default:
errorFree();
return EINT;
}
data1->varType = T_STRING;
break;
// FUNKCE SUBSTRING
case I_FSUBS:
if(data1 != NULL && data2 != NULL && data3 != NULL)
{
if(data1->varType == T_STRING && data2->varType == T_NUMBER && data3->varType == T_NUMBER)
{
retData.varType = T_STRING;
retData.hasValue = HAVE_VALUE;
strInit(&retData.value.sValue);
strSub(&data1->value.sValue,&retData.value.sValue,(int)data2->value.dValue,(int)data3->value.dValue);
}
else
{
data1->varType = T_NIL;
data1->hasValue = 1;
data1->value.bValue = 0;
}
}
else
{
errorFree();
return EINT;
}
break;
// FUNKCE FIND
case I_FFIND:
if(data2->varType == T_STRING && data3->varType == T_STRING)
{
if(data2->hasValue != 0 && data2->hasValue != 0)
{
int number = 0;
if(data3->value.sValue.length == 0)
{
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->value.dValue = number;
data1->varType = T_NUMBER;
data1->hasValue = HAVE_VALUE;
break;
}
else
number = boyerMooreSearch(&data2->value.sValue, &data3->value.sValue);
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
if (number == 0)
{
data1->value.bValue = 0;
data1->varType = T_BOOLEAN;
data1->hasValue = HAVE_VALUE;
}
else
{
data1->value.dValue = number;
data1->varType = T_NUMBER;
data1->hasValue = HAVE_VALUE;
}
}
else
{
errorFree();
return EINT;
}
}
else
{
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->varType = T_NIL;
data1->hasValue = 1;
data1->value.bValue = 0;
}
break;
// FUNKCE SORT
case I_FSORT:
makeCopy(data1,&dataC);
if(data3->varType == T_STRING)
{
dataC.varType = T_STRING;
sort(&data3->value.sValue,&dataC.value.sValue);
if(data1->varType == T_STRING)
strFree(&data1->value.sValue);
data1->varType = T_STRING;
data1->hasValue = HAVE_VALUE;
strInitText(&data1->value.sValue,dataC.value.sValue.str);
}
else
{
data1->varType = T_NIL;
data1->hasValue = 1;
data1->value.bValue = 0;
}
if(dataC.varType == T_STRING)
strFree(&dataC.value.sValue);
break;
// PUSH
case I_PUSH:
if(data2 != NULL)
{
// ked pushujeme premenne pre funkciu potrebujeme data1 data2
// pre originalny nazov parametru
pushData.varType = data2->varType;
strInitText(&pushData.varKey,data1->varKey.str);
if(data2->varType == T_STRING)
strInitText(&pushData.value.sValue,data2->value.sValue.str);
else if(data2->varType == T_NIL)
pushData.value.bValue = 0;
else if(data2->varType == T_BOOLEAN)
pushData.value.bValue = data2->value.bValue;
else if(data2->varType == T_NUMBER)
pushData.value.dValue = data2->value.dValue;
pushData.hasValue = HAVE_VALUE;
hListInsert(&list2, &pushData, S_VAR);
strFree(&pushData.varKey);
if(pushData.varType == T_STRING)
strFree(&pushData.value.sValue);
}
// push lokalnej premennej
else if(data1 != NULL)
hListInsert(&list2, data1, S_VAR);
break;
// RETURN
case I_RETURN:
retData.varType = data1->varType;
retData.hasValue = data1->hasValue;
switch(retData.varType)
{
case T_STRING:
strInitText(&retData.value.sValue, data1->value.sValue.str);
break;
case T_NUMBER:
retData.value.dValue = data1->value.dValue;
break;
case T_BOOLEAN:
retData.value.bValue = data1->value.bValue;
break;
case T_NIL:
retData.value.bValue = 0;
break;
}
hListClearToLab(&list2);
listGoto(iList,jStackPop(&jStack));
break;
// KONEC PROGRAMU
case I_END:
errorFree();
return 0;
break;
}
// ukazatele na NULL
data1 = NULL;
data2 = NULL;
data3 = NULL;
var = NULL;
// nacteme dalsi instrukci
listNext(iList);
}
return EIOK;
}
