A minor removal of a few pieces of dead code. Nothing major. This is
[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         dfunction_t             *f;
28 } prstack_t;
29
30 #define MAX_STACK_DEPTH         32
31 prstack_t       pr_stack[MAX_STACK_DEPTH];
32 int                     pr_depth = 0;
33
34 #define LOCALSTACK_SIZE         2048
35 int                     localstack[LOCALSTACK_SIZE];
36 int                     localstack_used;
37
38
39 qboolean        pr_trace;
40 dfunction_t     *pr_xfunction;
41 int                     pr_xstatement;
42
43
44 int             pr_argc;
45
46 char *pr_opnames[] =
47 {
48 "DONE",
49
50 "MUL_F",
51 "MUL_V", 
52 "MUL_FV",
53 "MUL_VF",
54  
55 "DIV",
56
57 "ADD_F",
58 "ADD_V", 
59   
60 "SUB_F",
61 "SUB_V",
62
63 "EQ_F",
64 "EQ_V",
65 "EQ_S", 
66 "EQ_E",
67 "EQ_FNC",
68  
69 "NE_F",
70 "NE_V", 
71 "NE_S",
72 "NE_E", 
73 "NE_FNC",
74  
75 "LE",
76 "GE",
77 "LT",
78 "GT", 
79
80 "INDIRECT",
81 "INDIRECT",
82 "INDIRECT", 
83 "INDIRECT", 
84 "INDIRECT",
85 "INDIRECT", 
86
87 "ADDRESS", 
88
89 "STORE_F",
90 "STORE_V",
91 "STORE_S",
92 "STORE_ENT",
93 "STORE_FLD",
94 "STORE_FNC",
95
96 "STOREP_F",
97 "STOREP_V",
98 "STOREP_S",
99 "STOREP_ENT",
100 "STOREP_FLD",
101 "STOREP_FNC",
102
103 "RETURN",
104   
105 "NOT_F",
106 "NOT_V",
107 "NOT_S", 
108 "NOT_ENT", 
109 "NOT_FNC", 
110   
111 "IF",
112 "IFNOT",
113   
114 "CALL0",
115 "CALL1",
116 "CALL2",
117 "CALL3",
118 "CALL4",
119 "CALL5",
120 "CALL6",
121 "CALL7",
122 "CALL8",
123   
124 "STATE",
125
126 "GOTO", 
127   
128 "AND",
129 "OR", 
130
131 "BITAND",
132 "BITOR"
133 };
134
135 char *PR_GlobalString (int ofs);
136 char *PR_GlobalStringNoContents (int ofs);
137
138
139 //=============================================================================
140
141 /*
142 =================
143 PR_PrintStatement
144 =================
145 */
146 void PR_PrintStatement (dstatement_t *s)
147 {
148         int             i;
149         
150         if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0]))
151         {
152                 Con_Printf ("%s ",  pr_opnames[s->op]);
153                 i = strlen(pr_opnames[s->op]);
154                 for ( ; i<10 ; i++)
155                         Con_Printf (" ");
156         }
157                 
158         if (s->op == OP_IF || s->op == OP_IFNOT)
159                 Con_Printf ("%sbranch %i",PR_GlobalString((unsigned short) s->a),s->b);
160         else if (s->op == OP_GOTO)
161         {
162                 Con_Printf ("branch %i",s->a);
163         }
164         else if ( (unsigned)(s->op - OP_STORE_F) < 6)
165         {
166                 Con_Printf ("%s",PR_GlobalString((unsigned short) s->a));
167                 Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->b));
168         }
169         else
170         {
171                 if (s->a)
172                         Con_Printf ("%s",PR_GlobalString((unsigned short) s->a));
173                 if (s->b)
174                         Con_Printf ("%s",PR_GlobalString((unsigned short) s->b));
175                 if (s->c)
176                         Con_Printf ("%s", PR_GlobalStringNoContents((unsigned short) s->c));
177         }
178         Con_Printf ("\n");
179 }
180
181 /*
182 ============
183 PR_StackTrace
184 ============
185 */
186 void PR_StackTrace (void)
187 {
188         dfunction_t     *f;
189         int                     i;
190
191         pr_stack[pr_depth].s = pr_xstatement;
192         pr_stack[pr_depth].f = pr_xfunction;
193         for (i = pr_depth;i > 0;i--)
194         {
195                 f = pr_stack[i].f;
196
197                 if (!f)
198                         Con_Printf ("<NULL FUNCTION>\n");
199                 else
200                         Con_Printf ("%12s : %s : statement %i\n", pr_strings + f->s_file, pr_strings + f->s_name, pr_stack[i].s - f->first_statement);
201         }
202 }
203
204
205 /*
206 ============
207 PR_Profile_f
208
209 ============
210 */
211 void PR_Profile_f (void)
212 {
213         dfunction_t     *f, *best;
214         int                     max;
215         int                     num;
216         int                     i;
217
218         num = 0;
219         do
220         {
221                 max = 0;
222                 best = NULL;
223                 for (i=0 ; i<progs->numfunctions ; i++)
224                 {
225                         f = &pr_functions[i];
226                         if (f->profile > max)
227                         {
228                                 max = f->profile;
229                                 best = f;
230                         }
231                 }
232                 if (best)
233                 {
234                         if (num < 10)
235                                 Con_Printf ("%7i %s\n", best->profile, pr_strings+best->s_name);
236                         num++;
237                         best->profile = 0;
238                 }
239         } while (best);
240 }
241
242
243 /*
244 ============
245 PR_RunError
246
247 Aborts the currently executing function
248 ============
249 */
250 void PR_RunError (char *error, ...)
251 {
252         int                     i;
253         va_list         argptr;
254         char            string[1024];
255
256         va_start (argptr,error);
257         vsprintf (string,error,argptr);
258         va_end (argptr);
259
260         if (pr_xfunction)
261         {
262                 for (i = -4;i <= 0;i++)
263                         if (pr_xstatement + i >= pr_xfunction->first_statement)
264                                 PR_PrintStatement (pr_statements + pr_xstatement + i);
265         }
266         else
267                 Con_Printf("null function executing??\n");
268         PR_StackTrace ();
269         Con_Printf ("%s\n", string);
270
271         pr_depth = 0;           // dump the stack so host_error can shutdown functions
272
273         Host_Error ("Program error");
274 }
275
276 /*
277 ============================================================================
278 PR_ExecuteProgram
279
280 The interpretation main loop
281 ============================================================================
282 */
283
284 /*
285 ====================
286 PR_EnterFunction
287
288 Returns the new program statement counter
289 ====================
290 */
291 int PR_EnterFunction (dfunction_t *f)
292 {
293         int             i, j, c, o;
294
295         if (!f)
296                 PR_RunError ("PR_EnterFunction: NULL function\n");
297
298         pr_stack[pr_depth].s = pr_xstatement;
299         pr_stack[pr_depth].f = pr_xfunction;
300         pr_depth++;
301         if (pr_depth >= MAX_STACK_DEPTH)
302                 PR_RunError ("stack overflow");
303
304 // save off any locals that the new function steps on
305         c = f->locals;
306         if (localstack_used + c > LOCALSTACK_SIZE)
307                 PR_RunError ("PR_ExecuteProgram: locals stack overflow\n");
308
309         for (i=0 ; i < c ; i++)
310                 localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
311         localstack_used += c;
312
313 // copy parameters
314         o = f->parm_start;
315         for (i=0 ; i<f->numparms ; i++)
316         {
317                 for (j=0 ; j<f->parm_size[i] ; j++)
318                 {
319                         ((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j];
320                         o++;
321                 }
322         }
323
324         pr_xfunction = f;
325         return f->first_statement - 1;  // offset the s++
326 }
327
328 /*
329 ====================
330 PR_LeaveFunction
331 ====================
332 */
333 int PR_LeaveFunction (void)
334 {
335         int             i, c;
336
337         if (pr_depth <= 0)
338                 Host_Error ("prog stack underflow");
339
340         if (!pr_xfunction)
341                 PR_RunError ("PR_LeaveFunction: NULL function\n");
342 // restore locals from the stack
343         c = pr_xfunction->locals;
344         localstack_used -= c;
345         if (localstack_used < 0)
346                 PR_RunError ("PR_ExecuteProgram: locals stack underflow\n");
347
348         for (i=0 ; i < c ; i++)
349                 ((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];
350
351 // up stack
352         pr_depth--;
353         pr_xfunction = pr_stack[pr_depth].f;
354         return pr_stack[pr_depth].s;
355 }
356
357 /*
358 ====================
359 PR_ExecuteProgram
360 ====================
361 */
362 // LordHavoc: optimized
363 #define OPA ((eval_t *)&pr_globals[(unsigned short) st->a])
364 #define OPB ((eval_t *)&pr_globals[(unsigned short) st->b])
365 #define OPC ((eval_t *)&pr_globals[(unsigned short) st->c])
366 extern cvar_t pr_boundscheck;
367 void PR_ExecuteProgram (func_t fnum, char *errormessage)
368 {
369         dstatement_t    *st;
370         dfunction_t     *f, *newf;
371         edict_t *ed;
372         eval_t  *ptr;
373         int             profile, startprofile, cachedpr_trace, exitdepth;
374
375         if (!fnum || fnum >= progs->numfunctions)
376         {
377                 if (pr_global_struct->self)
378                         ED_Print (PROG_TO_EDICT(pr_global_struct->self));
379                 Host_Error ("PR_ExecuteProgram: %s", errormessage);
380         }
381
382         f = &pr_functions[fnum];
383
384         pr_trace = false;
385
386         // we know we're done when pr_depth drops to this
387         exitdepth = pr_depth;
388
389 // make a stack frame
390         st = &pr_statements[PR_EnterFunction (f)];
391         startprofile = profile = 0;
392
393 chooseexecprogram:
394         cachedpr_trace = pr_trace;
395         if (pr_boundscheck.integer)
396         {
397 #define PRBOUNDSCHECK 1
398                 if (pr_trace)
399                 {
400 #define PRTRACE 1
401 #include "pr_execprogram.h"
402                 }
403                 else
404                 {
405 #undef PRTRACE
406 #include "pr_execprogram.h"
407                 }
408         }
409         else
410         {
411 #undef PRBOUNDSCHECK
412                 if (pr_trace)
413                 {
414 #define PRTRACE 1
415 #include "pr_execprogram.h"
416                 }
417                 else
418                 {
419 #undef PRTRACE
420 #include "pr_execprogram.h"
421                 }
422         }
423 }
424