new cvar sys_useclockgettime (default 0) that makes DP use clock_gettime as time...
[divverent/darkplaces.git] / prvm_cmds.c
1 // AK
2 // Basically every vm builtin cmd should be in here.
3 // All 3 builtin and extension lists can be found here
4 // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
5 // also applies here
6
7 #include "quakedef.h"
8
9 #include "prvm_cmds.h"
10 #include <time.h>
11
12 extern cvar_t prvm_backtraceforwarnings;
13
14 // LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
15 void VM_Warning(const char *fmt, ...)
16 {
17         va_list argptr;
18         char msg[MAX_INPUTLINE];
19         static double recursive = -1;
20
21         va_start(argptr,fmt);
22         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
23         va_end(argptr);
24
25         Con_Printf(msg);
26
27         // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
28         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
29         {
30                 recursive = realtime;
31                 PRVM_PrintState();
32                 recursive = -1;
33         }
34 }
35
36
37 //============================================================================
38 // Common
39
40 // TODO DONE: move vm_files and vm_fssearchlist to prvm_prog_t struct
41 // TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black]
42 // TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct again) [2007-01-23 LordHavoc]
43 // TODO: will this war ever end? [2007-01-23 LordHavoc]
44
45 void VM_CheckEmptyString (const char *s)
46 {
47         if (s[0] <= ' ')
48                 PRVM_ERROR ("%s: Bad string", PRVM_NAME);
49 }
50
51 //============================================================================
52 //BUILT-IN FUNCTIONS
53
54 void VM_VarString(int first, char *out, int outlength)
55 {
56         int i;
57         const char *s;
58         char *outend;
59
60         outend = out + outlength - 1;
61         for (i = first;i < prog->argc && out < outend;i++)
62         {
63                 s = PRVM_G_STRING((OFS_PARM0+i*3));
64                 while (out < outend && *s)
65                         *out++ = *s++;
66         }
67         *out++ = 0;
68 }
69
70 /*
71 =================
72 VM_checkextension
73
74 returns true if the extension is supported by the server
75
76 checkextension(extensionname)
77 =================
78 */
79
80 // kind of helper function
81 static qboolean checkextension(const char *name)
82 {
83         int len;
84         char *e, *start;
85         len = (int)strlen(name);
86
87         for (e = prog->extensionstring;*e;e++)
88         {
89                 while (*e == ' ')
90                         e++;
91                 if (!*e)
92                         break;
93                 start = e;
94                 while (*e && *e != ' ')
95                         e++;
96                 if ((e - start) == len && !strncasecmp(start, name, len))
97                         return true;
98         }
99         return false;
100 }
101
102 void VM_checkextension (void)
103 {
104         VM_SAFEPARMCOUNT(1,VM_checkextension);
105
106         PRVM_G_FLOAT(OFS_RETURN) = checkextension(PRVM_G_STRING(OFS_PARM0));
107 }
108
109 /*
110 =================
111 VM_error
112
113 This is a TERMINAL error, which will kill off the entire prog.
114 Dumps self.
115
116 error(value)
117 =================
118 */
119 void VM_error (void)
120 {
121         prvm_edict_t    *ed;
122         char string[VM_STRINGTEMP_LENGTH];
123
124         VM_VarString(0, string, sizeof(string));
125         Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
126         if (prog->globaloffsets.self >= 0)
127         {
128                 ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict);
129                 PRVM_ED_Print(ed, NULL);
130         }
131
132         PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
133 }
134
135 /*
136 =================
137 VM_objerror
138
139 Dumps out self, then an error message.  The program is aborted and self is
140 removed, but the level can continue.
141
142 objerror(value)
143 =================
144 */
145 void VM_objerror (void)
146 {
147         prvm_edict_t    *ed;
148         char string[VM_STRINGTEMP_LENGTH];
149
150         VM_VarString(0, string, sizeof(string));
151         Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
152         if (prog->globaloffsets.self >= 0)
153         {
154                 ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict);
155                 PRVM_ED_Print(ed, NULL);
156
157                 PRVM_ED_Free (ed);
158         }
159         else
160                 // objerror has to display the object fields -> else call
161                 PRVM_ERROR ("VM_objecterror: self not defined !");
162         Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
163 }
164
165 /*
166 =================
167 VM_print
168
169 print to console
170
171 print(...[string])
172 =================
173 */
174 void VM_print (void)
175 {
176         char string[VM_STRINGTEMP_LENGTH];
177
178         VM_VarString(0, string, sizeof(string));
179         Con_Print(string);
180 }
181
182 /*
183 =================
184 VM_bprint
185
186 broadcast print to everyone on server
187
188 bprint(...[string])
189 =================
190 */
191 void VM_bprint (void)
192 {
193         char string[VM_STRINGTEMP_LENGTH];
194
195         if(!sv.active)
196         {
197                 VM_Warning("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
198                 return;
199         }
200
201         VM_VarString(0, string, sizeof(string));
202         SV_BroadcastPrint(string);
203 }
204
205 /*
206 =================
207 VM_sprint (menu & client but only if server.active == true)
208
209 single print to a specific client
210
211 sprint(float clientnum,...[string])
212 =================
213 */
214 void VM_sprint (void)
215 {
216         client_t        *client;
217         int                     clientnum;
218         char string[VM_STRINGTEMP_LENGTH];
219
220         VM_SAFEPARMCOUNTRANGE(1, 8, VM_sprint);
221
222         //find client for this entity
223         clientnum = (int)PRVM_G_FLOAT(OFS_PARM0);
224         if (!sv.active  || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
225         {
226                 VM_Warning("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
227                 return;
228         }
229
230         client = svs.clients + clientnum;
231         if (!client->netconnection)
232                 return;
233
234         VM_VarString(1, string, sizeof(string));
235         MSG_WriteChar(&client->netconnection->message,svc_print);
236         MSG_WriteString(&client->netconnection->message, string);
237 }
238
239 /*
240 =================
241 VM_centerprint
242
243 single print to the screen
244
245 centerprint(value)
246 =================
247 */
248 void VM_centerprint (void)
249 {
250         char string[VM_STRINGTEMP_LENGTH];
251
252         VM_SAFEPARMCOUNTRANGE(1, 8, VM_centerprint);
253         VM_VarString(0, string, sizeof(string));
254         SCR_CenterPrint(string);
255 }
256
257 /*
258 =================
259 VM_normalize
260
261 vector normalize(vector)
262 =================
263 */
264 void VM_normalize (void)
265 {
266         float   *value1;
267         vec3_t  newvalue;
268         double  f;
269
270         VM_SAFEPARMCOUNT(1,VM_normalize);
271
272         value1 = PRVM_G_VECTOR(OFS_PARM0);
273
274         f = VectorLength2(value1);
275         if (f)
276         {
277                 f = 1.0 / sqrt(f);
278                 VectorScale(value1, f, newvalue);
279         }
280         else
281                 VectorClear(newvalue);
282
283         VectorCopy (newvalue, PRVM_G_VECTOR(OFS_RETURN));
284 }
285
286 /*
287 =================
288 VM_vlen
289
290 scalar vlen(vector)
291 =================
292 */
293 void VM_vlen (void)
294 {
295         VM_SAFEPARMCOUNT(1,VM_vlen);
296         PRVM_G_FLOAT(OFS_RETURN) = VectorLength(PRVM_G_VECTOR(OFS_PARM0));
297 }
298
299 /*
300 =================
301 VM_vectoyaw
302
303 float vectoyaw(vector)
304 =================
305 */
306 void VM_vectoyaw (void)
307 {
308         float   *value1;
309         float   yaw;
310
311         VM_SAFEPARMCOUNT(1,VM_vectoyaw);
312
313         value1 = PRVM_G_VECTOR(OFS_PARM0);
314
315         if (value1[1] == 0 && value1[0] == 0)
316                 yaw = 0;
317         else
318         {
319                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
320                 if (yaw < 0)
321                         yaw += 360;
322         }
323
324         PRVM_G_FLOAT(OFS_RETURN) = yaw;
325 }
326
327
328 /*
329 =================
330 VM_vectoangles
331
332 vector vectoangles(vector[, vector])
333 =================
334 */
335 void VM_vectoangles (void)
336 {
337         VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles);
338
339         AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true);
340 }
341
342 /*
343 =================
344 VM_random
345
346 Returns a number from 0<= num < 1
347
348 float random()
349 =================
350 */
351 void VM_random (void)
352 {
353         VM_SAFEPARMCOUNT(0,VM_random);
354
355         PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
356 }
357
358 /*
359 =========
360 VM_localsound
361
362 localsound(string sample)
363 =========
364 */
365 void VM_localsound(void)
366 {
367         const char *s;
368
369         VM_SAFEPARMCOUNT(1,VM_localsound);
370
371         s = PRVM_G_STRING(OFS_PARM0);
372
373         if(!S_LocalSound (s))
374         {
375                 PRVM_G_FLOAT(OFS_RETURN) = -4;
376                 VM_Warning("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
377                 return;
378         }
379
380         PRVM_G_FLOAT(OFS_RETURN) = 1;
381 }
382
383 /*
384 =================
385 VM_break
386
387 break()
388 =================
389 */
390 void VM_break (void)
391 {
392         PRVM_ERROR ("%s: break statement", PRVM_NAME);
393 }
394
395 //============================================================================
396
397 /*
398 =================
399 VM_localcmd
400
401 Sends text over to the client's execution buffer
402
403 [localcmd (string, ...) or]
404 cmd (string, ...)
405 =================
406 */
407 void VM_localcmd (void)
408 {
409         char string[VM_STRINGTEMP_LENGTH];
410         VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd);
411         VM_VarString(0, string, sizeof(string));
412         Cbuf_AddText(string);
413 }
414
415 /*
416 =================
417 VM_cvar
418
419 float cvar (string)
420 =================
421 */
422 void VM_cvar (void)
423 {
424         char string[VM_STRINGTEMP_LENGTH];
425         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
426         VM_VarString(0, string, sizeof(string));
427         VM_CheckEmptyString(string);
428         PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
429 }
430
431 /*
432 =================
433 VM_cvar
434
435 float cvar_type (string)
436 float CVAR_TYPEFLAG_EXISTS = 1;
437 float CVAR_TYPEFLAG_SAVED = 2;
438 float CVAR_TYPEFLAG_PRIVATE = 4;
439 float CVAR_TYPEFLAG_ENGINE = 8;
440 float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
441 =================
442 */
443 void VM_cvar_type (void)
444 {
445         char string[VM_STRINGTEMP_LENGTH];
446         cvar_t *cvar;
447         int ret;
448
449         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
450         VM_VarString(0, string, sizeof(string));
451         VM_CheckEmptyString(string);
452         cvar = Cvar_FindVar(string);
453
454
455         if(!cvar)
456         {
457                 PRVM_G_FLOAT(OFS_RETURN) = 0;
458                 return; // CVAR_TYPE_NONE
459         }
460
461         ret = 1; // CVAR_EXISTS
462         if(cvar->flags & CVAR_SAVE)
463                 ret |= 2; // CVAR_TYPE_SAVED
464         if(cvar->flags & CVAR_PRIVATE)
465                 ret |= 4; // CVAR_TYPE_PRIVATE
466         if(!(cvar->flags & CVAR_ALLOCATED))
467                 ret |= 8; // CVAR_TYPE_ENGINE
468         if(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string
469                 ret |= 16; // CVAR_TYPE_HASDESCRIPTION
470         
471         PRVM_G_FLOAT(OFS_RETURN) = ret;
472 }
473
474 /*
475 =================
476 VM_cvar_string
477
478 const string    VM_cvar_string (string, ...)
479 =================
480 */
481 void VM_cvar_string(void)
482 {
483         char string[VM_STRINGTEMP_LENGTH];
484         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string);
485         VM_VarString(0, string, sizeof(string));
486         VM_CheckEmptyString(string);
487         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(string));
488 }
489
490
491 /*
492 ========================
493 VM_cvar_defstring
494
495 const string    VM_cvar_defstring (string, ...)
496 ========================
497 */
498 void VM_cvar_defstring (void)
499 {
500         char string[VM_STRINGTEMP_LENGTH];
501         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_defstring);
502         VM_VarString(0, string, sizeof(string));
503         VM_CheckEmptyString(string);
504         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string));
505 }
506 /*
507 =================
508 VM_cvar_set
509
510 void cvar_set (string,string, ...)
511 =================
512 */
513 void VM_cvar_set (void)
514 {
515         const char *name;
516         char string[VM_STRINGTEMP_LENGTH];
517         VM_SAFEPARMCOUNTRANGE(2,8,VM_cvar_set);
518         VM_VarString(1, string, sizeof(string));
519         name = PRVM_G_STRING(OFS_PARM0);
520         VM_CheckEmptyString(name);
521         Cvar_Set(name, string);
522 }
523
524 /*
525 =========
526 VM_dprint
527
528 dprint(...[string])
529 =========
530 */
531 void VM_dprint (void)
532 {
533         char string[VM_STRINGTEMP_LENGTH];
534         VM_SAFEPARMCOUNTRANGE(1, 8, VM_dprint);
535         if (developer.integer)
536         {
537                 VM_VarString(0, string, sizeof(string));
538 #if 1
539                 Con_Printf("%s", string);
540 #else
541                 Con_Printf("%s: %s", PRVM_NAME, string);
542 #endif
543         }
544 }
545
546 /*
547 =========
548 VM_ftos
549
550 string  ftos(float)
551 =========
552 */
553
554 void VM_ftos (void)
555 {
556         float v;
557         char s[128];
558
559         VM_SAFEPARMCOUNT(1, VM_ftos);
560
561         v = PRVM_G_FLOAT(OFS_PARM0);
562
563         if ((float)((int)v) == v)
564                 sprintf(s, "%i", (int)v);
565         else
566                 sprintf(s, "%f", v);
567         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
568 }
569
570 /*
571 =========
572 VM_fabs
573
574 float   fabs(float)
575 =========
576 */
577
578 void VM_fabs (void)
579 {
580         float   v;
581
582         VM_SAFEPARMCOUNT(1,VM_fabs);
583
584         v = PRVM_G_FLOAT(OFS_PARM0);
585         PRVM_G_FLOAT(OFS_RETURN) = fabs(v);
586 }
587
588 /*
589 =========
590 VM_vtos
591
592 string  vtos(vector)
593 =========
594 */
595
596 void VM_vtos (void)
597 {
598         char s[512];
599
600         VM_SAFEPARMCOUNT(1,VM_vtos);
601
602         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]);
603         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
604 }
605
606 /*
607 =========
608 VM_etos
609
610 string  etos(entity)
611 =========
612 */
613
614 void VM_etos (void)
615 {
616         char s[128];
617
618         VM_SAFEPARMCOUNT(1, VM_etos);
619
620         sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
621         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
622 }
623
624 /*
625 =========
626 VM_stof
627
628 float stof(...[string])
629 =========
630 */
631 void VM_stof(void)
632 {
633         char string[VM_STRINGTEMP_LENGTH];
634         VM_SAFEPARMCOUNTRANGE(1, 8, VM_stof);
635         VM_VarString(0, string, sizeof(string));
636         PRVM_G_FLOAT(OFS_RETURN) = atof(string);
637 }
638
639 /*
640 ========================
641 VM_itof
642
643 float itof(intt ent)
644 ========================
645 */
646 void VM_itof(void)
647 {
648         VM_SAFEPARMCOUNT(1, VM_itof);
649         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
650 }
651
652 /*
653 ========================
654 VM_ftoe
655
656 entity ftoe(float num)
657 ========================
658 */
659 void VM_ftoe(void)
660 {
661         int ent;
662         VM_SAFEPARMCOUNT(1, VM_ftoe);
663
664         ent = (int)PRVM_G_FLOAT(OFS_PARM0);
665         if (ent < 0 || ent >= MAX_EDICTS || PRVM_PROG_TO_EDICT(ent)->priv.required->free)
666                 ent = 0; // return world instead of a free or invalid entity
667
668         PRVM_G_INT(OFS_RETURN) = ent;
669 }
670
671 /*
672 ========================
673 VM_etof
674
675 float etof(entity ent)
676 ========================
677 */
678 void VM_etof(void)
679 {
680         VM_SAFEPARMCOUNT(1, VM_etof);
681         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0);
682 }
683
684 /*
685 =========
686 VM_strftime
687
688 string strftime(float uselocaltime, string[, string ...])
689 =========
690 */
691 void VM_strftime(void)
692 {
693         time_t t;
694         struct tm *tm;
695         char fmt[VM_STRINGTEMP_LENGTH];
696         char result[VM_STRINGTEMP_LENGTH];
697         VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime);
698         VM_VarString(1, fmt, sizeof(fmt));
699         t = time(NULL);
700         if (PRVM_G_FLOAT(OFS_PARM0))
701                 tm = localtime(&t);
702         else
703                 tm = gmtime(&t);
704         if (!tm)
705         {
706                 PRVM_G_INT(OFS_RETURN) = 0;
707                 return;
708         }
709         strftime(result, sizeof(result), fmt, tm);
710         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result);
711 }
712
713 /*
714 =========
715 VM_spawn
716
717 entity spawn()
718 =========
719 */
720
721 void VM_spawn (void)
722 {
723         prvm_edict_t    *ed;
724         VM_SAFEPARMCOUNT(0, VM_spawn);
725         prog->xfunction->builtinsprofile += 20;
726         ed = PRVM_ED_Alloc();
727         VM_RETURN_EDICT(ed);
728 }
729
730 /*
731 =========
732 VM_remove
733
734 remove(entity e)
735 =========
736 */
737
738 void VM_remove (void)
739 {
740         prvm_edict_t    *ed;
741         prog->xfunction->builtinsprofile += 20;
742
743         VM_SAFEPARMCOUNT(1, VM_remove);
744
745         ed = PRVM_G_EDICT(OFS_PARM0);
746         if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
747         {
748                 if (developer.integer >= 1)
749                         VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
750         }
751         else if( ed->priv.required->free )
752         {
753                 if (developer.integer >= 1)
754                         VM_Warning( "VM_remove: tried to remove an already freed entity!\n" );
755         }
756         else
757                 PRVM_ED_Free (ed);
758 }
759
760 /*
761 =========
762 VM_find
763
764 entity  find(entity start, .string field, string match)
765 =========
766 */
767
768 void VM_find (void)
769 {
770         int             e;
771         int             f;
772         const char      *s, *t;
773         prvm_edict_t    *ed;
774
775         VM_SAFEPARMCOUNT(3,VM_find);
776
777         e = PRVM_G_EDICTNUM(OFS_PARM0);
778         f = PRVM_G_INT(OFS_PARM1);
779         s = PRVM_G_STRING(OFS_PARM2);
780
781         // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
782         // expects it to find all the monsters, so we must be careful to support
783         // searching for ""
784
785         for (e++ ; e < prog->num_edicts ; e++)
786         {
787                 prog->xfunction->builtinsprofile++;
788                 ed = PRVM_EDICT_NUM(e);
789                 if (ed->priv.required->free)
790                         continue;
791                 t = PRVM_E_STRING(ed,f);
792                 if (!t)
793                         t = "";
794                 if (!strcmp(t,s))
795                 {
796                         VM_RETURN_EDICT(ed);
797                         return;
798                 }
799         }
800
801         VM_RETURN_EDICT(prog->edicts);
802 }
803
804 /*
805 =========
806 VM_findfloat
807
808   entity        findfloat(entity start, .float field, float match)
809   entity        findentity(entity start, .entity field, entity match)
810 =========
811 */
812 // LordHavoc: added this for searching float, int, and entity reference fields
813 void VM_findfloat (void)
814 {
815         int             e;
816         int             f;
817         float   s;
818         prvm_edict_t    *ed;
819
820         VM_SAFEPARMCOUNT(3,VM_findfloat);
821
822         e = PRVM_G_EDICTNUM(OFS_PARM0);
823         f = PRVM_G_INT(OFS_PARM1);
824         s = PRVM_G_FLOAT(OFS_PARM2);
825
826         for (e++ ; e < prog->num_edicts ; e++)
827         {
828                 prog->xfunction->builtinsprofile++;
829                 ed = PRVM_EDICT_NUM(e);
830                 if (ed->priv.required->free)
831                         continue;
832                 if (PRVM_E_FLOAT(ed,f) == s)
833                 {
834                         VM_RETURN_EDICT(ed);
835                         return;
836                 }
837         }
838
839         VM_RETURN_EDICT(prog->edicts);
840 }
841
842 /*
843 =========
844 VM_findchain
845
846 entity  findchain(.string field, string match)
847 =========
848 */
849 // chained search for strings in entity fields
850 // entity(.string field, string match) findchain = #402;
851 void VM_findchain (void)
852 {
853         int             i;
854         int             f;
855         const char      *s, *t;
856         prvm_edict_t    *ent, *chain;
857
858         VM_SAFEPARMCOUNT(2,VM_findchain);
859
860         if (prog->fieldoffsets.chain < 0)
861                 PRVM_ERROR("VM_findchain: %s doesnt have a chain field !", PRVM_NAME);
862
863         chain = prog->edicts;
864
865         f = PRVM_G_INT(OFS_PARM0);
866         s = PRVM_G_STRING(OFS_PARM1);
867
868         // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
869         // expects it to find all the monsters, so we must be careful to support
870         // searching for ""
871
872         ent = PRVM_NEXT_EDICT(prog->edicts);
873         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
874         {
875                 prog->xfunction->builtinsprofile++;
876                 if (ent->priv.required->free)
877                         continue;
878                 t = PRVM_E_STRING(ent,f);
879                 if (!t)
880                         t = "";
881                 if (strcmp(t,s))
882                         continue;
883
884                 PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_NUM_FOR_EDICT(chain);
885                 chain = ent;
886         }
887
888         VM_RETURN_EDICT(chain);
889 }
890
891 /*
892 =========
893 VM_findchainfloat
894
895 entity  findchainfloat(.string field, float match)
896 entity  findchainentity(.string field, entity match)
897 =========
898 */
899 // LordHavoc: chained search for float, int, and entity reference fields
900 // entity(.string field, float match) findchainfloat = #403;
901 void VM_findchainfloat (void)
902 {
903         int             i;
904         int             f;
905         float   s;
906         prvm_edict_t    *ent, *chain;
907
908         VM_SAFEPARMCOUNT(2, VM_findchainfloat);
909
910         if (prog->fieldoffsets.chain < 0)
911                 PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !", PRVM_NAME);
912
913         chain = (prvm_edict_t *)prog->edicts;
914
915         f = PRVM_G_INT(OFS_PARM0);
916         s = PRVM_G_FLOAT(OFS_PARM1);
917
918         ent = PRVM_NEXT_EDICT(prog->edicts);
919         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
920         {
921                 prog->xfunction->builtinsprofile++;
922                 if (ent->priv.required->free)
923                         continue;
924                 if (PRVM_E_FLOAT(ent,f) != s)
925                         continue;
926
927                 PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
928                 chain = ent;
929         }
930
931         VM_RETURN_EDICT(chain);
932 }
933
934 /*
935 ========================
936 VM_findflags
937
938 entity  findflags(entity start, .float field, float match)
939 ========================
940 */
941 // LordHavoc: search for flags in float fields
942 void VM_findflags (void)
943 {
944         int             e;
945         int             f;
946         int             s;
947         prvm_edict_t    *ed;
948
949         VM_SAFEPARMCOUNT(3, VM_findflags);
950
951
952         e = PRVM_G_EDICTNUM(OFS_PARM0);
953         f = PRVM_G_INT(OFS_PARM1);
954         s = (int)PRVM_G_FLOAT(OFS_PARM2);
955
956         for (e++ ; e < prog->num_edicts ; e++)
957         {
958                 prog->xfunction->builtinsprofile++;
959                 ed = PRVM_EDICT_NUM(e);
960                 if (ed->priv.required->free)
961                         continue;
962                 if (!PRVM_E_FLOAT(ed,f))
963                         continue;
964                 if ((int)PRVM_E_FLOAT(ed,f) & s)
965                 {
966                         VM_RETURN_EDICT(ed);
967                         return;
968                 }
969         }
970
971         VM_RETURN_EDICT(prog->edicts);
972 }
973
974 /*
975 ========================
976 VM_findchainflags
977
978 entity  findchainflags(.float field, float match)
979 ========================
980 */
981 // LordHavoc: chained search for flags in float fields
982 void VM_findchainflags (void)
983 {
984         int             i;
985         int             f;
986         int             s;
987         prvm_edict_t    *ent, *chain;
988
989         VM_SAFEPARMCOUNT(2, VM_findchainflags);
990
991         if (prog->fieldoffsets.chain < 0)
992                 PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !", PRVM_NAME);
993
994         chain = (prvm_edict_t *)prog->edicts;
995
996         f = PRVM_G_INT(OFS_PARM0);
997         s = (int)PRVM_G_FLOAT(OFS_PARM1);
998
999         ent = PRVM_NEXT_EDICT(prog->edicts);
1000         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1001         {
1002                 prog->xfunction->builtinsprofile++;
1003                 if (ent->priv.required->free)
1004                         continue;
1005                 if (!PRVM_E_FLOAT(ent,f))
1006                         continue;
1007                 if (!((int)PRVM_E_FLOAT(ent,f) & s))
1008                         continue;
1009
1010                 PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
1011                 chain = ent;
1012         }
1013
1014         VM_RETURN_EDICT(chain);
1015 }
1016
1017 /*
1018 =========
1019 VM_precache_sound
1020
1021 string  precache_sound (string sample)
1022 =========
1023 */
1024 void VM_precache_sound (void)
1025 {
1026         const char *s;
1027
1028         VM_SAFEPARMCOUNT(1, VM_precache_sound);
1029
1030         s = PRVM_G_STRING(OFS_PARM0);
1031         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1032         VM_CheckEmptyString(s);
1033
1034         if(snd_initialized.integer && !S_PrecacheSound(s, true, false))
1035         {
1036                 VM_Warning("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
1037                 return;
1038         }
1039 }
1040
1041 /*
1042 =================
1043 VM_precache_file
1044
1045 returns the same string as output
1046
1047 does nothing, only used by qcc to build .pak archives
1048 =================
1049 */
1050 void VM_precache_file (void)
1051 {
1052         VM_SAFEPARMCOUNT(1,VM_precache_file);
1053         // precache_file is only used to copy files with qcc, it does nothing
1054         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1055 }
1056
1057 /*
1058 =========
1059 VM_coredump
1060
1061 coredump()
1062 =========
1063 */
1064 void VM_coredump (void)
1065 {
1066         VM_SAFEPARMCOUNT(0,VM_coredump);
1067
1068         Cbuf_AddText("prvm_edicts ");
1069         Cbuf_AddText(PRVM_NAME);
1070         Cbuf_AddText("\n");
1071 }
1072
1073 /*
1074 =========
1075 VM_stackdump
1076
1077 stackdump()
1078 =========
1079 */
1080 void PRVM_StackTrace(void);
1081 void VM_stackdump (void)
1082 {
1083         VM_SAFEPARMCOUNT(0, VM_stackdump);
1084
1085         PRVM_StackTrace();
1086 }
1087
1088 /*
1089 =========
1090 VM_crash
1091
1092 crash()
1093 =========
1094 */
1095
1096 void VM_crash(void)
1097 {
1098         VM_SAFEPARMCOUNT(0, VM_crash);
1099
1100         PRVM_ERROR("Crash called by %s",PRVM_NAME);
1101 }
1102
1103 /*
1104 =========
1105 VM_traceon
1106
1107 traceon()
1108 =========
1109 */
1110 void VM_traceon (void)
1111 {
1112         VM_SAFEPARMCOUNT(0,VM_traceon);
1113
1114         prog->trace = true;
1115 }
1116
1117 /*
1118 =========
1119 VM_traceoff
1120
1121 traceoff()
1122 =========
1123 */
1124 void VM_traceoff (void)
1125 {
1126         VM_SAFEPARMCOUNT(0,VM_traceoff);
1127
1128         prog->trace = false;
1129 }
1130
1131 /*
1132 =========
1133 VM_eprint
1134
1135 eprint(entity e)
1136 =========
1137 */
1138 void VM_eprint (void)
1139 {
1140         VM_SAFEPARMCOUNT(1,VM_eprint);
1141
1142         PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0), NULL);
1143 }
1144
1145 /*
1146 =========
1147 VM_rint
1148
1149 float   rint(float)
1150 =========
1151 */
1152 void VM_rint (void)
1153 {
1154         float f;
1155         VM_SAFEPARMCOUNT(1,VM_rint);
1156
1157         f = PRVM_G_FLOAT(OFS_PARM0);
1158         if (f > 0)
1159                 PRVM_G_FLOAT(OFS_RETURN) = floor(f + 0.5);
1160         else
1161                 PRVM_G_FLOAT(OFS_RETURN) = ceil(f - 0.5);
1162 }
1163
1164 /*
1165 =========
1166 VM_floor
1167
1168 float   floor(float)
1169 =========
1170 */
1171 void VM_floor (void)
1172 {
1173         VM_SAFEPARMCOUNT(1,VM_floor);
1174
1175         PRVM_G_FLOAT(OFS_RETURN) = floor(PRVM_G_FLOAT(OFS_PARM0));
1176 }
1177
1178 /*
1179 =========
1180 VM_ceil
1181
1182 float   ceil(float)
1183 =========
1184 */
1185 void VM_ceil (void)
1186 {
1187         VM_SAFEPARMCOUNT(1,VM_ceil);
1188
1189         PRVM_G_FLOAT(OFS_RETURN) = ceil(PRVM_G_FLOAT(OFS_PARM0));
1190 }
1191
1192
1193 /*
1194 =============
1195 VM_nextent
1196
1197 entity  nextent(entity)
1198 =============
1199 */
1200 void VM_nextent (void)
1201 {
1202         int             i;
1203         prvm_edict_t    *ent;
1204
1205         VM_SAFEPARMCOUNT(1, VM_nextent);
1206
1207         i = PRVM_G_EDICTNUM(OFS_PARM0);
1208         while (1)
1209         {
1210                 prog->xfunction->builtinsprofile++;
1211                 i++;
1212                 if (i == prog->num_edicts)
1213                 {
1214                         VM_RETURN_EDICT(prog->edicts);
1215                         return;
1216                 }
1217                 ent = PRVM_EDICT_NUM(i);
1218                 if (!ent->priv.required->free)
1219                 {
1220                         VM_RETURN_EDICT(ent);
1221                         return;
1222                 }
1223         }
1224 }
1225
1226 //=============================================================================
1227
1228 /*
1229 ==============
1230 VM_changelevel
1231 server and menu
1232
1233 changelevel(string map)
1234 ==============
1235 */
1236 void VM_changelevel (void)
1237 {
1238         VM_SAFEPARMCOUNT(1, VM_changelevel);
1239
1240         if(!sv.active)
1241         {
1242                 VM_Warning("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
1243                 return;
1244         }
1245
1246 // make sure we don't issue two changelevels
1247         if (svs.changelevel_issued)
1248                 return;
1249         svs.changelevel_issued = true;
1250
1251         Cbuf_AddText (va("changelevel %s\n",PRVM_G_STRING(OFS_PARM0)));
1252 }
1253
1254 /*
1255 =========
1256 VM_sin
1257
1258 float   sin(float)
1259 =========
1260 */
1261 void VM_sin (void)
1262 {
1263         VM_SAFEPARMCOUNT(1,VM_sin);
1264         PRVM_G_FLOAT(OFS_RETURN) = sin(PRVM_G_FLOAT(OFS_PARM0));
1265 }
1266
1267 /*
1268 =========
1269 VM_cos
1270 float   cos(float)
1271 =========
1272 */
1273 void VM_cos (void)
1274 {
1275         VM_SAFEPARMCOUNT(1,VM_cos);
1276         PRVM_G_FLOAT(OFS_RETURN) = cos(PRVM_G_FLOAT(OFS_PARM0));
1277 }
1278
1279 /*
1280 =========
1281 VM_sqrt
1282
1283 float   sqrt(float)
1284 =========
1285 */
1286 void VM_sqrt (void)
1287 {
1288         VM_SAFEPARMCOUNT(1,VM_sqrt);
1289         PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
1290 }
1291
1292 /*
1293 =========
1294 VM_asin
1295
1296 float   asin(float)
1297 =========
1298 */
1299 void VM_asin (void)
1300 {
1301         VM_SAFEPARMCOUNT(1,VM_asin);
1302         PRVM_G_FLOAT(OFS_RETURN) = asin(PRVM_G_FLOAT(OFS_PARM0));
1303 }
1304
1305 /*
1306 =========
1307 VM_acos
1308 float   acos(float)
1309 =========
1310 */
1311 void VM_acos (void)
1312 {
1313         VM_SAFEPARMCOUNT(1,VM_acos);
1314         PRVM_G_FLOAT(OFS_RETURN) = acos(PRVM_G_FLOAT(OFS_PARM0));
1315 }
1316
1317 /*
1318 =========
1319 VM_atan
1320 float   atan(float)
1321 =========
1322 */
1323 void VM_atan (void)
1324 {
1325         VM_SAFEPARMCOUNT(1,VM_atan);
1326         PRVM_G_FLOAT(OFS_RETURN) = atan(PRVM_G_FLOAT(OFS_PARM0));
1327 }
1328
1329 /*
1330 =========
1331 VM_atan2
1332 float   atan2(float,float)
1333 =========
1334 */
1335 void VM_atan2 (void)
1336 {
1337         VM_SAFEPARMCOUNT(2,VM_atan2);
1338         PRVM_G_FLOAT(OFS_RETURN) = atan2(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1339 }
1340
1341 /*
1342 =========
1343 VM_tan
1344 float   tan(float)
1345 =========
1346 */
1347 void VM_tan (void)
1348 {
1349         VM_SAFEPARMCOUNT(1,VM_tan);
1350         PRVM_G_FLOAT(OFS_RETURN) = tan(PRVM_G_FLOAT(OFS_PARM0));
1351 }
1352
1353 /*
1354 =================
1355 VM_randomvec
1356
1357 Returns a vector of length < 1 and > 0
1358
1359 vector randomvec()
1360 =================
1361 */
1362 void VM_randomvec (void)
1363 {
1364         vec3_t          temp;
1365         //float         length;
1366
1367         VM_SAFEPARMCOUNT(0, VM_randomvec);
1368
1369         //// WTF ??
1370         do
1371         {
1372                 temp[0] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1373                 temp[1] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1374                 temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1375         }
1376         while (DotProduct(temp, temp) >= 1);
1377         VectorCopy (temp, PRVM_G_VECTOR(OFS_RETURN));
1378
1379         /*
1380         temp[0] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1381         temp[1] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1382         temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1383         // length returned always > 0
1384         length = (rand()&32766 + 1) * (1.0 / 32767.0) / VectorLength(temp);
1385         VectorScale(temp,length, temp);*/
1386         //VectorCopy(temp, PRVM_G_VECTOR(OFS_RETURN));
1387 }
1388
1389 //=============================================================================
1390
1391 /*
1392 =========
1393 VM_registercvar
1394
1395 float   registercvar (string name, string value[, float flags])
1396 =========
1397 */
1398 void VM_registercvar (void)
1399 {
1400         const char *name, *value;
1401         int     flags;
1402
1403         VM_SAFEPARMCOUNTRANGE(2, 3, VM_registercvar);
1404
1405         name = PRVM_G_STRING(OFS_PARM0);
1406         value = PRVM_G_STRING(OFS_PARM1);
1407         flags = prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : 0;
1408         PRVM_G_FLOAT(OFS_RETURN) = 0;
1409
1410         if(flags > CVAR_MAXFLAGSVAL)
1411                 return;
1412
1413 // first check to see if it has already been defined
1414         if (Cvar_FindVar (name))
1415                 return;
1416
1417 // check for overlap with a command
1418         if (Cmd_Exists (name))
1419         {
1420                 VM_Warning("VM_registercvar: %s is a command\n", name);
1421                 return;
1422         }
1423
1424         Cvar_Get(name, value, flags);
1425
1426         PRVM_G_FLOAT(OFS_RETURN) = 1; // success
1427 }
1428
1429
1430 /*
1431 =================
1432 VM_min
1433
1434 returns the minimum of two supplied floats
1435
1436 float min(float a, float b, ...[float])
1437 =================
1438 */
1439 void VM_min (void)
1440 {
1441         VM_SAFEPARMCOUNTRANGE(2, 8, VM_min);
1442         // LordHavoc: 3+ argument enhancement suggested by FrikaC
1443         if (prog->argc >= 3)
1444         {
1445                 int i;
1446                 float f = PRVM_G_FLOAT(OFS_PARM0);
1447                 for (i = 1;i < prog->argc;i++)
1448                         if (f > PRVM_G_FLOAT((OFS_PARM0+i*3)))
1449                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1450                 PRVM_G_FLOAT(OFS_RETURN) = f;
1451         }
1452         else
1453                 PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1454 }
1455
1456 /*
1457 =================
1458 VM_max
1459
1460 returns the maximum of two supplied floats
1461
1462 float   max(float a, float b, ...[float])
1463 =================
1464 */
1465 void VM_max (void)
1466 {
1467         VM_SAFEPARMCOUNTRANGE(2, 8, VM_max);
1468         // LordHavoc: 3+ argument enhancement suggested by FrikaC
1469         if (prog->argc >= 3)
1470         {
1471                 int i;
1472                 float f = PRVM_G_FLOAT(OFS_PARM0);
1473                 for (i = 1;i < prog->argc;i++)
1474                         if (f < PRVM_G_FLOAT((OFS_PARM0+i*3)))
1475                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1476                 PRVM_G_FLOAT(OFS_RETURN) = f;
1477         }
1478         else
1479                 PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1480 }
1481
1482 /*
1483 =================
1484 VM_bound
1485
1486 returns number bounded by supplied range
1487
1488 float   bound(float min, float value, float max)
1489 =================
1490 */
1491 void VM_bound (void)
1492 {
1493         VM_SAFEPARMCOUNT(3,VM_bound);
1494         PRVM_G_FLOAT(OFS_RETURN) = bound(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1), PRVM_G_FLOAT(OFS_PARM2));
1495 }
1496
1497 /*
1498 =================
1499 VM_pow
1500
1501 returns a raised to power b
1502
1503 float   pow(float a, float b)
1504 =================
1505 */
1506 void VM_pow (void)
1507 {
1508         VM_SAFEPARMCOUNT(2,VM_pow);
1509         PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1510 }
1511
1512 void VM_Files_Init(void)
1513 {
1514         int i;
1515         for (i = 0;i < PRVM_MAX_OPENFILES;i++)
1516                 prog->openfiles[i] = NULL;
1517 }
1518
1519 void VM_Files_CloseAll(void)
1520 {
1521         int i;
1522         for (i = 0;i < PRVM_MAX_OPENFILES;i++)
1523         {
1524                 if (prog->openfiles[i])
1525                         FS_Close(prog->openfiles[i]);
1526                 prog->openfiles[i] = NULL;
1527         }
1528 }
1529
1530 static qfile_t *VM_GetFileHandle( int index )
1531 {
1532         if (index < 0 || index >= PRVM_MAX_OPENFILES)
1533         {
1534                 Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, PRVM_NAME);
1535                 return NULL;
1536         }
1537         if (prog->openfiles[index] == NULL)
1538         {
1539                 Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME);
1540                 return NULL;
1541         }
1542         return prog->openfiles[index];
1543 }
1544
1545 /*
1546 =========
1547 VM_fopen
1548
1549 float   fopen(string filename, float mode)
1550 =========
1551 */
1552 // float(string filename, float mode) fopen = #110;
1553 // opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE),
1554 // returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason
1555 void VM_fopen(void)
1556 {
1557         int filenum, mode;
1558         const char *modestring, *filename;
1559
1560         VM_SAFEPARMCOUNT(2,VM_fopen);
1561
1562         for (filenum = 0;filenum < PRVM_MAX_OPENFILES;filenum++)
1563                 if (prog->openfiles[filenum] == NULL)
1564                         break;
1565         if (filenum >= PRVM_MAX_OPENFILES)
1566         {
1567                 PRVM_G_FLOAT(OFS_RETURN) = -2;
1568                 VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
1569                 return;
1570         }
1571         mode = (int)PRVM_G_FLOAT(OFS_PARM1);
1572         switch(mode)
1573         {
1574         case 0: // FILE_READ
1575                 modestring = "rb";
1576                 break;
1577         case 1: // FILE_APPEND
1578                 modestring = "ab";
1579                 break;
1580         case 2: // FILE_WRITE
1581                 modestring = "wb";
1582                 break;
1583         default:
1584                 PRVM_G_FLOAT(OFS_RETURN) = -3;
1585                 VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
1586                 return;
1587         }
1588         filename = PRVM_G_STRING(OFS_PARM0);
1589
1590         prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
1591         if (prog->openfiles[filenum] == NULL && mode == 0)
1592                 prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false);
1593
1594         if (prog->openfiles[filenum] == NULL)
1595         {
1596                 PRVM_G_FLOAT(OFS_RETURN) = -1;
1597                 if (developer.integer >= 100)
1598                         VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
1599         }
1600         else
1601         {
1602                 PRVM_G_FLOAT(OFS_RETURN) = filenum;
1603                 if (developer.integer >= 100)
1604                         Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
1605         }
1606 }
1607
1608 /*
1609 =========
1610 VM_fclose
1611
1612 fclose(float fhandle)
1613 =========
1614 */
1615 //void(float fhandle) fclose = #111; // closes a file
1616 void VM_fclose(void)
1617 {
1618         int filenum;
1619
1620         VM_SAFEPARMCOUNT(1,VM_fclose);
1621
1622         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
1623         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
1624         {
1625                 VM_Warning("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1626                 return;
1627         }
1628         if (prog->openfiles[filenum] == NULL)
1629         {
1630                 VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1631                 return;
1632         }
1633         FS_Close(prog->openfiles[filenum]);
1634         prog->openfiles[filenum] = NULL;
1635         if (developer.integer >= 100)
1636                 Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
1637 }
1638
1639 /*
1640 =========
1641 VM_fgets
1642
1643 string  fgets(float fhandle)
1644 =========
1645 */
1646 //string(float fhandle) fgets = #112; // reads a line of text from the file and returns as a tempstring
1647 void VM_fgets(void)
1648 {
1649         int c, end;
1650         char string[VM_STRINGTEMP_LENGTH];
1651         int filenum;
1652
1653         VM_SAFEPARMCOUNT(1,VM_fgets);
1654
1655         // set the return value regardless of any possible errors
1656         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1657
1658         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
1659         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
1660         {
1661                 VM_Warning("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1662                 return;
1663         }
1664         if (prog->openfiles[filenum] == NULL)
1665         {
1666                 VM_Warning("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1667                 return;
1668         }
1669         end = 0;
1670         for (;;)
1671         {
1672                 c = FS_Getc(prog->openfiles[filenum]);
1673                 if (c == '\r' || c == '\n' || c < 0)
1674                         break;
1675                 if (end < VM_STRINGTEMP_LENGTH - 1)
1676                         string[end++] = c;
1677         }
1678         string[end] = 0;
1679         // remove \n following \r
1680         if (c == '\r')
1681         {
1682                 c = FS_Getc(prog->openfiles[filenum]);
1683                 if (c != '\n')
1684                         FS_UnGetc(prog->openfiles[filenum], (unsigned char)c);
1685         }
1686         if (developer.integer >= 100)
1687                 Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
1688         if (c >= 0 || end)
1689                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
1690 }
1691
1692 /*
1693 =========
1694 VM_fputs
1695
1696 fputs(float fhandle, string s)
1697 =========
1698 */
1699 //void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
1700 void VM_fputs(void)
1701 {
1702         int stringlength;
1703         char string[VM_STRINGTEMP_LENGTH];
1704         int filenum;
1705
1706         VM_SAFEPARMCOUNT(2,VM_fputs);
1707
1708         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
1709         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
1710         {
1711                 VM_Warning("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1712                 return;
1713         }
1714         if (prog->openfiles[filenum] == NULL)
1715         {
1716                 VM_Warning("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1717                 return;
1718         }
1719         VM_VarString(1, string, sizeof(string));
1720         if ((stringlength = (int)strlen(string)))
1721                 FS_Write(prog->openfiles[filenum], string, stringlength);
1722         if (developer.integer >= 100)
1723                 Con_Printf("fputs: %s: %s\n", PRVM_NAME, string);
1724 }
1725
1726 /*
1727 =========
1728 VM_writetofile
1729
1730         writetofile(float fhandle, entity ent)
1731 =========
1732 */
1733 void VM_writetofile(void)
1734 {
1735         prvm_edict_t * ent;
1736         qfile_t *file;
1737
1738         VM_SAFEPARMCOUNT(2, VM_writetofile);
1739
1740         file = VM_GetFileHandle( (int)PRVM_G_FLOAT(OFS_PARM0) );
1741         if( !file )
1742         {
1743                 VM_Warning("VM_writetofile: invalid or closed file handle\n");
1744                 return;
1745         }
1746
1747         ent = PRVM_G_EDICT(OFS_PARM1);
1748         if(ent->priv.required->free)
1749         {
1750                 VM_Warning("VM_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
1751                 return;
1752         }
1753
1754         PRVM_ED_Write (file, ent);
1755 }
1756
1757 /*
1758 =========
1759 VM_strlen
1760
1761 float   strlen(string s)
1762 =========
1763 */
1764 //float(string s) strlen = #114; // returns how many characters are in a string
1765 void VM_strlen(void)
1766 {
1767         VM_SAFEPARMCOUNT(1,VM_strlen);
1768
1769         PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
1770 }
1771
1772 // DRESK - Decolorized String
1773 /*
1774 =========
1775 VM_strdecolorize
1776
1777 string  strdecolorize(string s)
1778 =========
1779 */
1780 // string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped
1781 void VM_strdecolorize(void)
1782 {
1783         char szNewString[VM_STRINGTEMP_LENGTH];
1784         const char *szString;
1785
1786         // Prepare Strings
1787         VM_SAFEPARMCOUNT(1,VM_strdecolorize);
1788         szString = PRVM_G_STRING(OFS_PARM0);
1789
1790         COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
1791
1792         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
1793 }
1794
1795 // DRESK - String Length (not counting color codes)
1796 /*
1797 =========
1798 VM_strlennocol
1799
1800 float   strlennocol(string s)
1801 =========
1802 */
1803 // float(string s) strlennocol = #471; // returns how many characters are in a string not including color codes
1804 // For example, ^2Dresk returns a length of 5
1805 void VM_strlennocol(void)
1806 {
1807         const char *szString;
1808         int nCnt;
1809
1810         VM_SAFEPARMCOUNT(1,VM_strlennocol);
1811
1812         szString = PRVM_G_STRING(OFS_PARM0);
1813
1814         nCnt = COM_StringLengthNoColors(szString, 0, NULL);
1815
1816         PRVM_G_FLOAT(OFS_RETURN) = nCnt;
1817 }
1818
1819 // DRESK - String to Uppercase and Lowercase
1820 /*
1821 =========
1822 VM_strtolower
1823
1824 string  strtolower(string s)
1825 =========
1826 */
1827 // string (string s) strtolower = #480; // returns passed in string in lowercase form
1828 void VM_strtolower(void)
1829 {
1830         char szNewString[VM_STRINGTEMP_LENGTH];
1831         const char *szString;
1832
1833         // Prepare Strings
1834         VM_SAFEPARMCOUNT(1,VM_strtolower);
1835         szString = PRVM_G_STRING(OFS_PARM0);
1836
1837         COM_ToLowerString(szString, szNewString, sizeof(szNewString) );
1838
1839         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
1840 }
1841
1842 /*
1843 =========
1844 VM_strtoupper
1845
1846 string  strtoupper(string s)
1847 =========
1848 */
1849 // string (string s) strtoupper = #481; // returns passed in string in uppercase form
1850 void VM_strtoupper(void)
1851 {
1852         char szNewString[VM_STRINGTEMP_LENGTH];
1853         const char *szString;
1854
1855         // Prepare Strings
1856         VM_SAFEPARMCOUNT(1,VM_strtoupper);
1857         szString = PRVM_G_STRING(OFS_PARM0);
1858
1859         COM_ToUpperString(szString, szNewString, sizeof(szNewString) );
1860
1861         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
1862 }
1863
1864 /*
1865 =========
1866 VM_strcat
1867
1868 string strcat(string,string,...[string])
1869 =========
1870 */
1871 //string(string s1, string s2) strcat = #115;
1872 // concatenates two strings (for example "abc", "def" would return "abcdef")
1873 // and returns as a tempstring
1874 void VM_strcat(void)
1875 {
1876         char s[VM_STRINGTEMP_LENGTH];
1877         VM_SAFEPARMCOUNTRANGE(1, 8, VM_strcat);
1878
1879         VM_VarString(0, s, sizeof(s));
1880         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
1881 }
1882
1883 /*
1884 =========
1885 VM_substring
1886
1887 string  substring(string s, float start, float length)
1888 =========
1889 */
1890 // string(string s, float start, float length) substring = #116;
1891 // returns a section of a string as a tempstring
1892 void VM_substring(void)
1893 {
1894         int i, start, length;
1895         const char *s;
1896         char string[VM_STRINGTEMP_LENGTH];
1897
1898         VM_SAFEPARMCOUNT(3,VM_substring);
1899
1900         s = PRVM_G_STRING(OFS_PARM0);
1901         start = (int)PRVM_G_FLOAT(OFS_PARM1);
1902         length = (int)PRVM_G_FLOAT(OFS_PARM2);
1903         for (i = 0;i < start && *s;i++, s++);
1904         for (i = 0;i < (int)sizeof(string) - 1 && *s && i < length;i++, s++)
1905                 string[i] = *s;
1906         string[i] = 0;
1907         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
1908 }
1909
1910 /*
1911 =========
1912 VM_strreplace
1913
1914 string(string search, string replace, string subject) strreplace = #484;
1915 =========
1916 */
1917 // replaces all occurrences of search with replace in the string subject, and returns the result
1918 void VM_strreplace(void)
1919 {
1920         int i, j, si;
1921         const char *search, *replace, *subject;
1922         char string[VM_STRINGTEMP_LENGTH];
1923         int search_len, replace_len, subject_len;
1924
1925         VM_SAFEPARMCOUNT(3,VM_strreplace);
1926
1927         search = PRVM_G_STRING(OFS_PARM0);
1928         replace = PRVM_G_STRING(OFS_PARM1);
1929         subject = PRVM_G_STRING(OFS_PARM2);
1930
1931         search_len = (int)strlen(search);
1932         replace_len = (int)strlen(replace);
1933         subject_len = (int)strlen(subject);
1934
1935         si = 0;
1936         for (i = 0; i < subject_len; i++)
1937         {
1938                 for (j = 0; j < search_len && i+j < subject_len; j++)
1939                         if (subject[i+j] != search[j])
1940                                 break;
1941                 if (j == search_len || i+j == subject_len)
1942                 {
1943                 // found it at offset 'i'
1944                         for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
1945                                 string[si++] = replace[j];
1946                         i += search_len - 1;
1947                 }
1948                 else
1949                 {
1950                 // not found
1951                         if (si < (int)sizeof(string) - 1)
1952                                 string[si++] = subject[i];
1953                 }
1954         }
1955         string[si] = '\0';
1956
1957         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
1958 }
1959
1960 /*
1961 =========
1962 VM_strireplace
1963
1964 string(string search, string replace, string subject) strireplace = #485;
1965 =========
1966 */
1967 // case-insensitive version of strreplace
1968 void VM_strireplace(void)
1969 {
1970         int i, j, si;
1971         const char *search, *replace, *subject;
1972         char string[VM_STRINGTEMP_LENGTH];
1973         int search_len, replace_len, subject_len;
1974
1975         VM_SAFEPARMCOUNT(3,VM_strreplace);
1976
1977         search = PRVM_G_STRING(OFS_PARM0);
1978         replace = PRVM_G_STRING(OFS_PARM1);
1979         subject = PRVM_G_STRING(OFS_PARM2);
1980
1981         search_len = (int)strlen(search);
1982         replace_len = (int)strlen(replace);
1983         subject_len = (int)strlen(subject);
1984
1985         si = 0;
1986         for (i = 0; i < subject_len; i++)
1987         {
1988                 for (j = 0; j < search_len && i+j < subject_len; j++)
1989                         if (tolower(subject[i+j]) != tolower(search[j]))
1990                                 break;
1991                 if (j == search_len || i+j == subject_len)
1992                 {
1993                 // found it at offset 'i'
1994                         for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
1995                                 string[si++] = replace[j];
1996                         i += search_len - 1;
1997                 }
1998                 else
1999                 {
2000                 // not found
2001                         if (si < (int)sizeof(string) - 1)
2002                                 string[si++] = subject[i];
2003                 }
2004         }
2005         string[si] = '\0';
2006
2007         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
2008 }
2009
2010 /*
2011 =========
2012 VM_stov
2013
2014 vector  stov(string s)
2015 =========
2016 */
2017 //vector(string s) stov = #117; // returns vector value from a string
2018 void VM_stov(void)
2019 {
2020         char string[VM_STRINGTEMP_LENGTH];
2021
2022         VM_SAFEPARMCOUNT(1,VM_stov);
2023
2024         VM_VarString(0, string, sizeof(string));
2025         Math_atov(string, PRVM_G_VECTOR(OFS_RETURN));
2026 }
2027
2028 /*
2029 =========
2030 VM_strzone
2031
2032 string  strzone(string s)
2033 =========
2034 */
2035 //string(string s, ...) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
2036 void VM_strzone(void)
2037 {
2038         char *out;
2039         char string[VM_STRINGTEMP_LENGTH];
2040         size_t alloclen;
2041
2042         VM_SAFEPARMCOUNT(1,VM_strzone);
2043
2044         VM_VarString(0, string, sizeof(string));
2045         alloclen = strlen(string) + 1;
2046         PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(alloclen, &out);
2047         memcpy(out, string, alloclen);
2048 }
2049
2050 /*
2051 =========
2052 VM_strunzone
2053
2054 strunzone(string s)
2055 =========
2056 */
2057 //void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
2058 void VM_strunzone(void)
2059 {
2060         VM_SAFEPARMCOUNT(1,VM_strunzone);
2061         PRVM_FreeString(PRVM_G_INT(OFS_PARM0));
2062 }
2063
2064 /*
2065 =========
2066 VM_command (used by client and menu)
2067
2068 clientcommand(float client, string s) (for client and menu)
2069 =========
2070 */
2071 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2072 //this function originally written by KrimZon, made shorter by LordHavoc
2073 void VM_clcommand (void)
2074 {
2075         client_t *temp_client;
2076         int i;
2077
2078         VM_SAFEPARMCOUNT(2,VM_clcommand);
2079
2080         i = (int)PRVM_G_FLOAT(OFS_PARM0);
2081         if (!sv.active  || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2082         {
2083                 VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
2084                 return;
2085         }
2086
2087         temp_client = host_client;
2088         host_client = svs.clients + i;
2089         Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
2090         host_client = temp_client;
2091 }
2092
2093
2094 /*
2095 =========
2096 VM_tokenize
2097
2098 float tokenize(string s)
2099 =========
2100 */
2101 //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
2102 //this function originally written by KrimZon, made shorter by LordHavoc
2103 //20040203: rewritten by LordHavoc (no longer uses allocations)
2104 int num_tokens = 0;
2105 int tokens[256];
2106 void VM_tokenize (void)
2107 {
2108         const char *p;
2109         static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
2110
2111         VM_SAFEPARMCOUNT(1,VM_tokenize);
2112
2113         strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
2114         p = string;
2115
2116         num_tokens = 0;
2117         while(COM_ParseToken_VM_Tokenize(&p, false))
2118         {
2119                 if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
2120                         break;
2121                 tokens[num_tokens++] = PRVM_SetTempString(com_token);
2122         }
2123
2124         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2125 }
2126
2127 /*
2128 =========
2129 VM_tokenizebyseparator
2130
2131 float tokenizebyseparator(string s, string separator1, ...)
2132 =========
2133 */
2134 //float(string s, string separator1, ...) tokenizebyseparator = #479; // takes apart a string into individal words (access them with argv), returns how many
2135 //this function returns the token preceding each instance of a separator (of
2136 //which there can be multiple), and the text following the last separator
2137 //useful for parsing certain kinds of data like IP addresses
2138 //example:
2139 //numnumbers = tokenizebyseparator("10.1.2.3", ".");
2140 //returns 4 and the tokens "10" "1" "2" "3".
2141 void VM_tokenizebyseparator (void)
2142 {
2143         int j, k;
2144         int numseparators;
2145         int separatorlen[7];
2146         const char *separators[7];
2147         const char *p;
2148         const char *token;
2149         char tokentext[MAX_INPUTLINE];
2150         static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
2151
2152         VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
2153
2154         strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
2155         p = string;
2156
2157         numseparators = 0;;
2158         for (j = 1;j < prog->argc;j++)
2159         {
2160                 // skip any blank separator strings
2161                 const char *s = PRVM_G_STRING(OFS_PARM0+j*3);
2162                 if (!s[0])
2163                         continue;
2164                 separators[numseparators] = s;
2165                 separatorlen[numseparators] = strlen(s);
2166                 numseparators++;
2167         }
2168
2169         num_tokens = 0;
2170         j = 0;
2171
2172         while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
2173         {
2174                 token = tokentext + j;
2175                 while (*p)
2176                 {
2177                         for (k = 0;k < numseparators;k++)
2178                         {
2179                                 if (!strncmp(p, separators[k], separatorlen[k]))
2180                                 {
2181                                         p += separatorlen[k];
2182                                         break;
2183                                 }
2184                         }
2185                         if (k < numseparators)
2186                                 break;
2187                         if (j < (int)sizeof(tokentext)-1)
2188                                 tokentext[j++] = *p;
2189                         p++;
2190                 }
2191                 if (j >= (int)sizeof(tokentext))
2192                         break;
2193                 tokentext[j++] = 0;
2194                 tokens[num_tokens++] = PRVM_SetTempString(token);
2195                 if (!*p)
2196                         break;
2197         }
2198
2199         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2200 }
2201
2202 //string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index)
2203 //this function originally written by KrimZon, made shorter by LordHavoc
2204 void VM_argv (void)
2205 {
2206         int token_num;
2207
2208         VM_SAFEPARMCOUNT(1,VM_argv);
2209
2210         token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
2211
2212         if (token_num >= 0 && token_num < num_tokens)
2213                 PRVM_G_INT(OFS_RETURN) = tokens[token_num];
2214         else
2215                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2216 }
2217
2218 /*
2219 =========
2220 VM_isserver
2221
2222 float   isserver()
2223 =========
2224 */
2225 void VM_isserver(void)
2226 {
2227         VM_SAFEPARMCOUNT(0,VM_serverstate);
2228
2229         PRVM_G_FLOAT(OFS_RETURN) = sv.active && (svs.maxclients > 1 || cls.state == ca_dedicated);
2230 }
2231
2232 /*
2233 =========
2234 VM_clientcount
2235
2236 float   clientcount()
2237 =========
2238 */
2239 void VM_clientcount(void)
2240 {
2241         VM_SAFEPARMCOUNT(0,VM_clientcount);
2242
2243         PRVM_G_FLOAT(OFS_RETURN) = svs.maxclients;
2244 }
2245
2246 /*
2247 =========
2248 VM_clientstate
2249
2250 float   clientstate()
2251 =========
2252 */
2253 void VM_clientstate(void)
2254 {
2255         VM_SAFEPARMCOUNT(0,VM_clientstate);
2256
2257
2258         switch( cls.state ) {
2259                 case ca_uninitialized:
2260                 case ca_dedicated:
2261                         PRVM_G_FLOAT(OFS_RETURN) = 0;
2262                         break;
2263                 case ca_disconnected:
2264                         PRVM_G_FLOAT(OFS_RETURN) = 1;
2265                         break;
2266                 case ca_connected:
2267                         PRVM_G_FLOAT(OFS_RETURN) = 2;
2268                         break;
2269                 default:
2270                         // should never be reached!
2271                         break;
2272         }
2273 }
2274
2275 /*
2276 =========
2277 VM_getostype
2278
2279 float   getostype(void)
2280 =========
2281 */ // not used at the moment -> not included in the common list
2282 void VM_getostype(void)
2283 {
2284         VM_SAFEPARMCOUNT(0,VM_getostype);
2285
2286         /*
2287         OS_WINDOWS
2288         OS_LINUX
2289         OS_MAC - not supported
2290         */
2291
2292 #ifdef WIN32
2293         PRVM_G_FLOAT(OFS_RETURN) = 0;
2294 #elif defined(MACOSX)
2295         PRVM_G_FLOAT(OFS_RETURN) = 2;
2296 #else
2297         PRVM_G_FLOAT(OFS_RETURN) = 1;
2298 #endif
2299 }
2300
2301 /*
2302 =========
2303 VM_gettime
2304
2305 float   gettime(void)
2306 =========
2307 */
2308 void VM_gettime(void)
2309 {
2310         VM_SAFEPARMCOUNT(0,VM_gettime);
2311
2312         PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
2313 }
2314
2315 /*
2316 =========
2317 VM_loadfromdata
2318
2319 loadfromdata(string data)
2320 =========
2321 */
2322 void VM_loadfromdata(void)
2323 {
2324         VM_SAFEPARMCOUNT(1,VM_loadentsfromfile);
2325
2326         PRVM_ED_LoadFromFile(PRVM_G_STRING(OFS_PARM0));
2327 }
2328
2329 /*
2330 ========================
2331 VM_parseentitydata
2332
2333 parseentitydata(entity ent, string data)
2334 ========================
2335 */
2336 void VM_parseentitydata(void)
2337 {
2338         prvm_edict_t *ent;
2339         const char *data;
2340
2341         VM_SAFEPARMCOUNT(2, VM_parseentitydata);
2342
2343         // get edict and test it
2344         ent = PRVM_G_EDICT(OFS_PARM0);
2345         if (ent->priv.required->free)
2346                 PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
2347
2348         data = PRVM_G_STRING(OFS_PARM1);
2349
2350         // parse the opening brace
2351         if (!COM_ParseToken_Simple(&data, false, false) || com_token[0] != '{' )
2352                 PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
2353
2354         PRVM_ED_ParseEdict (data, ent);
2355 }
2356
2357 /*
2358 =========
2359 VM_loadfromfile
2360
2361 loadfromfile(string file)
2362 =========
2363 */
2364 void VM_loadfromfile(void)
2365 {
2366         const char *filename;
2367         char *data;
2368
2369         VM_SAFEPARMCOUNT(1,VM_loadfromfile);
2370
2371         filename = PRVM_G_STRING(OFS_PARM0);
2372         if (FS_CheckNastyPath(filename, false))
2373         {
2374                 PRVM_G_FLOAT(OFS_RETURN) = -4;
2375                 VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
2376                 return;
2377         }
2378
2379         // not conform with VM_fopen
2380         data = (char *)FS_LoadFile(filename, tempmempool, false, NULL);
2381         if (data == NULL)
2382                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2383
2384         PRVM_ED_LoadFromFile(data);
2385
2386         if(data)
2387                 Mem_Free(data);
2388 }
2389
2390
2391 /*
2392 =========
2393 VM_modulo
2394
2395 float   mod(float val, float m)
2396 =========
2397 */
2398 void VM_modulo(void)
2399 {
2400         int val, m;
2401         VM_SAFEPARMCOUNT(2,VM_module);
2402
2403         val = (int) PRVM_G_FLOAT(OFS_PARM0);
2404         m       = (int) PRVM_G_FLOAT(OFS_PARM1);
2405
2406         PRVM_G_FLOAT(OFS_RETURN) = (float) (val % m);
2407 }
2408
2409 void VM_Search_Init(void)
2410 {
2411         int i;
2412         for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++)
2413                 prog->opensearches[i] = NULL;
2414 }
2415
2416 void VM_Search_Reset(void)
2417 {
2418         int i;
2419         // reset the fssearch list
2420         for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++)
2421         {
2422                 if(prog->opensearches[i])
2423                         FS_FreeSearch(prog->opensearches[i]);
2424                 prog->opensearches[i] = NULL;
2425         }
2426 }
2427
2428 /*
2429 =========
2430 VM_search_begin
2431
2432 float search_begin(string pattern, float caseinsensitive, float quiet)
2433 =========
2434 */
2435 void VM_search_begin(void)
2436 {
2437         int handle;
2438         const char *pattern;
2439         int caseinsens, quiet;
2440
2441         VM_SAFEPARMCOUNT(3, VM_search_begin);
2442
2443         pattern = PRVM_G_STRING(OFS_PARM0);
2444
2445         VM_CheckEmptyString(pattern);
2446
2447         caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
2448         quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
2449
2450         for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++)
2451                 if(!prog->opensearches[handle])
2452                         break;
2453
2454         if(handle >= PRVM_MAX_OPENSEARCHES)
2455         {
2456                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2457                 VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENSEARCHES);
2458                 return;
2459         }
2460
2461         if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
2462                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2463         else
2464                 PRVM_G_FLOAT(OFS_RETURN) = handle;
2465 }
2466
2467 /*
2468 =========
2469 VM_search_end
2470
2471 void    search_end(float handle)
2472 =========
2473 */
2474 void VM_search_end(void)
2475 {
2476         int handle;
2477         VM_SAFEPARMCOUNT(1, VM_search_end);
2478
2479         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
2480
2481         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
2482         {
2483                 VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
2484                 return;
2485         }
2486         if(prog->opensearches[handle] == NULL)
2487         {
2488                 VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
2489                 return;
2490         }
2491
2492         FS_FreeSearch(prog->opensearches[handle]);
2493         prog->opensearches[handle] = NULL;
2494 }
2495
2496 /*
2497 =========
2498 VM_search_getsize
2499
2500 float   search_getsize(float handle)
2501 =========
2502 */
2503 void VM_search_getsize(void)
2504 {
2505         int handle;
2506         VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
2507
2508         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
2509
2510         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
2511         {
2512                 VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
2513                 return;
2514         }
2515         if(prog->opensearches[handle] == NULL)
2516         {
2517                 VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
2518                 return;
2519         }
2520
2521         PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames;
2522 }
2523
2524 /*
2525 =========
2526 VM_search_getfilename
2527
2528 string  search_getfilename(float handle, float num)
2529 =========
2530 */
2531 void VM_search_getfilename(void)
2532 {
2533         int handle, filenum;
2534         VM_SAFEPARMCOUNT(2, VM_search_getfilename);
2535
2536         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
2537         filenum = (int)PRVM_G_FLOAT(OFS_PARM1);
2538
2539         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
2540         {
2541                 VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
2542                 return;
2543         }
2544         if(prog->opensearches[handle] == NULL)
2545         {
2546                 VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
2547                 return;
2548         }
2549         if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames)
2550         {
2551                 VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
2552                 return;
2553         }
2554
2555         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog->opensearches[handle]->filenames[filenum]);
2556 }
2557
2558 /*
2559 =========
2560 VM_chr
2561
2562 string  chr(float ascii)
2563 =========
2564 */
2565 void VM_chr(void)
2566 {
2567         char tmp[2];
2568         VM_SAFEPARMCOUNT(1, VM_chr);
2569
2570         tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0);
2571         tmp[1] = 0;
2572
2573         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp);
2574 }
2575
2576 //=============================================================================
2577 // Draw builtins (client & menu)
2578
2579 /*
2580 =========
2581 VM_iscachedpic
2582
2583 float   iscachedpic(string pic)
2584 =========
2585 */
2586 void VM_iscachedpic(void)
2587 {
2588         VM_SAFEPARMCOUNT(1,VM_iscachedpic);
2589
2590         // drawq hasnt such a function, thus always return true
2591         PRVM_G_FLOAT(OFS_RETURN) = false;
2592 }
2593
2594 /*
2595 =========
2596 VM_precache_pic
2597
2598 string  precache_pic(string pic)
2599 =========
2600 */
2601 void VM_precache_pic(void)
2602 {
2603         const char      *s;
2604
2605         VM_SAFEPARMCOUNT(1, VM_precache_pic);
2606
2607         s = PRVM_G_STRING(OFS_PARM0);
2608         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
2609         VM_CheckEmptyString (s);
2610
2611         // AK Draw_CachePic is supposed to always return a valid pointer
2612         if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture )
2613                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2614 }
2615
2616 /*
2617 =========
2618 VM_freepic
2619
2620 freepic(string s)
2621 =========
2622 */
2623 void VM_freepic(void)
2624 {
2625         const char *s;
2626
2627         VM_SAFEPARMCOUNT(1,VM_freepic);
2628
2629         s = PRVM_G_STRING(OFS_PARM0);
2630         VM_CheckEmptyString (s);
2631
2632         Draw_FreePic(s);
2633 }
2634
2635 dp_font_t *getdrawfont()
2636 {
2637         if(prog->globaloffsets.drawfont >= 0)
2638         {
2639                 int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
2640                 if(f < 0 || f >= MAX_FONTS)
2641                         return FONT_DEFAULT;
2642                 return &dp_fonts[f];
2643         }
2644         else
2645                 return FONT_DEFAULT;
2646 }
2647
2648 /*
2649 =========
2650 VM_drawcharacter
2651
2652 float   drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
2653 =========
2654 */
2655 void VM_drawcharacter(void)
2656 {
2657         float *pos,*scale,*rgb;
2658         char   character;
2659         int flag;
2660         VM_SAFEPARMCOUNT(6,VM_drawcharacter);
2661
2662         character = (char) PRVM_G_FLOAT(OFS_PARM1);
2663         if(character == 0)
2664         {
2665                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2666                 VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
2667                 return;
2668         }
2669
2670         pos = PRVM_G_VECTOR(OFS_PARM0);
2671         scale = PRVM_G_VECTOR(OFS_PARM2);
2672         rgb = PRVM_G_VECTOR(OFS_PARM3);
2673         flag = (int)PRVM_G_FLOAT(OFS_PARM5);
2674
2675         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2676         {
2677                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2678                 VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2679                 return;
2680         }
2681
2682         if(pos[2] || scale[2])
2683                 Con_Printf("VM_drawcharacter: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
2684
2685         if(!scale[0] || !scale[1])
2686         {
2687                 PRVM_G_FLOAT(OFS_RETURN) = -3;
2688                 VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
2689                 return;
2690         }
2691
2692         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());
2693         PRVM_G_FLOAT(OFS_RETURN) = 1;
2694 }
2695
2696 /*
2697 =========
2698 VM_drawstring
2699
2700 float   drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
2701 =========
2702 */
2703 void VM_drawstring(void)
2704 {
2705         float *pos,*scale,*rgb;
2706         const char  *string;
2707         int flag;
2708         VM_SAFEPARMCOUNT(6,VM_drawstring);
2709
2710         string = PRVM_G_STRING(OFS_PARM1);
2711         pos = PRVM_G_VECTOR(OFS_PARM0);
2712         scale = PRVM_G_VECTOR(OFS_PARM2);
2713         rgb = PRVM_G_VECTOR(OFS_PARM3);
2714         flag = (int)PRVM_G_FLOAT(OFS_PARM5);
2715
2716         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2717         {
2718                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2719                 VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2720                 return;
2721         }
2722
2723         if(!scale[0] || !scale[1])
2724         {
2725                 PRVM_G_FLOAT(OFS_RETURN) = -3;
2726                 VM_Warning("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
2727                 return;
2728         }
2729
2730         if(pos[2] || scale[2])
2731                 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")));
2732
2733         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());
2734         PRVM_G_FLOAT(OFS_RETURN) = 1;
2735 }
2736
2737 /*
2738 =========
2739 VM_drawcolorcodedstring
2740
2741 float   drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag)
2742 =========
2743 */
2744 void VM_drawcolorcodedstring(void)
2745 {
2746         float *pos,*scale;
2747         const char  *string;
2748         int flag,color;
2749         VM_SAFEPARMCOUNT(5,VM_drawstring);
2750
2751         string = PRVM_G_STRING(OFS_PARM1);
2752         pos = PRVM_G_VECTOR(OFS_PARM0);
2753         scale = PRVM_G_VECTOR(OFS_PARM2);
2754         flag = (int)PRVM_G_FLOAT(OFS_PARM5);
2755
2756         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2757         {
2758                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2759                 VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2760                 return;
2761         }
2762
2763         if(!scale[0] || !scale[1])
2764         {
2765                 PRVM_G_FLOAT(OFS_RETURN) = -3;
2766                 VM_Warning("VM_drawcolorcodedstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
2767                 return;
2768         }
2769
2770         if(pos[2] || scale[2])
2771                 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")));
2772
2773         color = -1;
2774         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());
2775         PRVM_G_FLOAT(OFS_RETURN) = 1;
2776 }
2777 /*
2778 =========
2779 VM_stringwidth
2780
2781 float   stringwidth(string text, float allowColorCodes)
2782 =========
2783 */
2784 void VM_stringwidth(void)
2785 {
2786         const char  *string;
2787         int colors;
2788         VM_SAFEPARMCOUNT(2,VM_drawstring);
2789
2790         string = PRVM_G_STRING(OFS_PARM0);
2791         colors = (int)PRVM_G_FLOAT(OFS_PARM1);
2792
2793         PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
2794 }
2795 /*
2796 =========
2797 VM_drawpic
2798
2799 float   drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
2800 =========
2801 */
2802 void VM_drawpic(void)
2803 {
2804         const char *picname;
2805         float *size, *pos, *rgb;
2806         int flag;
2807
2808         VM_SAFEPARMCOUNT(6,VM_drawpic);
2809
2810         picname = PRVM_G_STRING(OFS_PARM1);
2811         VM_CheckEmptyString (picname);
2812
2813         // is pic cached ? no function yet for that
2814         if(!1)
2815         {
2816                 PRVM_G_FLOAT(OFS_RETURN) = -4;
2817                 VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname);
2818                 return;
2819         }
2820
2821         pos = PRVM_G_VECTOR(OFS_PARM0);
2822         size = PRVM_G_VECTOR(OFS_PARM2);
2823         rgb = PRVM_G_VECTOR(OFS_PARM3);
2824         flag = (int) PRVM_G_FLOAT(OFS_PARM5);
2825
2826         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2827         {
2828                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2829                 VM_Warning("VM_drawpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2830                 return;
2831         }
2832
2833         if(pos[2] || size[2])
2834                 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")));
2835
2836         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);
2837         PRVM_G_FLOAT(OFS_RETURN) = 1;
2838 }
2839 /*
2840 =========
2841 VM_drawsubpic
2842
2843 float   drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag)
2844
2845 =========
2846 */
2847 void VM_drawsubpic(void)
2848 {
2849         const char *picname;
2850         float *size, *pos, *rgb, *srcPos, *srcSize, alpha;
2851         int flag;
2852
2853         VM_SAFEPARMCOUNT(8,VM_drawsubpic);
2854
2855         picname = PRVM_G_STRING(OFS_PARM2);
2856         VM_CheckEmptyString (picname);
2857
2858         // is pic cached ? no function yet for that
2859         if(!1)
2860         {
2861                 PRVM_G_FLOAT(OFS_RETURN) = -4;
2862                 VM_Warning("VM_drawsubpic: %s: %s not cached !\n", PRVM_NAME, picname);
2863                 return;
2864         }
2865
2866         pos = PRVM_G_VECTOR(OFS_PARM0);
2867         size = PRVM_G_VECTOR(OFS_PARM1);
2868         srcPos = PRVM_G_VECTOR(OFS_PARM3);
2869         srcSize = PRVM_G_VECTOR(OFS_PARM4);
2870         rgb = PRVM_G_VECTOR(OFS_PARM5);
2871         alpha = PRVM_G_FLOAT(OFS_PARM6);
2872         flag = (int) PRVM_G_FLOAT(OFS_PARM7);
2873
2874         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2875         {
2876                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2877                 VM_Warning("VM_drawsubpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2878                 return;
2879         }
2880
2881         if(pos[2] || size[2])
2882                 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")));
2883
2884         DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname),
2885                 size[0], size[1],
2886                 srcPos[0],              srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
2887                 srcPos[0] + srcSize[0], srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
2888                 srcPos[0],              srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
2889                 srcPos[0] + srcSize[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
2890                 flag);
2891         PRVM_G_FLOAT(OFS_RETURN) = 1;
2892 }
2893
2894 /*
2895 =========
2896 VM_drawfill
2897
2898 float drawfill(vector position, vector size, vector rgb, float alpha, float flag)
2899 =========
2900 */
2901 void VM_drawfill(void)
2902 {
2903         float *size, *pos, *rgb;
2904         int flag;
2905
2906         VM_SAFEPARMCOUNT(5,VM_drawfill);
2907
2908
2909         pos = PRVM_G_VECTOR(OFS_PARM0);
2910         size = PRVM_G_VECTOR(OFS_PARM1);
2911         rgb = PRVM_G_VECTOR(OFS_PARM2);
2912         flag = (int) PRVM_G_FLOAT(OFS_PARM4);
2913
2914         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2915         {
2916                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2917                 VM_Warning("VM_drawfill: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2918                 return;
2919         }
2920
2921         if(pos[2] || size[2])
2922                 Con_Printf("VM_drawfill: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
2923
2924         DrawQ_Fill(pos[0], pos[1], size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
2925         PRVM_G_FLOAT(OFS_RETURN) = 1;
2926 }
2927
2928 /*
2929 =========
2930 VM_drawsetcliparea
2931
2932 drawsetcliparea(float x, float y, float width, float height)
2933 =========
2934 */
2935 void VM_drawsetcliparea(void)
2936 {
2937         float x,y,w,h;
2938         VM_SAFEPARMCOUNT(4,VM_drawsetcliparea);
2939
2940         x = bound(0, PRVM_G_FLOAT(OFS_PARM0), vid_conwidth.integer);
2941         y = bound(0, PRVM_G_FLOAT(OFS_PARM1), vid_conheight.integer);
2942         w = bound(0, PRVM_G_FLOAT(OFS_PARM2) + PRVM_G_FLOAT(OFS_PARM0) - x, (vid_conwidth.integer  - x));
2943         h = bound(0, PRVM_G_FLOAT(OFS_PARM3) + PRVM_G_FLOAT(OFS_PARM1) - y, (vid_conheight.integer - y));
2944
2945         DrawQ_SetClipArea(x, y, w, h);
2946 }
2947
2948 /*
2949 =========
2950 VM_drawresetcliparea
2951
2952 drawresetcliparea()
2953 =========
2954 */
2955 void VM_drawresetcliparea(void)
2956 {
2957         VM_SAFEPARMCOUNT(0,VM_drawresetcliparea);
2958
2959         DrawQ_ResetClipArea();
2960 }
2961
2962 /*
2963 =========
2964 VM_getimagesize
2965
2966 vector  getimagesize(string pic)
2967 =========
2968 */
2969 void VM_getimagesize(void)
2970 {
2971         const char *p;
2972         cachepic_t *pic;
2973
2974         VM_SAFEPARMCOUNT(1,VM_getimagesize);
2975
2976         p = PRVM_G_STRING(OFS_PARM0);
2977         VM_CheckEmptyString (p);
2978
2979         pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT);
2980
2981         PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
2982         PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
2983         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
2984 }
2985
2986 /*
2987 =========
2988 VM_keynumtostring
2989
2990 string keynumtostring(float keynum)
2991 =========
2992 */
2993 void VM_keynumtostring (void)
2994 {
2995         VM_SAFEPARMCOUNT(1, VM_keynumtostring);
2996
2997         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0)));
2998 }
2999
3000 /*
3001 =========
3002 VM_stringtokeynum
3003
3004 float stringtokeynum(string key)
3005 =========
3006 */
3007 void VM_stringtokeynum (void)
3008 {
3009         VM_SAFEPARMCOUNT( 1, VM_keynumtostring );
3010
3011         PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0));
3012 }
3013
3014 // CL_Video interface functions
3015
3016 /*
3017 ========================
3018 VM_cin_open
3019
3020 float cin_open(string file, string name)
3021 ========================
3022 */
3023 void VM_cin_open( void )
3024 {
3025         const char *file;
3026         const char *name;
3027
3028         VM_SAFEPARMCOUNT( 2, VM_cin_open );
3029
3030         file = PRVM_G_STRING( OFS_PARM0 );
3031         name = PRVM_G_STRING( OFS_PARM1 );
3032
3033         VM_CheckEmptyString( file );
3034     VM_CheckEmptyString( name );
3035
3036         if( CL_OpenVideo( file, name, MENUOWNER ) )
3037                 PRVM_G_FLOAT( OFS_RETURN ) = 1;
3038         else
3039                 PRVM_G_FLOAT( OFS_RETURN ) = 0;
3040 }
3041
3042 /*
3043 ========================
3044 VM_cin_close
3045
3046 void cin_close(string name)
3047 ========================
3048 */
3049 void VM_cin_close( void )
3050 {
3051         const char *name;
3052
3053         VM_SAFEPARMCOUNT( 1, VM_cin_close );
3054
3055         name = PRVM_G_STRING( OFS_PARM0 );
3056         VM_CheckEmptyString( name );
3057
3058         CL_CloseVideo( CL_GetVideoByName( name ) );
3059 }
3060
3061 /*
3062 ========================
3063 VM_cin_setstate
3064 void cin_setstate(string name, float type)
3065 ========================
3066 */
3067 void VM_cin_setstate( void )
3068 {
3069         const char *name;
3070         clvideostate_t  state;
3071         clvideo_t               *video;
3072
3073         VM_SAFEPARMCOUNT( 2, VM_cin_netstate );
3074
3075         name = PRVM_G_STRING( OFS_PARM0 );
3076         VM_CheckEmptyString( name );
3077
3078         state = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 ));
3079
3080         video = CL_GetVideoByName( name );
3081         if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
3082                 CL_SetVideoState( video, state );
3083 }
3084
3085 /*
3086 ========================
3087 VM_cin_getstate
3088
3089 float cin_getstate(string name)
3090 ========================
3091 */
3092 void VM_cin_getstate( void )
3093 {
3094         const char *name;
3095         clvideo_t               *video;
3096
3097         VM_SAFEPARMCOUNT( 1, VM_cin_getstate );
3098
3099         name = PRVM_G_STRING( OFS_PARM0 );
3100         VM_CheckEmptyString( name );
3101
3102         video = CL_GetVideoByName( name );
3103         if( video )
3104                 PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state;
3105         else
3106                 PRVM_G_FLOAT( OFS_RETURN ) = 0;
3107 }
3108
3109 /*
3110 ========================
3111 VM_cin_restart
3112
3113 void cin_restart(string name)
3114 ========================
3115 */
3116 void VM_cin_restart( void )
3117 {
3118         const char *name;
3119         clvideo_t               *video;
3120
3121         VM_SAFEPARMCOUNT( 1, VM_cin_restart );
3122
3123         name = PRVM_G_STRING( OFS_PARM0 );
3124         VM_CheckEmptyString( name );
3125
3126         video = CL_GetVideoByName( name );
3127         if( video )
3128                 CL_RestartVideo( video );
3129 }
3130
3131 /*
3132 ========================
3133 VM_Gecko_Init
3134 ========================
3135 */
3136 void VM_Gecko_Init( void ) {
3137         // the prog struct is memset to 0 by Initprog? [12/6/2007 Black]
3138         // FIXME: remove the other _Init functions then, too? [12/6/2007 Black]
3139 }
3140
3141 /*
3142 ========================
3143 VM_Gecko_Destroy
3144 ========================
3145 */
3146 void VM_Gecko_Destroy( void ) {
3147         int i;
3148         for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
3149                 clgecko_t **instance = &prog->opengeckoinstances[ i ];
3150                 if( *instance ) {
3151                         CL_Gecko_DestroyBrowser( *instance );
3152                 }
3153                 *instance = NULL;
3154         }
3155 }
3156
3157 /*
3158 ========================
3159 VM_gecko_create
3160
3161 float[bool] gecko_create( string name )
3162 ========================
3163 */
3164 void VM_gecko_create( void ) {
3165         const char *name;
3166         int i;
3167         clgecko_t *instance;
3168         
3169         VM_SAFEPARMCOUNT( 1, VM_gecko_create );
3170
3171         name = PRVM_G_STRING( OFS_PARM0 );
3172         VM_CheckEmptyString( name );
3173
3174         // find an empty slot for this gecko browser..
3175         for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
3176                 if( prog->opengeckoinstances[ i ] == NULL ) {
3177                         break;
3178                 }
3179         }
3180         if( i == PRVM_MAX_GECKOINSTANCES ) {
3181                         VM_Warning("VM_gecko_create: %s ran out of gecko handles (%i)\n", PRVM_NAME, PRVM_MAX_GECKOINSTANCES);
3182                         PRVM_G_FLOAT( OFS_RETURN ) = 0;
3183                         return;
3184         }
3185
3186         instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() );
3187    if( !instance ) {
3188                 // TODO: error handling [12/3/2007 Black]
3189                 PRVM_G_FLOAT( OFS_RETURN ) = 0;
3190                 return;
3191         }
3192         PRVM_G_FLOAT( OFS_RETURN ) = 1;
3193 }
3194
3195 /*
3196 ========================
3197 VM_gecko_destroy
3198
3199 void gecko_destroy( string name )
3200 ========================
3201 */
3202 void VM_gecko_destroy( void ) {
3203         const char *name;
3204         clgecko_t *instance;
3205
3206         VM_SAFEPARMCOUNT( 1, VM_gecko_destroy );
3207
3208         name = PRVM_G_STRING( OFS_PARM0 );
3209         VM_CheckEmptyString( name );
3210         instance = CL_Gecko_FindBrowser( name );
3211         if( !instance ) {
3212                 return;
3213         }
3214         CL_Gecko_DestroyBrowser( instance );
3215 }
3216
3217 /*
3218 ========================
3219 VM_gecko_navigate
3220
3221 void gecko_navigate( string name, string URI )
3222 ========================
3223 */
3224 void VM_gecko_navigate( void ) {
3225         const char *name;
3226         const char *URI;
3227         clgecko_t *instance;
3228
3229         VM_SAFEPARMCOUNT( 2, VM_gecko_navigate );
3230
3231         name = PRVM_G_STRING( OFS_PARM0 );
3232         URI = PRVM_G_STRING( OFS_PARM1 );
3233         VM_CheckEmptyString( name );
3234         VM_CheckEmptyString( URI );
3235
3236    instance = CL_Gecko_FindBrowser( name );
3237         if( !instance ) {
3238                 return;
3239         }
3240         CL_Gecko_NavigateToURI( instance, URI );
3241 }
3242
3243 /*
3244 ========================
3245 VM_gecko_keyevent
3246
3247 float[bool] gecko_keyevent( string name, float key, float eventtype ) 
3248 ========================
3249 */
3250 void VM_gecko_keyevent( void ) {
3251         const char *name;
3252         unsigned int key;
3253         clgecko_buttoneventtype_t eventtype;
3254         clgecko_t *instance;
3255
3256         VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent );
3257
3258         name = PRVM_G_STRING( OFS_PARM0 );
3259         VM_CheckEmptyString( name );
3260         key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 );
3261         switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM2 ) ) {
3262         case 0:
3263                 eventtype = CLG_BET_DOWN;
3264                 break;
3265         case 1:
3266                 eventtype = CLG_BET_UP;
3267                 break;
3268         case 2:
3269                 eventtype = CLG_BET_PRESS;
3270                 break;
3271         case 3:
3272                 eventtype = CLG_BET_DOUBLECLICK;
3273                 break;
3274         default:
3275                 // TODO: console printf? [12/3/2007 Black]
3276                 PRVM_G_FLOAT( OFS_RETURN ) = 0;
3277                 return;
3278         }
3279
3280         instance = CL_Gecko_FindBrowser( name );
3281         if( !instance ) {
3282                 PRVM_G_FLOAT( OFS_RETURN ) = 0;
3283                 return;
3284         }
3285
3286         PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
3287 }
3288
3289 /*
3290 ========================
3291 VM_gecko_movemouse
3292
3293 void gecko_mousemove( string name, float x, float y )
3294 ========================
3295 */
3296 void VM_gecko_movemouse( void ) {
3297         const char *name;
3298         float x, y;
3299         clgecko_t *instance;
3300
3301         VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
3302
3303         name = PRVM_G_STRING( OFS_PARM0 );
3304         VM_CheckEmptyString( name );
3305         x = PRVM_G_FLOAT( OFS_PARM1 );
3306         y = PRVM_G_FLOAT( OFS_PARM2 );
3307         
3308         instance = CL_Gecko_FindBrowser( name );
3309         if( !instance ) {
3310                 return;
3311         }
3312         CL_Gecko_Event_CursorMove( instance, x, y );
3313 }
3314
3315
3316 /*
3317 ========================
3318 VM_gecko_resize
3319
3320 void gecko_resize( string name, float w, float h )
3321 ========================
3322 */
3323 void VM_gecko_resize( void ) {
3324         const char *name;
3325         float w, h;
3326         clgecko_t *instance;
3327
3328         VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
3329
3330         name = PRVM_G_STRING( OFS_PARM0 );
3331         VM_CheckEmptyString( name );
3332         w = PRVM_G_FLOAT( OFS_PARM1 );
3333         h = PRVM_G_FLOAT( OFS_PARM2 );
3334         
3335         instance = CL_Gecko_FindBrowser( name );
3336         if( !instance ) {
3337                 return;
3338         }
3339         CL_Gecko_Resize( instance, w, h );
3340 }
3341
3342
3343 /*
3344 ========================
3345 VM_gecko_get_texture_extent
3346
3347 vector gecko_get_texture_extent( string name )
3348 ========================
3349 */
3350 void VM_gecko_get_texture_extent( void ) {
3351         const char *name;
3352         clgecko_t *instance;
3353
3354         VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse );
3355
3356         name = PRVM_G_STRING( OFS_PARM0 );
3357         VM_CheckEmptyString( name );
3358         
3359         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
3360         instance = CL_Gecko_FindBrowser( name );
3361         if( !instance ) {
3362                 PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
3363                 PRVM_G_VECTOR(OFS_RETURN)[1] = 0;
3364                 return;
3365         }
3366         CL_Gecko_GetTextureExtent( instance, 
3367                 PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 );
3368 }
3369
3370
3371
3372 /*
3373 ==============
3374 VM_makevectors
3375
3376 Writes new values for v_forward, v_up, and v_right based on angles
3377 void makevectors(vector angle)
3378 ==============
3379 */
3380 void VM_makevectors (void)
3381 {
3382         prvm_eval_t *valforward, *valright, *valup;
3383         valforward = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_forward);
3384         valright = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_right);
3385         valup = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_up);
3386         if (!valforward || !valright || !valup)
3387         {
3388                 VM_Warning("makevectors: could not find v_forward, v_right, or v_up global variables\n");
3389                 return;
3390         }
3391         VM_SAFEPARMCOUNT(1, VM_makevectors);
3392         AngleVectors (PRVM_G_VECTOR(OFS_PARM0), valforward->vector, valright->vector, valup->vector);
3393 }
3394
3395 /*
3396 ==============
3397 VM_vectorvectors
3398
3399 Writes new values for v_forward, v_up, and v_right based on the given forward vector
3400 vectorvectors(vector)
3401 ==============
3402 */
3403 void VM_vectorvectors (void)
3404 {
3405         prvm_eval_t *valforward, *valright, *valup;
3406         valforward = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_forward);
3407         valright = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_right);
3408         valup = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.v_up);
3409         if (!valforward || !valright || !valup)
3410         {
3411                 VM_Warning("vectorvectors: could not find v_forward, v_right, or v_up global variables\n");
3412                 return;
3413         }
3414         VM_SAFEPARMCOUNT(1, VM_vectorvectors);
3415         VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), valforward->vector);
3416         VectorVectors(valforward->vector, valright->vector, valup->vector);
3417 }
3418
3419 /*
3420 ========================
3421 VM_drawline
3422
3423 void drawline(float width, vector pos1, vector pos2, vector rgb, float alpha, float flags)
3424 ========================
3425 */
3426 void VM_drawline (void)
3427 {
3428         float   *c1, *c2, *rgb;
3429         float   alpha, width;
3430         unsigned char   flags;
3431
3432         VM_SAFEPARMCOUNT(6, VM_drawline);
3433         width   = PRVM_G_FLOAT(OFS_PARM0);
3434         c1              = PRVM_G_VECTOR(OFS_PARM1);
3435         c2              = PRVM_G_VECTOR(OFS_PARM2);
3436         rgb             = PRVM_G_VECTOR(OFS_PARM3);
3437         alpha   = PRVM_G_FLOAT(OFS_PARM4);
3438         flags   = (int)PRVM_G_FLOAT(OFS_PARM5);
3439         DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
3440 }
3441
3442 // float(float number, float quantity) bitshift (EXT_BITSHIFT)
3443 void VM_bitshift (void)
3444 {
3445         int n1, n2;
3446         VM_SAFEPARMCOUNT(2, VM_bitshift);
3447
3448         n1 = (int)fabs((int)PRVM_G_FLOAT(OFS_PARM0));
3449         n2 = (int)PRVM_G_FLOAT(OFS_PARM1);
3450         if(!n1)
3451                 PRVM_G_FLOAT(OFS_RETURN) = n1;
3452         else
3453         if(n2 < 0)
3454                 PRVM_G_FLOAT(OFS_RETURN) = (n1 >> -n2);
3455         else
3456                 PRVM_G_FLOAT(OFS_RETURN) = (n1 << n2);
3457 }
3458
3459 ////////////////////////////////////////
3460 // AltString functions
3461 ////////////////////////////////////////
3462
3463 /*
3464 ========================
3465 VM_altstr_count
3466
3467 float altstr_count(string)
3468 ========================
3469 */
3470 void VM_altstr_count( void )
3471 {
3472         const char *altstr, *pos;
3473         int     count;
3474
3475         VM_SAFEPARMCOUNT( 1, VM_altstr_count );
3476
3477         altstr = PRVM_G_STRING( OFS_PARM0 );
3478         //VM_CheckEmptyString( altstr );
3479
3480         for( count = 0, pos = altstr ; *pos ; pos++ ) {
3481                 if( *pos == '\\' ) {
3482                         if( !*++pos ) {
3483                                 break;
3484                         }
3485                 } else if( *pos == '\'' ) {
3486                         count++;
3487                 }
3488         }
3489
3490         PRVM_G_FLOAT( OFS_RETURN ) = (float) (count / 2);
3491 }
3492
3493 /*
3494 ========================
3495 VM_altstr_prepare
3496
3497 string altstr_prepare(string)
3498 ========================
3499 */
3500 void VM_altstr_prepare( void )
3501 {
3502         char *out;
3503         const char *instr, *in;
3504         int size;
3505         char outstr[VM_STRINGTEMP_LENGTH];
3506
3507         VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
3508
3509         instr = PRVM_G_STRING( OFS_PARM0 );
3510
3511         for( out = outstr, in = instr, size = sizeof(outstr) - 1 ; size && *in ; size--, in++, out++ )
3512                 if( *in == '\'' ) {
3513                         *out++ = '\\';
3514                         *out = '\'';
3515                         size--;
3516                 } else
3517                         *out = *in;
3518         *out = 0;
3519
3520         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr );
3521 }
3522
3523 /*
3524 ========================
3525 VM_altstr_get
3526
3527 string altstr_get(string, float)
3528 ========================
3529 */
3530 void VM_altstr_get( void )
3531 {
3532         const char *altstr, *pos;
3533         char *out;
3534         int count, size;
3535         char outstr[VM_STRINGTEMP_LENGTH];
3536
3537         VM_SAFEPARMCOUNT( 2, VM_altstr_get );
3538
3539         altstr = PRVM_G_STRING( OFS_PARM0 );
3540
3541         count = (int)PRVM_G_FLOAT( OFS_PARM1 );
3542         count = count * 2 + 1;
3543
3544         for( pos = altstr ; *pos && count ; pos++ )
3545                 if( *pos == '\\' ) {
3546                         if( !*++pos )
3547                                 break;
3548                 } else if( *pos == '\'' )
3549                         count--;
3550
3551         if( !*pos ) {
3552                 PRVM_G_INT( OFS_RETURN ) = 0;
3553                 return;
3554         }
3555
3556         for( out = outstr, size = sizeof(outstr) - 1 ; size && *pos ; size--, pos++, out++ )
3557                 if( *pos == '\\' ) {
3558                         if( !*++pos )
3559                                 break;
3560                         *out = *pos;
3561                         size--;
3562                 } else if( *pos == '\'' )
3563                         break;
3564                 else
3565                         *out = *pos;
3566
3567         *out = 0;
3568         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr );
3569 }
3570
3571 /*
3572 ========================
3573 VM_altstr_set
3574
3575 string altstr_set(string altstr, float num, string set)
3576 ========================
3577 */
3578 void VM_altstr_set( void )
3579 {
3580     int num;
3581         const char *altstr, *str;
3582         const char *in;
3583         char *out;
3584         char outstr[VM_STRINGTEMP_LENGTH];
3585
3586         VM_SAFEPARMCOUNT( 3, VM_altstr_set );
3587
3588         altstr = PRVM_G_STRING( OFS_PARM0 );
3589
3590         num = (int)PRVM_G_FLOAT( OFS_PARM1 );
3591
3592         str = PRVM_G_STRING( OFS_PARM2 );
3593
3594         out = outstr;
3595         for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
3596                 if( *in == '\\' ) {
3597                         if( !*++in ) {
3598                                 break;
3599                         }
3600                 } else if( *in == '\'' ) {
3601                         num--;
3602                 }
3603
3604         // copy set in
3605         for( ; *str; *out++ = *str++ );
3606         // now jump over the old content
3607         for( ; *in ; in++ )
3608                 if( *in == '\'' || (*in == '\\' && !*++in) )
3609                         break;
3610
3611         strlcpy(out, in, outstr + sizeof(outstr) - out);
3612         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr );
3613 }
3614
3615 /*
3616 ========================
3617 VM_altstr_ins
3618 insert after num
3619 string  altstr_ins(string altstr, float num, string set)
3620 ========================
3621 */
3622 void VM_altstr_ins(void)
3623 {
3624         int num;
3625         const char *setstr;
3626         const char *set;
3627         const char *instr;
3628         const char *in;
3629         char *out;
3630         char outstr[VM_STRINGTEMP_LENGTH];
3631
3632         VM_SAFEPARMCOUNT(3, VM_altstr_ins);
3633
3634         in = instr = PRVM_G_STRING( OFS_PARM0 );
3635         num = (int)PRVM_G_FLOAT( OFS_PARM1 );
3636         set = setstr = PRVM_G_STRING( OFS_PARM2 );
3637
3638         out = outstr;
3639         for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ )
3640                 if( *in == '\\' ) {
3641                         if( !*++in ) {
3642                                 break;
3643                         }
3644                 } else if( *in == '\'' ) {
3645                         num--;
3646                 }
3647
3648         *out++ = '\'';
3649         for( ; *set ; *out++ = *set++ );
3650         *out++ = '\'';
3651
3652         strlcpy(out, in, outstr + sizeof(outstr) - out);
3653         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr );
3654 }
3655
3656
3657 ////////////////////////////////////////
3658 // BufString functions
3659 ////////////////////////////////////////
3660 //[515]: string buffers support
3661
3662 static size_t stringbuffers_sortlength;
3663
3664 static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex)
3665 {
3666         if (stringbuffer->max_strings <= strindex)
3667         {
3668                 char **oldstrings = stringbuffer->strings;
3669                 stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
3670                 while (stringbuffer->max_strings <= strindex)
3671                         stringbuffer->max_strings *= 2;
3672                 stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
3673                 if (stringbuffer->num_strings > 0)
3674                         memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
3675                 if (oldstrings)
3676                         Mem_Free(oldstrings);
3677         }
3678 }
3679
3680 static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer)
3681 {
3682         // reduce num_strings if there are empty string slots at the end
3683         while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL)
3684                 stringbuffer->num_strings--;
3685
3686         // if empty, free the string pointer array
3687         if (stringbuffer->num_strings == 0)
3688         {
3689                 stringbuffer->max_strings = 0;
3690                 if (stringbuffer->strings)
3691                         Mem_Free(stringbuffer->strings);
3692                 stringbuffer->strings = NULL;
3693         }
3694 }
3695
3696 static int BufStr_SortStringsUP (const void *in1, const void *in2)
3697 {
3698         const char *a, *b;
3699         a = *((const char **) in1);
3700         b = *((const char **) in2);
3701         if(!a[0])       return 1;
3702         if(!b[0])       return -1;
3703         return strncmp(a, b, stringbuffers_sortlength);
3704 }
3705
3706 static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
3707 {
3708         const char *a, *b;
3709         a = *((const char **) in1);
3710         b = *((const char **) in2);
3711         if(!a[0])       return 1;
3712         if(!b[0])       return -1;
3713         return strncmp(b, a, stringbuffers_sortlength);
3714 }
3715
3716 /*
3717 ========================
3718 VM_buf_create
3719 creates new buffer, and returns it's index, returns -1 if failed
3720 float buf_create(void) = #460;
3721 ========================
3722 */
3723 void VM_buf_create (void)
3724 {
3725         prvm_stringbuffer_t *stringbuffer;
3726         int i;
3727         VM_SAFEPARMCOUNT(0, VM_buf_create);
3728         stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
3729         for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
3730         PRVM_G_FLOAT(OFS_RETURN) = i;
3731 }
3732
3733 /*
3734 ========================
3735 VM_buf_del
3736 deletes buffer and all strings in it
3737 void buf_del(float bufhandle) = #461;
3738 ========================
3739 */
3740 void VM_buf_del (void)
3741 {
3742         prvm_stringbuffer_t *stringbuffer;
3743         VM_SAFEPARMCOUNT(1, VM_buf_del);
3744         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3745         if (stringbuffer)
3746         {
3747                 int i;
3748                 for (i = 0;i < stringbuffer->num_strings;i++)
3749                         if (stringbuffer->strings[i])
3750                                 Mem_Free(stringbuffer->strings[i]);
3751                 if (stringbuffer->strings)
3752                         Mem_Free(stringbuffer->strings);
3753                 Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
3754         }
3755         else
3756         {
3757                 VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
3758                 return;
3759         }
3760 }
3761
3762 /*
3763 ========================
3764 VM_buf_getsize
3765 how many strings are stored in buffer
3766 float buf_getsize(float bufhandle) = #462;
3767 ========================
3768 */
3769 void VM_buf_getsize (void)
3770 {
3771         prvm_stringbuffer_t *stringbuffer;
3772         VM_SAFEPARMCOUNT(1, VM_buf_getsize);
3773
3774         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3775         if(!stringbuffer)
3776         {
3777                 PRVM_G_FLOAT(OFS_RETURN) = -1;
3778                 VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
3779                 return;
3780         }
3781         else
3782                 PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings;
3783 }
3784
3785 /*
3786 ========================
3787 VM_buf_copy
3788 copy all content from one buffer to another, make sure it exists
3789 void buf_copy(float bufhandle_from, float bufhandle_to) = #463;
3790 ========================
3791 */
3792 void VM_buf_copy (void)
3793 {
3794         prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer;
3795         int i;
3796         VM_SAFEPARMCOUNT(2, VM_buf_copy);
3797
3798         srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3799         if(!srcstringbuffer)
3800         {
3801                 VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
3802                 return;
3803         }
3804         i = (int)PRVM_G_FLOAT(OFS_PARM1);
3805         if(i == (int)PRVM_G_FLOAT(OFS_PARM0))
3806         {
3807                 VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
3808                 return;
3809         }
3810         dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3811         if(!dststringbuffer)
3812         {
3813                 VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
3814                 return;
3815         }
3816
3817         for (i = 0;i < dststringbuffer->num_strings;i++)
3818                 if (dststringbuffer->strings[i])
3819                         Mem_Free(dststringbuffer->strings[i]);
3820         if (dststringbuffer->strings)
3821                 Mem_Free(dststringbuffer->strings);
3822         *dststringbuffer = *srcstringbuffer;
3823         if (dststringbuffer->max_strings)
3824                 dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings);
3825
3826         for (i = 0;i < dststringbuffer->num_strings;i++)
3827         {
3828                 if (srcstringbuffer->strings[i])
3829                 {
3830                         size_t stringlen;
3831                         stringlen = strlen(srcstringbuffer->strings[i]) + 1;
3832                         dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen);
3833                         memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen);
3834                 }
3835         }
3836 }
3837
3838 /*
3839 ========================
3840 VM_buf_sort
3841 sort buffer by beginnings of strings (cmplength defaults it's length)
3842 "backward == TRUE" means that sorting goes upside-down
3843 void buf_sort(float bufhandle, float cmplength, float backward) = #464;
3844 ========================
3845 */
3846 void VM_buf_sort (void)
3847 {
3848         prvm_stringbuffer_t *stringbuffer;
3849         VM_SAFEPARMCOUNT(3, VM_buf_sort);
3850
3851         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3852         if(!stringbuffer)
3853         {
3854                 VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
3855                 return;
3856         }
3857         if(stringbuffer->num_strings <= 0)
3858         {
3859                 VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
3860                 return;
3861         }
3862         stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1);
3863         if(stringbuffers_sortlen