void qspAddAction(QSPVariant *args, int count, QSPLineOfCode *code, int start, int end, QSP_BOOL isManageLines)
{
QSPCurAct *act;
QSP_CHAR *imgPath;
if (qspActIndex(QSP_STR(args[0])) >= 0) return;
if (qspCurActionsCount == QSP_MAXACTIONS)
{
qspSetError(QSP_ERR_CANTADDACTION);
return;
}
if (count == 2 && qspIsAnyString(QSP_STR(args[1])))
imgPath = qspGetAbsFromRelPath(QSP_STR(args[1]));
else
imgPath = 0;
act = qspCurActions + qspCurActionsCount++;
act->Image = imgPath;
act->Desc = qspGetNewText(QSP_STR(args[0]), -1);
qspCopyPrepLines(&act->OnPressLines, code, start, end);
act->OnPressLinesCount = end - start;
act->Location = qspRealCurLoc;
act->ActIndex = qspRealActIndex;
act->StartLine = qspRealLine;
act->IsManageLines = isManageLines;
qspIsActionsChanged = QSP_TRUE;
}
/* Получить значение указанного выражения */
void QSPGetExprValue(QSP_BOOL *res, const QSP_CHAR *expr, QSP_BOOL *isString, int *numVal, QSP_CHAR *strVal, int strValBufSize)
{
QSPVariant v;
if (qspIsExitOnError && qspErrorNum)
{
*res = QSP_FALSE;
return;
}
qspResetError();
if (qspIsDisableCodeExec)
{
*res = QSP_FALSE;
return;
}
v = qspExprValue((QSP_CHAR *)expr);
if (qspErrorNum)
{
*res = QSP_FALSE;
return;
}
*isString = v.IsStr;
if (v.IsStr)
{
qspStrNCopy(strVal, QSP_STR(v), strValBufSize - 1);
free(QSP_STR(v));
strVal[strValBufSize - 1] = 0;
}
else
*numVal = QSP_NUM(v);
*res = QSP_TRUE;
}
/* Получить значение указанного выражения */
AS3_Val QSPGetExprValue(void *param, AS3_Val args)
{
char *expr;
QSP_CHAR *exprWC;
char *strUTF8;
QSPVariant v;
AS3_Val res;
AS3_ArrayValue(args, "StrType", &expr);
if (qspIsExitOnError && qspErrorNum) return AS3_Null();
qspResetError();
if (qspIsDisableCodeExec) return AS3_Null();
exprWC = qspC2W(expr);
v = qspExprValue(exprWC);
free(exprWC);
if (qspErrorNum) return AS3_Null();
if (v.IsStr)
{
strUTF8 = qspW2C(QSP_STR(v));
free(QSP_STR(v));
res = AS3_Object("isString:IntType, numVal:IntType, strVal:StrType", QSP_TRUE, 0, strUTF8);
free(strUTF8);
}
else
res = AS3_Object("isString:IntType, numVal:IntType, strVal:StrType", QSP_FALSE, QSP_NUM(v), 0);
return res;
}
QSP_CHAR *qspFormatText(QSP_CHAR *txt, QSP_BOOL canReturnSelf)
{
QSPVariant val;
QSP_CHAR *newTxt, *lPos, *rPos;
int oldRefreshCount, len, txtLen, oldTxtLen, bufSize;
if (qspGetVarNumValue(QSP_FMT("DISABLESUBEX")))
{
if (canReturnSelf) return txt;
return qspGetNewText(txt, -1);
}
lPos = qspStrStr(txt, QSP_LSUBEX);
if (!lPos)
{
if (canReturnSelf) return txt;
return qspGetNewText(txt, -1);
}
bufSize = 256;
newTxt = (QSP_CHAR *)malloc(bufSize * sizeof(QSP_CHAR));
txtLen = oldTxtLen = 0;
oldRefreshCount = qspRefreshCount;
do
{
len = (int)(lPos - txt);
if ((txtLen += len) >= bufSize)
{
bufSize = txtLen + 128;
newTxt = (QSP_CHAR *)realloc(newTxt, bufSize * sizeof(QSP_CHAR));
}
qspStrNCopy(newTxt + oldTxtLen, txt, len);
oldTxtLen = txtLen;
txt = lPos + QSP_LEN(QSP_LSUBEX);
rPos = qspStrPos(txt, QSP_RSUBEX, QSP_FALSE);
if (!rPos)
{
qspSetError(QSP_ERR_BRACKNOTFOUND);
free(newTxt);
return 0;
}
*rPos = 0;
val = qspExprValue(txt);
*rPos = QSP_RSUBEX[0];
if (qspRefreshCount != oldRefreshCount || qspErrorNum)
{
free(newTxt);
return 0;
}
qspConvertVariantTo(&val, QSP_TRUE);
if ((txtLen += qspStrLen(QSP_STR(val))) >= bufSize)
{
bufSize = txtLen + 128;
newTxt = (QSP_CHAR *)realloc(newTxt, bufSize * sizeof(QSP_CHAR));
}
qspStrCopy(newTxt + oldTxtLen, QSP_STR(val));
free(QSP_STR(val));
oldTxtLen = txtLen;
txt = rPos + QSP_LEN(QSP_RSUBEX);
lPos = qspStrStr(txt, QSP_LSUBEX);
} while (lPos);
return qspGetAddText(newTxt, txt, txtLen, -1);
}
QSP_BOOL qspStatementAddObject(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
QSPObj *obj;
int i, objInd;
QSP_CHAR *imgPath;
if (count == 3)
{
objInd = QSP_NUM(args[2]) - 1;
if (objInd < 0 || objInd > qspCurObjectsCount) return QSP_FALSE;
}
else
objInd = qspCurObjectsCount;
if (qspCurObjectsCount == QSP_MAXOBJECTS)
{
qspSetError(QSP_ERR_CANTADDOBJECT);
return QSP_FALSE;
}
if (qspCurSelObject >= objInd) qspCurSelObject = -1;
if (count >= 2 && qspIsAnyString(QSP_STR(args[1])))
imgPath = qspGetAbsFromRelPath(QSP_STR(args[1]));
else
imgPath = 0;
for (i = qspCurObjectsCount; i > objInd; --i)
qspCurObjects[i] = qspCurObjects[i - 1];
++qspCurObjectsCount;
obj = qspCurObjects + objInd;
obj->Image = imgPath;
obj->Desc = qspGetNewText(QSP_STR(args[0]), -1);
qspIsObjectsChanged = QSP_TRUE;
qspExecLocByVarNameWithArgs(QSP_FMT("ONOBJADD"), args, (count < 3 ? count : 2));
return QSP_FALSE;
}
QSP_BOOL qspStatementKillVar(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
if (count == 1)
qspRemoveArray(QSP_STR(args[0]));
else if (count == 2)
qspRemoveArrayItem(QSP_STR(args[0]), QSP_NUM(args[1]));
else
qspClearVars(QSP_FALSE);
return QSP_FALSE;
}
QSP_BOOL qspStatementCopyArr(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
int start, num;
QSPVar *dest, *src;
if (!(dest = qspVarReferenceWithType(QSP_STR(args[0]), QSP_TRUE, 0))) return QSP_FALSE;
if (!(src = qspVarReferenceWithType(QSP_STR(args[1]), QSP_FALSE, 0))) return QSP_FALSE;
if (dest != src)
{
start = (count >= 3 ? QSP_NUM(args[2]) : 0);
num = (count == 4 ? QSP_NUM(args[3]) : src->ValsCount);
qspEmptyVar(dest);
qspCopyVar(dest, src, start, num);
}
return QSP_FALSE;
}
QSP_BOOL qspStatementShowMenu(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
int ind, maxItems, len;
QSPVar *var;
QSP_CHAR *imgPath, *str, *pos, *pos2;
if (!(var = qspVarReferenceWithType(QSP_STR(args[0]), QSP_FALSE, 0))) return QSP_FALSE;
qspClearMenu(QSP_FALSE);
qspCallDeleteMenu();
if (count == 1)
{
ind = 0;
maxItems = QSP_MAXMENUITEMS;
}
else
{
ind = QSP_NUM(args[1]);
if (ind < 0) ind = 0;
if (count == 2)
maxItems = QSP_MAXMENUITEMS;
else
{
maxItems = QSP_NUM(args[2]);
if (maxItems < 0) maxItems = 0;
}
}
while (ind < var->ValsCount)
{
if (qspCurMenuItems == maxItems) break;
if (!((str = var->Values[ind].Str) && qspIsAnyString(str))) break;
if (!(pos2 = qspInStrRChars(str, QSP_MENUDELIM, 0)))
{
qspSetError(QSP_ERR_COLONNOTFOUND);
return QSP_FALSE;
}
if (qspCurMenuItems == QSP_MAXMENUITEMS)
{
qspSetError(QSP_ERR_CANTADDMENUITEM);
return QSP_FALSE;
}
if (pos = qspInStrRChars(str, QSP_MENUDELIM, pos2))
{
len = (int)(pos2 - pos) - 1;
imgPath = (qspIsAnyString(++pos2) ? qspGetAbsFromRelPath(pos2) : 0);
}
else
{
pos = pos2;
len = -1;
imgPath = 0;
}
qspCurMenuLocs[qspCurMenuItems++] = qspGetNewText(pos + 1, len);
*pos = 0;
qspCallAddMenuItem(str, imgPath);
*pos = QSP_MENUDELIM[0];
if (imgPath) free(imgPath);
++ind;
}
if (qspCurMenuItems) qspCallShowMenu();
return QSP_FALSE;
}
static QSPVar *qspGetVarData(QSP_CHAR *s, QSP_BOOL isSet, int *index)
{
QSPVar *var;
QSPVariant ind;
int oldRefreshCount;
QSP_CHAR *temp, *rPos, *lPos = qspStrChar(s, QSP_LSBRACK[0]);
if (lPos)
{
rPos = qspStrPos(lPos, QSP_RSBRACK, QSP_FALSE);
if (!rPos)
{
qspSetError(QSP_ERR_BRACKNOTFOUND);
return 0;
}
*lPos = 0;
var = qspVarReference(s, isSet);
*lPos = QSP_LSBRACK[0];
if (!var) return 0;
temp = qspSkipSpaces(lPos + 1);
if (temp == rPos)
{
if (isSet)
*index = var->ValsCount;
else
*index = (var->ValsCount ? var->ValsCount - 1 : 0);
}
else
{
oldRefreshCount = qspRefreshCount;
*rPos = 0;
ind = qspExprValue(temp);
*rPos = QSP_RSBRACK[0];
if (qspRefreshCount != oldRefreshCount || qspErrorNum) return 0;
if (ind.IsStr)
{
*index = qspGetVarTextIndex(var, QSP_STR(ind), isSet);
free(QSP_STR(ind));
}
else
*index = QSP_NUM(ind);
}
return var;
}
*index = 0;
return qspVarReference(s, isSet);
}
static void qspRemoveObject(int index)
{
QSPVariant name;
if (index < 0 || index >= qspCurObjectsCount) return;
if (qspCurSelObject >= index) qspCurSelObject = -1;
name.IsStr = QSP_TRUE;
QSP_STR(name) = qspCurObjects[index].Desc;
if (qspCurObjects[index].Image) free(qspCurObjects[index].Image);
--qspCurObjectsCount;
while (index < qspCurObjectsCount)
{
qspCurObjects[index] = qspCurObjects[index + 1];
++index;
}
qspIsObjectsChanged = QSP_TRUE;
qspExecLocByVarNameWithArgs(QSP_FMT("ONOBJDEL"), &name, 1);
free(QSP_STR(name));
}
QSPVariant qspGetEmptyVariant(QSP_BOOL isStringType)
{
QSPVariant ret;
if (ret.IsStr = isStringType)
QSP_STR(ret) = qspGetNewText(QSP_FMT(""), 0);
else
QSP_NUM(ret) = 0;
return ret;
}
static void qspSetVar(QSP_CHAR *name, QSPVariant *val, QSP_CHAR op) {
QSPVariant oldVal;
QSPVar *var;
int index;
if (!(var = qspGetVarData(name, QSP_TRUE, &index)))
return;
if (op == QSP_EQUAL[0]) {
if (qspConvertVariantTo(val, *name == QSP_STRCHAR[0])) {
qspSetError(QSP_ERR_TYPEMISMATCH);
return;
}
qspSetVarValueByReference(var, index, val);
} else if (op == QSP_ADD[0]) {
oldVal = qspGetVarValueByReference(var, index, *name == QSP_STRCHAR[0]);
if (oldVal.IsStr && val->IsStr)
QSP_STR(oldVal) = qspGetAddText(QSP_STR(oldVal), QSP_PSTR(val), -1, -1);
else if (qspIsCanConvertToNum(&oldVal) && qspIsCanConvertToNum(val)) {
qspConvertVariantTo(&oldVal, QSP_FALSE);
qspConvertVariantTo(val, QSP_FALSE);
QSP_NUM(oldVal) += QSP_PNUM(val);
qspConvertVariantTo(&oldVal, *name == QSP_STRCHAR[0]);
} else {
if (!oldVal.IsStr) {
qspSetError(QSP_ERR_TYPEMISMATCH);
return;
}
qspConvertVariantTo(val, QSP_TRUE);
QSP_STR(oldVal) = qspGetAddText(QSP_STR(oldVal), QSP_PSTR(val), -1, -1);
}
qspSetVarValueByReference(var, index, &oldVal);
if (oldVal.IsStr)
free(QSP_STR(oldVal));
} else if (qspIsInList(QSP_SUB QSP_DIV QSP_MUL, op)) {
if (qspConvertVariantTo(val, QSP_FALSE)) {
qspSetError(QSP_ERR_TYPEMISMATCH);
return;
}
oldVal = qspGetVarValueByReference(var, index, *name == QSP_STRCHAR[0]);
if (qspConvertVariantTo(&oldVal, QSP_FALSE)) {
qspSetError(QSP_ERR_TYPEMISMATCH);
free(QSP_STR(oldVal));
return;
}
if (op == QSP_SUB[0])
QSP_NUM(oldVal) -= QSP_PNUM(val);
else if (op == QSP_DIV[0]) {
if (!QSP_PNUM(val)) {
qspSetError(QSP_ERR_DIVBYZERO);
return;
}
QSP_NUM(oldVal) /= QSP_PNUM(val);
} else
QSP_NUM(oldVal) *= QSP_PNUM(val);
qspConvertVariantTo(&oldVal, *name == QSP_STRCHAR[0]);
qspSetVarValueByReference(var, index, &oldVal);
if (oldVal.IsStr)
free(QSP_STR(oldVal));
}
}
QSPVariant qspArrayMinMaxItem(QSP_CHAR *name, QSP_BOOL isMin)
{
QSPVar *var;
QSP_CHAR *str;
QSP_BOOL isString;
int curInd, count;
QSPVariant res;
if (!(var = qspVarReferenceWithType(name, QSP_FALSE, &isString)))
return qspGetEmptyVariant(QSP_FALSE);
curInd = -1;
count = var->ValsCount;
while (--count >= 0)
{
if (isString)
{
str = var->Values[count].Str;
if (str && *str)
{
if (curInd >= 0)
{
if (isMin)
{
if (QSP_STRCOLL(str, var->Values[curInd].Str) < 0)
curInd = count;
}
else if (QSP_STRCOLL(str, var->Values[curInd].Str) > 0)
curInd = count;
}
else
curInd = count;
}
}
else if (curInd >= 0)
{
if (isMin)
{
if (var->Values[count].Num < var->Values[curInd].Num)
curInd = count;
}
else if (var->Values[count].Num > var->Values[curInd].Num)
curInd = count;
}
else
curInd = count;
}
if (curInd < 0) return qspGetEmptyVariant(isString);
if (res.IsStr = isString)
QSP_STR(res) = qspGetNewText(var->Values[curInd].Str, -1);
else
QSP_NUM(res) = var->Values[curInd].Num;
return res;
}
QSPVariant qspGetVarValueByReference(QSPVar *var, int ind,
QSP_BOOL isStringType) {
QSPVariant ret;
QSP_CHAR *text;
if (ind >= 0 && ind < var->ValsCount) {
if (ret.IsStr = isStringType) {
text = var->Values[ind].Str;
QSP_STR(ret) =
(text ? qspGetNewText(text, -1) : qspGetNewText(QSP_FMT(""), 0));
} else
QSP_NUM(ret) = var->Values[ind].Num;
return ret;
}
return qspGetEmptyVariant(isStringType);
}
QSP_BOOL qspStatementCloseFile(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
int pos;
QSP_CHAR *file;
if (!qspPLFilesCount) return QSP_FALSE;
if (count)
{
if (qspIsAnyString(QSP_STR(args[0])))
{
pos = qspSearchPlayList(QSP_STR(args[0]));
if (pos >= 0)
{
file = qspGetAbsFromRelPath(QSP_STR(args[0]));
qspCallCloseFile(file);
free(file);
do
{
free(qspPLFiles[pos]);
--qspPLFilesCount;
while (pos < qspPLFilesCount)
{
qspPLFiles[pos] = qspPLFiles[pos + 1];
++pos;
}
pos = qspSearchPlayList(QSP_STR(args[0]));
} while (pos >= 0);
}
}
}
else
{
qspClearPlayList(QSP_FALSE);
qspCallCloseFile(0);
}
return QSP_FALSE;
}
QSP_BOOL qspStatementDelObj(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
switch (extArg)
{
case 0:
qspRemoveObject(qspObjIndex(QSP_STR(args[0])));
break;
case 1:
if (count)
qspRemoveObject(QSP_NUM(args[0]) - 1);
else
qspClearObjectsWithNotify();
break;
}
return QSP_FALSE;
}
QSP_BOOL qspStatementDelAct(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
int actInd = qspActIndex(QSP_STR(args[0]));
if (actInd < 0) return QSP_FALSE;
if (qspCurSelAction >= actInd) qspCurSelAction = -1;
if (qspCurActions[actInd].Image) free(qspCurActions[actInd].Image);
free(qspCurActions[actInd].Desc);
qspFreePrepLines(qspCurActions[actInd].OnPressLines, qspCurActions[actInd].OnPressLinesCount);
--qspCurActionsCount;
while (actInd < qspCurActionsCount)
{
qspCurActions[actInd] = qspCurActions[actInd + 1];
++actInd;
}
qspIsActionsChanged = QSP_TRUE;
return QSP_FALSE;
}
void qspStatementSetVarValue(QSP_CHAR *s)
{
QSPVariant v;
int oldRefreshCount;
QSP_CHAR ch, *name, *pos = qspStrPos(s, QSP_EQUAL, QSP_FALSE);
if (!pos)
{
qspSetError(QSP_ERR_EQNOTFOUND);
return;
}
oldRefreshCount = qspRefreshCount;
v = qspExprValue(pos + QSP_LEN(QSP_EQUAL));
if (qspRefreshCount != oldRefreshCount || qspErrorNum) return;
if (pos != s && qspIsInList(QSP_ADD QSP_SUB QSP_DIV QSP_MUL, *(pos - 1))) --pos;
ch = *pos;
*pos = 0;
name = qspDelSpcCanRetSelf(s);
qspSetVarValue(name, &v, ch);
*pos = ch;
if (name != s) free(name);
if (v.IsStr) free(QSP_STR(v));
}
void qspClearObjectsWithNotify()
{
QSPVariant v;
QSP_CHAR **objs;
int i, oldRefreshCount, oldCount = qspCurObjectsCount;
if (oldCount)
{
objs = (QSP_CHAR **)malloc(oldCount * sizeof(QSP_CHAR *));
for (i = 0; i < oldCount; ++i)
qspAddText(objs + i, qspCurObjects[i].Desc, 0, -1, QSP_TRUE);
qspClearObjects(QSP_FALSE);
v.IsStr = QSP_TRUE;
oldRefreshCount = qspRefreshCount;
for (i = 0; i < oldCount; ++i)
{
QSP_STR(v) = objs[i];
qspExecLocByVarNameWithArgs(QSP_FMT("ONOBJDEL"), &v, 1);
if (qspRefreshCount != oldRefreshCount || qspErrorNum) break;
}
qspFreeStrs(objs, oldCount);
}
}
int qspArrayPos(QSPVariant *args, int argsCount, QSP_BOOL isRegExp)
{
int num, count, ind;
QSPVar *var;
QSPVariant *val;
QSP_CHAR *str;
OnigUChar *tempBeg, *tempEnd;
regex_t *onigExp;
OnigErrorInfo onigInfo;
QSP_BOOL isString;
if (qspConvertVariantTo(args, argsCount == 2))
{
qspSetError(QSP_ERR_TYPEMISMATCH);
return -1;
}
if (argsCount == 2)
{
str = QSP_STR(args[0]);
ind = 0;
val = args + 1;
}
else
{
qspConvertVariantTo(args + 1, QSP_TRUE);
str = QSP_STR(args[1]);
ind = QSP_NUM(args[0]);
val = args + 2;
if (ind < 0) ind = 0;
}
if (!(var = qspVarReferenceWithType(str, QSP_FALSE, &isString))) return -1;
if (qspConvertVariantTo(val, isRegExp || isString))
{
qspSetError(QSP_ERR_TYPEMISMATCH);
return -1;
}
if (isRegExp)
{
tempBeg = (OnigUChar *)QSP_PSTR(val);
tempEnd = (OnigUChar *)qspStrEnd(QSP_PSTR(val));
if (onig_new(&onigExp, tempBeg, tempEnd, ONIG_OPTION_DEFAULT, QSP_ONIG_ENC, ONIG_SYNTAX_PERL_NG, &onigInfo))
{
qspSetError(QSP_ERR_INCORRECTREGEXP);
return -1;
}
}
count = var->ValsCount;
if (ind > count) ind = count;
while (ind <= count)
{
if (val->IsStr)
{
if (!(ind < count && (str = var->Values[ind].Str))) str = QSP_FMT("");
if (isRegExp)
{
tempBeg = (OnigUChar *)str;
tempEnd = (OnigUChar *)qspStrEnd(str);
if (onig_match(onigExp, tempBeg, tempEnd, tempBeg, 0, ONIG_OPTION_NONE) == tempEnd - tempBeg)
{
onig_free(onigExp);
return ind;
}
}
else if (!qspStrsComp(str, QSP_PSTR(val)))
return ind;
}
else
{
num = (ind < count ? var->Values[ind].Num : 0);
if (num == QSP_PNUM(val)) return ind;
}
++ind;
}
if (isRegExp) onig_free(onigExp);
return -1;
}
void qspStatementLocal(QSP_CHAR *s)
{
QSPVariant v;
QSPVar *var;
QSP_BOOL isVarFound;
QSP_CHAR *curPos, *varName, *commaPos, *eqPos;
int i, groupInd, count, bufSize, oldRefreshCount;
s = qspSkipSpaces(s);
if (!(*s))
{
qspSetError(QSP_ERR_SYNTAX);
return;
}
groupInd = qspSavedVarsGroupsCount - 1;
count = bufSize = qspSavedVarsGroups[groupInd].VarsCount;
isVarFound = QSP_FALSE;
curPos = s;
eqPos = qspStrPos(curPos, QSP_EQUAL, QSP_FALSE);
if (eqPos) *eqPos = 0;
while (1)
{
/* Skip type char */
if (*curPos == QSP_STRCHAR[0]) ++curPos;
/* Get variable's name */
commaPos = qspStrPos(curPos, QSP_COMMA, QSP_FALSE);
if (commaPos)
{
*commaPos = 0;
varName = (eqPos ? qspGetVarNameOnly(curPos) : qspDelSpc(curPos));
*commaPos = QSP_COMMA[0];
}
else
varName = (eqPos ? qspGetVarNameOnly(curPos) : qspDelSpc(curPos));
qspUpperStr(varName);
/* Check for the existence */
for (i = 0; i < count; ++i)
{
if (!qspStrsComp(varName, qspSavedVarsGroups[groupInd].Vars[i].Name))
{
isVarFound = QSP_TRUE;
break;
}
}
/* Get variable's data */
if (isVarFound)
{
/* Already exists */
isVarFound = QSP_FALSE;
free(varName);
}
else
{
/* Add variable to the local group */
if (!(var = qspVarReference(varName, QSP_FALSE)))
{
free(varName);
if (eqPos) *eqPos = QSP_EQUAL[0];
return;
}
if (count >= bufSize)
{
bufSize = count + 4;
qspSavedVarsGroups[groupInd].Vars = (QSPVar *)realloc(qspSavedVarsGroups[groupInd].Vars, bufSize * sizeof(QSPVar));
}
qspMoveVar(qspSavedVarsGroups[groupInd].Vars + count, var);
qspSavedVarsGroups[groupInd].Vars[count].Name = varName;
qspSavedVarsGroups[groupInd].VarsCount = ++count;
}
if (!commaPos) break;
curPos = qspSkipSpaces(commaPos + QSP_LEN(QSP_COMMA));
if (!(*curPos))
{
qspSetError(QSP_ERR_SYNTAX);
if (eqPos) *eqPos = QSP_EQUAL[0];
return;
}
}
if (eqPos)
{
oldRefreshCount = qspRefreshCount;
v = qspExprValue(eqPos + QSP_LEN(QSP_EQUAL));
if (qspRefreshCount != oldRefreshCount || qspErrorNum)
{
*eqPos = QSP_EQUAL[0];
return;
}
varName = qspDelSpcCanRetSelf(s);
qspSetVarValue(varName, &v, QSP_EQUAL[0]);
if (varName != s) free(varName);
if (v.IsStr) free(QSP_STR(v));
*eqPos = QSP_EQUAL[0];
}
}
static void qspSetVarValue(QSP_CHAR *name, QSPVariant *v, QSP_CHAR op)
{
QSPVariant v2;
QSP_BOOL isSingleValue, notFirstValue = QSP_FALSE;
QSP_CHAR *newValPos, *newCommaPos, *valPos, *commaPos = name;
int oldRefreshCount = qspRefreshCount;
if (v->IsStr)
{
valPos = QSP_PSTR(v);
isSingleValue = QSP_FALSE; /* Multiple values by default */
}
else
isSingleValue = QSP_TRUE;
while (1)
{
newCommaPos = qspStrPos(commaPos, QSP_COMMA, QSP_FALSE);
if (newCommaPos)
{
*newCommaPos = 0;
if (isSingleValue)
{
if (notFirstValue)
qspSetVar(commaPos, &v2, op);
else
qspSetVar(commaPos, v, op);
if (qspRefreshCount != oldRefreshCount || qspErrorNum)
{
*newCommaPos = QSP_COMMA[0];
break;
}
}
else
{
newValPos = qspStrStr(valPos, QSP_VALSDELIM);
if (newValPos)
{
notFirstValue = QSP_TRUE;
v2.IsStr = QSP_TRUE;
QSP_STR(v2) = qspGetNewText(valPos, (int)(newValPos - valPos));
qspSetVar(commaPos, &v2, op);
if (qspRefreshCount != oldRefreshCount || qspErrorNum)
{
*newCommaPos = QSP_COMMA[0];
break;
}
if (v2.IsStr) free(QSP_STR(v2));
valPos = newValPos + QSP_LEN(QSP_VALSDELIM);
}
else /* The last value */
{
isSingleValue = QSP_TRUE;
if (notFirstValue)
{
v2.IsStr = QSP_TRUE;
QSP_STR(v2) = qspGetNewText(valPos, -1);
qspSetVar(commaPos, &v2, op);
}
else
qspSetVar(commaPos, v, op);
if (qspRefreshCount != oldRefreshCount || qspErrorNum)
{
*newCommaPos = QSP_COMMA[0];
break;
}
}
}
*newCommaPos = QSP_COMMA[0];
}
else /* The last variable */
{
if (notFirstValue) /* Not a first value */
{
if (!isSingleValue)
{
v2.IsStr = QSP_TRUE;
QSP_STR(v2) = qspGetNewText(valPos, -1);
}
qspSetVar(commaPos, &v2, op);
}
else
qspSetVar(commaPos, v, op);
break;
}
commaPos = newCommaPos + QSP_LEN(QSP_COMMA);
}
if (notFirstValue && v2.IsStr) free(QSP_STR(v2));
}
void qspFreeVariants(QSPVariant *args, int count)
{
while (--count >= 0)
if (args[count].IsStr) free(QSP_STR(args[count]));
}
QSP_BOOL qspStatementPlayFile(QSPVariant *args, int count, QSP_CHAR **jumpTo, int extArg)
{
int volume = (count == 2 ? QSP_NUM(args[1]) : 100);
qspPlayFile(QSP_STR(args[0]), volume, QSP_TRUE);
return QSP_FALSE;
}
