Added in_mouse_x and in_mouse_y, which contain the rel. coords of the mouse.
[divverent/darkplaces.git] / pr_exec.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20
21 #include "quakedef.h"
22
23
24 typedef struct
25 {
26         int                             s;
27         mfunction_t             *f;
28 } prstack_t;
29
30 #define MAX_STACK_DEPTH         256
31 // stacktrace writes into pr_stack[MAX_STACK_DEPTH]
32 // thus increase the array, so depth wont be overwritten
33 prstack_t       pr_stack[MAX_STACK_DEPTH+1];
34 int                     pr_depth = 0;
35
36 #define LOCALSTACK_SIZE         2048
37 int                     localstack[LOCALSTACK_SIZE];
38 int                     localstack_used;
39
40
41 int                     pr_trace;
42 mfunction_t     *pr_xfunction;
43 int                     pr_xstatement;
44
45
46 int             pr_argc;
47
48 char *pr_opnames[] =
49 {
50 "DONE",
51
52 "MUL_F",
53 "MUL_V",
54 "MUL_FV",
55 "MUL_VF",
56
57 "DIV",
58
59 "ADD_F",
60 "ADD_V",
61
62 "SUB_F",
63 "SUB_V",
64
65 "EQ_F",
66 "EQ_V",
67 "EQ_S",
68 "EQ_E",
69 "EQ_FNC",
70
71 "NE_F",
72 "NE_V",
73 "NE_S",
74 "NE_E",
75 "NE_FNC",
76
77 "LE",
78 "GE",
79 "LT",
80 "GT",
81
82 "INDIRECT",
83 "INDIRECT",
84 "INDIRECT",
85 "INDIRECT",
86 "INDIRECT",
87 "INDIRECT",
88
89 "ADDRESS",
90
91 "STORE_F",
92 "STORE_V",
93 "STORE_S",
94 "STORE_ENT",
95 "STORE_FLD",
96 "STORE_FNC",
97
98 "STOREP_F",
99 "STOREP_V",
100 "STOREP_S",
101 "STOREP_ENT",
102 "STOREP_FLD",
103 "STOREP_FNC",
104
105 "RETURN",
106
107 "NOT_F",
108 "NOT_V",
109 "NOT_S",
110 "NOT_ENT",
111 "NOT_FNC",
112
113 "IF",
114 "IFNOT",
115
116 "CALL0",
117 "CALL1",
118 "CALL2",
119 "CALL3",
120 "CALL4",
121 "CALL5",
122 "CALL6",
123 "CALL7",
124 "CALL8",
125
126 "STATE",
127
128 "GOTO",
129
130 "AND",
131 "OR",
132
133 "BITAND",
134 "BITOR"
135 };
136
137 char *PR_GlobalString (int ofs);
138 char *PR_GlobalStringNoContents (int ofs);
139
140
141 //=============================================================================
142
143 /*
144 =================
145 PR_PrintStatement
146 =================
147 */
148 void PR_PrintStatement (dstatement_t *s)
149 {
150         int             i;
151
152         if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0]))
153         {
154                 Con_Printf ("%s ",  pr_opnames[s->op]);
155                 i = strlen(pr_opnames[s->op]);
156                 for ( ; i<10 ; i++)
157                         Con_Printf (" ");
158         }
159
160         if (s->op == OP_IF || s->op == OP_IFNOT)
161                 Con_Printf ("%sbranch %i",PR_GlobalString((unsigned short) s->a),s->b);
162         else if (s->op == OP_GOTO)
163         {
164                 Con_Printf ("branch %i",s->a);
165         }
166         else if ( (unsigned)(s->op - OP_STORE_F) < 6)
167         {
168                 Con_Printf ("%s", PR_GlobalString((unsigned short) s->a));
169                 Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->b));
170         }
171         else
172         {
173                 if (s->a)
174                         Con_Printf ("%s", PR_GlobalString((unsigned short) s->a));
175                 if (s->b)
176                         Con_Printf ("%s", PR_GlobalString((unsigned short) s->b));
177                 if (s->c)
178                         Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->c));
179         }
180         Con_Printf ("\n");
181 }
182
183 /*
184 ============
185 PR_StackTrace
186 ============
187 */
188 void PR_StackTrace (void)
189 {
190         mfunction_t     *f;
191         int                     i;
192
193         pr_stack[pr_depth].s = pr_xstatement;
194         pr_stack[pr_depth].f = pr_xfunction;
195         for (i = pr_depth;i > 0;i--)
196         {
197                 f = pr_stack[i].f;
198
199                 if (!f)
200                         Con_Printf ("<NULL FUNCTION>\n");
201                 else
202                         Con_Printf ("%12s : %s : statement %i\n", PR_GetString(f->s_file), PR_GetString(f->s_name), pr_stack[i].s - f->first_statement);
203         }
204 }
205
206
207 /*
208 ============
209 PR_Profile_f
210
211 ============
212 */
213 void PR_Profile_f (void)
214 {
215         mfunction_t *f, *best;
216         int i, num, max/*, howmany*/;
217
218         //howmany = 10;
219         //if (Cmd_Argc() == 2)
220         //      howmany = atoi(Cmd_Argv(1));
221         num = 0;
222         do
223         {
224                 max = 0;
225                 best = NULL;
226                 for (i=0 ; i<progs->numfunctions ; i++)
227                 {
228                         f = &pr_functions[i];
229                         if (f->profile > max)
230                         {
231                                 max = f->profile;
232                                 best = f;
233                         }
234                 }
235                 if (best)
236                 {
237                         //if (num < howmany)
238                                 Con_Printf ("%7i %7i %s\n", best->profile, best->builtinsprofile, PR_GetString(best->s_name));
239                         num++;
240                         best->profile = 0;
241                         best->builtinsprofile = 0;
242                 }
243         } while (best);
244 }
245
246
247 void PR_Crash(void)
248 {
249         int i;
250         if (pr_depth < 1)
251         {
252                 // kill the stack just to be sure
253                 pr_depth = 0;
254                 localstack_used = 0;
255                 return;
256         }
257
258         Con_Printf("QuakeC crash report:\n");
259         if (pr_xfunction)
260         {
261                 for (i = -4;i <= 0;i++)
262                         if (pr_xstatement + i >= pr_xfunction->first_statement)
263                                 PR_PrintStatement (pr_statements + pr_xstatement + i);
264         }
265         else
266                 Con_Printf("null function executing??\n");
267         PR_StackTrace ();
268
269         // dump the stack so host_error can shutdown functions
270         pr_depth = 0;
271         localstack_used = 0;
272 }
273
274 /*
275 ============================================================================
276 PR_ExecuteProgram
277
278 The interpretation main loop
279 ============================================================================
280 */
281
282 /*
283 ====================
284 PR_EnterFunction
285
286 Returns the new program statement counter
287 ====================
288 */
289 int PR_EnterFunction (mfunction_t *f)
290 {
291         int             i, j, c, o;
292
293         if (!f)
294                 Host_Error ("PR_EnterFunction: NULL function\n");
295
296         pr_stack[pr_depth].s = pr_xstatement;
297         pr_stack[pr_depth].f = pr_xfunction;
298         pr_depth++;
299         if (pr_depth >= MAX_STACK_DEPTH)
300                 Host_Error ("stack overflow");
301
302 // save off any locals that the new function steps on
303         c = f->locals;
304         if (localstack_used + c > LOCALSTACK_SIZE)
305                 Host_Error ("PR_ExecuteProgram: locals stack overflow\n");
306
307         for (i=0 ; i < c ; i++)
308                 localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
309         localstack_used += c;
310
311 // copy parameters
312         o = f->parm_start;
313         for (i=0 ; i<f->numparms ; i++)
314         {
315                 for (j=0 ; j<f->parm_size[i] ; j++)
316                 {
317                         ((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j];
318                         o++;
319                 }
320         }
321
322         pr_xfunction = f;
323         return f->first_statement - 1;  // offset the s++
324 }
325
326 /*
327 ====================
328 PR_LeaveFunction
329 ====================
330 */
331 int PR_LeaveFunction (void)
332 {
333         int             i, c;
334
335         if (pr_depth <= 0)
336                 Host_Error ("prog stack underflow");
337
338         if (!pr_xfunction)
339                 Host_Error ("PR_LeaveFunction: NULL function\n");
340 // restore locals from the stack
341         c = pr_xfunction->locals;
342         localstack_used -= c;
343         if (localstack_used < 0)
344                 Host_Error ("PR_ExecuteProgram: locals stack underflow\n");
345
346         for (i=0 ; i < c ; i++)
347                 ((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];
348
349 // up stack
350         pr_depth--;
351         pr_xfunction = pr_stack[pr_depth].f;
352         return pr_stack[pr_depth].s;
353 }
354
355 void PR_ReInitStrings (void);
356 void PR_Execute_ProgsLoaded(void)
357 {
358         // dump the stack
359         pr_depth = 0;
360         localstack_used = 0;
361         // reset the string table
362         PR_ReInitStrings();
363 }
364
365 /*
366 ====================
367 PR_ExecuteProgram
368 ====================
369 */
370 // LordHavoc: optimized
371 #define OPA ((eval_t *)&pr_globals[(unsigned short) st->a])
372 #define OPB ((eval_t *)&pr_globals[(unsigned short) st->b])
373 #define OPC ((eval_t *)&pr_globals[(unsigned short) st->c])
374 extern cvar_t pr_boundscheck;
375 extern cvar_t pr_traceqc;
376 void PR_ExecuteProgram (func_t fnum, const char *errormessage)
377 {
378         dstatement_t    *st;
379         mfunction_t     *f, *newf;
380         edict_t *ed;
381         eval_t  *ptr;
382         int             profile, startprofile, cachedpr_trace, exitdepth;
383
384         if (!fnum || fnum >= progs->numfunctions)
385         {
386                 if (pr_global_struct->self)
387                         ED_Print (PROG_TO_EDICT(pr_global_struct->self));
388                 Host_Error ("PR_ExecuteProgram: %s", errormessage);
389         }
390
391         f = &pr_functions[fnum];
392
393         pr_trace = pr_traceqc.integer;
394
395         // we know we're done when pr_depth drops to this
396         exitdepth = pr_depth;
397
398 // make a stack frame
399         st = &pr_statements[PR_EnterFunction (f)];
400         startprofile = profile = 0;
401
402 chooseexecprogram:
403         cachedpr_trace = pr_trace;
404         if (pr_boundscheck.integer)
405         {
406 #define PRBOUNDSCHECK 1
407                 if (pr_trace)
408                 {
409 #define PRTRACE 1
410 #include "pr_execprogram.h"
411                 }
412                 else
413                 {
414 #undef PRTRACE
415 #include "pr_execprogram.h"
416                 }
417         }
418         else
419         {
420 #undef PRBOUNDSCHECK
421                 if (pr_trace)
422                 {
423 #define PRTRACE 1
424 #include "pr_execprogram.h"
425                 }
426                 else
427                 {
428 #undef PRTRACE
429 #include "pr_execprogram.h"
430                 }
431         }
432 }
433
434 void PR_ReInitStrings (void)
435 {
436 }