#include "libcurl.h"
#include <time.h>
+#include "ft2.h"
+
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
PRVM_ERROR ("%s: Bad string", PRVM_NAME);
}
+void VM_GenerateFrameGroupBlend(framegroupblend_t *framegroupblend, const prvm_edict_t *ed)
+{
+ prvm_eval_t *val;
+ // self.frame is the interpolation target (new frame)
+ // self.frame1time is the animation base time for the interpolation target
+ // self.frame2 is the interpolation start (previous frame)
+ // self.frame2time is the animation base time for the interpolation start
+ // self.lerpfrac is the interpolation strength for self.frame2
+ // self.lerpfrac3 is the interpolation strength for self.frame3
+ // self.lerpfrac4 is the interpolation strength for self.frame4
+ // pitch angle on a player model where the animator set up 5 sets of
+ // animations and the csqc simply lerps between sets)
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame))) framegroupblend[0].frame = (int) val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2))) framegroupblend[1].frame = (int) val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3))) framegroupblend[2].frame = (int) val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4))) framegroupblend[3].frame = (int) val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame1time))) framegroupblend[0].start = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2time))) framegroupblend[1].start = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3time))) framegroupblend[2].start = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4time))) framegroupblend[3].start = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac))) framegroupblend[1].lerp = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac3))) framegroupblend[2].lerp = val->_float;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac4))) framegroupblend[3].lerp = val->_float;
+ // assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed
+ framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp;
+}
+
+// LordHavoc: quite tempting to break apart this function to reuse the
+// duplicated code, but I suspect it is better for performance
+// this way
+void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const dp_model_t *model)
+{
+ int sub2, numframes, f, i, k;
+ int isfirstframegroup = true;
+ int nolerp;
+ double sublerp, lerp, d;
+ const animscene_t *scene;
+ const framegroupblend_t *g;
+ frameblend_t *blend = frameblend;
+
+ memset(blend, 0, MAX_FRAMEBLENDS * sizeof(*blend));
+
+ if (!model || !model->surfmesh.isanimated)
+ {
+ blend[0].lerp = 1;
+ return;
+ }
+
+ nolerp = (model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer;
+ numframes = model->numframes;
+ for (k = 0, g = framegroupblend;k < MAX_FRAMEGROUPBLENDS;k++, g++)
+ {
+ f = g->frame;
+ if ((unsigned int)f >= (unsigned int)numframes)
+ {
+ Con_DPrintf("VM_FrameBlendFromFrameGroupBlend: no such frame %d in model %s\n", f, model->name);
+ f = 0;
+ }
+ d = lerp = g->lerp;
+ if (lerp <= 0)
+ continue;
+ if (nolerp)
+ {
+ if (isfirstframegroup)
+ {
+ d = lerp = 1;
+ isfirstframegroup = false;
+ }
+ else
+ continue;
+ }
+ if (model->animscenes)
+ {
+ scene = model->animscenes + f;
+ f = scene->firstframe;
+ if (scene->framecount > 1)
+ {
+ // this code path is only used on .zym models and torches
+ sublerp = scene->framerate * (cl.time - g->start);
+ f = (int) floor(sublerp);
+ sublerp -= f;
+ sub2 = f + 1;
+ if (sublerp < (1.0 / 65536.0f))
+ sublerp = 0;
+ if (sublerp > (65535.0f / 65536.0f))
+ sublerp = 1;
+ if (nolerp)
+ sublerp = 0;
+ if (scene->loop)
+ {
+ f = (f % scene->framecount);
+ sub2 = (sub2 % scene->framecount);
+ }
+ f = bound(0, f, (scene->framecount - 1)) + scene->firstframe;
+ sub2 = bound(0, sub2, (scene->framecount - 1)) + scene->firstframe;
+ d = sublerp * lerp;
+ // two framelerps produced from one animation
+ if (d > 0)
+ {
+ for (i = 0;i < MAX_FRAMEBLENDS;i++)
+ {
+ if (blend[i].lerp <= 0 || blend[i].subframe == sub2)
+ {
+ blend[i].subframe = sub2;
+ blend[i].lerp += d;
+ break;
+ }
+ }
+ }
+ d = (1 - sublerp) * lerp;
+ }
+ }
+ if (d > 0)
+ {
+ for (i = 0;i < MAX_FRAMEBLENDS;i++)
+ {
+ if (blend[i].lerp <= 0 || blend[i].subframe == f)
+ {
+ blend[i].subframe = f;
+ blend[i].lerp += d;
+ break;
+ }
+ }
+ }
+ }
+}
+
+void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const frameblend_t *frameblend)
+{
+ if (ed->priv.server->skeleton.model != edmodel)
+ {
+ VM_RemoveEdictSkeleton(ed);
+ ed->priv.server->skeleton.model = edmodel;
+ }
+ if (!ed->priv.server->skeleton.relativetransforms && ed->priv.server->skeleton.model && ed->priv.server->skeleton.model->num_bones)
+ ed->priv.server->skeleton.relativetransforms = Mem_Alloc(prog->progs_mempool, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
+ if (ed->priv.server->skeleton.relativetransforms)
+ {
+ int skeletonindex = 0;
+ skeleton_t *skeleton;
+ prvm_eval_t *val;
+ if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float;
+ if (skeletonindex > 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)
+ {
+ // custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS)
+ memcpy(ed->priv.server->skeleton.relativetransforms, skeleton->relativetransforms, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
+ }
+ else
+ {
+ // generated skeleton from frame animation
+ int blendindex;
+ int bonenum;
+ int numbones = ed->priv.server->skeleton.model->num_bones;
+ const float *poses = ed->priv.server->skeleton.model->data_poses;
+ const float *framebones;
+ float lerp;
+ matrix4x4_t *relativetransforms = ed->priv.server->skeleton.relativetransforms;
+ matrix4x4_t matrix;
+ memset(relativetransforms, 0, numbones * sizeof(matrix4x4_t));
+ for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+ {
+ lerp = frameblend[blendindex].lerp;
+ framebones = poses + 12 * frameblend[blendindex].subframe * numbones;
+ for (bonenum = 0;bonenum < numbones;bonenum++)
+ {
+ Matrix4x4_FromArray12FloatD3D(&matrix, framebones + 12 * bonenum);
+ Matrix4x4_Accumulate(&ed->priv.server->skeleton.relativetransforms[bonenum], &matrix, lerp);
+ }
+ }
+ }
+ }
+}
+
+void VM_RemoveEdictSkeleton(prvm_edict_t *ed)
+{
+ if (ed->priv.server->skeleton.relativetransforms)
+ Mem_Free(ed->priv.server->skeleton.relativetransforms);
+ memset(&ed->priv.server->skeleton, 0, sizeof(ed->priv.server->skeleton));
+}
+
+
+
+
//============================================================================
//BUILT-IN FUNCTIONS
s = PRVM_G_STRING(OFS_PARM0);
PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
- VM_CheckEmptyString(s);
+ //VM_CheckEmptyString(s);
if(snd_initialized.integer && !S_PrecacheSound(s, true, true))
{
PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
}
+void VM_log (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_log);
+ PRVM_G_FLOAT(OFS_RETURN) = log(PRVM_G_FLOAT(OFS_PARM0));
+}
+
void VM_Files_Init(void)
{
int i;
{
VM_SAFEPARMCOUNT(1,VM_strlen);
- PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
+ //PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
+ PRVM_G_FLOAT(OFS_RETURN) = u8_strlen(PRVM_G_STRING(OFS_PARM0));
}
// DRESK - Decolorized String
szString = PRVM_G_STRING(OFS_PARM0);
- nCnt = COM_StringLengthNoColors(szString, 0, NULL);
+ //nCnt = COM_StringLengthNoColors(szString, 0, NULL);
+ nCnt = u8_COM_StringLengthNoColors(szString, 0, NULL);
PRVM_G_FLOAT(OFS_RETURN) = nCnt;
}
// returns a section of a string as a tempstring
void VM_substring(void)
{
- int start, length, slength, maxlen;
+ int start, length;
+ int u_slength = 0, u_start;
+ size_t u_length;
const char *s;
char string[VM_STRINGTEMP_LENGTH];
VM_SAFEPARMCOUNT(3,VM_substring);
+ /*
s = PRVM_G_STRING(OFS_PARM0);
start = (int)PRVM_G_FLOAT(OFS_PARM1);
length = (int)PRVM_G_FLOAT(OFS_PARM2);
memcpy(string, s + start, length);
string[length] = 0;
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+ */
+
+ s = PRVM_G_STRING(OFS_PARM0);
+ start = (int)PRVM_G_FLOAT(OFS_PARM1);
+ length = (int)PRVM_G_FLOAT(OFS_PARM2);
+
+ if (start < 0) // FTE_STRINGS feature
+ {
+ u_slength = u8_strlen(s);
+ start += u_slength;
+ start = bound(0, start, u_slength);
+ }
+
+ if (length < 0) // FTE_STRINGS feature
+ {
+ if (!u_slength) // it's not calculated when it's not needed above
+ u_slength = u8_strlen(s);
+ length += u_slength - start + 1;
+ }
+
+ // positive start, positive length
+ u_start = u8_byteofs(s, start, NULL);
+ if (u_start < 0)
+ {
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+ return;
+ }
+ u_length = u8_bytelen(s + u_start, length);
+ if (u_length >= sizeof(string)-1)
+ u_length = sizeof(string)-1;
+
+ memcpy(string, s + u_start, u_length);
+ string[u_length] = 0;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
}
/*
*/
void VM_chr(void)
{
+ /*
char tmp[2];
VM_SAFEPARMCOUNT(1, VM_chr);
tmp[1] = 0;
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp);
+ */
+
+ char tmp[8];
+ int len;
+ VM_SAFEPARMCOUNT(1, VM_chr);
+
+ len = u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0), tmp, sizeof(tmp));
+ tmp[len] = 0;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp);
}
//=============================================================================
Draw_FreePic(s);
}
+void getdrawfontscale(float *sx, float *sy)
+{
+ vec3_t v;
+ *sx = *sy = 1;
+ if(prog->globaloffsets.drawfontscale >= 0)
+ {
+ VectorCopy(PRVM_G_VECTOR(prog->globaloffsets.drawfontscale), v);
+ if(VectorLength2(v) > 0)
+ {
+ *sx = v[0];
+ *sy = v[1];
+ }
+ }
+}
+
dp_font_t *getdrawfont(void)
{
if(prog->globaloffsets.drawfont >= 0)
float *pos,*scale,*rgb;
char character;
int flag;
+ float sx, sy;
VM_SAFEPARMCOUNT(6,VM_drawcharacter);
character = (char) PRVM_G_FLOAT(OFS_PARM1);
return;
}
- 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());
+ getdrawfontscale(&sx, &sy);
+ DrawQ_String_Font_Scale(pos[0], pos[1], &character, 1, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
float *pos,*scale,*rgb;
const char *string;
int flag;
+ float sx, sy;
VM_SAFEPARMCOUNT(6,VM_drawstring);
string = PRVM_G_STRING(OFS_PARM1);
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_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());
+ getdrawfontscale(&sx, &sy);
+ DrawQ_String_Font_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
+ //Font_DrawString(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
float *pos,*scale;
const char *string;
int flag,color;
+ float sx, sy;
VM_SAFEPARMCOUNT(5,VM_drawstring);
string = PRVM_G_STRING(OFS_PARM1);
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());
+ getdrawfontscale(&sx, &sy);
+ DrawQ_String_Font_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
/*
void VM_stringwidth(void)
{
const char *string;
- float sz, mult; // sz is intended font size so we can later add freetype support, mult is font size multiplier in pixels per character cell
+ float *szv;
+ float mult; // sz is intended font size so we can later add freetype support, mult is font size multiplier in pixels per character cell
int colors;
+ float sx, sy;
+ size_t maxlen = 0;
VM_SAFEPARMCOUNTRANGE(2,3,VM_drawstring);
+ getdrawfontscale(&sx, &sy);
+ if(prog->argc == 3)
+ {
+ szv = PRVM_G_VECTOR(OFS_PARM2);
+ mult = 1;
+ }
+ else
+ {
+ // we want the width for 8x8 font size, divided by 8
+ static float defsize[] = {8, 8};
+ szv = defsize;
+ mult = 0.125;
+ // to make sure snapping is turned off, ALWAYS use a nontrivial scale in this case
+ if(sx >= 0.9 && sx <= 1.1)
+ {
+ mult *= 2;
+ sx /= 2;
+ sy /= 2;
+ }
+ }
+
+ string = PRVM_G_STRING(OFS_PARM0);
+ colors = (int)PRVM_G_FLOAT(OFS_PARM1);
+
+ PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font_UntilWidth_TrackColors_Size_Scale(string, szv[0], szv[1], sx, sy, &maxlen, NULL, !colors, getdrawfont(), 1000000000) * mult; // 1x1 characters, don't actually draw
+/*
if(prog->argc == 3)
{
mult = sz = PRVM_G_FLOAT(OFS_PARM2);
colors = (int)PRVM_G_FLOAT(OFS_PARM1);
PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()) * mult; // 1x1 characters, don't actually draw
+*/
+
}
/*
=========
instr = PRVM_G_STRING(OFS_PARM0);
match = PRVM_G_STRING(OFS_PARM1);
firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
+ firstofs = u8_bytelen(instr, firstofs);
if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
{
void VM_str2chr (void)
{
const char *s;
+ Uchar ch;
+ int index;
VM_SAFEPARMCOUNT(2, VM_str2chr);
s = PRVM_G_STRING(OFS_PARM0);
- if((unsigned)PRVM_G_FLOAT(OFS_PARM1) < strlen(s))
- PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(unsigned)PRVM_G_FLOAT(OFS_PARM1)];
+ index = u8_bytelen(s, (int)PRVM_G_FLOAT(OFS_PARM1));
+
+ if((unsigned)index < strlen(s))
+ {
+ ch = u8_getchar(s + index, NULL);
+ PRVM_G_FLOAT(OFS_RETURN) = ch;
+ }
else
PRVM_G_FLOAT(OFS_RETURN) = 0;
}
//#223 string(float c, ...) chr2str (FTE_STRINGS)
void VM_chr2str (void)
{
+ /*
char t[9];
int i;
VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
t[i] = (unsigned char)PRVM_G_FLOAT(OFS_PARM0+i*3);
t[i] = 0;
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
+ */
+ char t[9 * 4 + 1];
+ int i;
+ size_t len = 0;
+ VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
+ for(i = 0; i < prog->argc && len < sizeof(t)-1; ++i)
+ len += u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0+i*3), t + len, sizeof(t)-1);
+ t[len] = 0;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
}
static int chrconv_number(int i, int base, int conv)
}
//string(void) getextresponse = #624; // returns the next extResponse packet that was sent to this client
-void VM_getextresponse (void)
+void VM_CL_getextresponse (void)
+{
+ VM_SAFEPARMCOUNT(0,VM_argv);
+
+ if (cl_net_extresponse_count <= 0)
+ PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+ else
+ {
+ int first;
+ --cl_net_extresponse_count;
+ first = (cl_net_extresponse_last + NET_EXTRESPONSE_MAX - cl_net_extresponse_count) % NET_EXTRESPONSE_MAX;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(cl_net_extresponse[first]);
+ }
+}
+
+void VM_SV_getextresponse (void)
{
VM_SAFEPARMCOUNT(0,VM_argv);
- if (net_extresponse_count <= 0)
+ if (sv_net_extresponse_count <= 0)
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
else
{
int first;
- --net_extresponse_count;
- first = (net_extresponse_last + NET_EXTRESPONSE_MAX - net_extresponse_count) % NET_EXTRESPONSE_MAX;
- PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(net_extresponse[first]);
+ --sv_net_extresponse_count;
+ first = (sv_net_extresponse_last + NET_EXTRESPONSE_MAX - sv_net_extresponse_count) % NET_EXTRESPONSE_MAX;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(sv_net_extresponse[first]);
+ }
+}
+
+/*
+=========
+VM_M_callfunction
+
+ callfunction(...,string function_name)
+Extension: pass
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_callfunction(void)
+{
+ mfunction_t *func;
+ const char *s;
+
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_callfunction);
+
+ s = PRVM_G_STRING(OFS_PARM0+(prog->argc - 1)*3);
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_ERROR("VM_callfunciton: function %s not found !", s);
+ else if (func->first_statement < 0)
+ {
+ // negative statements are built in functions
+ int builtinnumber = -func->first_statement;
+ prog->xfunction->builtinsprofile++;
+ if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
+ prog->builtins[builtinnumber]();
+ else
+ PRVM_ERROR("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, PRVM_NAME);
+ }
+ else if(func - prog->functions > 0)
+ {
+ prog->argc--;
+ PRVM_ExecuteProgram(func - prog->functions,"");
+ prog->argc++;
+ }
+}
+
+/*
+=========
+VM_isfunction
+
+float isfunction(string function_name)
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_isfunction(void)
+{
+ mfunction_t *func;
+ const char *s;
+
+ VM_SAFEPARMCOUNT(1, VM_isfunction);
+
+ s = PRVM_G_STRING(OFS_PARM0);
+
+ VM_CheckEmptyString(s);
+
+ func = PRVM_ED_FindFunction(s);
+
+ if(!func)
+ PRVM_G_FLOAT(OFS_RETURN) = false;
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = true;
+}
+
+/*
+=========
+VM_sprintf
+
+string sprintf(string format, ...)
+=========
+*/
+
+void VM_sprintf(void)
+{
+ const char *s, *s0;
+ char outbuf[MAX_INPUTLINE];
+ char *o = outbuf, *end = outbuf + sizeof(outbuf), *err;
+ int argpos = 1;
+ int width, precision, thisarg, flags;
+ char formatbuf[16];
+ char *f;
+ qboolean isfloat;
+#define PRINTF_ALTERNATE 1
+#define PRINTF_ZEROPAD 2
+#define PRINTF_LEFT 4
+#define PRINTF_SPACEPOSITIVE 8
+#define PRINTF_SIGNPOSITIVE 16
+
+ formatbuf[0] = '%';
+
+ s = PRVM_G_STRING(OFS_PARM0);
+
+#define GETARG_FLOAT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_FLOAT(OFS_PARM0 + 3 * (a))) : 0)
+#define GETARG_INT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_INT(OFS_PARM0 + 3 * (a))) : 0)
+#define GETARG_STRING(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_STRING(OFS_PARM0 + 3 * (a))) : "")
+
+ for(;;)
+ {
+ s0 = s;
+ switch(*s)
+ {
+ case 0:
+ goto finished;
+ break;
+ case '%':
+ ++s;
+
+ if(*s == '%')
+ goto verbatim;
+
+ // complete directive format:
+ // %3$*1$.*2$ld
+
+ width = -1;
+ precision = -1;
+ thisarg = -1;
+ flags = 0;
+
+ // is number following?
+ if(*s >= '0' && *s <= '9')
+ {
+ width = strtol(s, &err, 10);
+ if(!err)
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ if(*err == '$')
+ {
+ thisarg = width;
+ width = -1;
+ s = err + 1;
+ }
+ else
+ {
+ if(*s == '0')
+ {
+ flags |= PRINTF_ZEROPAD;
+ if(width == 0)
+ width = -1; // it was just a flag
+ }
+ s = err;
+ }
+ }
+
+ if(width < 0)
+ {
+ for(;;)
+ {
+ switch(*s)
+ {
+ case '#': flags |= PRINTF_ALTERNATE; break;
+ case '0': flags |= PRINTF_ZEROPAD; break;
+ case '-': flags |= PRINTF_LEFT; break;
+ case ' ': flags |= PRINTF_SPACEPOSITIVE; break;
+ case '+': flags |= PRINTF_SIGNPOSITIVE; break;
+ default:
+ goto noflags;
+ }
+ ++s;
+ }
+noflags:
+ if(*s == '*')
+ {
+ ++s;
+ if(*s >= '0' && *s <= '9')
+ {
+ width = strtol(s, &err, 10);
+ if(!err || *err != '$')
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ s = err + 1;
+ }
+ else
+ width = argpos++;
+ width = GETARG_FLOAT(width);
+ }
+ else if(*s >= '0' && *s <= '9')
+ {
+ width = strtol(s, &err, 10);
+ if(!err)
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ s = err;
+ }
+ if(width < 0)
+ {
+ flags |= PRINTF_LEFT;
+ width = -width;
+ }
+ }
+
+ if(*s == '.')
+ {
+ ++s;
+ if(*s == '*')
+ {
+ ++s;
+ if(*s >= '0' && *s <= '9')
+ {
+ precision = strtol(s, &err, 10);
+ if(!err || *err != '$')
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ s = err + 1;
+ }
+ else
+ precision = argpos++;
+ precision = GETARG_FLOAT(precision);
+ }
+ else if(*s >= '0' && *s <= '9')
+ {
+ precision = strtol(s, &err, 10);
+ if(!err)
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ s = err;
+ }
+ else
+ {
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ }
+
+ isfloat = true;
+ for(;;)
+ {
+ switch(*s)
+ {
+ case 'h': isfloat = true; break;
+ case 'l': isfloat = false; break;
+ case 'L': isfloat = false; break;
+ case 'j': break;
+ case 'z': break;
+ case 't': break;
+ default:
+ goto nolength;
+ }
+ ++s;
+ }
+nolength:
+
+ if(thisarg < 0)
+ thisarg = argpos++;
+
+ if(o < end - 1)
+ {
+ f = &formatbuf[1];
+ if(*s != 's' && *s != 'c')
+ if(flags & PRINTF_ALTERNATE) *f++ = '#';
+ if(flags & PRINTF_ZEROPAD) *f++ = '0';
+ if(flags & PRINTF_LEFT) *f++ = '-';
+ if(flags & PRINTF_SPACEPOSITIVE) *f++ = ' ';
+ if(flags & PRINTF_SIGNPOSITIVE) *f++ = '+';
+ *f++ = '*';
+ *f++ = '.';
+ *f++ = '*';
+ *f++ = *s;
+ *f++ = 0;
+
+ if(width < 0)
+ width = 0;
+
+ switch(*s)
+ {
+ case 'd': case 'i':
+ o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (int) GETARG_FLOAT(thisarg) : (int) GETARG_INT(thisarg)));
+ break;
+ case 'o': case 'u': case 'x': case 'X':
+ o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+ break;
+ case 'e': case 'E': case 'f': case 'F': case 'g': case 'G':
+ if(precision < 0)
+ precision = 6;
+ o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
+ break;
+ case 'c':
+ if(precision < 0)
+ precision = end - o - 1;
+ if(flags & PRINTF_ALTERNATE)
+ o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+ else
+ {
+ unsigned int c = (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg));
+ const char *buf = u8_encodech(c, NULL);
+ if(!buf)
+ buf = "";
+ o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision);
+ }
+ break;
+ case 's':
+ if(precision < 0)
+ precision = end - o - 1;
+ if(flags & PRINTF_ALTERNATE)
+ o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg));
+ else
+ o += u8_strpad(o, end - o, GETARG_STRING(thisarg), (flags & PRINTF_LEFT) != 0, width, precision);
+ break;
+ default:
+ VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+ goto finished;
+ }
+ }
+ ++s;
+ break;
+ default:
+verbatim:
+ if(o < end - 1)
+ *o++ = *s++;
+ break;
+ }
}
+finished:
+ *o = 0;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(outbuf);
}