doom3-gpl
Doom 3 GPL source release
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Script_Compiler.cpp
Go to the documentation of this file.
1 /*
2 ===========================================================================
3 
4 Doom 3 GPL Source Code
5 Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
6 
7 This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
8 
9 Doom 3 Source Code is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13 
14 Doom 3 Source Code is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
21 
22 In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
23 
24 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
25 
26 ===========================================================================
27 */
28 
29 #include "../../idlib/precompiled.h"
30 #pragma hdrstop
31 
32 #include "../Game_local.h"
33 
34 #define FUNCTION_PRIORITY 2
35 #define INT_PRIORITY 2
36 #define NOT_PRIORITY 5
37 #define TILDE_PRIORITY 5
38 #define TOP_PRIORITY 7
39 
40 bool idCompiler::punctuationValid[ 256 ];
41 const char *idCompiler::punctuation[] = {
42  "+=", "-=", "*=", "/=", "%=", "&=", "|=", "++", "--",
43  "&&", "||", "<=", ">=", "==", "!=", "::", ";", ",",
44  "~", "!", "*", "/", "%", "(", ")", "-", "+",
45  "=", "[", "]", ".", "<", ">" , "&", "|", ":", NULL
46 };
47 
48 opcode_t idCompiler::opcodes[] = {
49  { "<RETURN>", "RETURN", -1, false, &def_void, &def_void, &def_void },
50 
51  { "++", "UINC_F", 1, true, &def_float, &def_void, &def_void },
52  { "++", "UINCP_F", 1, true, &def_object, &def_field, &def_float },
53  { "--", "UDEC_F", 1, true, &def_float, &def_void, &def_void },
54  { "--", "UDECP_F", 1, true, &def_object, &def_field, &def_float },
55 
56  { "~", "COMP_F", -1, false, &def_float, &def_void, &def_float },
57 
58  { "*", "MUL_F", 3, false, &def_float, &def_float, &def_float },
59  { "*", "MUL_V", 3, false, &def_vector, &def_vector, &def_float },
60  { "*", "MUL_FV", 3, false, &def_float, &def_vector, &def_vector },
61  { "*", "MUL_VF", 3, false, &def_vector, &def_float, &def_vector },
62 
63  { "/", "DIV", 3, false, &def_float, &def_float, &def_float },
64  { "%", "MOD_F", 3, false, &def_float, &def_float, &def_float },
65 
66  { "+", "ADD_F", 4, false, &def_float, &def_float, &def_float },
67  { "+", "ADD_V", 4, false, &def_vector, &def_vector, &def_vector },
68  { "+", "ADD_S", 4, false, &def_string, &def_string, &def_string },
69  { "+", "ADD_FS", 4, false, &def_float, &def_string, &def_string },
70  { "+", "ADD_SF", 4, false, &def_string, &def_float, &def_string },
71  { "+", "ADD_VS", 4, false, &def_vector, &def_string, &def_string },
72  { "+", "ADD_SV", 4, false, &def_string, &def_vector, &def_string },
73 
74  { "-", "SUB_F", 4, false, &def_float, &def_float, &def_float },
75  { "-", "SUB_V", 4, false, &def_vector, &def_vector, &def_vector },
76 
77  { "==", "EQ_F", 5, false, &def_float, &def_float, &def_float },
78  { "==", "EQ_V", 5, false, &def_vector, &def_vector, &def_float },
79  { "==", "EQ_S", 5, false, &def_string, &def_string, &def_float },
80  { "==", "EQ_E", 5, false, &def_entity, &def_entity, &def_float },
81  { "==", "EQ_EO", 5, false, &def_entity, &def_object, &def_float },
82  { "==", "EQ_OE", 5, false, &def_object, &def_entity, &def_float },
83  { "==", "EQ_OO", 5, false, &def_object, &def_object, &def_float },
84 
85  { "!=", "NE_F", 5, false, &def_float, &def_float, &def_float },
86  { "!=", "NE_V", 5, false, &def_vector, &def_vector, &def_float },
87  { "!=", "NE_S", 5, false, &def_string, &def_string, &def_float },
88  { "!=", "NE_E", 5, false, &def_entity, &def_entity, &def_float },
89  { "!=", "NE_EO", 5, false, &def_entity, &def_object, &def_float },
90  { "!=", "NE_OE", 5, false, &def_object, &def_entity, &def_float },
91  { "!=", "NE_OO", 5, false, &def_object, &def_object, &def_float },
92 
93  { "<=", "LE", 5, false, &def_float, &def_float, &def_float },
94  { ">=", "GE", 5, false, &def_float, &def_float, &def_float },
95  { "<", "LT", 5, false, &def_float, &def_float, &def_float },
96  { ">", "GT", 5, false, &def_float, &def_float, &def_float },
97 
98  { ".", "INDIRECT_F", 1, false, &def_object, &def_field, &def_float },
99  { ".", "INDIRECT_V", 1, false, &def_object, &def_field, &def_vector },
100  { ".", "INDIRECT_S", 1, false, &def_object, &def_field, &def_string },
101  { ".", "INDIRECT_E", 1, false, &def_object, &def_field, &def_entity },
102  { ".", "INDIRECT_BOOL", 1, false, &def_object, &def_field, &def_boolean },
103  { ".", "INDIRECT_OBJ", 1, false, &def_object, &def_field, &def_object },
104 
105  { ".", "ADDRESS", 1, false, &def_entity, &def_field, &def_pointer },
106 
107  { ".", "EVENTCALL", 2, false, &def_entity, &def_function, &def_void },
108  { ".", "OBJECTCALL", 2, false, &def_object, &def_function, &def_void },
109  { ".", "SYSCALL", 2, false, &def_void, &def_function, &def_void },
110 
111  { "=", "STORE_F", 6, true, &def_float, &def_float, &def_float },
112  { "=", "STORE_V", 6, true, &def_vector, &def_vector, &def_vector },
113  { "=", "STORE_S", 6, true, &def_string, &def_string, &def_string },
114  { "=", "STORE_ENT", 6, true, &def_entity, &def_entity, &def_entity },
115  { "=", "STORE_BOOL", 6, true, &def_boolean, &def_boolean, &def_boolean },
116  { "=", "STORE_OBJENT", 6, true, &def_object, &def_entity, &def_object },
117  { "=", "STORE_OBJ", 6, true, &def_object, &def_object, &def_object },
118  { "=", "STORE_OBJENT", 6, true, &def_entity, &def_object, &def_object },
119 
120  { "=", "STORE_FTOS", 6, true, &def_string, &def_float, &def_string },
121  { "=", "STORE_BTOS", 6, true, &def_string, &def_boolean, &def_string },
122  { "=", "STORE_VTOS", 6, true, &def_string, &def_vector, &def_string },
123  { "=", "STORE_FTOBOOL", 6, true, &def_boolean, &def_float, &def_boolean },
124  { "=", "STORE_BOOLTOF", 6, true, &def_float, &def_boolean, &def_float },
125 
126  { "=", "STOREP_F", 6, true, &def_pointer, &def_float, &def_float },
127  { "=", "STOREP_V", 6, true, &def_pointer, &def_vector, &def_vector },
128  { "=", "STOREP_S", 6, true, &def_pointer, &def_string, &def_string },
129  { "=", "STOREP_ENT", 6, true, &def_pointer, &def_entity, &def_entity },
130  { "=", "STOREP_FLD", 6, true, &def_pointer, &def_field, &def_field },
131  { "=", "STOREP_BOOL", 6, true, &def_pointer, &def_boolean, &def_boolean },
132  { "=", "STOREP_OBJ", 6, true, &def_pointer, &def_object, &def_object },
133  { "=", "STOREP_OBJENT", 6, true, &def_pointer, &def_object, &def_object },
134 
135  { "<=>", "STOREP_FTOS", 6, true, &def_pointer, &def_float, &def_string },
136  { "<=>", "STOREP_BTOS", 6, true, &def_pointer, &def_boolean, &def_string },
137  { "<=>", "STOREP_VTOS", 6, true, &def_pointer, &def_vector, &def_string },
138  { "<=>", "STOREP_FTOBOOL", 6, true, &def_pointer, &def_float, &def_boolean },
139  { "<=>", "STOREP_BOOLTOF", 6, true, &def_pointer, &def_boolean, &def_float },
140 
141  { "*=", "UMUL_F", 6, true, &def_float, &def_float, &def_void },
142  { "*=", "UMUL_V", 6, true, &def_vector, &def_float, &def_void },
143  { "/=", "UDIV_F", 6, true, &def_float, &def_float, &def_void },
144  { "/=", "UDIV_V", 6, true, &def_vector, &def_float, &def_void },
145  { "%=", "UMOD_F", 6, true, &def_float, &def_float, &def_void },
146  { "+=", "UADD_F", 6, true, &def_float, &def_float, &def_void },
147  { "+=", "UADD_V", 6, true, &def_vector, &def_vector, &def_void },
148  { "-=", "USUB_F", 6, true, &def_float, &def_float, &def_void },
149  { "-=", "USUB_V", 6, true, &def_vector, &def_vector, &def_void },
150  { "&=", "UAND_F", 6, true, &def_float, &def_float, &def_void },
151  { "|=", "UOR_F", 6, true, &def_float, &def_float, &def_void },
152 
153  { "!", "NOT_BOOL", -1, false, &def_boolean, &def_void, &def_float },
154  { "!", "NOT_F", -1, false, &def_float, &def_void, &def_float },
155  { "!", "NOT_V", -1, false, &def_vector, &def_void, &def_float },
156  { "!", "NOT_S", -1, false, &def_vector, &def_void, &def_float },
157  { "!", "NOT_ENT", -1, false, &def_entity, &def_void, &def_float },
158 
159  { "<NEG_F>", "NEG_F", -1, false, &def_float, &def_void, &def_float },
160  { "<NEG_V>", "NEG_V", -1, false, &def_vector, &def_void, &def_vector },
161 
162  { "int", "INT_F", -1, false, &def_float, &def_void, &def_float },
163 
164  { "<IF>", "IF", -1, false, &def_float, &def_jumpoffset, &def_void },
165  { "<IFNOT>", "IFNOT", -1, false, &def_float, &def_jumpoffset, &def_void },
166 
167  // calls returns REG_RETURN
168  { "<CALL>", "CALL", -1, false, &def_function, &def_argsize, &def_void },
169  { "<THREAD>", "THREAD", -1, false, &def_function, &def_argsize, &def_void },
170  { "<THREAD>", "OBJTHREAD", -1, false, &def_function, &def_argsize, &def_void },
171 
172  { "<PUSH>", "PUSH_F", -1, false, &def_float, &def_float, &def_void },
173  { "<PUSH>", "PUSH_V", -1, false, &def_vector, &def_vector, &def_void },
174  { "<PUSH>", "PUSH_S", -1, false, &def_string, &def_string, &def_void },
175  { "<PUSH>", "PUSH_ENT", -1, false, &def_entity, &def_entity, &def_void },
176  { "<PUSH>", "PUSH_OBJ", -1, false, &def_object, &def_object, &def_void },
177  { "<PUSH>", "PUSH_OBJENT", -1, false, &def_entity, &def_object, &def_void },
178  { "<PUSH>", "PUSH_FTOS", -1, false, &def_string, &def_float, &def_void },
179  { "<PUSH>", "PUSH_BTOF", -1, false, &def_float, &def_boolean, &def_void },
180  { "<PUSH>", "PUSH_FTOB", -1, false, &def_boolean, &def_float, &def_void },
181  { "<PUSH>", "PUSH_VTOS", -1, false, &def_string, &def_vector, &def_void },
182  { "<PUSH>", "PUSH_BTOS", -1, false, &def_string, &def_boolean, &def_void },
183 
184  { "<GOTO>", "GOTO", -1, false, &def_jumpoffset, &def_void, &def_void },
185 
186  { "&&", "AND", 7, false, &def_float, &def_float, &def_float },
187  { "&&", "AND_BOOLF", 7, false, &def_boolean, &def_float, &def_float },
188  { "&&", "AND_FBOOL", 7, false, &def_float, &def_boolean, &def_float },
189  { "&&", "AND_BOOLBOOL", 7, false, &def_boolean, &def_boolean, &def_float },
190  { "||", "OR", 7, false, &def_float, &def_float, &def_float },
191  { "||", "OR_BOOLF", 7, false, &def_boolean, &def_float, &def_float },
192  { "||", "OR_FBOOL", 7, false, &def_float, &def_boolean, &def_float },
193  { "||", "OR_BOOLBOOL", 7, false, &def_boolean, &def_boolean, &def_float },
194 
195  { "&", "BITAND", 3, false, &def_float, &def_float, &def_float },
196  { "|", "BITOR", 3, false, &def_float, &def_float, &def_float },
197 
198  { "<BREAK>", "BREAK", -1, false, &def_float, &def_void, &def_void },
199  { "<CONTINUE>", "CONTINUE", -1, false, &def_float, &def_void, &def_void },
200 
201  { NULL }
202 };
203 
204 /*
205 ================
206 idCompiler::idCompiler()
207 ================
208 */
209 idCompiler::idCompiler() {
210  char **ptr;
211  int id;
212 
213  // make sure we have the right # of opcodes in the table
214  assert( ( sizeof( opcodes ) / sizeof( opcodes[ 0 ] ) ) == ( NUM_OPCODES + 1 ) );
215 
216  eof = true;
217  parserPtr = &parser;
218 
219  callthread = false;
220  loopDepth = 0;
221  eof = false;
222  braceDepth = 0;
223  immediateType = NULL;
224  basetype = NULL;
225  currentLineNumber = 0;
226  currentFileNumber = 0;
227  errorCount = 0;
228  console = false;
229  scope = &def_namespace;
230 
231  memset( &immediate, 0, sizeof( immediate ) );
232  memset( punctuationValid, 0, sizeof( punctuationValid ) );
233  for( ptr = punctuation; *ptr != NULL; ptr++ ) {
234  id = parserPtr->GetPunctuationId( *ptr );
235  if ( ( id >= 0 ) && ( id < 256 ) ) {
236  punctuationValid[ id ] = true;
237  }
238  }
239 }
240 
241 /*
242 ============
243 idCompiler::Error
244 
245 Aborts the current file load
246 ============
247 */
248 void idCompiler::Error( const char *message, ... ) const {
249  va_list argptr;
250  char string[ 1024 ];
251 
252  va_start( argptr, message );
253  vsprintf( string, message, argptr );
254  va_end( argptr );
255 
256  throw idCompileError( string );
257 }
258 
259 /*
260 ============
261 idCompiler::Warning
262 
263 Prints a warning about the current line
264 ============
265 */
266 void idCompiler::Warning( const char *message, ... ) const {
267  va_list argptr;
268  char string[ 1024 ];
269 
270  va_start( argptr, message );
271  vsprintf( string, message, argptr );
272  va_end( argptr );
273 
274  parserPtr->Warning( "%s", string );
275 }
276 
277 /*
278 ============
279 idCompiler::VirtualFunctionConstant
280 
281 Creates a def for an index into a virtual function table
282 ============
283 */
284 ID_INLINE idVarDef *idCompiler::VirtualFunctionConstant( idVarDef *func ) {
285  eval_t eval;
286 
287  memset( &eval, 0, sizeof( eval ) );
288  eval._int = func->scope->TypeDef()->GetFunctionNumber( func->value.functionPtr );
289  if ( eval._int < 0 ) {
290  Error( "Function '%s' not found in scope '%s'", func->Name(), func->scope->Name() );
291  }
292 
293  return GetImmediate( &type_virtualfunction, &eval, "" );
294 }
295 
296 /*
297 ============
298 idCompiler::SizeConstant
299 
300 Creates a def for a size constant
301 ============
302 */
303 ID_INLINE idVarDef *idCompiler::SizeConstant( int size ) {
304  eval_t eval;
305 
306  memset( &eval, 0, sizeof( eval ) );
307  eval._int = size;
308  return GetImmediate( &type_argsize, &eval, "" );
309 }
310 
311 /*
312 ============
313 idCompiler::JumpConstant
314 
315 Creates a def for a jump constant
316 ============
317 */
318 ID_INLINE idVarDef *idCompiler::JumpConstant( int value ) {
319  eval_t eval;
320 
321  memset( &eval, 0, sizeof( eval ) );
322  eval._int = value;
323  return GetImmediate( &type_jumpoffset, &eval, "" );
324 }
325 
326 /*
327 ============
328 idCompiler::JumpDef
329 
330 Creates a def for a relative jump from one code location to another
331 ============
332 */
333 ID_INLINE idVarDef *idCompiler::JumpDef( int jumpfrom, int jumpto ) {
334  return JumpConstant( jumpto - jumpfrom );
335 }
336 
337 /*
338 ============
339 idCompiler::JumpTo
340 
341 Creates a def for a relative jump from current code location
342 ============
343 */
344 ID_INLINE idVarDef *idCompiler::JumpTo( int jumpto ) {
345  return JumpDef( gameLocal.program.NumStatements(), jumpto );
346 }
347 
348 /*
349 ============
350 idCompiler::JumpFrom
351 
352 Creates a def for a relative jump from code location to current code location
353 ============
354 */
355 ID_INLINE idVarDef *idCompiler::JumpFrom( int jumpfrom ) {
356  return JumpDef( jumpfrom, gameLocal.program.NumStatements() );
357 }
358 
359 /*
360 ============
361 idCompiler::Divide
362 ============
363 */
364 ID_INLINE float idCompiler::Divide( float numerator, float denominator ) {
365  if ( denominator == 0 ) {
366  Error( "Divide by zero" );
367  return 0;
368  }
369 
370  return numerator / denominator;
371 }
372 
373 /*
374 ============
375 idCompiler::FindImmediate
376 
377 tries to find an existing immediate with the same value
378 ============
379 */
380 idVarDef *idCompiler::FindImmediate( const idTypeDef *type, const eval_t *eval, const char *string ) const {
381  idVarDef *def;
382  etype_t etype;
383 
384  etype = type->Type();
385 
386  // check for a constant with the same value
387  for( def = gameLocal.program.GetDefList( "<IMMEDIATE>" ); def != NULL; def = def->Next() ) {
388  if ( def->TypeDef() != type ) {
389  continue;
390  }
391 
392  switch( etype ) {
393  case ev_field :
394  if ( *def->value.intPtr == eval->_int ) {
395  return def;
396  }
397  break;
398 
399  case ev_argsize :
400  if ( def->value.argSize == eval->_int ) {
401  return def;
402  }
403  break;
404 
405  case ev_jumpoffset :
406  if ( def->value.jumpOffset == eval->_int ) {
407  return def;
408  }
409  break;
410 
411  case ev_entity :
412  if ( *def->value.intPtr == eval->entity ) {
413  return def;
414  }
415  break;
416 
417  case ev_string :
418  if ( idStr::Cmp( def->value.stringPtr, string ) == 0 ) {
419  return def;
420  }
421  break;
422 
423  case ev_float :
424  if ( *def->value.floatPtr == eval->_float ) {
425  return def;
426  }
427  break;
428 
429  case ev_virtualfunction :
430  if ( def->value.virtualFunction == eval->_int ) {
431  return def;
432  }
433  break;
434 
435 
436  case ev_vector :
437  if ( ( def->value.vectorPtr->x == eval->vector[ 0 ] ) &&
438  ( def->value.vectorPtr->y == eval->vector[ 1 ] ) &&
439  ( def->value.vectorPtr->z == eval->vector[ 2 ] ) ) {
440  return def;
441  }
442  break;
443 
444  default :
445  Error( "weird immediate type" );
446  break;
447  }
448  }
449 
450  return NULL;
451 }
452 
453 /*
454 ============
455 idCompiler::GetImmediate
456 
457 returns an existing immediate with the same value, or allocates a new one
458 ============
459 */
460 idVarDef *idCompiler::GetImmediate( idTypeDef *type, const eval_t *eval, const char *string ) {
461  idVarDef *def;
462 
463  def = FindImmediate( type, eval, string );
464  if ( def ) {
465  def->numUsers++;
466  } else {
467  // allocate a new def
468  def = gameLocal.program.AllocDef( type, "<IMMEDIATE>", &def_namespace, true );
469  if ( type->Type() == ev_string ) {
470  def->SetString( string, true );
471  } else {
472  def->SetValue( *eval, true );
473  }
474  }
475 
476  return def;
477 }
478 
479 /*
480 ============
481 idCompiler::OptimizeOpcode
482 
483 try to optimize when the operator works on constants only
484 ============
485 */
486 idVarDef *idCompiler::OptimizeOpcode( const opcode_t *op, idVarDef *var_a, idVarDef *var_b ) {
487  eval_t c;
488  idTypeDef *type;
489 
490  if ( var_a && var_a->initialized != idVarDef::initializedConstant ) {
491  return NULL;
492  }
493  if ( var_b && var_b->initialized != idVarDef::initializedConstant ) {
494  return NULL;
495  }
496 
497  idVec3 &vec_c = *reinterpret_cast<idVec3 *>( &c.vector[ 0 ] );
498 
499  memset( &c, 0, sizeof( c ) );
500  switch( op - opcodes ) {
501  case OP_ADD_F: c._float = *var_a->value.floatPtr + *var_b->value.floatPtr; type = &type_float; break;
502  case OP_ADD_V: vec_c = *var_a->value.vectorPtr + *var_b->value.vectorPtr; type = &type_vector; break;
503  case OP_SUB_F: c._float = *var_a->value.floatPtr - *var_b->value.floatPtr; type = &type_float; break;
504  case OP_SUB_V: vec_c = *var_a->value.vectorPtr - *var_b->value.vectorPtr; type = &type_vector; break;
505  case OP_MUL_F: c._float = *var_a->value.floatPtr * *var_b->value.floatPtr; type = &type_float; break;
506  case OP_MUL_V: c._float = *var_a->value.vectorPtr * *var_b->value.vectorPtr; type = &type_float; break;
507  case OP_MUL_FV: vec_c = *var_b->value.vectorPtr * *var_a->value.floatPtr; type = &type_vector; break;
508  case OP_MUL_VF: vec_c = *var_a->value.vectorPtr * *var_b->value.floatPtr; type = &type_vector; break;
509  case OP_DIV_F: c._float = Divide( *var_a->value.floatPtr, *var_b->value.floatPtr ); type = &type_float; break;
510  case OP_MOD_F: c._float = (int)*var_a->value.floatPtr % (int)*var_b->value.floatPtr; type = &type_float; break;
511  case OP_BITAND: c._float = ( int )*var_a->value.floatPtr & ( int )*var_b->value.floatPtr; type = &type_float; break;
512  case OP_BITOR: c._float = ( int )*var_a->value.floatPtr | ( int )*var_b->value.floatPtr; type = &type_float; break;
513  case OP_GE: c._float = *var_a->value.floatPtr >= *var_b->value.floatPtr; type = &type_float; break;
514  case OP_LE: c._float = *var_a->value.floatPtr <= *var_b->value.floatPtr; type = &type_float; break;
515  case OP_GT: c._float = *var_a->value.floatPtr > *var_b->value.floatPtr; type = &type_float; break;
516  case OP_LT: c._float = *var_a->value.floatPtr < *var_b->value.floatPtr; type = &type_float; break;
517  case OP_AND: c._float = *var_a->value.floatPtr && *var_b->value.floatPtr; type = &type_float; break;
518  case OP_OR: c._float = *var_a->value.floatPtr || *var_b->value.floatPtr; type = &type_float; break;
519  case OP_NOT_BOOL: c._int = !*var_a->value.intPtr; type = &type_boolean; break;
520  case OP_NOT_F: c._float = !*var_a->value.floatPtr; type = &type_float; break;
521  case OP_NOT_V: c._float = !var_a->value.vectorPtr->x && !var_a->value.vectorPtr->y && !var_a->value.vectorPtr->z; type = &type_float; break;
522  case OP_NEG_F: c._float = -*var_a->value.floatPtr; type = &type_float; break;
523  case OP_NEG_V: vec_c = -*var_a->value.vectorPtr; type = &type_vector; break;
524  case OP_INT_F: c._float = ( int )*var_a->value.floatPtr; type = &type_float; break;
525  case OP_EQ_F: c._float = ( *var_a->value.floatPtr == *var_b->value.floatPtr ); type = &type_float; break;
526  case OP_EQ_V: c._float = var_a->value.vectorPtr->Compare( *var_b->value.vectorPtr ); type = &type_float; break;
527  case OP_EQ_E: c._float = ( *var_a->value.intPtr == *var_b->value.intPtr ); type = &type_float; break;
528  case OP_NE_F: c._float = ( *var_a->value.floatPtr != *var_b->value.floatPtr ); type = &type_float; break;
529  case OP_NE_V: c._float = !var_a->value.vectorPtr->Compare( *var_b->value.vectorPtr ); type = &type_float; break;
530  case OP_NE_E: c._float = ( *var_a->value.intPtr != *var_b->value.intPtr ); type = &type_float; break;
531  case OP_UADD_F: c._float = *var_b->value.floatPtr + *var_a->value.floatPtr; type = &type_float; break;
532  case OP_USUB_F: c._float = *var_b->value.floatPtr - *var_a->value.floatPtr; type = &type_float; break;
533  case OP_UMUL_F: c._float = *var_b->value.floatPtr * *var_a->value.floatPtr; type = &type_float; break;
534  case OP_UDIV_F: c._float = Divide( *var_b->value.floatPtr, *var_a->value.floatPtr ); type = &type_float; break;
535  case OP_UMOD_F: c._float = ( int ) *var_b->value.floatPtr % ( int )*var_a->value.floatPtr; type = &type_float; break;
536  case OP_UOR_F: c._float = ( int )*var_b->value.floatPtr | ( int )*var_a->value.floatPtr; type = &type_float; break;
537  case OP_UAND_F: c._float = ( int )*var_b->value.floatPtr & ( int )*var_a->value.floatPtr; type = &type_float; break;
538  case OP_UINC_F: c._float = *var_a->value.floatPtr + 1; type = &type_float; break;
539  case OP_UDEC_F: c._float = *var_a->value.floatPtr - 1; type = &type_float; break;
540  case OP_COMP_F: c._float = ( float )~( int )*var_a->value.floatPtr; type = &type_float; break;
541  default: type = NULL; break;
542  }
543 
544  if ( !type ) {
545  return NULL;
546  }
547 
548  if ( var_a ) {
549  var_a->numUsers--;
550  if ( var_a->numUsers <= 0 ) {
551  gameLocal.program.FreeDef( var_a, NULL );
552  }
553  }
554  if ( var_b ) {
555  var_b->numUsers--;
556  if ( var_b->numUsers <= 0 ) {
557  gameLocal.program.FreeDef( var_b, NULL );
558  }
559  }
560 
561  return GetImmediate( type, &c, "" );
562 }
563 
564 /*
565 ============
566 idCompiler::EmitOpcode
567 
568 Emits a primitive statement, returning the var it places it's value in
569 ============
570 */
571 idVarDef *idCompiler::EmitOpcode( const opcode_t *op, idVarDef *var_a, idVarDef *var_b ) {
572  statement_t *statement;
573  idVarDef *var_c;
574 
575  var_c = OptimizeOpcode( op, var_a, var_b );
576  if ( var_c ) {
577  return var_c;
578  }
579 
580  if ( var_a && !strcmp( var_a->Name(), RESULT_STRING ) ) {
581  var_a->numUsers++;
582  }
583  if ( var_b && !strcmp( var_b->Name(), RESULT_STRING ) ) {
584  var_b->numUsers++;
585  }
586 
587  statement = gameLocal.program.AllocStatement();
588  statement->linenumber = currentLineNumber;
589  statement->file = currentFileNumber;
590 
591  if ( ( op->type_c == &def_void ) || op->rightAssociative ) {
592  // ifs, gotos, and assignments don't need vars allocated
593  var_c = NULL;
594  } else {
595  // allocate result space
596  // try to reuse result defs as much as possible
597  var_c = gameLocal.program.FindFreeResultDef( op->type_c->TypeDef(), RESULT_STRING, scope, var_a, var_b );
598  // set user count back to 1, a result def needs to be used twice before it can be reused
599  var_c->numUsers = 1;
600  }
601 
602  statement->op = op - opcodes;
603  statement->a = var_a;
604  statement->b = var_b;
605  statement->c = var_c;
606 
607  if ( op->rightAssociative ) {
608  return var_a;
609  }
610 
611  return var_c;
612 }
613 
614 /*
615 ============
616 idCompiler::EmitOpcode
617 
618 Emits a primitive statement, returning the var it places it's value in
619 ============
620 */
621 ID_INLINE idVarDef *idCompiler::EmitOpcode( int op, idVarDef *var_a, idVarDef *var_b ) {
622  return EmitOpcode( &opcodes[ op ], var_a, var_b );
623 }
624 
625 /*
626 ============
627 idCompiler::EmitPush
628 
629 Emits an opcode to push the variable onto the stack.
630 ============
631 */
632 bool idCompiler::EmitPush( idVarDef *expression, const idTypeDef *funcArg ) {
633  opcode_t *op;
634  opcode_t *out;
635 
636  out = NULL;
637  for( op = &opcodes[ OP_PUSH_F ]; op->name && !strcmp( op->name, "<PUSH>" ); op++ ) {
638  if ( ( funcArg->Type() == op->type_a->Type() ) && ( expression->Type() == op->type_b->Type() ) ) {
639  out = op;
640  break;
641  }
642  }
643 
644  if ( !out ) {
645  if ( ( expression->TypeDef() != funcArg ) && !expression->TypeDef()->Inherits( funcArg ) ) {
646  return false;
647  }
648 
649  out = &opcodes[ OP_PUSH_ENT ];
650  }
651 
652  EmitOpcode( out, expression, 0 );
653 
654  return true;
655 }
656 
657 /*
658 ==============
659 idCompiler::NextToken
660 
661 Sets token, immediateType, and possibly immediate
662 ==============
663 */
664 void idCompiler::NextToken( void ) {
665  int i;
666 
667  // reset our type
668  immediateType = NULL;
669  memset( &immediate, 0, sizeof( immediate ) );
670 
671  // Save the token's line number and filename since when we emit opcodes the current
672  // token is always the next one to be read
673  currentLineNumber = token.line;
674  currentFileNumber = gameLocal.program.GetFilenum( parserPtr->GetFileName() );
675 
676  if ( !parserPtr->ReadToken( &token ) ) {
677  eof = true;
678  return;
679  }
680 
681  if ( currentFileNumber != gameLocal.program.GetFilenum( parserPtr->GetFileName() ) ) {
682  if ( ( braceDepth > 0 ) && ( token != "}" ) ) {
683  // missing a closing brace. try to give as much info as possible.
684  if ( scope->Type() == ev_function ) {
685  Error( "Unexpected end of file inside function '%s'. Missing closing braces.", scope->Name() );
686  } else if ( scope->Type() == ev_object ) {
687  Error( "Unexpected end of file inside object '%s'. Missing closing braces.", scope->Name() );
688  } else if ( scope->Type() == ev_namespace ) {
689  Error( "Unexpected end of file inside namespace '%s'. Missing closing braces.", scope->Name() );
690  } else {
691  Error( "Unexpected end of file inside braced section" );
692  }
693  }
694  }
695 
696  switch( token.type ) {
697  case TT_STRING:
698  // handle quoted strings as a unit
699  immediateType = &type_string;
700  return;
701 
702  case TT_LITERAL: {
703  // handle quoted vectors as a unit
704  immediateType = &type_vector;
705  idLexer lex( token, token.Length(), parserPtr->GetFileName(), LEXFL_NOERRORS );
706  idToken token2;
707  for( i = 0; i < 3; i++ ) {
708  if ( !lex.ReadToken( &token2 ) ) {
709  Error( "Couldn't read vector. '%s' is not in the form of 'x y z'", token.c_str() );
710  }
711  if ( token2.type == TT_PUNCTUATION && token2 == "-" ) {
712  if ( !lex.CheckTokenType( TT_NUMBER, 0, &token2 ) ) {
713  Error( "expected a number following '-' but found '%s' in vector '%s'", token2.c_str(), token.c_str() );
714  }
715  immediate.vector[ i ] = -token2.GetFloatValue();
716  } else if ( token2.type == TT_NUMBER ) {
717  immediate.vector[ i ] = token2.GetFloatValue();
718  } else {
719  Error( "vector '%s' is not in the form of 'x y z'. expected float value, found '%s'", token.c_str(), token2.c_str() );
720  }
721  }
722  return;
723  }
724 
725  case TT_NUMBER:
726  immediateType = &type_float;
727  immediate._float = token.GetFloatValue();
728  return;
729 
730  case TT_PUNCTUATION:
731  // entity names
732  if ( token == "$" ) {
733  immediateType = &type_entity;
734  parserPtr->ReadToken( &token );
735  return;
736  }
737 
738  if ( token == "{" ) {
739  braceDepth++;
740  return;
741  }
742 
743  if ( token == "}" ) {
744  braceDepth--;
745  return;
746  }
747 
748  if ( punctuationValid[ token.subtype ] ) {
749  return;
750  }
751 
752  Error( "Unknown punctuation '%s'", token.c_str() );
753  break;
754 
755  case TT_NAME:
756  return;
757 
758  default:
759  Error( "Unknown token '%s'", token.c_str() );
760  }
761 }
762 
763 /*
764 =============
765 idCompiler::ExpectToken
766 
767 Issues an Error if the current token isn't equal to string
768 Gets the next token
769 =============
770 */
771 void idCompiler::ExpectToken( const char *string ) {
772  if ( token != string ) {
773  Error( "expected '%s', found '%s'", string, token.c_str() );
774  }
775 
776  NextToken();
777 }
778 
779 /*
780 =============
781 idCompiler::CheckToken
782 
783 Returns true and gets the next token if the current token equals string
784 Returns false and does nothing otherwise
785 =============
786 */
787 bool idCompiler::CheckToken( const char *string ) {
788  if ( token != string ) {
789  return false;
790  }
791 
792  NextToken();
793 
794  return true;
795 }
796 
797 /*
798 ============
799 idCompiler::ParseName
800 
801 Checks to see if the current token is a valid name
802 ============
803 */
804 void idCompiler::ParseName( idStr &name ) {
805  if ( token.type != TT_NAME ) {
806  Error( "'%s' is not a name", token.c_str() );
807  }
808 
809  name = token;
810  NextToken();
811 }
812 
813 /*
814 ============
815 idCompiler::SkipOutOfFunction
816 
817 For error recovery, pops out of nested braces
818 ============
819 */
820 void idCompiler::SkipOutOfFunction( void ) {
821  while( braceDepth ) {
822  parserPtr->SkipBracedSection( false );
823  braceDepth--;
824  }
825  NextToken();
826 }
827 
828 /*
829 ============
830 idCompiler::SkipToSemicolon
831 
832 For error recovery
833 ============
834 */
835 void idCompiler::SkipToSemicolon( void ) {
836  do {
837  if ( CheckToken( ";" ) ) {
838  return;
839  }
840 
841  NextToken();
842  } while( !eof );
843 }
844 
845 /*
846 ============
847 idCompiler::CheckType
848 
849 Parses a variable type, including functions types
850 ============
851 */
852 idTypeDef *idCompiler::CheckType( void ) {
853  idTypeDef *type;
854 
855  if ( token == "float" ) {
856  type = &type_float;
857  } else if ( token == "vector" ) {
858  type = &type_vector;
859  } else if ( token == "entity" ) {
860  type = &type_entity;
861  } else if ( token == "string" ) {
862  type = &type_string;
863  } else if ( token == "void" ) {
864  type = &type_void;
865  } else if ( token == "object" ) {
866  type = &type_object;
867  } else if ( token == "boolean" ) {
868  type = &type_boolean;
869  } else if ( token == "namespace" ) {
870  type = &type_namespace;
871  } else if ( token == "scriptEvent" ) {
872  type = &type_scriptevent;
873  } else {
874  type = gameLocal.program.FindType( token.c_str() );
875  if ( type && !type->Inherits( &type_object ) ) {
876  type = NULL;
877  }
878  }
879 
880  return type;
881 }
882 
883 /*
884 ============
885 idCompiler::ParseType
886 
887 Parses a variable type, including functions types
888 ============
889 */
890 idTypeDef *idCompiler::ParseType( void ) {
891  idTypeDef *type;
892 
893  type = CheckType();
894  if ( !type ) {
895  Error( "\"%s\" is not a type", token.c_str() );
896  }
897 
898  if ( ( type == &type_scriptevent ) && ( scope != &def_namespace ) ) {
899  Error( "scriptEvents can only defined in the global namespace" );
900  }
901 
902  if ( ( type == &type_namespace ) && ( scope->Type() != ev_namespace ) ) {
903  Error( "A namespace may only be defined globally, or within another namespace" );
904  }
905 
906  NextToken();
907 
908  return type;
909 }
910 
911 /*
912 ============
913 idCompiler::ParseImmediate
914 
915 Looks for a preexisting constant
916 ============
917 */
918 idVarDef *idCompiler::ParseImmediate( void ) {
919  idVarDef *def;
920 
921  def = GetImmediate( immediateType, &immediate, token.c_str() );
922  NextToken();
923 
924  return def;
925 }
926 
927 /*
928 ============
929 idCompiler::EmitFunctionParms
930 ============
931 */
932 idVarDef *idCompiler::EmitFunctionParms( int op, idVarDef *func, int startarg, int startsize, idVarDef *object ) {
933  idVarDef *e;
934  const idTypeDef *type;
935  const idTypeDef *funcArg;
936  idVarDef *returnDef;
937  idTypeDef *returnType;
938  int arg;
939  int size;
940  int resultOp;
941 
942  type = func->TypeDef();
943  if ( func->Type() != ev_function ) {
944  Error( "'%s' is not a function", func->Name() );
945  }
946 
947  // copy the parameters to the global parameter variables
948  arg = startarg;
949  size = startsize;
950  if ( !CheckToken( ")" ) ) {
951  do {
952  if ( arg >= type->NumParameters() ) {
953  Error( "too many parameters" );
954  }
955 
956  e = GetExpression( TOP_PRIORITY );
957 
958  funcArg = type->GetParmType( arg );
959  if ( !EmitPush( e, funcArg ) ) {
960  Error( "type mismatch on parm %i of call to '%s'", arg + 1, func->Name() );
961  }
962 
963  if ( funcArg->Type() == ev_object ) {
964  size += type_object.Size();
965  } else {
966  size += funcArg->Size();
967  }
968 
969  arg++;
970  } while( CheckToken( "," ) );
971 
972  ExpectToken( ")" );
973  }
974 
975  if ( arg < type->NumParameters() ) {
976  Error( "too few parameters for function '%s'", func->Name() );
977  }
978 
979  if ( op == OP_CALL ) {
980  EmitOpcode( op, func, 0 );
981  } else if ( ( op == OP_OBJECTCALL ) || ( op == OP_OBJTHREAD ) ) {
982  EmitOpcode( op, object, VirtualFunctionConstant( func ) );
983 
984  // need arg size seperate since script object may be NULL
985  statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
986  statement.c = SizeConstant( func->value.functionPtr->parmTotal );
987  } else {
988  EmitOpcode( op, func, SizeConstant( size ) );
989  }
990 
991  // we need to copy off the result into a temporary result location, so figure out the opcode
992  returnType = type->ReturnType();
993  if ( returnType->Type() == ev_string ) {
994  resultOp = OP_STORE_S;
995  returnDef = gameLocal.program.returnStringDef;
996  } else {
997  gameLocal.program.returnDef->SetTypeDef( returnType );
998  returnDef = gameLocal.program.returnDef;
999 
1000  switch( returnType->Type() ) {
1001  case ev_void :
1002  resultOp = OP_STORE_F;
1003  break;
1004 
1005  case ev_boolean :
1006  resultOp = OP_STORE_BOOL;
1007  break;
1008 
1009  case ev_float :
1010  resultOp = OP_STORE_F;
1011  break;
1012 
1013  case ev_vector :
1014  resultOp = OP_STORE_V;
1015  break;
1016 
1017  case ev_entity :
1018  resultOp = OP_STORE_ENT;
1019  break;
1020 
1021  case ev_object :
1022  resultOp = OP_STORE_OBJ;
1023  break;
1024 
1025  default :
1026  Error( "Invalid return type for function '%s'", func->Name() );
1027  // shut up compiler
1028  resultOp = OP_STORE_OBJ;
1029  break;
1030  }
1031  }
1032 
1033  if ( returnType->Type() == ev_void ) {
1034  // don't need result space since there's no result, so just return the normal result def.
1035  return returnDef;
1036  }
1037 
1038  // allocate result space
1039  // try to reuse result defs as much as possible
1040  statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
1041  idVarDef *resultDef = gameLocal.program.FindFreeResultDef( returnType, RESULT_STRING, scope, statement.a, statement.b );
1042  // set user count back to 0, a result def needs to be used twice before it can be reused
1043  resultDef->numUsers = 0;
1044 
1045  EmitOpcode( resultOp, returnDef, resultDef );
1046 
1047  return resultDef;
1048 }
1049 
1050 /*
1051 ============
1052 idCompiler::ParseFunctionCall
1053 ============
1054 */
1055 idVarDef *idCompiler::ParseFunctionCall( idVarDef *funcDef ) {
1056  assert( funcDef );
1057 
1058  if ( funcDef->Type() != ev_function ) {
1059  Error( "'%s' is not a function", funcDef->Name() );
1060  }
1061 
1062  if ( funcDef->initialized == idVarDef::uninitialized ) {
1063  Error( "Function '%s' has not been defined yet", funcDef->GlobalName() );
1064  }
1065 
1066  assert( funcDef->value.functionPtr );
1067  if ( callthread ) {
1068  if ( ( funcDef->initialized != idVarDef::uninitialized ) && funcDef->value.functionPtr->eventdef ) {
1069  Error( "Built-in functions cannot be called as threads" );
1070  }
1071  callthread = false;
1072  return EmitFunctionParms( OP_THREAD, funcDef, 0, 0, NULL );
1073  } else {
1074  if ( ( funcDef->initialized != idVarDef::uninitialized ) && funcDef->value.functionPtr->eventdef ) {
1075  if ( ( scope->Type() != ev_namespace ) && ( scope->scope->Type() == ev_object ) ) {
1076  // get the local object pointer
1077  idVarDef *thisdef = gameLocal.program.GetDef( scope->scope->TypeDef(), "self", scope );
1078  if ( !thisdef ) {
1079  Error( "No 'self' within scope" );
1080  }
1081 
1082  return ParseEventCall( thisdef, funcDef );
1083  } else {
1084  Error( "Built-in functions cannot be called without an object" );
1085  }
1086  }
1087 
1088  return EmitFunctionParms( OP_CALL, funcDef, 0, 0, NULL );
1089  }
1090 }
1091 
1092 /*
1093 ============
1094 idCompiler::ParseObjectCall
1095 ============
1096 */
1097 idVarDef *idCompiler::ParseObjectCall( idVarDef *object, idVarDef *func ) {
1098  EmitPush( object, object->TypeDef() );
1099  if ( callthread ) {
1100  callthread = false;
1101  return EmitFunctionParms( OP_OBJTHREAD, func, 1, type_object.Size(), object );
1102  } else {
1103  return EmitFunctionParms( OP_OBJECTCALL, func, 1, 0, object );
1104  }
1105 }
1106 
1107 /*
1108 ============
1109 idCompiler::ParseEventCall
1110 ============
1111 */
1112 idVarDef *idCompiler::ParseEventCall( idVarDef *object, idVarDef *funcDef ) {
1113  if ( callthread ) {
1114  Error( "Cannot call built-in functions as a thread" );
1115  }
1116 
1117  if ( funcDef->Type() != ev_function ) {
1118  Error( "'%s' is not a function", funcDef->Name() );
1119  }
1120 
1121  if ( !funcDef->value.functionPtr->eventdef ) {
1122  Error( "\"%s\" cannot be called with object notation", funcDef->Name() );
1123  }
1124 
1125  if ( object->Type() == ev_object ) {
1126  EmitPush( object, &type_entity );
1127  } else {
1128  EmitPush( object, object->TypeDef() );
1129  }
1130 
1131  return EmitFunctionParms( OP_EVENTCALL, funcDef, 0, type_object.Size(), NULL );
1132 }
1133 
1134 /*
1135 ============
1136 idCompiler::ParseSysObjectCall
1137 ============
1138 */
1139 idVarDef *idCompiler::ParseSysObjectCall( idVarDef *funcDef ) {
1140  if ( callthread ) {
1141  Error( "Cannot call built-in functions as a thread" );
1142  }
1143 
1144  if ( funcDef->Type() != ev_function ) {
1145  Error( "'%s' is not a function", funcDef->Name() );
1146  }
1147 
1148  if ( !funcDef->value.functionPtr->eventdef ) {
1149  Error( "\"%s\" cannot be called with object notation", funcDef->Name() );
1150  }
1151 
1152  if ( !idThread::Type.RespondsTo( *funcDef->value.functionPtr->eventdef ) ) {
1153  Error( "\"%s\" is not callable as a 'sys' function", funcDef->Name() );
1154  }
1155 
1156  return EmitFunctionParms( OP_SYSCALL, funcDef, 0, 0, NULL );
1157 }
1158 
1159 /*
1160 ============
1161 idCompiler::LookupDef
1162 ============
1163 */
1164 idVarDef *idCompiler::LookupDef( const char *name, const idVarDef *baseobj ) {
1165  idVarDef *def;
1166  idVarDef *field;
1167  etype_t type_b;
1168  etype_t type_c;
1169  opcode_t *op;
1170 
1171  // check if we're accessing a field
1172  if ( baseobj && ( baseobj->Type() == ev_object ) ) {
1173  const idVarDef *tdef;
1174 
1175  def = NULL;
1176  for( tdef = baseobj; tdef != &def_object; tdef = tdef->TypeDef()->SuperClass()->def ) {
1177  def = gameLocal.program.GetDef( NULL, name, tdef );
1178  if ( def ) {
1179  break;
1180  }
1181  }
1182  } else {
1183  // first look through the defs in our scope
1184  def = gameLocal.program.GetDef( NULL, name, scope );
1185  if ( !def ) {
1186  // if we're in a member function, check types local to the object
1187  if ( ( scope->Type() != ev_namespace ) && ( scope->scope->Type() == ev_object ) ) {
1188  // get the local object pointer
1189  idVarDef *thisdef = gameLocal.program.GetDef( scope->scope->TypeDef(), "self", scope );
1190 
1191  field = LookupDef( name, scope->scope->TypeDef()->def );
1192  if ( !field ) {
1193  Error( "Unknown value \"%s\"", name );
1194  }
1195 
1196  // type check
1197  type_b = field->Type();
1198  if ( field->Type() == ev_function ) {
1199  type_c = field->TypeDef()->ReturnType()->Type();
1200  } else {
1201  type_c = field->TypeDef()->FieldType()->Type(); // field access gets type from field
1202  if ( CheckToken( "++" ) ) {
1203  if ( type_c != ev_float ) {
1204  Error( "Invalid type for ++" );
1205  }
1206  def = EmitOpcode( OP_UINCP_F, thisdef, field );
1207  return def;
1208  } else if ( CheckToken( "--" ) ) {
1209  if ( type_c != ev_float ) {
1210  Error( "Invalid type for --" );
1211  }
1212  def = EmitOpcode( OP_UDECP_F, thisdef, field );
1213  return def;
1214  }
1215  }
1216 
1217  op = &opcodes[ OP_INDIRECT_F ];
1218  while( ( op->type_a->Type() != ev_object )
1219  || ( type_b != op->type_b->Type() ) || ( type_c != op->type_c->Type() ) ) {
1220  if ( ( op->priority == FUNCTION_PRIORITY ) && ( op->type_a->Type() == ev_object ) && ( op->type_c->Type() == ev_void ) &&
1221  ( type_c != op->type_c->Type() ) ) {
1222  // catches object calls that return a value
1223  break;
1224  }
1225  op++;
1226  if ( !op->name || strcmp( op->name, "." ) ) {
1227  Error( "no valid opcode to access type '%s'", field->TypeDef()->SuperClass()->Name() );
1228  }
1229  }
1230 
1231  if ( ( op - opcodes ) == OP_OBJECTCALL ) {
1232  ExpectToken( "(" );
1233  def = ParseObjectCall( thisdef, field );
1234  } else {
1235  // emit the conversion opcode
1236  def = EmitOpcode( op, thisdef, field );
1237 
1238  // field access gets type from field
1239  def->SetTypeDef( field->TypeDef()->FieldType() );
1240  }
1241  }
1242  }
1243  }
1244 
1245  return def;
1246 }
1247 
1248 /*
1249 ============
1250 idCompiler::ParseValue
1251 
1252 Returns the def for the current token
1253 ============
1254 */
1255 idVarDef *idCompiler::ParseValue( void ) {
1256  idVarDef *def;
1257  idVarDef *namespaceDef;
1258  idStr name;
1259 
1260  if ( immediateType == &type_entity ) {
1261  // if an immediate entity ($-prefaced name) then create or lookup a def for it.
1262  // when entities are spawned, they'll lookup the def and point it to them.
1263  def = gameLocal.program.GetDef( &type_entity, "$" + token, &def_namespace );
1264  if ( !def ) {
1265  def = gameLocal.program.AllocDef( &type_entity, "$" + token, &def_namespace, true );
1266  }
1267  NextToken();
1268  return def;
1269  } else if ( immediateType ) {
1270  // if the token is an immediate, allocate a constant for it
1271  return ParseImmediate();
1272  }
1273 
1274  ParseName( name );
1275  def = LookupDef( name, basetype );
1276  if ( !def ) {
1277  if ( basetype ) {
1278  Error( "%s is not a member of %s", name.c_str(), basetype->TypeDef()->Name() );
1279  } else {
1280  Error( "Unknown value \"%s\"", name.c_str() );
1281  }
1282  // if namespace, then look up the variable in that namespace
1283  } else if ( def->Type() == ev_namespace ) {
1284  while( def->Type() == ev_namespace ) {
1285  ExpectToken( "::" );
1286  ParseName( name );
1287  namespaceDef = def;
1288  def = gameLocal.program.GetDef( NULL, name, namespaceDef );
1289  if ( !def ) {
1290  Error( "Unknown value \"%s::%s\"", namespaceDef->GlobalName(), name.c_str() );
1291  }
1292  }
1293  //def = LookupDef( name, basetype );
1294  }
1295 
1296  return def;
1297 }
1298 
1299 /*
1300 ============
1301 idCompiler::GetTerm
1302 ============
1303 */
1304 idVarDef *idCompiler::GetTerm( void ) {
1305  idVarDef *e;
1306  int op;
1307 
1308  if ( !immediateType && CheckToken( "~" ) ) {
1309  e = GetExpression( TILDE_PRIORITY );
1310  switch( e->Type() ) {
1311  case ev_float :
1312  op = OP_COMP_F;
1313  break;
1314 
1315  default :
1316  Error( "type mismatch for ~" );
1317 
1318  // shut up compiler
1319  op = OP_COMP_F;
1320  break;
1321  }
1322 
1323  return EmitOpcode( op, e, 0 );
1324  }
1325 
1326  if ( !immediateType && CheckToken( "!" ) ) {
1327  e = GetExpression( NOT_PRIORITY );
1328  switch( e->Type() ) {
1329  case ev_boolean :
1330  op = OP_NOT_BOOL;
1331  break;
1332 
1333  case ev_float :
1334  op = OP_NOT_F;
1335  break;
1336 
1337  case ev_string :
1338  op = OP_NOT_S;
1339  break;
1340 
1341  case ev_vector :
1342  op = OP_NOT_V;
1343  break;
1344 
1345  case ev_entity :
1346  op = OP_NOT_ENT;
1347  break;
1348 
1349  case ev_function :
1350  Error( "Invalid type for !" );
1351 
1352  // shut up compiler
1353  op = OP_NOT_F;
1354  break;
1355 
1356  case ev_object :
1357  op = OP_NOT_ENT;
1358  break;
1359 
1360  default :
1361  Error( "type mismatch for !" );
1362 
1363  // shut up compiler
1364  op = OP_NOT_F;
1365  break;
1366  }
1367 
1368  return EmitOpcode( op, e, 0 );
1369  }
1370 
1371  // check for negation operator
1372  if ( !immediateType && CheckToken( "-" ) ) {
1373  // constants are directly negated without an instruction
1374  if ( immediateType == &type_float ) {
1375  immediate._float = -immediate._float;
1376  return ParseImmediate();
1377  } else if ( immediateType == &type_vector ) {
1378  immediate.vector[0] = -immediate.vector[0];
1379  immediate.vector[1] = -immediate.vector[1];
1380  immediate.vector[2] = -immediate.vector[2];
1381  return ParseImmediate();
1382  } else {
1383  e = GetExpression( NOT_PRIORITY );
1384  switch( e->Type() ) {
1385  case ev_float :
1386  op = OP_NEG_F;
1387  break;
1388 
1389  case ev_vector :
1390  op = OP_NEG_V;
1391  break;
1392  default :
1393  Error( "type mismatch for -" );
1394 
1395  // shut up compiler
1396  op = OP_NEG_F;
1397  break;
1398  }
1399  return EmitOpcode( &opcodes[ op ], e, 0 );
1400  }
1401  }
1402 
1403  if ( CheckToken( "int" ) ) {
1404  ExpectToken( "(" );
1405 
1406  e = GetExpression( INT_PRIORITY );
1407  if ( e->Type() != ev_float ) {
1408  Error( "type mismatch for int()" );
1409  }
1410 
1411  ExpectToken( ")" );
1412 
1413  return EmitOpcode( OP_INT_F, e, 0 );
1414  }
1415 
1416  if ( CheckToken( "thread" ) ) {
1417  callthread = true;
1418  e = GetExpression( FUNCTION_PRIORITY );
1419 
1420  if ( callthread ) {
1421  Error( "Invalid thread call" );
1422  }
1423 
1424  // threads return the thread number
1425  gameLocal.program.returnDef->SetTypeDef( &type_float );
1426  return gameLocal.program.returnDef;
1427  }
1428 
1429  if ( !immediateType && CheckToken( "(" ) ) {
1430  e = GetExpression( TOP_PRIORITY );
1431  ExpectToken( ")" );
1432 
1433  return e;
1434  }
1435 
1436  return ParseValue();
1437 }
1438 
1439 /*
1440 ==============
1441 idCompiler::TypeMatches
1442 ==============
1443 */
1444 bool idCompiler::TypeMatches( etype_t type1, etype_t type2 ) const {
1445  if ( type1 == type2 ) {
1446  return true;
1447  }
1448 
1449  //if ( ( type1 == ev_entity ) && ( type2 == ev_object ) ) {
1450  // return true;
1451  //}
1452 
1453  //if ( ( type2 == ev_entity ) && ( type1 == ev_object ) ) {
1454  // return true;
1455  //}
1456 
1457  return false;
1458 }
1459 
1460 /*
1461 ==============
1462 idCompiler::GetExpression
1463 ==============
1464 */
1465 idVarDef *idCompiler::GetExpression( int priority ) {
1466  opcode_t *op;
1467  opcode_t *oldop;
1468  idVarDef *e;
1469  idVarDef *e2;
1470  const idVarDef *oldtype;
1471  etype_t type_a;
1472  etype_t type_b;
1473  etype_t type_c;
1474 
1475  if ( priority == 0 ) {
1476  return GetTerm();
1477  }
1478 
1479  e = GetExpression( priority - 1 );
1480  if ( token == ";" ) {
1481  // save us from searching through the opcodes unneccesarily
1482  return e;
1483  }
1484 
1485  while( 1 ) {
1486  if ( ( priority == FUNCTION_PRIORITY ) && CheckToken( "(" ) ) {
1487  return ParseFunctionCall( e );
1488  }
1489 
1490  // has to be a punctuation
1491  if ( immediateType ) {
1492  break;
1493  }
1494 
1495  for( op = opcodes; op->name; op++ ) {
1496  if ( ( op->priority == priority ) && CheckToken( op->name ) ) {
1497  break;
1498  }
1499  }
1500 
1501  if ( !op->name ) {
1502  // next token isn't at this priority level
1503  break;
1504  }
1505 
1506  // unary operators act only on the left operand
1507  if ( op->type_b == &def_void ) {
1508  e = EmitOpcode( op, e, 0 );
1509  return e;
1510  }
1511 
1512  // preserve our base type
1513  oldtype = basetype;
1514 
1515  // field access needs scope from object
1516  if ( ( op->name[ 0 ] == '.' ) && e->TypeDef()->Inherits( &type_object ) ) {
1517  // save off what type this field is part of
1518  basetype = e->TypeDef()->def;
1519  }
1520 
1521  if ( op->rightAssociative ) {
1522  // if last statement is an indirect, change it to an address of
1523  if ( gameLocal.program.NumStatements() > 0 ) {
1524  statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
1525  if ( ( statement.op >= OP_INDIRECT_F ) && ( statement.op < OP_ADDRESS ) ) {
1526  statement.op = OP_ADDRESS;
1527  type_pointer.SetPointerType( e->TypeDef() );
1528  e->SetTypeDef( &type_pointer );
1529  }
1530  }
1531 
1532  e2 = GetExpression( priority );
1533  } else {
1534  e2 = GetExpression( priority - 1 );
1535  }
1536 
1537  // restore type
1538  basetype = oldtype;
1539 
1540  // type check
1541  type_a = e->Type();
1542  type_b = e2->Type();
1543 
1544  // field access gets type from field
1545  if ( op->name[ 0 ] == '.' ) {
1546  if ( ( e2->Type() == ev_function ) && e2->TypeDef()->ReturnType() ) {
1547  type_c = e2->TypeDef()->ReturnType()->Type();
1548  } else if ( e2->TypeDef()->FieldType() ) {
1549  type_c = e2->TypeDef()->FieldType()->Type();
1550  } else {
1551  // not a field
1552  type_c = ev_error;
1553  }
1554  } else {
1555  type_c = ev_void;
1556  }
1557 
1558  oldop = op;
1559  while( !TypeMatches( type_a, op->type_a->Type() ) || !TypeMatches( type_b, op->type_b->Type() ) ||
1560  ( ( type_c != ev_void ) && !TypeMatches( type_c, op->type_c->Type() ) ) ) {
1561  if ( ( op->priority == FUNCTION_PRIORITY ) && TypeMatches( type_a, op->type_a->Type() ) && TypeMatches( type_b, op->type_b->Type() ) ) {
1562  break;
1563  }
1564 
1565  op++;
1566  if ( !op->name || strcmp( op->name, oldop->name ) ) {
1567  Error( "type mismatch for '%s'", oldop->name );
1568  }
1569  }
1570 
1571  switch( op - opcodes ) {
1572  case OP_SYSCALL :
1573  ExpectToken( "(" );
1574  e = ParseSysObjectCall( e2 );
1575  break;
1576 
1577  case OP_OBJECTCALL :
1578  ExpectToken( "(" );
1579  if ( ( e2->initialized != idVarDef::uninitialized ) && e2->value.functionPtr->eventdef ) {
1580  e = ParseEventCall( e, e2 );
1581  } else {
1582  e = ParseObjectCall( e, e2 );
1583  }
1584  break;
1585 
1586  case OP_EVENTCALL :
1587  ExpectToken( "(" );
1588  if ( ( e2->initialized != idVarDef::uninitialized ) && e2->value.functionPtr->eventdef ) {
1589  e = ParseEventCall( e, e2 );
1590  } else {
1591  e = ParseObjectCall( e, e2 );
1592  }
1593  break;
1594 
1595  default:
1596  if ( callthread ) {
1597  Error( "Expecting function call after 'thread'" );
1598  }
1599 
1600  if ( ( type_a == ev_pointer ) && ( type_b != e->TypeDef()->PointerType()->Type() ) ) {
1601  // FIXME: need to make a general case for this
1602  if ( ( op - opcodes == OP_STOREP_F ) && ( e->TypeDef()->PointerType()->Type() == ev_boolean ) ) {
1603  // copy from float to boolean pointer
1604  op = &opcodes[ OP_STOREP_FTOBOOL ];
1605  } else if ( ( op - opcodes == OP_STOREP_BOOL ) && ( e->TypeDef()->PointerType()->Type() == ev_float ) ) {
1606  // copy from boolean to float pointer
1607  op = &opcodes[ OP_STOREP_BOOLTOF ];
1608  } else if ( ( op - opcodes == OP_STOREP_F ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
1609  // copy from float to string pointer
1610  op = &opcodes[ OP_STOREP_FTOS ];
1611  } else if ( ( op - opcodes == OP_STOREP_BOOL ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
1612  // copy from boolean to string pointer
1613  op = &opcodes[ OP_STOREP_BTOS ];
1614  } else if ( ( op - opcodes == OP_STOREP_V ) && ( e->TypeDef()->PointerType()->Type() == ev_string ) ) {
1615  // copy from vector to string pointer
1616  op = &opcodes[ OP_STOREP_VTOS ];
1617  } else if ( ( op - opcodes == OP_STOREP_ENT ) && ( e->TypeDef()->PointerType()->Type() == ev_object ) ) {
1618  // store an entity into an object pointer
1619  op = &opcodes[ OP_STOREP_OBJENT ];
1620  } else {
1621  Error( "type mismatch for '%s'", op->name );
1622  }
1623  }
1624 
1625  if ( op->rightAssociative ) {
1626  e = EmitOpcode( op, e2, e );
1627  } else {
1628  e = EmitOpcode( op, e, e2 );
1629  }
1630 
1631  if ( op - opcodes == OP_STOREP_OBJENT ) {
1632  // statement.b points to type_pointer, which is just a temporary that gets its type reassigned, so we store the real type in statement.c
1633  // so that we can do a type check during run time since we don't know what type the script object is at compile time because it
1634  // comes from an entity
1635  statement_t &statement = gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 );
1636  statement.c = type_pointer.PointerType()->def;
1637  }
1638 
1639  // field access gets type from field
1640  if ( type_c != ev_void ) {
1641  e->SetTypeDef( e2->TypeDef()->FieldType() );
1642  }
1643  break;
1644  }
1645  }
1646 
1647  return e;
1648 }
1649 
1650 /*
1651 ================
1652 idCompiler::PatchLoop
1653 ================
1654 */
1655 void idCompiler::PatchLoop( int start, int continuePos ) {
1656  int i;
1657  statement_t *pos;
1658 
1659  pos = &gameLocal.program.GetStatement( start );
1660  for( i = start; i < gameLocal.program.NumStatements(); i++, pos++ ) {
1661  if ( pos->op == OP_BREAK ) {
1662  pos->op = OP_GOTO;
1663  pos->a = JumpFrom( i );
1664  } else if ( pos->op == OP_CONTINUE ) {
1665  pos->op = OP_GOTO;
1666  pos->a = JumpDef( i, continuePos );
1667  }
1668  }
1669 }
1670 
1671 /*
1672 ================
1673 idCompiler::ParseReturnStatement
1674 ================
1675 */
1676 void idCompiler::ParseReturnStatement( void ) {
1677  idVarDef *e;
1678  etype_t type_a;
1679  etype_t type_b;
1680  opcode_t *op;
1681 
1682  if ( CheckToken( ";" ) ) {
1683  if ( scope->TypeDef()->ReturnType()->Type() != ev_void ) {
1684  Error( "expecting return value" );
1685  }
1686 
1687  EmitOpcode( OP_RETURN, 0, 0 );
1688  return;
1689  }
1690 
1691  e = GetExpression( TOP_PRIORITY );
1692  ExpectToken( ";" );
1693 
1694  type_a = e->Type();
1695  type_b = scope->TypeDef()->ReturnType()->Type();
1696 
1697  if ( TypeMatches( type_a, type_b ) ) {
1698  EmitOpcode( OP_RETURN, e, 0 );
1699  return;
1700  }
1701 
1702  for( op = opcodes; op->name; op++ ) {
1703  if ( !strcmp( op->name, "=" ) ) {
1704  break;
1705  }
1706  }
1707 
1708  assert( op->name );
1709 
1710  while( !TypeMatches( type_a, op->type_a->Type() ) || !TypeMatches( type_b, op->type_b->Type() ) ) {
1711  op++;
1712  if ( !op->name || strcmp( op->name, "=" ) ) {
1713  Error( "type mismatch for return value" );
1714  }
1715  }
1716 
1717  idTypeDef *returnType = scope->TypeDef()->ReturnType();
1718  if ( returnType->Type() == ev_string ) {
1719  EmitOpcode( op, e, gameLocal.program.returnStringDef );
1720  } else {
1721  gameLocal.program.returnDef->SetTypeDef( returnType );
1722  EmitOpcode( op, e, gameLocal.program.returnDef );
1723  }
1724  EmitOpcode( OP_RETURN, 0, 0 );
1725 }
1726 
1727 /*
1728 ================
1729 idCompiler::ParseWhileStatement
1730 ================
1731 */
1732 void idCompiler::ParseWhileStatement( void ) {
1733  idVarDef *e;
1734  int patch1;
1735  int patch2;
1736 
1737  loopDepth++;
1738 
1739  ExpectToken( "(" );
1740 
1741  patch2 = gameLocal.program.NumStatements();
1742  e = GetExpression( TOP_PRIORITY );
1743  ExpectToken( ")" );
1744 
1745  if ( ( e->initialized == idVarDef::initializedConstant ) && ( *e->value.intPtr != 0 ) ) {
1746  //FIXME: we can completely skip generation of this code in the opposite case
1747  ParseStatement();
1748  EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
1749  } else {
1750  patch1 = gameLocal.program.NumStatements();
1751  EmitOpcode( OP_IFNOT, e, 0 );
1752  ParseStatement();
1753  EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
1754  gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
1755  }
1756 
1757  // fixup breaks and continues
1758  PatchLoop( patch2, patch2 );
1759 
1760  loopDepth--;
1761 }
1762 
1763 /*
1764 ================
1765 idCompiler::ParseForStatement
1766 
1767 Form of for statement with a counter:
1768 
1769  a = 0;
1770 start: << patch4
1771  if ( !( a < 10 ) ) {
1772  goto end; << patch1
1773  } else {
1774  goto process; << patch3
1775  }
1776 
1777 increment: << patch2
1778  a = a + 1;
1779  goto start; << goto patch4
1780 
1781 process:
1782  statements;
1783  goto increment; << goto patch2
1784 
1785 end:
1786 
1787 Form of for statement without a counter:
1788 
1789  a = 0;
1790 start: << patch2
1791  if ( !( a < 10 ) ) {
1792  goto end; << patch1
1793  }
1794 
1795 process:
1796  statements;
1797  goto start; << goto patch2
1798 
1799 end:
1800 ================
1801 */
1802 void idCompiler::ParseForStatement( void ) {
1803  idVarDef *e;
1804  int start;
1805  int patch1;
1806  int patch2;
1807  int patch3;
1808  int patch4;
1809 
1810  loopDepth++;
1811 
1812  start = gameLocal.program.NumStatements();
1813 
1814  ExpectToken( "(" );
1815 
1816  // init
1817  if ( !CheckToken( ";" ) ) {
1818  do {
1819  GetExpression( TOP_PRIORITY );
1820  } while( CheckToken( "," ) );
1821 
1822  ExpectToken( ";" );
1823  }
1824 
1825  // condition
1826  patch2 = gameLocal.program.NumStatements();
1827 
1828  e = GetExpression( TOP_PRIORITY );
1829  ExpectToken( ";" );
1830 
1831  //FIXME: add check for constant expression
1832  patch1 = gameLocal.program.NumStatements();
1833  EmitOpcode( OP_IFNOT, e, 0 );
1834 
1835  // counter
1836  if ( !CheckToken( ")" ) ) {
1837  patch3 = gameLocal.program.NumStatements();
1838  EmitOpcode( OP_IF, e, 0 );
1839 
1840  patch4 = patch2;
1841  patch2 = gameLocal.program.NumStatements();
1842  do {
1843  GetExpression( TOP_PRIORITY );
1844  } while( CheckToken( "," ) );
1845 
1846  ExpectToken( ")" );
1847 
1848  // goto patch4
1849  EmitOpcode( OP_GOTO, JumpTo( patch4 ), 0 );
1850 
1851  // fixup patch3
1852  gameLocal.program.GetStatement( patch3 ).b = JumpFrom( patch3 );
1853  }
1854 
1855  ParseStatement();
1856 
1857  // goto patch2
1858  EmitOpcode( OP_GOTO, JumpTo( patch2 ), 0 );
1859 
1860  // fixup patch1
1861  gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
1862 
1863  // fixup breaks and continues
1864  PatchLoop( start, patch2 );
1865 
1866  loopDepth--;
1867 }
1868 
1869 /*
1870 ================
1871 idCompiler::ParseDoWhileStatement
1872 ================
1873 */
1874 void idCompiler::ParseDoWhileStatement( void ) {
1875  idVarDef *e;
1876  int patch1;
1877 
1878  loopDepth++;
1879 
1880  patch1 = gameLocal.program.NumStatements();
1881  ParseStatement();
1882  ExpectToken( "while" );
1883  ExpectToken( "(" );
1884  e = GetExpression( TOP_PRIORITY );
1885  ExpectToken( ")" );
1886  ExpectToken( ";" );
1887 
1888  EmitOpcode( OP_IF, e, JumpTo( patch1 ) );
1889 
1890  // fixup breaks and continues
1891  PatchLoop( patch1, patch1 );
1892 
1893  loopDepth--;
1894 }
1895 
1896 /*
1897 ================
1898 idCompiler::ParseIfStatement
1899 ================
1900 */
1901 void idCompiler::ParseIfStatement( void ) {
1902  idVarDef *e;
1903  int patch1;
1904  int patch2;
1905 
1906  ExpectToken( "(" );
1907  e = GetExpression( TOP_PRIORITY );
1908  ExpectToken( ")" );
1909 
1910  //FIXME: add check for constant expression
1911  patch1 = gameLocal.program.NumStatements();
1912  EmitOpcode( OP_IFNOT, e, 0 );
1913 
1914  ParseStatement();
1915 
1916  if ( CheckToken( "else" ) ) {
1917  patch2 = gameLocal.program.NumStatements();
1918  EmitOpcode( OP_GOTO, 0, 0 );
1919  gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
1920  ParseStatement();
1921  gameLocal.program.GetStatement( patch2 ).a = JumpFrom( patch2 );
1922  } else {
1923  gameLocal.program.GetStatement( patch1 ).b = JumpFrom( patch1 );
1924  }
1925 }
1926 
1927 /*
1928 ============
1929 idCompiler::ParseStatement
1930 ============
1931 */
1932 void idCompiler::ParseStatement( void ) {
1933  if ( CheckToken( ";" ) ) {
1934  // skip semicolons, which are harmless and ok syntax
1935  return;
1936  }
1937 
1938  if ( CheckToken( "{" ) ) {
1939  do {
1940  ParseStatement();
1941  } while( !CheckToken( "}" ) );
1942 
1943  return;
1944  }
1945 
1946  if ( CheckToken( "return" ) ) {
1947  ParseReturnStatement();
1948  return;
1949  }
1950 
1951  if ( CheckToken( "while" ) ) {
1952  ParseWhileStatement();
1953  return;
1954  }
1955 
1956  if ( CheckToken( "for" ) ) {
1957  ParseForStatement();
1958  return;
1959  }
1960 
1961  if ( CheckToken( "do" ) ) {
1962  ParseDoWhileStatement();
1963  return;
1964  }
1965 
1966  if ( CheckToken( "break" ) ) {
1967  ExpectToken( ";" );
1968  if ( !loopDepth ) {
1969  Error( "cannot break outside of a loop" );
1970  }
1971  EmitOpcode( OP_BREAK, 0, 0 );
1972  return;
1973  }
1974 
1975  if ( CheckToken( "continue" ) ) {
1976  ExpectToken( ";" );
1977  if ( !loopDepth ) {
1978  Error( "cannot contine outside of a loop" );
1979  }
1980  EmitOpcode( OP_CONTINUE, 0, 0 );
1981  return;
1982  }
1983 
1984  if ( CheckType() != NULL ) {
1985  ParseDefs();
1986  return;
1987  }
1988 
1989  if ( CheckToken( "if" ) ) {
1990  ParseIfStatement();
1991  return;
1992  }
1993 
1994  GetExpression( TOP_PRIORITY );
1995  ExpectToken(";");
1996 }
1997 
1998 /*
1999 ================
2000 idCompiler::ParseObjectDef
2001 ================
2002 */
2003 void idCompiler::ParseObjectDef( const char *objname ) {
2004  idTypeDef *objtype;
2005  idTypeDef *type;
2006  idTypeDef *parentType;
2007  idTypeDef *fieldtype;
2008  idStr name;
2009  const char *fieldname;
2010  idTypeDef newtype( ev_field, NULL, "", 0, NULL );
2011  idVarDef *oldscope;
2012  int num;
2013  int i;
2014 
2015  oldscope = scope;
2016  if ( scope->Type() != ev_namespace ) {
2017  Error( "Objects cannot be defined within functions or other objects" );
2018  }
2019 
2020  // make sure it doesn't exist before we create it
2021  if ( gameLocal.program.FindType( objname ) != NULL ) {
2022  Error( "'%s' : redefinition; different basic types", objname );
2023  }
2024 
2025  // base type
2026  if ( !CheckToken( ":" ) ) {
2027  parentType = &type_object;
2028  } else {
2029  parentType = ParseType();
2030  if ( !parentType->Inherits( &type_object ) ) {
2031  Error( "Objects may only inherit from objects." );
2032  }
2033  }
2034 
2035  objtype = gameLocal.program.AllocType( ev_object, NULL, objname, parentType == &type_object ? 0 : parentType->Size(), parentType );
2036  objtype->def = gameLocal.program.AllocDef( objtype, objname, scope, true );
2037  scope = objtype->def;
2038 
2039  // inherit all the functions
2040  num = parentType->NumFunctions();
2041  for( i = 0; i < parentType->NumFunctions(); i++ ) {
2042  const function_t *func = parentType->GetFunction( i );
2043  objtype->AddFunction( func );
2044  }
2045 
2046  ExpectToken( "{" );
2047 
2048  do {
2049  if ( CheckToken( ";" ) ) {
2050  // skip semicolons, which are harmless and ok syntax
2051  continue;
2052  }
2053 
2054  fieldtype = ParseType();
2055  newtype.SetFieldType( fieldtype );
2056 
2057  fieldname = va( "%s field", fieldtype->Name() );
2058  newtype.SetName( fieldname );
2059 
2060  ParseName( name );
2061 
2062  // check for a function prototype or declaraction
2063  if ( CheckToken( "(" ) ) {
2064  ParseFunctionDef( newtype.FieldType(), name );
2065  } else {
2066  type = gameLocal.program.GetType( newtype, true );
2067  assert( !type->def );
2068  gameLocal.program.AllocDef( type, name, scope, true );
2069  objtype->AddField( type, name );
2070  ExpectToken( ";" );
2071  }
2072  } while( !CheckToken( "}" ) );
2073 
2074  scope = oldscope;
2075 
2076  ExpectToken( ";" );
2077 }
2078 
2079 /*
2080 ============
2081 idCompiler::ParseFunction
2082 
2083 parse a function type
2084 ============
2085 */
2086 idTypeDef *idCompiler::ParseFunction( idTypeDef *returnType, const char *name ) {
2087  idTypeDef newtype( ev_function, NULL, name, type_function.Size(), returnType );
2088  idTypeDef *type;
2089 
2090  if ( scope->Type() != ev_namespace ) {
2091  // create self pointer
2092  newtype.AddFunctionParm( scope->TypeDef(), "self" );
2093  }
2094 
2095  if ( !CheckToken( ")" ) ) {
2096  idStr parmName;
2097  do {
2098  type = ParseType();
2099  ParseName( parmName );
2100  newtype.AddFunctionParm( type, parmName );
2101  } while( CheckToken( "," ) );
2102 
2103  ExpectToken( ")" );
2104  }
2105 
2106  return gameLocal.program.GetType( newtype, true );
2107 }
2108 
2109 /*
2110 ================
2111 idCompiler::ParseFunctionDef
2112 ================
2113 */
2114 void idCompiler::ParseFunctionDef( idTypeDef *returnType, const char *name ) {
2115  idTypeDef *type;
2116  idVarDef *def;
2117  const idVarDef *parm;
2118  idVarDef *oldscope;
2119  int i;
2120  int numParms;
2121  const idTypeDef *parmType;
2122  function_t *func;
2123  statement_t *pos;
2124 
2125  if ( ( scope->Type() != ev_namespace ) && !scope->TypeDef()->Inherits( &type_object ) ) {
2126  Error( "Functions may not be defined within other functions" );
2127  }
2128 
2129  type = ParseFunction( returnType, name );
2130  def = gameLocal.program.GetDef( type, name, scope );
2131  if ( !def ) {
2132  def = gameLocal.program.AllocDef( type, name, scope, true );
2133  type->def = def;
2134 
2135  func = &gameLocal.program.AllocFunction( def );
2136  if ( scope->TypeDef()->Inherits( &type_object ) ) {
2137  scope->TypeDef()->AddFunction( func );
2138  }
2139  } else {
2140  func = def->value.functionPtr;
2141  assert( func );
2142  if ( func->firstStatement ) {
2143  Error( "%s redeclared", def->GlobalName() );
2144  }
2145  }
2146 
2147  // check if this is a prototype or declaration
2148  if ( !CheckToken( "{" ) ) {
2149  // it's just a prototype, so get the ; and move on
2150  ExpectToken( ";" );
2151  return;
2152  }
2153 
2154  // calculate stack space used by parms
2155  numParms = type->NumParameters();
2156  func->parmSize.SetNum( numParms );
2157  for( i = 0; i < numParms; i++ ) {
2158  parmType = type->GetParmType( i );
2159  if ( parmType->Inherits( &type_object ) ) {
2160  func->parmSize[ i ] = type_object.Size();
2161  } else {
2162  func->parmSize[ i ] = parmType->Size();
2163  }
2164  func->parmTotal += func->parmSize[ i ];
2165  }
2166 
2167  // define the parms
2168  for( i = 0; i < numParms; i++ ) {
2169  if ( gameLocal.program.GetDef( type->GetParmType( i ), type->GetParmName( i ), def ) ) {
2170  Error( "'%s' defined more than once in function parameters", type->GetParmName( i ) );
2171  }
2172  parm = gameLocal.program.AllocDef( type->GetParmType( i ), type->GetParmName( i ), def, false );
2173  }
2174 
2175  oldscope = scope;
2176  scope = def;
2177 
2178  func->firstStatement = gameLocal.program.NumStatements();
2179 
2180  // check if we should call the super class constructor
2181  if ( oldscope->TypeDef()->Inherits( &type_object ) && !idStr::Icmp( name, "init" ) ) {
2182  idTypeDef *superClass;
2183  function_t *constructorFunc = NULL;
2184 
2185  // find the superclass constructor
2186  for( superClass = oldscope->TypeDef()->SuperClass(); superClass != &type_object; superClass = superClass->SuperClass() ) {
2187  constructorFunc = gameLocal.program.FindFunction( va( "%s::init", superClass->Name() ) );
2188  if ( constructorFunc ) {
2189  break;
2190  }
2191  }
2192 
2193  // emit the call to the constructor
2194  if ( constructorFunc ) {
2195  idVarDef *selfDef = gameLocal.program.GetDef( type->GetParmType( 0 ), type->GetParmName( 0 ), def );
2196  assert( selfDef );
2197  EmitPush( selfDef, selfDef->TypeDef() );
2198  EmitOpcode( &opcodes[ OP_CALL ], constructorFunc->def, 0 );
2199  }
2200  }
2201 
2202  // parse regular statements
2203  while( !CheckToken( "}" ) ) {
2204  ParseStatement();
2205  }
2206 
2207  // check if we should call the super class destructor
2208  if ( oldscope->TypeDef()->Inherits( &type_object ) && !idStr::Icmp( name, "destroy" ) ) {
2209  idTypeDef *superClass;
2210  function_t *destructorFunc = NULL;
2211 
2212  // find the superclass destructor
2213  for( superClass = oldscope->TypeDef()->SuperClass(); superClass != &type_object; superClass = superClass->SuperClass() ) {
2214  destructorFunc = gameLocal.program.FindFunction( va( "%s::destroy", superClass->Name() ) );
2215  if ( destructorFunc ) {
2216  break;
2217  }
2218  }
2219 
2220  if ( destructorFunc ) {
2221  if ( func->firstStatement < gameLocal.program.NumStatements() ) {
2222  // change all returns to point to the call to the destructor
2223  pos = &gameLocal.program.GetStatement( func->firstStatement );
2224  for( i = func->firstStatement; i < gameLocal.program.NumStatements(); i++, pos++ ) {
2225  if ( pos->op == OP_RETURN ) {
2226  pos->op = OP_GOTO;
2227  pos->a = JumpDef( i, gameLocal.program.NumStatements() );
2228  }
2229  }
2230  }
2231 
2232  // emit the call to the destructor
2233  idVarDef *selfDef = gameLocal.program.GetDef( type->GetParmType( 0 ), type->GetParmName( 0 ), def );
2234  assert( selfDef );
2235  EmitPush( selfDef, selfDef->TypeDef() );
2236  EmitOpcode( &opcodes[ OP_CALL ], destructorFunc->def, 0 );
2237  }
2238  }
2239 
2240 // Disabled code since it caused a function to fall through to the next function when last statement is in the form "if ( x ) { return; }"
2241 #if 0
2242  // don't bother adding a return opcode if the "return" statement was used.
2243  if ( ( func->firstStatement == gameLocal.program.NumStatements() ) || ( gameLocal.program.GetStatement( gameLocal.program.NumStatements() - 1 ).op != OP_RETURN ) ) {
2244  // emit an end of statements opcode
2245  EmitOpcode( OP_RETURN, 0, 0 );
2246  }
2247 #else
2248  // always emit the return opcode
2249  EmitOpcode( OP_RETURN, 0, 0 );
2250 #endif
2251 
2252  // record the number of statements in the function
2253  func->numStatements = gameLocal.program.NumStatements() - func->firstStatement;
2254 
2255  scope = oldscope;
2256 }
2257 
2258 /*
2259 ================
2260 idCompiler::ParseVariableDef
2261 ================
2262 */
2263 void idCompiler::ParseVariableDef( idTypeDef *type, const char *name ) {
2264  idVarDef *def, *def2;
2265  bool negate;
2266 
2267  def = gameLocal.program.GetDef( type, name, scope );
2268  if ( def ) {
2269  Error( "%s redeclared", name );
2270  }
2271 
2272  def = gameLocal.program.AllocDef( type, name, scope, false );
2273 
2274  // check for an initialization
2275  if ( CheckToken( "=" ) ) {
2276  // if a local variable in a function then write out interpreter code to initialize variable
2277  if ( scope->Type() == ev_function ) {
2278  def2 = GetExpression( TOP_PRIORITY );
2279  if ( ( type == &type_float ) && ( def2->TypeDef() == &type_float ) ) {
2280  EmitOpcode( OP_STORE_F, def2, def );
2281  } else if ( ( type == &type_vector ) && ( def2->TypeDef() == &type_vector ) ) {
2282  EmitOpcode( OP_STORE_V, def2, def );
2283  } else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_string ) ) {
2284  EmitOpcode( OP_STORE_S, def2, def );
2285  } else if ( ( type == &type_entity ) && ( ( def2->TypeDef() == &type_entity ) || ( def2->TypeDef()->Inherits( &type_object ) ) ) ) {
2286  EmitOpcode( OP_STORE_ENT, def2, def );
2287  } else if ( ( type->Inherits( &type_object ) ) && ( def2->TypeDef() == &type_entity ) ) {
2288  EmitOpcode( OP_STORE_OBJENT, def2, def );
2289  } else if ( ( type->Inherits( &type_object ) ) && ( def2->TypeDef()->Inherits( type ) ) ) {
2290  EmitOpcode( OP_STORE_OBJ, def2, def );
2291  } else if ( ( type == &type_boolean ) && ( def2->TypeDef() == &type_boolean ) ) {
2292  EmitOpcode( OP_STORE_BOOL, def2, def );
2293  } else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_float ) ) {
2294  EmitOpcode( OP_STORE_FTOS, def2, def );
2295  } else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_boolean ) ) {
2296  EmitOpcode( OP_STORE_BTOS, def2, def );
2297  } else if ( ( type == &type_string ) && ( def2->TypeDef() == &type_vector ) ) {
2298  EmitOpcode( OP_STORE_VTOS, def2, def );
2299  } else if ( ( type == &type_boolean ) && ( def2->TypeDef() == &type_float ) ) {
2300  EmitOpcode( OP_STORE_FTOBOOL, def2, def );
2301  } else if ( ( type == &type_float ) && ( def2->TypeDef() == &type_boolean ) ) {
2302  EmitOpcode( OP_STORE_BOOLTOF, def2, def );
2303  } else {
2304  Error( "bad initialization for '%s'", name );
2305  }
2306  } else {
2307  // global variables can only be initialized with immediate values
2308  negate = false;
2309  if ( token.type == TT_PUNCTUATION && token == "-" ) {
2310  negate = true;
2311  NextToken();
2312  if ( immediateType != &type_float ) {
2313  Error( "wrong immediate type for '-' on variable '%s'", name );
2314  }
2315  }
2316 
2317  if ( immediateType != type ) {
2318  Error( "wrong immediate type for '%s'", name );
2319  }
2320 
2321  // global variables are initialized at start up
2322  if ( type == &type_string ) {
2323  def->SetString( token, false );
2324  } else {
2325  if ( negate ) {
2326  immediate._float = -immediate._float;
2327  }
2328  def->SetValue( immediate, false );
2329  }
2330  NextToken();
2331  }
2332  } else if ( type == &type_string ) {
2333  // local strings on the stack are initialized in the interpreter
2334  if ( scope->Type() != ev_function ) {
2335  def->SetString( "", false );
2336  }
2337  } else if ( type->Inherits( &type_object ) ) {
2338  if ( scope->Type() != ev_function ) {
2339  def->SetObject( NULL );
2340  }
2341  }
2342 }
2343 
2344 /*
2345 ================
2346 idCompiler::GetTypeForEventArg
2347 ================
2348 */
2349 idTypeDef *idCompiler::GetTypeForEventArg( char argType ) {
2350  idTypeDef *type;
2351 
2352  switch( argType ) {
2353  case D_EVENT_INTEGER :
2354  // this will get converted to int by the interpreter
2355  type = &type_float;
2356  break;
2357 
2358  case D_EVENT_FLOAT :
2359  type = &type_float;
2360  break;
2361 
2362  case D_EVENT_VECTOR :
2363  type = &type_vector;
2364  break;
2365 
2366  case D_EVENT_STRING :
2367  type = &type_string;
2368  break;
2369 
2370  case D_EVENT_ENTITY :
2371  case D_EVENT_ENTITY_NULL :
2372  type = &type_entity;
2373  break;
2374 
2375  case D_EVENT_VOID :
2376  type = &type_void;
2377  break;
2378 
2379  case D_EVENT_TRACE :
2380  // This data type isn't available from script
2381  type = NULL;
2382  break;
2383 
2384  default:
2385  // probably a typo
2386  type = NULL;
2387  break;
2388  }
2389 
2390  return type;
2391 }
2392 
2393 /*
2394 ================
2395 idCompiler::ParseEventDef
2396 ================
2397 */
2398 void idCompiler::ParseEventDef( idTypeDef *returnType, const char *name ) {
2399  const idTypeDef *expectedType;
2400  idTypeDef *argType;
2401  idTypeDef *type;
2402  int i;
2403  int num;
2404  const char *format;
2405  const idEventDef *ev;
2406  idStr parmName;
2407 
2408  ev = idEventDef::FindEvent( name );
2409  if ( !ev ) {
2410  Error( "Unknown event '%s'", name );
2411  }
2412 
2413  // set the return type
2414  expectedType = GetTypeForEventArg( ev->GetReturnType() );
2415  if ( !expectedType ) {
2416  Error( "Invalid return type '%c' in definition of '%s' event.", ev->GetReturnType(), name );
2417  }
2418  if ( returnType != expectedType ) {
2419  Error( "Return type doesn't match internal return type '%s'", expectedType->Name() );
2420  }
2421 
2422  idTypeDef newtype( ev_function, NULL, name, type_function.Size(), returnType );
2423 
2424  ExpectToken( "(" );
2425 
2426  format = ev->GetArgFormat();
2427  num = strlen( format );
2428  for( i = 0; i < num; i++ ) {
2429  expectedType = GetTypeForEventArg( format[ i ] );
2430  if ( !expectedType || ( expectedType == &type_void ) ) {
2431  Error( "Invalid parameter '%c' in definition of '%s' event.", format[ i ], name );
2432  }
2433 
2434  argType = ParseType();
2435  ParseName( parmName );
2436  if ( argType != expectedType ) {
2437  Error( "The type of parm %d ('%s') does not match the internal type '%s' in definition of '%s' event.",
2438  i + 1, parmName.c_str(), expectedType->Name(), name );
2439  }
2440 
2441  newtype.AddFunctionParm( argType, "" );
2442 
2443  if ( i < num - 1 ) {
2444  if ( CheckToken( ")" ) ) {
2445  Error( "Too few parameters for event definition. Internal definition has %d parameters.", num );
2446  }
2447  ExpectToken( "," );
2448  }
2449  }
2450  if ( !CheckToken( ")" ) ) {
2451  Error( "Too many parameters for event definition. Internal definition has %d parameters.", num );
2452  }
2453  ExpectToken( ";" );
2454 
2455  type = gameLocal.program.FindType( name );
2456  if ( type ) {
2457  if ( !newtype.MatchesType( *type ) || ( type->def->value.functionPtr->eventdef != ev ) ) {
2458  Error( "Type mismatch on redefinition of '%s'", name );
2459  }
2460  } else {
2461  type = gameLocal.program.AllocType( newtype );
2462  type->def = gameLocal.program.AllocDef( type, name, &def_namespace, true );
2463 
2464  function_t &func = gameLocal.program.AllocFunction( type->def );
2465  func.eventdef = ev;
2466  func.parmSize.SetNum( num );
2467  for( i = 0; i < num; i++ ) {
2468  argType = newtype.GetParmType( i );
2469  func.parmTotal += argType->Size();
2470  func.parmSize[ i ] = argType->Size();
2471  }
2472 
2473  // mark the parms as local
2474  func.locals = func.parmTotal;
2475  }
2476 }
2477 
2478 /*
2479 ================
2480 idCompiler::ParseDefs
2481 
2482 Called at the outer layer and when a local statement is hit
2483 ================
2484 */
2485 void idCompiler::ParseDefs( void ) {
2486  idStr name;
2487  idTypeDef *type;
2488  idVarDef *def;
2489  idVarDef *oldscope;
2490 
2491  if ( CheckToken( ";" ) ) {
2492  // skip semicolons, which are harmless and ok syntax
2493  return;
2494  }
2495 
2496  type = ParseType();
2497  if ( type == &type_scriptevent ) {
2498  type = ParseType();
2499  ParseName( name );
2500  ParseEventDef( type, name );
2501  return;
2502  }
2503 
2504  ParseName( name );
2505 
2506  if ( type == &type_namespace ) {
2507  def = gameLocal.program.GetDef( type, name, scope );
2508  if ( !def ) {
2509  def = gameLocal.program.AllocDef( type, name, scope, true );
2510  }
2511  ParseNamespace( def );
2512  } else if ( CheckToken( "::" ) ) {
2513  def = gameLocal.program.GetDef( NULL, name, scope );
2514  if ( !def ) {
2515  Error( "Unknown object name '%s'", name.c_str() );
2516  }
2517  ParseName( name );
2518  oldscope = scope;
2519  scope = def;
2520 
2521  ExpectToken( "(" );
2522  ParseFunctionDef( type, name.c_str() );
2523  scope = oldscope;
2524  } else if ( type == &type_object ) {
2525  ParseObjectDef( name.c_str() );
2526  } else if ( CheckToken( "(" ) ) { // check for a function prototype or declaraction
2527  ParseFunctionDef( type, name.c_str() );
2528  } else {
2529  ParseVariableDef( type, name.c_str() );
2530  while( CheckToken( "," ) ) {
2531  ParseName( name );
2532  ParseVariableDef( type, name.c_str() );
2533  }
2534  ExpectToken( ";" );
2535  }
2536 }
2537 
2538 /*
2539 ================
2540 idCompiler::ParseNamespace
2541 
2542 Parses anything within a namespace definition
2543 ================
2544 */
2545 void idCompiler::ParseNamespace( idVarDef *newScope ) {
2546  idVarDef *oldscope;
2547 
2548  oldscope = scope;
2549  if ( newScope != &def_namespace ) {
2550  ExpectToken( "{" );
2551  }
2552 
2553  while( !eof ) {
2554  scope = newScope;
2555  callthread = false;
2556 
2557  if ( ( newScope != &def_namespace ) && CheckToken( "}" ) ) {
2558  break;
2559  }
2560 
2561  ParseDefs();
2562  }
2563 
2564  scope = oldscope;
2565 }
2566 
2567 /*
2568 ============
2569 idCompiler::CompileFile
2570 
2571 compiles the 0 terminated text, adding definitions to the program structure
2572 ============
2573 */
2574 void idCompiler::CompileFile( const char *text, const char *filename, bool toConsole ) {
2575  idTimer compile_time;
2576  bool error;
2577 
2578  compile_time.Start();
2579 
2580  scope = &def_namespace;
2581  basetype = NULL;
2582  callthread = false;
2583  loopDepth = 0;
2584  eof = false;
2585  braceDepth = 0;
2586  immediateType = NULL;
2587  currentLineNumber = 0;
2588  console = toConsole;
2589 
2590  memset( &immediate, 0, sizeof( immediate ) );
2591 
2592  parser.SetFlags( LEXFL_ALLOWMULTICHARLITERALS );
2593  parser.LoadMemory( text, strlen( text ), filename );
2594  parserPtr = &parser;
2595 
2596  // unread tokens to include script defines
2597  token = SCRIPT_DEFAULTDEFS;
2598  token.type = TT_STRING;
2599  token.subtype = token.Length();
2600  token.line = token.linesCrossed = 0;
2601  parser.UnreadToken( &token );
2602 
2603  token = "include";
2604  token.type = TT_NAME;
2605  token.subtype = token.Length();
2606  token.line = token.linesCrossed = 0;
2607  parser.UnreadToken( &token );
2608 
2609  token = "#";
2610  token.type = TT_PUNCTUATION;
2611  token.subtype = P_PRECOMP;
2612  token.line = token.linesCrossed = 0;
2613  parser.UnreadToken( &token );
2614 
2615  // init the current token line to be the first line so that currentLineNumber is set correctly in NextToken
2616  token.line = 1;
2617 
2618  error = false;
2619  try {
2620  // read first token
2621  NextToken();
2622  while( !eof && !error ) {
2623  // parse from global namespace
2624  ParseNamespace( &def_namespace );
2625  }
2626  }
2627 
2628  catch( idCompileError &err ) {
2629  idStr error;
2630 
2631  if ( console ) {
2632  // don't print line number of an error if were calling script from the console using the "script" command
2633  sprintf( error, "Error: %s\n", err.error );
2634  } else {
2635  sprintf( error, "Error: file %s, line %d: %s\n", gameLocal.program.GetFilename( currentFileNumber ), currentLineNumber, err.error );
2636  }
2637 
2638  parser.FreeSource();
2639 
2640  throw idCompileError( error );
2641  }
2642 
2643  parser.FreeSource();
2644 
2645  compile_time.Stop();
2646  if ( !toConsole ) {
2647  gameLocal.Printf( "Compiled '%s': %.1f ms\n", filename, compile_time.Milliseconds() );
2648  }
2649 }
OP_UADD_F
Definition: Script_Compiler.h:141
function_t::parmSize
idList< int > parmSize
Definition: Script_Program.h:85
OP_COMP_F
Definition: Script_Compiler.h:54
idTypeDef::SetName
void SetName(const char *newname)
Definition: Script_Program.cpp:331
OP_NOT_V
Definition: Script_Compiler.h:150
OP_EVENTCALL
Definition: Script_Compiler.h:102
idCompiler::CheckType
idTypeDef * CheckType(void)
Definition: Script_Compiler.cpp:852
statement_s
Definition: Script_Program.h:428
strcmp
#define strcmp
Definition: Str.h:41
idCompiler::TypeMatches
bool TypeMatches(etype_t type1, etype_t type2) const
Definition: Script_Compiler.cpp:1444
idToken::type
int type
Definition: Token.h:77
value
GLsizei const GLfloat * value
Definition: glext.h:3614
idVec3::Compare
bool Compare(const idVec3 &a) const
Definition: Vector.h:496
idProgram::GetDefList
idVarDef * GetDefList(const char *name) const
Definition: Script_Program.cpp:1196
OP_NE_E
Definition: Script_Compiler.h:83
idCompiler::ParseWhileStatement
void ParseWhileStatement(void)
Definition: Script_Compiler.cpp:1732
def_entity
idVarDef def_entity
OP_EQ_F
Definition: Script_Compiler.h:72
def_object
idVarDef def_object
assert
assert(prefInfo.fullscreenBtn)
type_string
idVarDef def_string & type_string
Definition: Script_Program.cpp:54
varEval_s::stringPtr
char * stringPtr
Definition: Script_Program.h:308
def_vector
idVarDef def_vector
idParser::UnreadToken
void UnreadToken(idToken *token)
Definition: Parser.cpp:2745
idStr::Cmp
int Cmp(const char *text) const
Definition: Str.h:652
OP_ADDRESS
Definition: Script_Compiler.h:100
idTypeDef::Type
etype_t Type(void) const
Definition: Script_Program.cpp:349
idCompiler::SkipOutOfFunction
void SkipOutOfFunction(void)
Definition: Script_Compiler.cpp:820
idCompiler::opcodes
static opcode_t opcodes[]
Definition: Script_Compiler.h:272
OP_STOREP_BOOLTOF
Definition: Script_Compiler.h:134
idCompiler::JumpDef
idVarDef * JumpDef(int jumpfrom, int jumpto)
Definition: Script_Compiler.cpp:333
OP_UINCP_F
Definition: Script_Compiler.h:51
idCompiler::ParseDefs
void ParseDefs(void)
Definition: Script_Compiler.cpp:2485
OP_GT
Definition: Script_Compiler.h:91
idVarDef::Type
etype_t Type(void) const
Definition: Script_Program.h:349
idGameLocal::Printf
void Printf(const char *fmt,...) const id_attribute((format(printf
Definition: Game_local.cpp:699
idTimer
Definition: Timer.h:40
idCompiler::NextToken
void NextToken(void)
Definition: Script_Compiler.cpp:664
varEval_s::floatPtr
float * floatPtr
Definition: Script_Program.h:309
idProgram::AllocStatement
statement_t * AllocStatement(void)
Definition: Script_Program.cpp:1577
OP_STORE_ENT
Definition: Script_Compiler.h:109
etype_t
etype_t
Definition: Script_Program.h:61
format
GLenum GLsizei GLenum format
Definition: glext.h:2846
idProgram::GetStatement
statement_t & GetStatement(int index)
Definition: Script_Program.h:543
eval_s
Definition: Script_Program.h:88
idProgram::GetDef
idVarDef * GetDef(const idTypeDef *type, const char *name, const idVarDef *scope) const
Definition: Script_Program.cpp:1339
idList::SetNum
void SetNum(int newnum, bool resize=true)
Definition: List.h:289
idCompiler::ParseReturnStatement
void ParseReturnStatement(void)
Definition: Script_Compiler.cpp:1676
D_EVENT_ENTITY_NULL
#define D_EVENT_ENTITY_NULL
Definition: Event.h:45
ev_argsize
Definition: Script_Program.h:62
TT_NAME
#define TT_NAME
Definition: Token.h:44
function_t::parmTotal
int parmTotal
Definition: Script_Program.h:82
OP_GOTO
Definition: Script_Compiler.h:177
D_EVENT_VOID
#define D_EVENT_VOID
Definition: Event.h:39
idStr::Length
int Length(void) const
Definition: Str.h:702
varEval_s::functionPtr
function_t * functionPtr
Definition: Script_Program.h:311
idCompiler::EmitOpcode
idVarDef * EmitOpcode(const opcode_t *op, idVarDef *var_a, idVarDef *var_b)
Definition: Script_Compiler.cpp:571
OP_STORE_FTOBOOL
Definition: Script_Compiler.h:118
idCompiler::ParseName
void ParseName(idStr &name)
Definition: Script_Compiler.cpp:804
OP_STORE_FTOS
Definition: Script_Compiler.h:115
idCompiler::ParseImmediate
idVarDef * ParseImmediate(void)
Definition: Script_Compiler.cpp:918
D_EVENT_STRING
#define D_EVENT_STRING
Definition: Event.h:43
OP_NOT_ENT
Definition: Script_Compiler.h:152
idVarDef::value
varEval_t value
Definition: Script_Program.h:330
function_t::eventdef
const idEventDef * eventdef
Definition: Script_Program.h:77
type_object
idVarDef def_object & type_object
Definition: Script_Program.cpp:62
idVec3::z
float z
Definition: Vector.h:320
ev_jumpoffset
Definition: Script_Program.h:62
int
case const int
Definition: Callbacks.cpp:52
OP_PUSH_ENT
Definition: Script_Compiler.h:168
LEXFL_ALLOWMULTICHARLITERALS
Definition: Lexer.h:61
idToken::subtype
int subtype
Definition: Token.h:78
OP_ADD_F
Definition: Script_Compiler.h:62
ev_object
Definition: Script_Program.h:62
idCompiler::parser
idParser parser
Definition: Script_Compiler.h:202
idToken::linesCrossed
int linesCrossed
Definition: Token.h:80
OP_DIV_F
Definition: Script_Compiler.h:60
OP_NEG_F
Definition: Script_Compiler.h:154
idToken::GetFloatValue
float GetFloatValue(void)
Definition: Token.h:138
idProgram::GetFilenum
int GetFilenum(const char *name)
Definition: Script_Program.cpp:2097
idVec3
Definition: Vector.h:316
idCompiler::ParseFunctionCall
idVarDef * ParseFunctionCall(idVarDef *func)
Definition: Script_Compiler.cpp:1055
float
case const float
Definition: Callbacks.cpp:62
idCompiler::ParseIfStatement
void ParseIfStatement(void)
Definition: Script_Compiler.cpp:1901
idCompiler::GetTerm
idVarDef * GetTerm(void)
Definition: Script_Compiler.cpp:1304
idCompiler::SkipToSemicolon
void SkipToSemicolon(void)
Definition: Script_Compiler.cpp:835
opcode_s::type_c
idVarDef * type_c
Definition: Script_Compiler.h:40
type_namespace
idVarDef def_namespace & type_namespace
Definition: Script_Program.cpp:53
OP_STORE_OBJENT
Definition: Script_Compiler.h:111
idParser::LoadMemory
int LoadMemory(const char *ptr, int length, const char *name)
Definition: Parser.cpp:3049
idParser::FreeSource
void FreeSource(bool keepDefines=false)
Definition: Parser.cpp:3084
idTimer::Start
void Start(void)
Definition: Timer.h:144
opcode_s::priority
int priority
Definition: Script_Compiler.h:36
idVarDef::SetTypeDef
void SetTypeDef(idTypeDef *_type)
Definition: Script_Program.h:347
type
GLuint GLuint GLsizei GLenum type
Definition: glext.h:2845
OP_LT
Definition: Script_Compiler.h:90
idCompiler::ParseNamespace
void ParseNamespace(idVarDef *newScope)
Definition: Script_Compiler.cpp:2545
idToken
Definition: Token.h:71
TT_STRING
#define TT_STRING
Definition: Token.h:41
function_t::numStatements
int numStatements
Definition: Script_Program.h:81
D_EVENT_ENTITY
#define D_EVENT_ENTITY
Definition: Event.h:44
idCompiler::JumpFrom
idVarDef * JumpFrom(int jumpfrom)
Definition: Script_Compiler.cpp:355
type_scriptevent
idVarDef def_scriptevent & type_scriptevent
Definition: Script_Program.cpp:52
opcode_s::name
const char * name
Definition: Script_Compiler.h:34
idTypeDef::NumParameters
int NumParameters(void) const
Definition: Script_Program.cpp:472
idTimer::Milliseconds
double Milliseconds(void) const
Definition: Timer.h:191
statement_s::a
idVarDef * a
Definition: Script_Program.h:430
varEval_s::vectorPtr
idVec3 * vectorPtr
Definition: Script_Program.h:310
idVec3::x
float x
Definition: Vector.h:318
P_PRECOMP
#define P_PRECOMP
Definition: Lexer.h:126
process.i
int i
Definition: process.py:33
num
GLuint GLuint num
Definition: glext.h:5390
ev_namespace
Definition: Script_Program.h:62
idTypeDef::Name
const char * Name(void) const
Definition: Script_Program.cpp:340
idCompiler::GetExpression
idVarDef * GetExpression(int priority)
Definition: Script_Compiler.cpp:1465
NOT_PRIORITY
#define NOT_PRIORITY
Definition: Script_Compiler.cpp:36
OP_STOREP_FTOS
Definition: Script_Compiler.h:130
idStr::Icmp
int Icmp(const char *text) const
Definition: Str.h:667
D_EVENT_FLOAT
#define D_EVENT_FLOAT
Definition: Event.h:41
idCompiler::basetype
const idVarDef * basetype
Definition: Script_Compiler.h:219
OP_NEG_V
Definition: Script_Compiler.h:155
TT_NUMBER
#define TT_NUMBER
Definition: Token.h:43
type_void
idVarDef def_void & type_void
Definition: Script_Program.cpp:51
idGameLocal::program
idProgram program
Definition: Game_local.h:293
OP_OR
Definition: Script_Compiler.h:183
statement_s::op
unsigned short op
Definition: Script_Program.h:429
idVarDef::GlobalName
const char * GlobalName(void) const
Definition: Script_Program.cpp:600
idProgram::FreeDef
void FreeDef(idVarDef *d, const idVarDef *scope)
Definition: Script_Program.cpp:1380
function_t
Definition: Script_Program.h:65
LEXFL_NOERRORS
Definition: Lexer.h:50
idCompiler::ParseForStatement
void ParseForStatement(void)
Definition: Script_Compiler.cpp:1802
idTypeDef::GetFunction
const function_t * GetFunction(int funcNumber) const
Definition: Script_Program.cpp:528
idCompiler::ParseObjectCall
idVarDef * ParseObjectCall(idVarDef *object, idVarDef *func)
Definition: Script_Compiler.cpp:1097
idCompiler::OptimizeOpcode
void void idVarDef * OptimizeOpcode(const opcode_t *op, idVarDef *var_a, idVarDef *var_b)
Definition: Script_Compiler.cpp:486
idCompiler::CheckToken
bool CheckToken(const char *string)
Definition: Script_Compiler.cpp:787
def_field
idVarDef def_field
type_vector
idVarDef def_vector & type_vector
Definition: Script_Program.cpp:56
OP_STORE_BTOS
Definition: Script_Compiler.h:116
idCompiler::immediateType
idTypeDef * immediateType
Definition: Script_Compiler.h:206
eval_s::vector
float vector[3]
Definition: Script_Program.h:91
OP_STOREP_F
Definition: Script_Compiler.h:121
OP_STOREP_OBJENT
Definition: Script_Compiler.h:128
idParser::ReadToken
int ReadToken(idToken *token)
Definition: Parser.cpp:2338
OP_SYSCALL
Definition: Script_Compiler.h:104
OP_STORE_V
Definition: Script_Compiler.h:107
idCompiler::Error
void Error(const char *error,...) const id_attribute((format(printf
Definition: Script_Compiler.cpp:248
idVarDef::SetString
void SetString(const char *string, bool constant)
Definition: Script_Program.cpp:721
idCompiler::punctuation
static const char * punctuation[]
Definition: Script_Compiler.h:200
idProgram::GetFilename
const char * GetFilename(int num)
Definition: Script_Program.h:615
idLexer
Definition: Lexer.h:137
idToken::line
int line
Definition: Token.h:79
OP_MOD_F
Definition: Script_Compiler.h:61
idTypeDef::Size
int Size(void) const
Definition: Script_Program.cpp:358
idEventDef::FindEvent
static const idEventDef * FindEvent(const char *name)
Definition: Event.cpp:192
idTypeDef::GetParmName
const char * GetParmName(int parmNumber) const
Definition: Script_Program.cpp:492
OP_STOREP_ENT
Definition: Script_Compiler.h:124
idVarDef::TypeDef
idTypeDef * TypeDef(void) const
Definition: Script_Program.h:348
c
const GLubyte * c
Definition: glext.h:4677
ev_vector
Definition: Script_Program.h:62
OP_CALL
Definition: Script_Compiler.h:161
numerator
INT32 * numerator
Definition: wglext.h:503
OP_SUB_F
Definition: Script_Compiler.h:69
opcode_s::type_b
idVarDef * type_b
Definition: Script_Compiler.h:39
idTypeDef::GetFunctionNumber
int GetFunctionNumber(const function_t *func) const
Definition: Script_Program.cpp:512
OP_LE
Definition: Script_Compiler.h:88
type_float
idVarDef def_float & type_float
Definition: Script_Program.cpp:55
opcode_s
Definition: Script_Compiler.h:33
idVarDef::Name
const char * Name(void) const
Definition: Script_Program.cpp:591
type_boolean
idVarDef def_boolean & type_boolean
Definition: Script_Program.cpp:65
SCRIPT_DEFAULTDEFS
#define SCRIPT_DEFAULTDEFS
Definition: Game.h:41
idProgram::AllocDef
idVarDef * AllocDef(idTypeDef *type, const char *name, idVarDef *scope, bool constant)
Definition: Script_Program.cpp:1234
OP_STOREP_BTOS
Definition: Script_Compiler.h:131
idTypeDef::ReturnType
idTypeDef * ReturnType(void) const
Definition: Script_Program.cpp:384
OP_INT_F
Definition: Script_Compiler.h:157
NULL
#define NULL
Definition: Lib.h:88
OP_EQ_E
Definition: Script_Compiler.h:75
idTypeDef::AddFunction
void AddFunction(const function_t *func)
Definition: Script_Program.cpp:539
idCompiler::LookupDef
idVarDef * LookupDef(const char *name, const idVarDef *baseobj)
Definition: Script_Compiler.cpp:1164
idVec3::y
float y
Definition: Vector.h:319
ev_float
Definition: Script_Program.h:62
D_EVENT_VECTOR
#define D_EVENT_VECTOR
Definition: Event.h:42
idCompiler::ParseDoWhileStatement
void ParseDoWhileStatement(void)
Definition: Script_Compiler.cpp:1874
function_t::def
idVarDef * def
Definition: Script_Program.h:78
idCompiler::SizeConstant
idVarDef * SizeConstant(int size)
Definition: Script_Compiler.cpp:303
OP_STORE_BOOLTOF
Definition: Script_Compiler.h:119
idCompiler::ParseObjectDef
void ParseObjectDef(const char *objname)
Definition: Script_Compiler.cpp:2003
idCompiler::ParseFunction
idTypeDef * ParseFunction(idTypeDef *returnType, const char *name)
Definition: Script_Compiler.cpp:2086
NUM_OPCODES
Definition: Script_Compiler.h:194
idCompiler::parserPtr
idParser * parserPtr
Definition: Script_Compiler.h:203
idVarDef::initialized
initialized_t initialized
Definition: Script_Program.h:338
idCompiler::GetImmediate
idVarDef * GetImmediate(idTypeDef *type, const eval_t *eval, const char *string)
Definition: Script_Compiler.cpp:460
OP_IF
Definition: Script_Compiler.h:158
type_entity
idVarDef def_entity & type_entity
Definition: Script_Program.cpp:57
FUNCTION_PRIORITY
#define FUNCTION_PRIORITY
Definition: Script_Compiler.cpp:34
D_EVENT_TRACE
#define D_EVENT_TRACE
Definition: Event.h:46
idParser::GetPunctuationId
int GetPunctuationId(const char *p)
Definition: Parser.cpp:3154
idCompiler::ParseVariableDef
void ParseVariableDef(idTypeDef *type, const char *name)
Definition: Script_Compiler.cpp:2263
idTypeDef::NumFunctions
int NumFunctions(void) const
Definition: Script_Program.cpp:503
idParser::Warning
void void Warning(const char *str,...) const id_attribute((format(printf
Definition: Parser.cpp:335
OP_UINC_F
Definition: Script_Compiler.h:50
OP_ADD_V
Definition: Script_Compiler.h:63
idParser::SetFlags
void SetFlags(int flags)
Definition: Parser.cpp:2990
idTypeDef::AddField
void AddField(idTypeDef *fieldtype, const char *name)
Definition: Script_Program.cpp:310
type_virtualfunction
idVarDef def_virtualfunction & type_virtualfunction
Definition: Script_Program.cpp:60
OP_UAND_F
Definition: Script_Compiler.h:145
idCompiler::FindImmediate
idVarDef * FindImmediate(const idTypeDef *type, const eval_t *eval, const char *string) const
Definition: Script_Compiler.cpp:380
eval_s::_int
int _int
Definition: Script_Program.h:93
idTypeDef::GetParmType
idTypeDef * GetParmType(int parmNumber) const
Definition: Script_Program.cpp:481
OP_NOT_F
Definition: Script_Compiler.h:149
idCompiler::ParseEventDef
void ParseEventDef(idTypeDef *type, const char *name)
Definition: Script_Compiler.cpp:2398
opcode_s::rightAssociative
bool rightAssociative
Definition: Script_Compiler.h:37
gameLocal
idGameLocal gameLocal
Definition: Game_local.cpp:64
def_string
idVarDef def_string
function_t::firstStatement
int firstStatement
Definition: Script_Program.h:80
OP_PUSH_F
Definition: Script_Compiler.h:165
statement_s::c
idVarDef * c
Definition: Script_Program.h:432
OP_USUB_F
Definition: Script_Compiler.h:143
OP_UOR_F
Definition: Script_Compiler.h:146
idTypeDef::SuperClass
idTypeDef * SuperClass(void) const
Definition: Script_Program.cpp:369
type_pointer
idVarDef def_pointer & type_pointer
Definition: Script_Program.cpp:61
idCompiler::ExpectToken
void ExpectToken(const char *string)
Definition: Script_Compiler.cpp:771
OP_AND
Definition: Script_Compiler.h:179
OP_STOREP_V
Definition: Script_Compiler.h:122
idCompiler::ParseType
idTypeDef * ParseType(void)
Definition: Script_Compiler.cpp:890
idCompiler::JumpTo
idVarDef * JumpTo(int jumpto)
Definition: Script_Compiler.cpp:344
idTypeDef::SetFieldType
void SetFieldType(idTypeDef *type)
Definition: Script_Program.cpp:429
OP_MUL_FV
Definition: Script_Compiler.h:58
def_boolean
idVarDef def_boolean
OP_UMUL_F
Definition: Script_Compiler.h:136
idTypeDef::Inherits
bool Inherits(const idTypeDef *basetype) const
Definition: Script_Program.cpp:199
OP_STOREP_FTOBOOL
Definition: Script_Compiler.h:133
TT_LITERAL
#define TT_LITERAL
Definition: Token.h:42
idProgram::NumStatements
int NumStatements(void)
Definition: Script_Program.h:525
ev_field
Definition: Script_Program.h:62
varEval_s::jumpOffset
int jumpOffset
Definition: Script_Program.h:316
OP_STORE_S
Definition: Script_Compiler.h:108
OP_STORE_BOOL
Definition: Script_Compiler.h:110
denominator
INT32 INT32 * denominator
Definition: wglext.h:503
OP_CONTINUE
Definition: Script_Compiler.h:192
idProgram::AllocType
idTypeDef * AllocType(idTypeDef &type)
Definition: Script_Program.cpp:1121
idProgram::GetType
idTypeDef * GetType(idTypeDef &type, bool allocate)
Definition: Script_Program.cpp:1152
idCompiler::CompileFile
void CompileFile(const char *text, const char *filename, bool console)
Definition: Script_Compiler.cpp:2574
OP_EQ_V
Definition: Script_Compiler.h:73
idTimer::Stop
void Stop(void)
Definition: Timer.h:155
idProgram::FindFreeResultDef
idVarDef * FindFreeResultDef(idTypeDef *type, const char *name, idVarDef *scope, const idVarDef *a, const idVarDef *b)
Definition: Script_Program.cpp:1419
def_pointer
idVarDef def_pointer
OP_UDEC_F
Definition: Script_Compiler.h:52
OP_NE_F
Definition: Script_Compiler.h:80
OP_THREAD
Definition: Script_Compiler.h:162
idCompiler::PatchLoop
void PatchLoop(int start, int continuePos)
Definition: Script_Compiler.cpp:1655
def_jumpoffset
idVarDef def_jumpoffset
idCompiler::EmitFunctionParms
idVarDef * EmitFunctionParms(int op, idVarDef *func, int startarg, int startsize, idVarDef *object)
Definition: Script_Compiler.cpp:932
idTypeDef::def
idVarDef * def
Definition: Script_Program.h:118
err
static WindowRef ValidModeCallbackProc inCallback OSStatus err
Definition: PreferencesDialog.cpp:708
type_function
idVarDef def_function & type_function
Definition: Script_Program.cpp:59
statement_s::linenumber
unsigned short linenumber
Definition: Script_Program.h:433
idProgram::FindType
idTypeDef * FindType(const char *name)
Definition: Script_Program.cpp:1177
OP_OBJTHREAD
Definition: Script_Compiler.h:163
idVarDef::SetValue
void SetValue(const eval_t &value, bool constant)
Definition: Script_Program.cpp:657
ev_void
Definition: Script_Program.h:62
id
GLuint id
Definition: glext.h:3103
OP_NOT_BOOL
Definition: Script_Compiler.h:148
OP_MUL_V
Definition: Script_Compiler.h:57
TT_PUNCTUATION
#define TT_PUNCTUATION
Definition: Token.h:45
ev_error
Definition: Script_Program.h:62
eval_s::_float
float _float
Definition: Script_Program.h:90
idCompiler::Divide
float Divide(float numerator, float denominator)
Definition: Script_Compiler.cpp:364
idException::error
char error[MAX_STRING_CHARS]
Definition: Lib.h:152
TILDE_PRIORITY
#define TILDE_PRIORITY
Definition: Script_Compiler.cpp:37
idCompiler::JumpConstant
idVarDef * JumpConstant(int value)
Definition: Script_Compiler.cpp:318
statement_s::b
idVarDef * b
Definition: Script_Program.h:431
idProgram::returnDef
idVarDef * returnDef
Definition: Script_Program.h:475
ev_pointer
Definition: Script_Program.h:62
idCompiler::immediate
eval_t immediate
Definition: Script_Compiler.h:207
name
const GLcharARB * name
Definition: glext.h:3629
OP_OBJECTCALL
Definition: Script_Compiler.h:103
size
GLsizeiptr size
Definition: glext.h:3112
def_argsize
idVarDef def_argsize
idEventDef::GetArgFormat
const char * GetArgFormat(void) const
Definition: Event.h:153
OP_UDIV_F
Definition: Script_Compiler.h:138
ev_function
Definition: Script_Program.h:62
idCompiler::ParseValue
idVarDef * ParseValue(void)
Definition: Script_Compiler.cpp:1255
idStr
Definition: Str.h:116
statement_s::file
unsigned short file
Definition: Script_Program.h:434
idVarDef::Next
idVarDef * Next(void) const
Definition: Script_Program.h:358
OP_STOREP_BOOL
Definition: Script_Compiler.h:126
idParser::SkipBracedSection
int SkipBracedSection(bool parseFirstBrace=true)
Definition: Parser.cpp:2611
idCompiler::ParseEventCall
idVarDef * ParseEventCall(idVarDef *object, idVarDef *func)
Definition: Script_Compiler.cpp:1112
idCompiler::scope
idVarDef * scope
Definition: Script_Compiler.h:218
vsprintf
int vsprintf(idStr &string, const char *fmt, va_list argptr)
Definition: Str.cpp:1549
OP_MUL_VF
Definition: Script_Compiler.h:59
type_argsize
idVarDef def_argsize & type_argsize
Definition: Script_Program.cpp:64
idStr::c_str
const char * c_str(void) const
Definition: Str.h:487
OP_NE_V
Definition: Script_Compiler.h:81
OP_BITAND
Definition: Script_Compiler.h:188
def_function
idVarDef def_function
idCompiler::VirtualFunctionConstant
idVarDef * VirtualFunctionConstant(idVarDef *func)
Definition: Script_Compiler.cpp:284
idCompiler::GetTypeForEventArg
idTypeDef * GetTypeForEventArg(char argType)
Definition: Script_Compiler.cpp:2349
opcode_s::type_a
idVarDef * type_a
Definition: Script_Compiler.h:38
idProgram::returnStringDef
idVarDef * returnStringDef
Definition: Script_Program.h:476
varEval_s::intPtr
int * intPtr
Definition: Script_Program.h:312
idCompiler::Warning
void void Warning(const char *message,...) const id_attribute((format(printf
Definition: Script_Compiler.cpp:266
idCompiler::EmitPush
bool EmitPush(idVarDef *expression, const idTypeDef *funcArg)
Definition: Script_Compiler.cpp:632
varEval_s::argSize
int argSize
Definition: Script_Program.h:318
OP_STOREP_VTOS
Definition: Script_Compiler.h:132
OP_INDIRECT_F
Definition: Script_Compiler.h:93
type_jumpoffset
idVarDef def_jumpoffset & type_jumpoffset
Definition: Script_Program.cpp:63
INT_PRIORITY
#define INT_PRIORITY
Definition: Script_Compiler.cpp:35
OP_UMOD_F
Definition: Script_Compiler.h:140
idProgram::FindFunction
function_t * FindFunction(const char *name) const
Definition: Script_Program.cpp:1452
idTypeDef::PointerType
idTypeDef * PointerType(void) const
Definition: Script_Program.cpp:444
OP_BITOR
Definition: Script_Compiler.h:189
ev_virtualfunction
Definition: Script_Program.h:62
idEventDef::GetReturnType
char GetReturnType(void) const
Definition: Event.h:171
OP_SUB_V
Definition: Script_Compiler.h:70
idCompiler::punctuationValid
static bool punctuationValid[256]
Definition: Script_Compiler.h:199
OP_IFNOT
Definition: Script_Compiler.h:159
TOP_PRIORITY
#define TOP_PRIORITY
Definition: Script_Compiler.cpp:38
va
char * va(const char *fmt,...)
Definition: Str.cpp:1568
OP_STORE_VTOS
Definition: Script_Compiler.h:117
OP_STORE_OBJ
Definition: Script_Compiler.h:112
idProgram::AllocFunction
function_t & AllocFunction(idVarDef *def)
Definition: Script_Program.cpp:1527
RESULT_STRING
const char *const RESULT_STRING
Definition: Script_Compiler.h:31
idVarDef::scope
idVarDef * scope
Definition: Script_Program.h:331
idCompiler::ParseStatement
void ParseStatement(void)
Definition: Script_Compiler.cpp:1932
def_void
idVarDef def_void
OP_BREAK
Definition: Script_Compiler.h:191
D_EVENT_INTEGER
#define D_EVENT_INTEGER
Definition: Event.h:40
ev_boolean
Definition: Script_Program.h:62
ev_entity
Definition: Script_Program.h:62
def_namespace
idVarDef def_namespace
OP_GE
Definition: Script_Compiler.h:89
sprintf
int sprintf(idStr &string, const char *fmt,...)
Definition: Str.cpp:1528
def_float
idVarDef def_float
idCompiler::ParseFunctionDef
void ParseFunctionDef(idTypeDef *returnType, const char *name)
Definition: Script_Compiler.cpp:2114
OP_UDECP_F
Definition: Script_Compiler.h:53
OP_STORE_F
Definition: Script_Compiler.h:106
eval_s::entity
int entity
Definition: Script_Program.h:94
OP_MUL_F
Definition: Script_Compiler.h:56
ev_string
Definition: Script_Program.h:62
start
GLuint start
Definition: glext.h:2845
varEval_s::virtualFunction
int virtualFunction
Definition: Script_Program.h:315
idParser::GetFileName
const char * GetFileName(void) const
Definition: Parser.h:247
function_t::locals
int locals
Definition: Script_Program.h:83
OP_NOT_S
Definition: Script_Compiler.h:151
idVarDef::SetObject
void SetObject(idScriptObject *object)
Definition: Script_Program.cpp:645
idCompiler::ParseSysObjectCall
idVarDef * ParseSysObjectCall(idVarDef *func)
Definition: Script_Compiler.cpp:1139
OP_RETURN
Definition: Script_Compiler.h:48
idTypeDef::FieldType
idTypeDef * FieldType(void) const
Definition: Script_Program.cpp:414
This page is maintained by Wladimir van der Laan. Generated on Mon Nov 17 2014 12:23:19 for doom3-gpl by doxygen 1.8.6.