示例#1
0
ScriptVariant *ScriptVariant_Add(ScriptVariant * svar, ScriptVariant * rightChild) {
	static ScriptVariant retvar;
	static int flag = 1;
	DOUBLE dbl1, dbl2;
	CHAR buf[MAX_STR_VAR_LEN + 1];
	if(flag) {
		ScriptVariant_Init(&retvar);
		flag = 0;
	} else
		ScriptVariant_Clear(&retvar);
	if(ScriptVariant_DecimalValue(svar, &dbl1) == S_OK && ScriptVariant_DecimalValue(rightChild, &dbl2) == S_OK) {
		if(svar->vt == VT_DECIMAL || rightChild->vt == VT_DECIMAL) {
			ScriptVariant_ChangeType(&retvar, VT_DECIMAL);
			retvar.dblVal = dbl1 + dbl2;
		} else {
			ScriptVariant_ChangeType(&retvar, VT_INTEGER);
			retvar.lVal = (LONG) (dbl1 + dbl2);
		}
	} else if(svar->vt == VT_STR || rightChild->vt == VT_STR) {
		ScriptVariant_ChangeType(&retvar, VT_STR);
		StrCache_Get(retvar.strVal)[0] = 0;
		ScriptVariant_ToString(svar, StrCache_Get(retvar.strVal));
		ScriptVariant_ToString(rightChild, buf);
		strcat(StrCache_Get(retvar.strVal), buf);
	}

	return &retvar;
}
示例#2
0
// faster if it is not VT_STR
void ScriptVariant_Copy(ScriptVariant * svar, ScriptVariant * rightChild) {
	// collect the str cache index
	if(svar->vt == VT_STR && rightChild->vt != VT_STR) {
		StrCache_Collect(svar->strVal);
	}
	switch (rightChild->vt) {
		case VT_INTEGER:
			svar->lVal = rightChild->lVal;
			break;
		case VT_DECIMAL:
			svar->dblVal = rightChild->dblVal;
			break;
		case VT_PTR:
			svar->ptrVal = rightChild->ptrVal;
			break;
		case VT_STR:
			// if it is not string, give it a string cache index
			if(svar->vt != VT_STR)
				svar->strVal = StrCache_Pop();
			StrCache_Get(rightChild->strVal)[MAX_STR_VAR_LEN] = 0;
			strcpy(StrCache_Get(svar->strVal), StrCache_Get(rightChild->strVal));
			break;
		default:
			//should not happen unless the variant is not intialized correctly
			//shutdown(1, "invalid variant type");
			svar->ptrVal = NULL;
			break;
	}
	svar->vt = rightChild->vt;
}
示例#3
0
文件: string.c 项目: DCurrent/openbor
//strleft(char string, int i);
HRESULT openbor_strleft(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    const char *src;
    char *dst;
    int srcLength, dstLength;

    if(paramCount < 2)
    {
        goto sl_error;
    }

    if(varlist[0]->vt != VT_STR || varlist[1]->vt != VT_INTEGER)
    {
        printf("\n Error, strleft({string}, {characters}): Invalid or missing parameter. Strleft must be passed valid {string} and number of {characters}.\n");
        goto sl_error;
    }

    src = StrCache_Get(varlist[0]->strVal);
    srcLength = strlen(src);
    dstLength = (srcLength < varlist[1]->lVal) ? srcLength : varlist[1]->lVal;
    ScriptVariant_ChangeType(*pretvar, VT_STR);
    (*pretvar)->strVal = StrCache_Pop(dstLength);
    dst = StrCache_Get((*pretvar)->strVal);
    memcpy(dst, src, dstLength);
    dst[dstLength] = '\0';

    return S_OK;
sl_error:
    *pretvar = NULL;
    return E_FAIL;
}
示例#4
0
文件: string.c 项目: DCurrent/openbor
//strinfirst(char string, char search_string);
HRESULT openbor_strinfirst(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    char *tempstr = NULL;

    if(paramCount < 2)
    {
        goto sif_error;
    }

    if(varlist[0]->vt != VT_STR || varlist[1]->vt != VT_STR)
    {
        printf("\n Error, strinfirst({string}, {search string}): Strinfirst must be passed valid {string} and {search string}. \n");
        goto sif_error;
    }

    tempstr = strstr((char *)StrCache_Get(varlist[0]->strVal), (char *)StrCache_Get(varlist[1]->strVal));

    if (tempstr != NULL)
    {
        ScriptVariant_ChangeType(*pretvar, VT_STR);
        (*pretvar)->strVal = StrCache_CreateNewFrom(tempstr);
    }
    else
    {
        ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
        (*pretvar)->lVal = -1;
    }
    return S_OK;

sif_error:
    *pretvar = NULL;
    return E_FAIL;
}
示例#5
0
文件: string.c 项目: DCurrent/openbor
//strinlast(char string, char search_string);
HRESULT openbor_strinlast(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    char *tempstr = NULL;

    if(paramCount < 2)
    {
        goto sil_error;
    }

    if(varlist[0]->vt != VT_STR || varlist[1]->vt != VT_STR)
    {
        printf("\n Error, strinlast({string}, {search string}): Strinlast must be passed valid {string} and {search string}. \n");
        goto sil_error;
    }

    // this definitely doesn't work??? it interprets a string cache index as a character
    tempstr = strrchr((char *)StrCache_Get(varlist[0]->strVal), varlist[1]->strVal);

    if (tempstr != NULL)
    {
        ScriptVariant_ChangeType(*pretvar, VT_STR);
        (*pretvar)->strVal = StrCache_CreateNewFrom(tempstr);
    }
    else
    {
        ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
        (*pretvar)->lVal = -1;
    }
    return S_OK;
sil_error:
    *pretvar = NULL;
    return E_FAIL;
}
示例#6
0
文件: string.c 项目: DCurrent/openbor
//strright(char string, int i);
HRESULT openbor_strright(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    char *tempstr = NULL;

    if(paramCount < 2)
    {
        goto sr_error;
    }

    if(varlist[0]->vt != VT_STR || varlist[1]->vt != VT_INTEGER)
    {
        printf("\n Error, strright({string}, {characters}): Invalid or missing parameter. Strright must be passed valid {string} and number of {characters}.\n");
        goto sr_error;
    }

    tempstr = (char *)StrCache_Get(varlist[0]->strVal);

    if (tempstr && tempstr[0])
    {
        ScriptVariant_ChangeType(*pretvar, VT_STR);
        (*pretvar)->strVal = StrCache_CreateNewFrom(&tempstr[varlist[1]->lVal]);
    }
    else
    {
        ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
        (*pretvar)->lVal = -1;
    }

    return S_OK;
sr_error:
    *pretvar = NULL;
    return E_FAIL;
}
示例#7
0
ScriptVariant *ScriptVariant_Le(ScriptVariant * svar, ScriptVariant * rightChild) {
	DOUBLE dbl1, dbl2;
	static ScriptVariant retvar;
	retvar.vt = VT_INTEGER;

	if(ScriptVariant_DecimalValue(svar, &dbl1) == S_OK && ScriptVariant_DecimalValue(rightChild, &dbl2) == S_OK) {
		retvar.lVal = (dbl1 <= dbl2);
	} else if(svar->vt == VT_STR && rightChild->vt == VT_STR) {
		retvar.lVal = (strcmp(StrCache_Get(svar->strVal), StrCache_Get(rightChild->strVal)) <= 0);
	} else if(svar->vt == VT_PTR && rightChild->vt == VT_PTR) {
		retvar.lVal = (svar->ptrVal <= rightChild->ptrVal);
	} else if(svar->vt == VT_EMPTY || rightChild->vt == VT_EMPTY) {
		retvar.lVal = 0;
	} else {
		retvar.lVal = (memcmp(svar, rightChild, sizeof(ScriptVariant)) <= 0);
	}

	return &retvar;
}
示例#8
0
BOOL ScriptVariant_IsTrue(ScriptVariant * svar) {
	switch (svar->vt) {
		case VT_STR:
			return StrCache_Get(svar->strVal)[0] != 0;
		case VT_INTEGER:
			return svar->lVal != 0;
		case VT_DECIMAL:
			return svar->dblVal != 0.0;
		case VT_PTR:
			return svar->ptrVal != 0;
		default:
			return 0;
	}
}
示例#9
0
文件: string.c 项目: DCurrent/openbor
//strlength(char string);
HRESULT openbor_strlength(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    if(paramCount < 1 || varlist[0]->vt != VT_STR)
    {
        goto strlength_error;
    }

    ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
    (*pretvar)->lVal = strlen((char *)StrCache_Get(varlist[0]->strVal));
    return S_OK;

strlength_error:
    printf("Error, strlength({string}): Invalid or missing parameter. Strlength must be passed a valid {string}.\n");
    *pretvar = NULL;
    return E_FAIL;
}
示例#10
0
文件: string.c 项目: DCurrent/openbor
//strwidth(char string, int font);
HRESULT openbor_strwidth(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
{
    LONG ltemp;
    if(paramCount < 2 || varlist[0]->vt != VT_STR ||
            FAILED(ScriptVariant_IntegerValue(varlist[1], &ltemp)))
    {
        goto strwidth_error;
    }

    ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
    (*pretvar)->lVal = font_string_width((int)ltemp, (char *)StrCache_Get(varlist[0]->strVal));
    return S_OK;

strwidth_error:
    printf("Error, strwidth({string}, {font}): Invalid or missing parameter.\n");
    *pretvar = NULL;
    return E_FAIL;
}
示例#11
0
void ScriptVariant_ToString(ScriptVariant * svar, LPSTR buffer) {
	switch (svar->vt) {
		case VT_EMPTY:
			sprintf(buffer, "<VT_EMPTY>   Unitialized");
			break;
		case VT_INTEGER:
			sprintf(buffer, "%d", svar->lVal);
			break;
		case VT_DECIMAL:
			sprintf(buffer, "%lf", svar->dblVal);
			break;
		case VT_PTR:
			sprintf(buffer, "#%ld", (long) (svar->ptrVal));
			break;
		case VT_STR:
			sprintf(buffer, "%s", StrCache_Get(svar->strVal));
			break;
		default:
			sprintf(buffer, "<Unprintable VARIANT type.>");
			break;
	}
}
示例#12
0
//'compile' constant to improve speed
void Instruction_ConvertConstant(Instruction * pins) {
	ScriptVariant *pvar;
	if(pins->theVal)
		return;		//already have the constant as a variant
	if(pins->OpCode == CONSTDBL) {
		pvar = (ScriptVariant *) malloc(sizeof(ScriptVariant));
		ScriptVariant_Init(pvar);
		ScriptVariant_ChangeType(pvar, VT_DECIMAL);
		if(pins->theToken->theType != END_OF_TOKENS)
			pvar->dblVal = (DOUBLE) atof(pins->theToken->theSource);
		else
			pvar->dblVal = (DOUBLE) atof(pins->Label);
	} else if(pins->OpCode == CONSTINT || pins->OpCode == CHECKARG) {
		pvar = (ScriptVariant *) malloc(sizeof(ScriptVariant));
		ScriptVariant_Init(pvar);
		ScriptVariant_ChangeType(pvar, VT_INTEGER);
		if(pins->theToken->theType != END_OF_TOKENS) {
			if(pins->theToken->theType == TOKEN_HEXCONSTANT)
				pvar->lVal = (LONG) htoi(pins->theToken->theSource);
			else
				pvar->lVal = (LONG) atoi(pins->theToken->theSource);
		} else {
			if(pins->Label[1] == 'x' || pins->Label[1] == 'X')
				pvar->lVal = (LONG) htoi(pins->Label);
			else
				pvar->lVal = (LONG) atoi(pins->Label);
		}
	} else if(pins->OpCode == CONSTSTR) {
		pvar = (ScriptVariant *) malloc(sizeof(ScriptVariant));
		ScriptVariant_Init(pvar);
		ScriptVariant_ChangeType(pvar, VT_STR);
		strcpy(StrCache_Get(pvar->strVal), pins->theToken->theSource);
	} else
		return;
	pins->theVal = pvar;
}