X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=696ffea0439643df575f5b301f9025f7e9dd2c91;hp=fcf3d8ba40967301ca9134116435bc9ca4b52d12;hb=547431f0203479c4e594e1e85cb294ea843282b9;hpb=6d6d58848fff87265ba4b74328d5902f36631ff6 diff --git a/prvm_cmds.c b/prvm_cmds.c index fcf3d8ba..696ffea0 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -4,22 +4,34 @@ // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds // also applies here +#include "quakedef.h" + #include "prvm_cmds.h" +#include "libcurl.h" #include +extern cvar_t prvm_backtraceforwarnings; + // LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value void VM_Warning(const char *fmt, ...) { va_list argptr; char msg[MAX_INPUTLINE]; + static double recursive = -1; va_start(argptr,fmt); dpvsnprintf(msg,sizeof(msg),fmt,argptr); va_end(argptr); Con_Print(msg); + // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black] - //PRVM_PrintState(); + if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set + { + recursive = realtime; + PRVM_PrintState(); + recursive = -1; + } } @@ -318,50 +330,14 @@ void VM_vectoyaw (void) ================= VM_vectoangles -vector vectoangles(vector) +vector vectoangles(vector[, vector]) ================= */ void VM_vectoangles (void) { - float *value1; - float forward; - float yaw, pitch; - - VM_SAFEPARMCOUNT(1,VM_vectoangles); - - value1 = PRVM_G_VECTOR(OFS_PARM0); - - if (value1[1] == 0 && value1[0] == 0) - { - yaw = 0; - if (value1[2] > 0) - pitch = 90; - else - pitch = 270; - } - else - { - // LordHavoc: optimized a bit - if (value1[0]) - { - yaw = (atan2(value1[1], value1[0]) * 180 / M_PI); - if (yaw < 0) - yaw += 360; - } - else if (value1[1] > 0) - yaw = 90; - else - yaw = 270; + VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles); - forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]); - pitch = (atan2(value1[2], forward) * 180 / M_PI); - if (pitch < 0) - pitch += 360; - } - - PRVM_G_FLOAT(OFS_RETURN+0) = pitch; - PRVM_G_FLOAT(OFS_RETURN+1) = yaw; - PRVM_G_FLOAT(OFS_RETURN+2) = 0; + AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true); } /* @@ -453,6 +429,49 @@ void VM_cvar (void) PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string); } +/* +================= +VM_cvar + +float cvar_type (string) +float CVAR_TYPEFLAG_EXISTS = 1; +float CVAR_TYPEFLAG_SAVED = 2; +float CVAR_TYPEFLAG_PRIVATE = 4; +float CVAR_TYPEFLAG_ENGINE = 8; +float CVAR_TYPEFLAG_HASDESCRIPTION = 16; +================= +*/ +void VM_cvar_type (void) +{ + char string[VM_STRINGTEMP_LENGTH]; + cvar_t *cvar; + int ret; + + VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar); + VM_VarString(0, string, sizeof(string)); + VM_CheckEmptyString(string); + cvar = Cvar_FindVar(string); + + + if(!cvar) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; + return; // CVAR_TYPE_NONE + } + + ret = 1; // CVAR_EXISTS + if(cvar->flags & CVAR_SAVE) + ret |= 2; // CVAR_TYPE_SAVED + if(cvar->flags & CVAR_PRIVATE) + ret |= 4; // CVAR_TYPE_PRIVATE + if(!(cvar->flags & CVAR_ALLOCATED)) + ret |= 8; // CVAR_TYPE_ENGINE + if(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string + ret |= 16; // CVAR_TYPE_HASDESCRIPTION + + PRVM_G_FLOAT(OFS_RETURN) = ret; +} + /* ================= VM_cvar_string @@ -543,9 +562,9 @@ void VM_ftos (void) v = PRVM_G_FLOAT(OFS_PARM0); if ((float)((int)v) == v) - sprintf(s, "%i", (int)v); + dpsnprintf(s, sizeof(s), "%i", (int)v); else - sprintf(s, "%f", v); + dpsnprintf(s, sizeof(s), "%f", v); PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } @@ -581,7 +600,7 @@ void VM_vtos (void) VM_SAFEPARMCOUNT(1,VM_vtos); - sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]); + dpsnprintf (s, sizeof(s), "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]); PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } @@ -599,7 +618,7 @@ void VM_etos (void) VM_SAFEPARMCOUNT(1, VM_etos); - sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0)); + dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0)); PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } @@ -650,6 +669,19 @@ void VM_ftoe(void) PRVM_G_INT(OFS_RETURN) = ent; } +/* +======================== +VM_etof + +float etof(entity ent) +======================== +*/ +void VM_etof(void) +{ + VM_SAFEPARMCOUNT(1, VM_etof); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0); +} + /* ========= VM_strftime @@ -660,23 +692,40 @@ string strftime(float uselocaltime, string[, string ...]) void VM_strftime(void) { time_t t; +#if _MSC_VER >= 1400 + struct tm tm; + int tmresult; +#else struct tm *tm; +#endif char fmt[VM_STRINGTEMP_LENGTH]; char result[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime); VM_VarString(1, fmt, sizeof(fmt)); t = time(NULL); +#if _MSC_VER >= 1400 + if (PRVM_G_FLOAT(OFS_PARM0)) + tmresult = localtime_s(&tm, &t); + else + tmresult = gmtime_s(&tm, &t); + if (!tmresult) +#else if (PRVM_G_FLOAT(OFS_PARM0)) tm = localtime(&t); else tm = gmtime(&t); if (!tm) +#endif { - PRVM_G_FLOAT(OFS_RETURN) = 0; + PRVM_G_INT(OFS_RETURN) = 0; return; } +#if _MSC_VER >= 1400 + strftime(result, sizeof(result), fmt, &tm); +#else strftime(result, sizeof(result), fmt, tm); - PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result); +#endif + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result); } /* @@ -1537,28 +1586,29 @@ void VM_fopen(void) VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES); return; } + filename = PRVM_G_STRING(OFS_PARM0); mode = (int)PRVM_G_FLOAT(OFS_PARM1); switch(mode) { case 0: // FILE_READ modestring = "rb"; + prog->openfiles[filenum] = FS_OpenVirtualFile(va("data/%s", filename), false); + if (prog->openfiles[filenum] == NULL) + prog->openfiles[filenum] = FS_OpenVirtualFile(va("%s", filename), false); break; case 1: // FILE_APPEND - modestring = "ab"; + modestring = "a"; + prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false); break; case 2: // FILE_WRITE - modestring = "wb"; + modestring = "w"; + prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false); break; default: PRVM_G_FLOAT(OFS_RETURN) = -3; VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode); return; } - filename = PRVM_G_STRING(OFS_PARM0); - - prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false); - if (prog->openfiles[filenum] == NULL && mode == 0) - prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false); if (prog->openfiles[filenum] == NULL) { @@ -1571,6 +1621,7 @@ void VM_fopen(void) PRVM_G_FLOAT(OFS_RETURN) = filenum; if (developer.integer >= 100) Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum); + prog->openfiles_origin[filenum] = PRVM_AllocationOrigin(); } } @@ -1601,6 +1652,8 @@ void VM_fclose(void) } FS_Close(prog->openfiles[filenum]); prog->openfiles[filenum] = NULL; + if(prog->openfiles_origin[filenum]) + PRVM_Free((char *)prog->openfiles_origin[filenum]); if (developer.integer >= 100) Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum); } @@ -1621,6 +1674,9 @@ void VM_fgets(void) VM_SAFEPARMCOUNT(1,VM_fgets); + // set the return value regardless of any possible errors + PRVM_G_INT(OFS_RETURN) = OFS_NULL; + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES) { @@ -1653,8 +1709,6 @@ void VM_fgets(void) Con_Printf("fgets: %s: %s\n", PRVM_NAME, string); if (c >= 0 || end) PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); - else - PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -1722,6 +1776,155 @@ void VM_writetofile(void) PRVM_ED_Write (file, ent); } +// KrimZon - DP_QC_ENTITYDATA +/* +========= +VM_numentityfields + +float() numentityfields +Return the number of entity fields - NOT offsets +========= +*/ +void VM_numentityfields(void) +{ + PRVM_G_FLOAT(OFS_RETURN) = prog->progs->numfielddefs; +} + +// KrimZon - DP_QC_ENTITYDATA +/* +========= +VM_entityfieldname + +string(float fieldnum) entityfieldname +Return name of the specified field as a string, or empty if the field is invalid (warning) +========= +*/ +void VM_entityfieldname(void) +{ + ddef_t *d; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfieldname: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + return; + } + + d = &prog->fielddefs[i]; + PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already +} + +// KrimZon - DP_QC_ENTITYDATA +/* +========= +VM_entityfieldtype + +float(float fieldnum) entityfieldtype +========= +*/ +void VM_entityfieldtype(void) +{ + ddef_t *d; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfieldtype: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = -1.0; + return; + } + + d = &prog->fielddefs[i]; + PRVM_G_FLOAT(OFS_RETURN) = (float)d->type; +} + +// KrimZon - DP_QC_ENTITYDATA +/* +========= +VM_getentityfieldstring + +string(float fieldnum, entity ent) getentityfieldstring +========= +*/ +void VM_getentityfieldstring(void) +{ + // put the data into a string + ddef_t *d; + int type, j; + int *v; + prvm_edict_t * ent; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + return; + } + + d = &prog->fielddefs[i]; + + // get the entity + ent = PRVM_G_EDICT(OFS_PARM1); + if(ent->priv.required->free) + { + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); + VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + return; + } + v = (int *)((char *)ent->fields.vp + d->ofs*4); + + // if it's 0 or blank, return an empty string + type = d->type & ~DEF_SAVEGLOBAL; + for (j=0 ; jtype, (prvm_eval_t *)v)); +} + +// KrimZon - DP_QC_ENTITYDATA +/* +========= +VM_putentityfieldstring + +float(float fieldnum, entity ent, string s) putentityfieldstring +========= +*/ +void VM_putentityfieldstring(void) +{ + ddef_t *d; + prvm_edict_t * ent; + int i = (int)PRVM_G_FLOAT(OFS_PARM0); + + if (i < 0 || i >= prog->progs->numfielddefs) + { + VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME); + PRVM_G_FLOAT(OFS_RETURN) = 0.0f; + return; + } + + d = &prog->fielddefs[i]; + + // get the entity + ent = PRVM_G_EDICT(OFS_PARM1); + if(ent->priv.required->free) + { + VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent)); + PRVM_G_FLOAT(OFS_RETURN) = 0.0f; + return; + } + + // parse the string into the value + PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2)) ) ? 1.0f : 0.0f; +} + /* ========= VM_strlen @@ -1754,9 +1957,7 @@ void VM_strdecolorize(void) // Prepare Strings VM_SAFEPARMCOUNT(1,VM_strdecolorize); szString = PRVM_G_STRING(OFS_PARM0); - COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE); - PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); } @@ -1875,6 +2076,106 @@ void VM_substring(void) PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } +/* +========= +VM_strreplace + +string(string search, string replace, string subject) strreplace = #484; +========= +*/ +// replaces all occurrences of search with replace in the string subject, and returns the result +void VM_strreplace(void) +{ + int i, j, si; + const char *search, *replace, *subject; + char string[VM_STRINGTEMP_LENGTH]; + int search_len, replace_len, subject_len; + + VM_SAFEPARMCOUNT(3,VM_strreplace); + + search = PRVM_G_STRING(OFS_PARM0); + replace = PRVM_G_STRING(OFS_PARM1); + subject = PRVM_G_STRING(OFS_PARM2); + + search_len = (int)strlen(search); + replace_len = (int)strlen(replace); + subject_len = (int)strlen(subject); + + si = 0; + for (i = 0; i < subject_len; i++) + { + for (j = 0; j < search_len && i+j < subject_len; j++) + if (subject[i+j] != search[j]) + break; + if (j == search_len || i+j == subject_len) + { + // found it at offset 'i' + for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++) + string[si++] = replace[j]; + i += search_len - 1; + } + else + { + // not found + if (si < (int)sizeof(string) - 1) + string[si++] = subject[i]; + } + } + string[si] = '\0'; + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); +} + +/* +========= +VM_strireplace + +string(string search, string replace, string subject) strireplace = #485; +========= +*/ +// case-insensitive version of strreplace +void VM_strireplace(void) +{ + int i, j, si; + const char *search, *replace, *subject; + char string[VM_STRINGTEMP_LENGTH]; + int search_len, replace_len, subject_len; + + VM_SAFEPARMCOUNT(3,VM_strreplace); + + search = PRVM_G_STRING(OFS_PARM0); + replace = PRVM_G_STRING(OFS_PARM1); + subject = PRVM_G_STRING(OFS_PARM2); + + search_len = (int)strlen(search); + replace_len = (int)strlen(replace); + subject_len = (int)strlen(subject); + + si = 0; + for (i = 0; i < subject_len; i++) + { + for (j = 0; j < search_len && i+j < subject_len; j++) + if (tolower(subject[i+j]) != tolower(search[j])) + break; + if (j == search_len || i+j == subject_len) + { + // found it at offset 'i' + for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++) + string[si++] = replace[j]; + i += search_len - 1; + } + else + { + // not found + if (si < (int)sizeof(string) - 1) + string[si++] = subject[i]; + } + } + string[si] = '\0'; + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); +} + /* ========= VM_stov @@ -1969,22 +2270,68 @@ float tokenize(string s) //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many //this function originally written by KrimZon, made shorter by LordHavoc //20040203: rewritten by LordHavoc (no longer uses allocations) -int num_tokens = 0; -int tokens[256]; +static int num_tokens = 0; +static int tokens[256]; +static int tokens_startpos[256]; +static int tokens_endpos[256]; void VM_tokenize (void) { const char *p; + const char *string; VM_SAFEPARMCOUNT(1,VM_tokenize); - p = PRVM_G_STRING(OFS_PARM0); + string = PRVM_G_STRING(OFS_PARM0); + p = string; + + num_tokens = 0; + for(;;) + { + if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) + break; + + // skip whitespace here to find token start pos + while(*p && (unsigned char) *p <= ' ') + ++p; + + tokens_startpos[num_tokens] = p - string; + if(!COM_ParseToken_VM_Tokenize(&p, false)) + break; + tokens_endpos[num_tokens] = p - string; + tokens[num_tokens] = PRVM_SetTempString(com_token); + ++num_tokens; + } + + PRVM_G_FLOAT(OFS_RETURN) = num_tokens; +} + +//float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many +void VM_tokenize_console (void) +{ + const char *p; + const char *string; + + VM_SAFEPARMCOUNT(1,VM_tokenize); + + string = PRVM_G_STRING(OFS_PARM0); + p = string; num_tokens = 0; - while(COM_ParseToken_VM_Tokenize(&p, false)) + for(;;) { if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) break; - tokens[num_tokens++] = PRVM_SetTempString(com_token); + + // skip whitespace here to find token start pos + while(*p && (unsigned char) *p <= ' ') + ++p; + + tokens_startpos[num_tokens] = p - string; + if(!COM_ParseToken_Console(&p)) + break; + tokens_endpos[num_tokens] = p - string; + tokens[num_tokens] = PRVM_SetTempString(com_token); + ++num_tokens; } PRVM_G_FLOAT(OFS_RETURN) = num_tokens; @@ -2013,12 +2360,14 @@ void VM_tokenizebyseparator (void) const char *p; const char *token; char tokentext[MAX_INPUTLINE]; + const char *string; VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator); - p = PRVM_G_STRING(OFS_PARM0); + string = PRVM_G_STRING(OFS_PARM0); + p = string; - numseparators = 0;; + numseparators = 0; for (j = 1;j < prog->argc;j++) { // skip any blank separator strings @@ -2036,6 +2385,7 @@ void VM_tokenizebyseparator (void) while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0]))) { token = tokentext + j; + tokens_startpos[num_tokens] = p - string; while (*p) { for (k = 0;k < numseparators;k++) @@ -2052,6 +2402,7 @@ void VM_tokenizebyseparator (void) tokentext[j++] = *p; p++; } + tokens_endpos[num_tokens] = p - string; if (j >= (int)sizeof(tokentext)) break; tokentext[j++] = 0; @@ -2073,12 +2424,51 @@ void VM_argv (void) token_num = (int)PRVM_G_FLOAT(OFS_PARM0); + if(token_num < 0) + token_num += num_tokens; + if (token_num >= 0 && token_num < num_tokens) PRVM_G_INT(OFS_RETURN) = tokens[token_num]; else PRVM_G_INT(OFS_RETURN) = OFS_NULL; } +//float(float n) argv_start_index = #515; // returns the start index of a token +void VM_argv_start_index (void) +{ + int token_num; + + VM_SAFEPARMCOUNT(1,VM_argv); + + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); + + if(token_num < 0) + token_num += num_tokens; + + if (token_num >= 0 && token_num < num_tokens) + PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num]; + else + PRVM_G_FLOAT(OFS_RETURN) = -1; +} + +//float(float n) argv_end_index = #516; // returns the end index of a token +void VM_argv_end_index (void) +{ + int token_num; + + VM_SAFEPARMCOUNT(1,VM_argv); + + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); + + if(token_num < 0) + token_num += num_tokens; + + if (token_num >= 0 && token_num < num_tokens) + PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num]; + else + PRVM_G_FLOAT(OFS_RETURN) = -1; +} + /* ========= VM_isserver @@ -2118,7 +2508,22 @@ void VM_clientstate(void) { VM_SAFEPARMCOUNT(0,VM_clientstate); - PRVM_G_FLOAT(OFS_RETURN) = cls.state; + + switch( cls.state ) { + case ca_uninitialized: + case ca_dedicated: + PRVM_G_FLOAT(OFS_RETURN) = 0; + break; + case ca_disconnected: + PRVM_G_FLOAT(OFS_RETURN) = 1; + break; + case ca_connected: + PRVM_G_FLOAT(OFS_RETURN) = 2; + break; + default: + // should never be reached! + break; + } } /* @@ -2147,23 +2552,6 @@ void VM_getostype(void) #endif } -/* -========= -VM_getmousepos - -vector getmousepos() -========= -*/ -void VM_getmousepos(void) -{ - - VM_SAFEPARMCOUNT(0,VM_getmousepos); - - PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x * vid_conwidth.integer / vid.width; - PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y * vid_conheight.integer / vid.height; - PRVM_G_VECTOR(OFS_RETURN)[2] = 0; -} - /* ========= VM_gettime @@ -2214,7 +2602,7 @@ void VM_parseentitydata(void) data = PRVM_G_STRING(OFS_PARM1); // parse the opening brace - if (!COM_ParseToken_Simple(&data, false) || com_token[0] != '{' ) + if (!COM_ParseToken_Simple(&data, false, false) || com_token[0] != '{' ) PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data ); PRVM_ED_ParseEdict (data, ent); @@ -2327,7 +2715,10 @@ void VM_search_begin(void) if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet))) PRVM_G_FLOAT(OFS_RETURN) = -1; else + { + prog->opensearches_origin[handle] = PRVM_AllocationOrigin(); PRVM_G_FLOAT(OFS_RETURN) = handle; + } } /* @@ -2357,6 +2748,8 @@ void VM_search_end(void) FS_FreeSearch(prog->opensearches[handle]); prog->opensearches[handle] = NULL; + if(prog->opensearches_origin[handle]) + PRVM_Free((char *)prog->opensearches_origin[handle]); } /* @@ -2475,7 +2868,7 @@ void VM_precache_pic(void) VM_CheckEmptyString (s); // AK Draw_CachePic is supposed to always return a valid pointer - if( Draw_CachePic(s, false)->tex == r_texture_notexture ) + if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture ) PRVM_G_INT(OFS_RETURN) = OFS_NULL; } @@ -2498,6 +2891,19 @@ void VM_freepic(void) Draw_FreePic(s); } +dp_font_t *getdrawfont() +{ + if(prog->globaloffsets.drawfont >= 0) + { + int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont); + if(f < 0 || f >= MAX_FONTS) + return FONT_DEFAULT; + return &dp_fonts[f]; + } + else + return FONT_DEFAULT; +} + /* ========= VM_drawcharacter @@ -2542,7 +2948,7 @@ void VM_drawcharacter(void) return; } - DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true); + DrawQ_String_Font(pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont()); PRVM_G_FLOAT(OFS_RETURN) = 1; } @@ -2583,9 +2989,68 @@ void VM_drawstring(void) if(pos[2] || scale[2]) Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); - DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true); + DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont()); PRVM_G_FLOAT(OFS_RETURN) = 1; } + +/* +========= +VM_drawcolorcodedstring + +float drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag) +========= +*/ +void VM_drawcolorcodedstring(void) +{ + float *pos,*scale; + const char *string; + int flag,color; + VM_SAFEPARMCOUNT(5,VM_drawstring); + + string = PRVM_G_STRING(OFS_PARM1); + pos = PRVM_G_VECTOR(OFS_PARM0); + scale = PRVM_G_VECTOR(OFS_PARM2); + flag = (int)PRVM_G_FLOAT(OFS_PARM4); + + if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(!scale[0] || !scale[1]) + { + PRVM_G_FLOAT(OFS_RETURN) = -3; + VM_Warning("VM_drawcolorcodedstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y"); + return; + } + + if(pos[2] || scale[2]) + Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); + + color = -1; + DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont()); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} +/* +========= +VM_stringwidth + +float stringwidth(string text, float allowColorCodes) +========= +*/ +void VM_stringwidth(void) +{ + const char *string; + int colors; + VM_SAFEPARMCOUNT(2,VM_drawstring); + + string = PRVM_G_STRING(OFS_PARM0); + colors = (int)PRVM_G_FLOAT(OFS_PARM1); + + PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw +} /* ========= VM_drawpic @@ -2627,7 +3092,61 @@ void VM_drawpic(void) if(pos[2] || size[2]) Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); - DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); + DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag); + PRVM_G_FLOAT(OFS_RETURN) = 1; +} +/* +========= +VM_drawsubpic + +float drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag) + +========= +*/ +void VM_drawsubpic(void) +{ + const char *picname; + float *size, *pos, *rgb, *srcPos, *srcSize, alpha; + int flag; + + VM_SAFEPARMCOUNT(8,VM_drawsubpic); + + picname = PRVM_G_STRING(OFS_PARM2); + VM_CheckEmptyString (picname); + + // is pic cached ? no function yet for that + if(!1) + { + PRVM_G_FLOAT(OFS_RETURN) = -4; + VM_Warning("VM_drawsubpic: %s: %s not cached !\n", PRVM_NAME, picname); + return; + } + + pos = PRVM_G_VECTOR(OFS_PARM0); + size = PRVM_G_VECTOR(OFS_PARM1); + srcPos = PRVM_G_VECTOR(OFS_PARM3); + srcSize = PRVM_G_VECTOR(OFS_PARM4); + rgb = PRVM_G_VECTOR(OFS_PARM5); + alpha = PRVM_G_FLOAT(OFS_PARM6); + flag = (int) PRVM_G_FLOAT(OFS_PARM7); + + if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS) + { + PRVM_G_FLOAT(OFS_RETURN) = -2; + VM_Warning("VM_drawsubpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag); + return; + } + + if(pos[2] || size[2]) + Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size"))); + + DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname), + size[0], size[1], + srcPos[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0] + srcSize[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha, + srcPos[0] + srcSize[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha, + flag); PRVM_G_FLOAT(OFS_RETURN) = 1; } @@ -2716,7 +3235,7 @@ void VM_getimagesize(void) p = PRVM_G_STRING(OFS_PARM0); VM_CheckEmptyString (p); - pic = Draw_CachePic (p, false); + pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT); PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width; PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height; @@ -2737,6 +3256,40 @@ void VM_keynumtostring (void) PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0))); } +/* +========= +VM_findkeysforcommand + +string findkeysforcommand(string command) + +the returned string is an altstring +========= +*/ +#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen + +void M_FindKeysForCommand(const char *command, int *keys); +void VM_findkeysforcommand(void) +{ + const char *cmd; + char ret[VM_STRINGTEMP_LENGTH]; + int keys[NUMKEYS]; + int i; + + VM_SAFEPARMCOUNT(1, VM_findkeysforcommand); + + cmd = PRVM_G_STRING(OFS_PARM0); + + VM_CheckEmptyString(cmd); + + M_FindKeysForCommand(cmd, keys); + + ret[0] = 0; + for(i = 0; i < NUMKEYS; i++) + strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret)); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret); +} + /* ========= VM_stringtokeynum @@ -2868,6 +3421,247 @@ void VM_cin_restart( void ) CL_RestartVideo( video ); } +/* +======================== +VM_Gecko_Init +======================== +*/ +void VM_Gecko_Init( void ) { + // the prog struct is memset to 0 by Initprog? [12/6/2007 Black] + // FIXME: remove the other _Init functions then, too? [12/6/2007 Black] +} + +/* +======================== +VM_Gecko_Destroy +======================== +*/ +void VM_Gecko_Destroy( void ) { + int i; + for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) { + clgecko_t **instance = &prog->opengeckoinstances[ i ]; + if( *instance ) { + CL_Gecko_DestroyBrowser( *instance ); + } + *instance = NULL; + } +} + +/* +======================== +VM_gecko_create + +float[bool] gecko_create( string name ) +======================== +*/ +void VM_gecko_create( void ) { + const char *name; + int i; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_create ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + + // find an empty slot for this gecko browser.. + for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) { + if( prog->opengeckoinstances[ i ] == NULL ) { + break; + } + } + if( i == PRVM_MAX_GECKOINSTANCES ) { + VM_Warning("VM_gecko_create: %s ran out of gecko handles (%i)\n", PRVM_NAME, PRVM_MAX_GECKOINSTANCES); + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() ); + if( !instance ) { + // TODO: error handling [12/3/2007 Black] + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + PRVM_G_FLOAT( OFS_RETURN ) = 1; +} + +/* +======================== +VM_gecko_destroy + +void gecko_destroy( string name ) +======================== +*/ +void VM_gecko_destroy( void ) { + const char *name; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_destroy ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_DestroyBrowser( instance ); +} + +/* +======================== +VM_gecko_navigate + +void gecko_navigate( string name, string URI ) +======================== +*/ +void VM_gecko_navigate( void ) { + const char *name; + const char *URI; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 2, VM_gecko_navigate ); + + name = PRVM_G_STRING( OFS_PARM0 ); + URI = PRVM_G_STRING( OFS_PARM1 ); + VM_CheckEmptyString( name ); + VM_CheckEmptyString( URI ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_NavigateToURI( instance, URI ); +} + +/* +======================== +VM_gecko_keyevent + +float[bool] gecko_keyevent( string name, float key, float eventtype ) +======================== +*/ +void VM_gecko_keyevent( void ) { + const char *name; + unsigned int key; + clgecko_buttoneventtype_t eventtype; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 ); + switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM2 ) ) { + case 0: + eventtype = CLG_BET_DOWN; + break; + case 1: + eventtype = CLG_BET_UP; + break; + case 2: + eventtype = CLG_BET_PRESS; + break; + case 3: + eventtype = CLG_BET_DOUBLECLICK; + break; + default: + // TODO: console printf? [12/3/2007 Black] + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + PRVM_G_FLOAT( OFS_RETURN ) = 0; + return; + } + + PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true); +} + +/* +======================== +VM_gecko_movemouse + +void gecko_mousemove( string name, float x, float y ) +======================== +*/ +void VM_gecko_movemouse( void ) { + const char *name; + float x, y; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + x = PRVM_G_FLOAT( OFS_PARM1 ); + y = PRVM_G_FLOAT( OFS_PARM2 ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_Event_CursorMove( instance, x, y ); +} + + +/* +======================== +VM_gecko_resize + +void gecko_resize( string name, float w, float h ) +======================== +*/ +void VM_gecko_resize( void ) { + const char *name; + float w, h; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + w = PRVM_G_FLOAT( OFS_PARM1 ); + h = PRVM_G_FLOAT( OFS_PARM2 ); + + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + return; + } + CL_Gecko_Resize( instance, w, h ); +} + + +/* +======================== +VM_gecko_get_texture_extent + +vector gecko_get_texture_extent( string name ) +======================== +*/ +void VM_gecko_get_texture_extent( void ) { + const char *name; + clgecko_t *instance; + + VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( name ); + + PRVM_G_VECTOR(OFS_RETURN)[2] = 0; + instance = CL_Gecko_FindBrowser( name ); + if( !instance ) { + PRVM_G_VECTOR(OFS_RETURN)[0] = 0; + PRVM_G_VECTOR(OFS_RETURN)[1] = 0; + return; + } + CL_Gecko_GetTextureExtent( instance, + PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 ); +} + + + /* ============== VM_makevectors @@ -2938,10 +3732,6 @@ void VM_drawline (void) DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags); } - - - - // float(float number, float quantity) bitshift (EXT_BITSHIFT) void VM_bitshift (void) { @@ -3161,67 +3951,41 @@ void VM_altstr_ins(void) // BufString functions //////////////////////////////////////// //[515]: string buffers support -#define MAX_QCSTR_BUFFERS 128 -#define MAX_QCSTR_STRINGS 1024 - -typedef struct -{ - int num_strings; - char *strings[MAX_QCSTR_STRINGS]; -}qcstrbuffer_t; -// FIXME: move stringbuffers to prog_t to allow multiple progs! -static qcstrbuffer_t *qcstringbuffers[MAX_QCSTR_BUFFERS]; -static int num_qcstringbuffers; -static int buf_sortpower; +static size_t stringbuffers_sortlength; -#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a]) -#define BUFSTR_ISFREE(a) (anum_strings<=0) ? 1 : 0 - -static int BufStr_FindFreeBuffer (void) +static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex) { - int i; - if(num_qcstringbuffers == MAX_QCSTR_BUFFERS) - return -1; - for(i=0;imax_strings <= strindex) + { + char **oldstrings = stringbuffer->strings; + stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128); + while (stringbuffer->max_strings <= strindex) + stringbuffer->max_strings *= 2; + stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0])); + if (stringbuffer->num_strings > 0) + memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0])); + if (oldstrings) + Mem_Free(oldstrings); + } } -static void BufStr_ClearBuffer (int index) +static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer) { - qcstrbuffer_t *b = qcstringbuffers[index]; - int i; + // reduce num_strings if there are empty string slots at the end + while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL) + stringbuffer->num_strings--; - if(b) + // if empty, free the string pointer array + if (stringbuffer->num_strings == 0) { - if(b->num_strings > 0) - { - for(i=0;inum_strings;i++) - if(b->strings[i]) - Z_Free(b->strings[i]); - num_qcstringbuffers--; - } - Z_Free(qcstringbuffers[index]); - qcstringbuffers[index] = NULL; + stringbuffer->max_strings = 0; + if (stringbuffer->strings) + Mem_Free(stringbuffer->strings); + stringbuffer->strings = NULL; } } -static int BufStr_FindFreeString (qcstrbuffer_t *b) -{ - int i; - for(i=0;inum_strings;i++) - if(!b->strings[i] || !b->strings[i][0]) - return i; - if(i == MAX_QCSTR_STRINGS) return -1; - else return i; -} - static int BufStr_SortStringsUP (const void *in1, const void *in2) { const char *a, *b; @@ -3229,7 +3993,7 @@ static int BufStr_SortStringsUP (const void *in1, const void *in2) b = *((const char **) in2); if(!a[0]) return 1; if(!b[0]) return -1; - return strncmp(a, b, buf_sortpower); + return strncmp(a, b, stringbuffers_sortlength); } static int BufStr_SortStringsDOWN (const void *in1, const void *in2) @@ -3239,7 +4003,7 @@ static int BufStr_SortStringsDOWN (const void *in1, const void *in2) b = *((const char **) in2); if(!a[0]) return 1; if(!b[0]) return -1; - return strncmp(b, a, buf_sortpower); + return strncmp(b, a, stringbuffers_sortlength); } /* @@ -3251,13 +4015,12 @@ float buf_create(void) = #460; */ void VM_buf_create (void) { + prvm_stringbuffer_t *stringbuffer; int i; VM_SAFEPARMCOUNT(0, VM_buf_create); - i = BufStr_FindFreeBuffer(); - if(i >= 0) - num_qcstringbuffers++; - //else - //Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME); + stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray); + for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++); + stringbuffer->origin = PRVM_AllocationOrigin(); PRVM_G_FLOAT(OFS_RETURN) = i; } @@ -3270,9 +4033,21 @@ void buf_del(float bufhandle) = #461; */ void VM_buf_del (void) { + prvm_stringbuffer_t *stringbuffer; VM_SAFEPARMCOUNT(1, VM_buf_del); - if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0))) - BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0)); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if (stringbuffer) + { + int i; + for (i = 0;i < stringbuffer->num_strings;i++) + if (stringbuffer->strings[i]) + Mem_Free(stringbuffer->strings[i]); + if (stringbuffer->strings) + Mem_Free(stringbuffer->strings); + if(stringbuffer->origin) + PRVM_Free((char *)stringbuffer->origin); + Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer); + } else { VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); @@ -3289,18 +4064,18 @@ float buf_getsize(float bufhandle) = #462; */ void VM_buf_getsize (void) { - qcstrbuffer_t *b; + prvm_stringbuffer_t *stringbuffer; VM_SAFEPARMCOUNT(1, VM_buf_getsize); - b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - if(!b) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) { PRVM_G_FLOAT(OFS_RETURN) = -1; VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } else - PRVM_G_FLOAT(OFS_RETURN) = b->num_strings; + PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings; } /* @@ -3312,12 +4087,12 @@ void buf_copy(float bufhandle_from, float bufhandle_to) = #463; */ void VM_buf_copy (void) { - qcstrbuffer_t *b1, *b2; - int i; + prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer; + int i; VM_SAFEPARMCOUNT(2, VM_buf_copy); - b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - if(!b1) + srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!srcstringbuffer) { VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; @@ -3328,81 +4103,68 @@ void VM_buf_copy (void) VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME); return; } - b2 = BUFSTR_BUFFER(i); - if(!b2) + dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!dststringbuffer) { VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME); return; } - BufStr_ClearBuffer(i); - qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t)); - memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t)); - b2->num_strings = b1->num_strings; + for (i = 0;i < dststringbuffer->num_strings;i++) + if (dststringbuffer->strings[i]) + Mem_Free(dststringbuffer->strings[i]); + if (dststringbuffer->strings) + Mem_Free(dststringbuffer->strings); + *dststringbuffer = *srcstringbuffer; + if (dststringbuffer->max_strings) + dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings); - for(i=0;inum_strings;i++) - if(b1->strings[i] && b1->strings[i][0]) + for (i = 0;i < dststringbuffer->num_strings;i++) + { + if (srcstringbuffer->strings[i]) { size_t stringlen; - stringlen = strlen(b1->strings[i]) + 1; - b2->strings[i] = (char *)Z_Malloc(stringlen); - if(!b2->strings[i]) - { - VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME); - break; - } - memcpy(b2->strings[i], b1->strings[i], stringlen); + stringlen = strlen(srcstringbuffer->strings[i]) + 1; + dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen); + memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen); } + } } /* ======================== VM_buf_sort -sort buffer by beginnings of strings (sortpower defaults it's lenght) +sort buffer by beginnings of strings (cmplength defaults it's length) "backward == TRUE" means that sorting goes upside-down -void buf_sort(float bufhandle, float sortpower, float backward) = #464; +void buf_sort(float bufhandle, float cmplength, float backward) = #464; ======================== */ void VM_buf_sort (void) { - qcstrbuffer_t *b; - int i; + prvm_stringbuffer_t *stringbuffer; VM_SAFEPARMCOUNT(3, VM_buf_sort); - b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - if(!b) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) { VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } - if(b->num_strings <= 0) + if(stringbuffer->num_strings <= 0) { VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } - buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1); - if(buf_sortpower <= 0) - buf_sortpower = 99999999; + stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1); + if(stringbuffers_sortlength <= 0) + stringbuffers_sortlength = 0x7FFFFFFF; if(!PRVM_G_FLOAT(OFS_PARM2)) - qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP); + qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP); else - qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN); + qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN); - for(i=b->num_strings-1;i>=0;i--) //[515]: delete empty lines - if(b->strings) - { - if(b->strings[i][0]) - break; - else - { - Z_Free(b->strings[i]); - --b->num_strings; - b->strings[i] = NULL; - } - } - else - --b->num_strings; + BufStr_Shrink(stringbuffer); } /* @@ -3414,33 +4176,35 @@ string buf_implode(float bufhandle, string glue) = #465; */ void VM_buf_implode (void) { - qcstrbuffer_t *b; + prvm_stringbuffer_t *stringbuffer; char k[VM_STRINGTEMP_LENGTH]; const char *sep; int i; size_t l; VM_SAFEPARMCOUNT(2, VM_buf_implode); - b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); PRVM_G_INT(OFS_RETURN) = OFS_NULL; - if(!b) + if(!stringbuffer) { VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } - if(!b->num_strings) + if(!stringbuffer->num_strings) return; sep = PRVM_G_STRING(OFS_PARM1); k[0] = 0; - for(l=i=0;inum_strings;i++) - if(b->strings[i]) + for(l = i = 0;i < stringbuffer->num_strings;i++) + { + if(stringbuffer->strings[i]) { - l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]); + l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]); if (l >= sizeof(k) - 1) break; strlcat(k, sep, sizeof(k)); - strlcat(k, b->strings[i], sizeof(k)); + strlcat(k, stringbuffer->strings[i], sizeof(k)); } + } PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k); } @@ -3453,27 +4217,25 @@ string bufstr_get(float bufhandle, float string_index) = #465; */ void VM_bufstr_get (void) { - qcstrbuffer_t *b; + prvm_stringbuffer_t *stringbuffer; int strindex; VM_SAFEPARMCOUNT(2, VM_bufstr_get); PRVM_G_INT(OFS_RETURN) = OFS_NULL; - b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - if(!b) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) { VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } strindex = (int)PRVM_G_FLOAT(OFS_PARM1); - if(strindex < 0 || strindex > MAX_QCSTR_STRINGS) + if (strindex < 0) { VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME); return; } - if(b->num_strings <= strindex) - return; - if(b->strings[strindex]) - PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]); + if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex]) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(stringbuffer->strings[strindex]); } /* @@ -3485,88 +4247,88 @@ void bufstr_set(float bufhandle, float string_index, string str) = #466; */ void VM_bufstr_set (void) { - int bufindex, strindex; - qcstrbuffer_t *b; + int strindex; + prvm_stringbuffer_t *stringbuffer; const char *news; - size_t alloclen; VM_SAFEPARMCOUNT(3, VM_bufstr_set); - bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); - b = BUFSTR_BUFFER(bufindex); - if(!b) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) { - VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME); + VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } strindex = (int)PRVM_G_FLOAT(OFS_PARM1); - if(strindex < 0 || strindex > MAX_QCSTR_STRINGS) + if(strindex < 0 || strindex >= 1000000) // huge number of strings { VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME); return; } + + BufStr_Expand(stringbuffer, strindex); + stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1); + + if(stringbuffer->strings[strindex]) + Mem_Free(stringbuffer->strings[strindex]); + stringbuffer->strings[strindex] = NULL; + news = PRVM_G_STRING(OFS_PARM2); - if(b->strings[strindex]) - Z_Free(b->strings[strindex]); - alloclen = strlen(news) + 1; - b->strings[strindex] = (char *)Z_Malloc(alloclen); - memcpy(b->strings[strindex], news, alloclen); + if (news && news[0]) + { + size_t alloclen = strlen(news) + 1; + stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen); + memcpy(stringbuffer->strings[strindex], news, alloclen); + } + + BufStr_Shrink(stringbuffer); } /* ======================== VM_bufstr_add -adds string to buffer in nearest free slot and returns it +adds string to buffer in first free slot and returns its index "order == TRUE" means that string will be added after last "full" slot float bufstr_add(float bufhandle, string str, float order) = #467; ======================== */ void VM_bufstr_add (void) { - int bufindex, order, strindex; - qcstrbuffer_t *b; + int order, strindex; + prvm_stringbuffer_t *stringbuffer; const char *string; size_t alloclen; VM_SAFEPARMCOUNT(3, VM_bufstr_add); - bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); - b = BUFSTR_BUFFER(bufindex); + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); PRVM_G_FLOAT(OFS_RETURN) = -1; - if(!b) + if(!stringbuffer) { - VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME); + VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } string = PRVM_G_STRING(OFS_PARM1); + if(!string || !string[0]) + { + VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); + return; + } order = (int)PRVM_G_FLOAT(OFS_PARM2); if(order) - strindex = b->num_strings; + strindex = stringbuffer->num_strings; else - { - strindex = BufStr_FindFreeString(b); - if(strindex < 0) - { - VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME); - return; - } - } + for (strindex = 0;strindex < stringbuffer->num_strings;strindex++) + if (stringbuffer->strings[strindex] == NULL) + break; - while(b->num_strings <= strindex) - { - if(b->num_strings == MAX_QCSTR_STRINGS) - { - VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME); - return; - } - b->strings[b->num_strings] = NULL; - b->num_strings++; - } - if(b->strings[strindex]) - Z_Free(b->strings[strindex]); + BufStr_Expand(stringbuffer, strindex); + + stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1); alloclen = strlen(string) + 1; - b->strings[strindex] = (char *)Z_Malloc(alloclen); - memcpy(b->strings[strindex], string, alloclen); + stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen); + memcpy(stringbuffer->strings[strindex], string, alloclen); + PRVM_G_FLOAT(OFS_RETURN) = strindex; } @@ -3580,26 +4342,30 @@ void bufstr_free(float bufhandle, float string_index) = #468; void VM_bufstr_free (void) { int i; - qcstrbuffer_t *b; + prvm_stringbuffer_t *stringbuffer; VM_SAFEPARMCOUNT(2, VM_bufstr_free); - b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - if(!b) + stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0)); + if(!stringbuffer) { VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME); return; } i = (int)PRVM_G_FLOAT(OFS_PARM1); - if(i < 0 || i > MAX_QCSTR_STRINGS) + if(i < 0) { VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME); return; } - if(b->strings[i]) - Z_Free(b->strings[i]); - b->strings[i] = NULL; - if(i+1 == b->num_strings) - --b->num_strings; + + if (i < stringbuffer->num_strings) + { + if(stringbuffer->strings[i]) + Mem_Free(stringbuffer->strings[i]); + stringbuffer->strings[i] = NULL; + } + + BufStr_Shrink(stringbuffer); } //============= @@ -3727,49 +4493,17 @@ void VM_changepitch (void) } -static int Is_Text_Color (char c, char t) -{ - int a = 0; - char c2 = c - (c & 128); - char t2 = t - (t & 128); - - if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG) return 0; - if(t >= '0' && t <= '9') a = 1; - if(t2 >= '0' && t2 <= '9') a = 1; -/* if(t >= 'A' && t <= 'Z') a = 2; - if(t2 >= 'A' && t2 <= 'Z') a = 2; - - if(a == 1 && scr_colortext.integer > 0) - return 1; - if(a == 2 && scr_multifonts.integer > 0) - return 2; -*/ - return a; -} - void VM_uncolorstring (void) { - const char *in; - char out[VM_STRINGTEMP_LENGTH]; - int k = 0, i = 0; + char szNewString[VM_STRINGTEMP_LENGTH]; + const char *szString; + // Prepare Strings VM_SAFEPARMCOUNT(1, VM_uncolorstring); - in = PRVM_G_STRING(OFS_PARM0); - VM_CheckEmptyString (in); - - while (in[k]) - { - if(in[k+1]) - if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/) - { - k += 2; - continue; - } - out[i] = in[k]; - ++k; - ++i; - } - PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out); + szString = PRVM_G_STRING(OFS_PARM0); + COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString); + } // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS) @@ -4038,6 +4772,17 @@ void VM_strncasecmp (void) } } +// #494 float(float caseinsensitive, string s, ...) crc16 +void VM_crc16(void) +{ + float insensitive; + static char s[VM_STRINGTEMP_LENGTH]; + VM_SAFEPARMCOUNTRANGE(2, 8, VM_hash); + insensitive = PRVM_G_FLOAT(OFS_PARM0); + VM_VarString(1, s, sizeof(s)); + PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s))); +} + void VM_wasfreed (void) { VM_SAFEPARMCOUNT(1, VM_wasfreed); @@ -4082,6 +4827,7 @@ void VM_Cmd_Init(void) // only init the stuff for the current prog VM_Files_Init(); VM_Search_Init(); + VM_Gecko_Init(); // VM_BufStr_Init(); } @@ -4090,6 +4836,190 @@ void VM_Cmd_Reset(void) CL_PurgeOwner( MENUOWNER ); VM_Search_Reset(); VM_Files_CloseAll(); + VM_Gecko_Destroy(); // VM_BufStr_ShutDown(); } +// #510 string(string input, ...) uri_escape (DP_QC_URI_ESCAPE) +// does URI escaping on a string (replace evil stuff by %AB escapes) +void VM_uri_escape (void) +{ + char src[VM_STRINGTEMP_LENGTH]; + char dest[VM_STRINGTEMP_LENGTH]; + char *p, *q; + static const char *hex = "0123456789ABCDEF"; + + VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_escape); + VM_VarString(0, src, sizeof(src)); + + for(p = src, q = dest; *p && q < dest + sizeof(dest) - 3; ++p) + { + if((*p >= 'A' && *p <= 'Z') + || (*p >= 'a' && *p <= 'z') + || (*p >= '0' && *p <= '9') + || (*p == '-') || (*p == '_') || (*p == '.') + || (*p == '!') || (*p == '~') || (*p == '*') + || (*p == '\'') || (*p == '(') || (*p == ')')) + *q++ = *p; + else + { + *q++ = '%'; + *q++ = hex[(*(unsigned char *)p >> 4) & 0xF]; + *q++ = hex[ *(unsigned char *)p & 0xF]; + } + } + *q++ = 0; + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest); +} + +// #510 string(string input, ...) uri_unescape (DP_QC_URI_ESCAPE) +// does URI unescaping on a string (get back the evil stuff) +void VM_uri_unescape (void) +{ + char src[VM_STRINGTEMP_LENGTH]; + char dest[VM_STRINGTEMP_LENGTH]; + char *p, *q; + int hi, lo; + + VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_unescape); + VM_VarString(0, src, sizeof(src)); + + for(p = src, q = dest; *p; ) // no need to check size, because unescape can't expand + { + if(*p == '%') + { + if(p[1] >= '0' && p[1] <= '9') + hi = p[1] - '0'; + else if(p[1] >= 'a' && p[1] <= 'f') + hi = p[1] - 'a' + 10; + else if(p[1] >= 'A' && p[1] <= 'F') + hi = p[1] - 'A' + 10; + else + goto nohex; + if(p[2] >= '0' && p[2] <= '9') + lo = p[2] - '0'; + else if(p[2] >= 'a' && p[2] <= 'f') + lo = p[2] - 'a' + 10; + else if(p[2] >= 'A' && p[2] <= 'F') + lo = p[2] - 'A' + 10; + else + goto nohex; + if(hi != 0 || lo != 0) // don't unescape NUL bytes + *q++ = (char) (hi * 0x10 + lo); + p += 3; + continue; + } + +nohex: + // otherwise: + *q++ = *p++; + } + *q++ = 0; + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest); +} + +// #502 string(string filename) whichpack (DP_QC_WHICHPACK) +// returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant) +void VM_whichpack (void) +{ + const char *fn, *pack; + + VM_SAFEPARMCOUNT(1, VM_whichpack); + fn = PRVM_G_STRING(OFS_PARM0); + pack = FS_WhichPack(fn); + + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(pack ? pack : ""); +} + +typedef struct +{ + int prognr; + double starttime; + float id; + char buffer[MAX_INPUTLINE]; +} +uri_to_prog_t; + +static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata) +{ + uri_to_prog_t *handle = cbdata; + + if(!PRVM_ProgLoaded(handle->prognr)) + { + // curl reply came too late... so just drop it + Z_Free(handle); + return; + } + + PRVM_SetProg(handle->prognr); + PRVM_Begin; + if((prog->starttime == handle->starttime) && (prog->funcoffsets.URI_Get_Callback)) + { + if(length_received >= sizeof(handle->buffer)) + length_received = sizeof(handle->buffer) - 1; + handle->buffer[length_received] = 0; + + PRVM_G_FLOAT(OFS_PARM0) = handle->id; + PRVM_G_FLOAT(OFS_PARM1) = status; + PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(handle->buffer); + PRVM_ExecuteProgram(prog->funcoffsets.URI_Get_Callback, "QC function URI_Get_Callback is missing"); + } + PRVM_End; + + Z_Free(handle); +} + +// uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned +// returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string +void VM_uri_get (void) +{ + const char *url; + float id; + qboolean ret; + uri_to_prog_t *handle; + + if(!prog->funcoffsets.URI_Get_Callback) + PRVM_ERROR("uri_get called by %s without URI_Get_Callback defined", PRVM_NAME); + + VM_SAFEPARMCOUNT(2, VM_uri_get); + + url = PRVM_G_STRING(OFS_PARM0); + id = PRVM_G_FLOAT(OFS_PARM1); + handle = Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later! + + handle->prognr = PRVM_GetProgNr(); + handle->starttime = prog->starttime; + handle->id = id; + ret = Curl_Begin_ToMemory(url, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle); + if(ret) + { + PRVM_G_INT(OFS_RETURN) = 1; + } + else + { + Z_Free(handle); + PRVM_G_INT(OFS_RETURN) = 0; + } +} + +void VM_netaddress_resolve (void) +{ + const char *ip; + char normalized[128]; + int port; + lhnetaddress_t addr; + + VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve); + + ip = PRVM_G_STRING(OFS_PARM0); + port = 0; + if(prog->argc > 1) + port = PRVM_G_FLOAT(OFS_PARM1); + + if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1)) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(normalized); + else + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(""); +}