![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pr_exec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to pr_exec.c CVS log | Up to [Quake] / quake1 |
1.1 ! root 1: ! 2: #include "quakedef.h" ! 3: ! 4: ! 5: /* ! 6: ! 7: */ ! 8: ! 9: typedef struct ! 10: { ! 11: int s; ! 12: dfunction_t *f; ! 13: } prstack_t; ! 14: ! 15: #define MAX_STACK_DEPTH 32 ! 16: prstack_t pr_stack[MAX_STACK_DEPTH]; ! 17: int pr_depth; ! 18: ! 19: #define LOCALSTACK_SIZE 2048 ! 20: int localstack[LOCALSTACK_SIZE]; ! 21: int localstack_used; ! 22: ! 23: ! 24: qboolean pr_trace; ! 25: dfunction_t *pr_xfunction; ! 26: int pr_xstatement; ! 27: ! 28: ! 29: int pr_argc; ! 30: ! 31: char *pr_opnames[] = ! 32: { ! 33: "DONE", ! 34: ! 35: "MUL_F", ! 36: "MUL_V", ! 37: "MUL_FV", ! 38: "MUL_VF", ! 39: ! 40: "DIV", ! 41: ! 42: "ADD_F", ! 43: "ADD_V", ! 44: ! 45: "SUB_F", ! 46: "SUB_V", ! 47: ! 48: "EQ_F", ! 49: "EQ_V", ! 50: "EQ_S", ! 51: "EQ_E", ! 52: "EQ_FNC", ! 53: ! 54: "NE_F", ! 55: "NE_V", ! 56: "NE_S", ! 57: "NE_E", ! 58: "NE_FNC", ! 59: ! 60: "LE", ! 61: "GE", ! 62: "LT", ! 63: "GT", ! 64: ! 65: "INDIRECT", ! 66: "INDIRECT", ! 67: "INDIRECT", ! 68: "INDIRECT", ! 69: "INDIRECT", ! 70: "INDIRECT", ! 71: ! 72: "ADDRESS", ! 73: ! 74: "STORE_F", ! 75: "STORE_V", ! 76: "STORE_S", ! 77: "STORE_ENT", ! 78: "STORE_FLD", ! 79: "STORE_FNC", ! 80: ! 81: "STOREP_F", ! 82: "STOREP_V", ! 83: "STOREP_S", ! 84: "STOREP_ENT", ! 85: "STOREP_FLD", ! 86: "STOREP_FNC", ! 87: ! 88: "RETURN", ! 89: ! 90: "NOT_F", ! 91: "NOT_V", ! 92: "NOT_S", ! 93: "NOT_ENT", ! 94: "NOT_FNC", ! 95: ! 96: "IF", ! 97: "IFNOT", ! 98: ! 99: "CALL0", ! 100: "CALL1", ! 101: "CALL2", ! 102: "CALL3", ! 103: "CALL4", ! 104: "CALL5", ! 105: "CALL6", ! 106: "CALL7", ! 107: "CALL8", ! 108: ! 109: "STATE", ! 110: ! 111: "GOTO", ! 112: ! 113: "AND", ! 114: "OR", ! 115: ! 116: "BITAND", ! 117: "BITOR" ! 118: }; ! 119: ! 120: char *PR_GlobalString (int ofs); ! 121: char *PR_GlobalStringNoContents (int ofs); ! 122: ! 123: ! 124: //============================================================================= ! 125: ! 126: /* ! 127: ================= ! 128: PR_PrintStatement ! 129: ================= ! 130: */ ! 131: void PR_PrintStatement (dstatement_t *s) ! 132: { ! 133: int i; ! 134: ! 135: if ( (unsigned)s->op < sizeof(pr_opnames)/sizeof(pr_opnames[0])) ! 136: { ! 137: Con_Printf ("%s ", pr_opnames[s->op]); ! 138: i = strlen(pr_opnames[s->op]); ! 139: for ( ; i<10 ; i++) ! 140: Con_Printf (" "); ! 141: } ! 142: ! 143: if (s->op == OP_IF || s->op == OP_IFNOT) ! 144: Con_Printf ("%sbranch %i",PR_GlobalString(s->a),s->b); ! 145: else if (s->op == OP_GOTO) ! 146: { ! 147: Con_Printf ("branch %i",s->a); ! 148: } ! 149: else if ( (unsigned)(s->op - OP_STORE_F) < 6) ! 150: { ! 151: Con_Printf ("%s",PR_GlobalString(s->a)); ! 152: Con_Printf ("%s", PR_GlobalStringNoContents(s->b)); ! 153: } ! 154: else ! 155: { ! 156: if (s->a) ! 157: Con_Printf ("%s",PR_GlobalString(s->a)); ! 158: if (s->b) ! 159: Con_Printf ("%s",PR_GlobalString(s->b)); ! 160: if (s->c) ! 161: Con_Printf ("%s", PR_GlobalStringNoContents(s->c)); ! 162: } ! 163: Con_Printf ("\n"); ! 164: } ! 165: ! 166: /* ! 167: ============ ! 168: PR_StackTrace ! 169: ============ ! 170: */ ! 171: void PR_StackTrace (void) ! 172: { ! 173: dfunction_t *f; ! 174: int i; ! 175: ! 176: if (pr_depth == 0) ! 177: { ! 178: Con_Printf ("<NO STACK>\n"); ! 179: return; ! 180: } ! 181: ! 182: pr_stack[pr_depth].f = pr_xfunction; ! 183: for (i=pr_depth ; i>=0 ; i--) ! 184: { ! 185: f = pr_stack[i].f; ! 186: ! 187: if (!f) ! 188: { ! 189: Con_Printf ("<NO FUNCTION>\n"); ! 190: } ! 191: else ! 192: Con_Printf ("%12s : %s\n", pr_strings + f->s_file, pr_strings + f->s_name); ! 193: } ! 194: } ! 195: ! 196: ! 197: /* ! 198: ============ ! 199: PR_Profile_f ! 200: ! 201: ============ ! 202: */ ! 203: void PR_Profile_f (void) ! 204: { ! 205: dfunction_t *f, *best; ! 206: int max; ! 207: int num; ! 208: int i; ! 209: ! 210: num = 0; ! 211: do ! 212: { ! 213: max = 0; ! 214: best = NULL; ! 215: for (i=0 ; i<progs->numfunctions ; i++) ! 216: { ! 217: f = &pr_functions[i]; ! 218: if (f->profile > max) ! 219: { ! 220: max = f->profile; ! 221: best = f; ! 222: } ! 223: } ! 224: if (best) ! 225: { ! 226: if (num < 10) ! 227: Con_Printf ("%7i %s\n", best->profile, pr_strings+best->s_name); ! 228: num++; ! 229: best->profile = 0; ! 230: } ! 231: } while (best); ! 232: } ! 233: ! 234: ! 235: /* ! 236: ============ ! 237: PR_RunError ! 238: ! 239: Aborts the currently executing function ! 240: ============ ! 241: */ ! 242: void PR_RunError (char *error, ...) ! 243: { ! 244: va_list argptr; ! 245: char string[1024]; ! 246: ! 247: va_start (argptr,error); ! 248: vsprintf (string,error,argptr); ! 249: va_end (argptr); ! 250: ! 251: PR_PrintStatement (pr_statements + pr_xstatement); ! 252: PR_StackTrace (); ! 253: Con_Printf ("%s\n", string); ! 254: ! 255: pr_depth = 0; // dump the stack so host_error can shutdown functions ! 256: ! 257: Host_Error ("Program error"); ! 258: } ! 259: ! 260: /* ! 261: ============================================================================ ! 262: PR_ExecuteProgram ! 263: ! 264: The interpretation main loop ! 265: ============================================================================ ! 266: */ ! 267: ! 268: /* ! 269: ==================== ! 270: PR_EnterFunction ! 271: ! 272: Returns the new program statement counter ! 273: ==================== ! 274: */ ! 275: int PR_EnterFunction (dfunction_t *f) ! 276: { ! 277: int i, j, c, o; ! 278: ! 279: pr_stack[pr_depth].s = pr_xstatement; ! 280: pr_stack[pr_depth].f = pr_xfunction; ! 281: pr_depth++; ! 282: if (pr_depth >= MAX_STACK_DEPTH) ! 283: PR_RunError ("stack overflow"); ! 284: ! 285: // save off any locals that the new function steps on ! 286: c = f->locals; ! 287: if (localstack_used + c > LOCALSTACK_SIZE) ! 288: PR_RunError ("PR_ExecuteProgram: locals stack overflow\n"); ! 289: ! 290: for (i=0 ; i < c ; i++) ! 291: localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i]; ! 292: localstack_used += c; ! 293: ! 294: // copy parameters ! 295: o = f->parm_start; ! 296: for (i=0 ; i<f->numparms ; i++) ! 297: { ! 298: for (j=0 ; j<f->parm_size[i] ; j++) ! 299: { ! 300: ((int *)pr_globals)[o] = ((int *)pr_globals)[OFS_PARM0+i*3+j]; ! 301: o++; ! 302: } ! 303: } ! 304: ! 305: pr_xfunction = f; ! 306: return f->first_statement - 1; // offset the s++ ! 307: } ! 308: ! 309: /* ! 310: ==================== ! 311: PR_LeaveFunction ! 312: ==================== ! 313: */ ! 314: int PR_LeaveFunction (void) ! 315: { ! 316: int i, c; ! 317: ! 318: if (pr_depth <= 0) ! 319: Sys_Error ("prog stack underflow"); ! 320: ! 321: // restore locals from the stack ! 322: c = pr_xfunction->locals; ! 323: localstack_used -= c; ! 324: if (localstack_used < 0) ! 325: PR_RunError ("PR_ExecuteProgram: locals stack underflow\n"); ! 326: ! 327: for (i=0 ; i < c ; i++) ! 328: ((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i]; ! 329: ! 330: // up stack ! 331: pr_depth--; ! 332: pr_xfunction = pr_stack[pr_depth].f; ! 333: return pr_stack[pr_depth].s; ! 334: } ! 335: ! 336: ! 337: /* ! 338: ==================== ! 339: PR_ExecuteProgram ! 340: ==================== ! 341: */ ! 342: void PR_ExecuteProgram (func_t fnum) ! 343: { ! 344: eval_t *a, *b, *c; ! 345: int s; ! 346: dstatement_t *st; ! 347: dfunction_t *f, *newf; ! 348: int runaway; ! 349: int i; ! 350: edict_t *ed; ! 351: int exitdepth; ! 352: eval_t *ptr; ! 353: ! 354: if (!fnum || fnum >= progs->numfunctions) ! 355: { ! 356: if (pr_global_struct->self) ! 357: ED_Print (PROG_TO_EDICT(pr_global_struct->self)); ! 358: Host_Error ("PR_ExecuteProgram: NULL function"); ! 359: } ! 360: ! 361: f = &pr_functions[fnum]; ! 362: ! 363: runaway = 100000; ! 364: pr_trace = false; ! 365: ! 366: // make a stack frame ! 367: exitdepth = pr_depth; ! 368: ! 369: s = PR_EnterFunction (f); ! 370: ! 371: while (1) ! 372: { ! 373: s++; // next statement ! 374: ! 375: st = &pr_statements[s]; ! 376: a = (eval_t *)&pr_globals[st->a]; ! 377: b = (eval_t *)&pr_globals[st->b]; ! 378: c = (eval_t *)&pr_globals[st->c]; ! 379: ! 380: if (!--runaway) ! 381: PR_RunError ("runaway loop error"); ! 382: ! 383: pr_xfunction->profile++; ! 384: pr_xstatement = s; ! 385: ! 386: if (pr_trace) ! 387: PR_PrintStatement (st); ! 388: ! 389: switch (st->op) ! 390: { ! 391: case OP_ADD_F: ! 392: c->_float = a->_float + b->_float; ! 393: break; ! 394: case OP_ADD_V: ! 395: c->vector[0] = a->vector[0] + b->vector[0]; ! 396: c->vector[1] = a->vector[1] + b->vector[1]; ! 397: c->vector[2] = a->vector[2] + b->vector[2]; ! 398: break; ! 399: ! 400: case OP_SUB_F: ! 401: c->_float = a->_float - b->_float; ! 402: break; ! 403: case OP_SUB_V: ! 404: c->vector[0] = a->vector[0] - b->vector[0]; ! 405: c->vector[1] = a->vector[1] - b->vector[1]; ! 406: c->vector[2] = a->vector[2] - b->vector[2]; ! 407: break; ! 408: ! 409: case OP_MUL_F: ! 410: c->_float = a->_float * b->_float; ! 411: break; ! 412: case OP_MUL_V: ! 413: c->_float = a->vector[0]*b->vector[0] ! 414: + a->vector[1]*b->vector[1] ! 415: + a->vector[2]*b->vector[2]; ! 416: break; ! 417: case OP_MUL_FV: ! 418: c->vector[0] = a->_float * b->vector[0]; ! 419: c->vector[1] = a->_float * b->vector[1]; ! 420: c->vector[2] = a->_float * b->vector[2]; ! 421: break; ! 422: case OP_MUL_VF: ! 423: c->vector[0] = b->_float * a->vector[0]; ! 424: c->vector[1] = b->_float * a->vector[1]; ! 425: c->vector[2] = b->_float * a->vector[2]; ! 426: break; ! 427: ! 428: case OP_DIV_F: ! 429: c->_float = a->_float / b->_float; ! 430: break; ! 431: ! 432: case OP_BITAND: ! 433: c->_float = (int)a->_float & (int)b->_float; ! 434: break; ! 435: ! 436: case OP_BITOR: ! 437: c->_float = (int)a->_float | (int)b->_float; ! 438: break; ! 439: ! 440: ! 441: case OP_GE: ! 442: c->_float = a->_float >= b->_float; ! 443: break; ! 444: case OP_LE: ! 445: c->_float = a->_float <= b->_float; ! 446: break; ! 447: case OP_GT: ! 448: c->_float = a->_float > b->_float; ! 449: break; ! 450: case OP_LT: ! 451: c->_float = a->_float < b->_float; ! 452: break; ! 453: case OP_AND: ! 454: c->_float = a->_float && b->_float; ! 455: break; ! 456: case OP_OR: ! 457: c->_float = a->_float || b->_float; ! 458: break; ! 459: ! 460: case OP_NOT_F: ! 461: c->_float = !a->_float; ! 462: break; ! 463: case OP_NOT_V: ! 464: c->_float = !a->vector[0] && !a->vector[1] && !a->vector[2]; ! 465: break; ! 466: case OP_NOT_S: ! 467: c->_float = !a->string || !pr_strings[a->string]; ! 468: break; ! 469: case OP_NOT_FNC: ! 470: c->_float = !a->function; ! 471: break; ! 472: case OP_NOT_ENT: ! 473: c->_float = (PROG_TO_EDICT(a->edict) == sv.edicts); ! 474: break; ! 475: ! 476: case OP_EQ_F: ! 477: c->_float = a->_float == b->_float; ! 478: break; ! 479: case OP_EQ_V: ! 480: c->_float = (a->vector[0] == b->vector[0]) && ! 481: (a->vector[1] == b->vector[1]) && ! 482: (a->vector[2] == b->vector[2]); ! 483: break; ! 484: case OP_EQ_S: ! 485: c->_float = !strcmp(pr_strings+a->string,pr_strings+b->string); ! 486: break; ! 487: case OP_EQ_E: ! 488: c->_float = a->_int == b->_int; ! 489: break; ! 490: case OP_EQ_FNC: ! 491: c->_float = a->function == b->function; ! 492: break; ! 493: ! 494: ! 495: case OP_NE_F: ! 496: c->_float = a->_float != b->_float; ! 497: break; ! 498: case OP_NE_V: ! 499: c->_float = (a->vector[0] != b->vector[0]) || ! 500: (a->vector[1] != b->vector[1]) || ! 501: (a->vector[2] != b->vector[2]); ! 502: break; ! 503: case OP_NE_S: ! 504: c->_float = strcmp(pr_strings+a->string,pr_strings+b->string); ! 505: break; ! 506: case OP_NE_E: ! 507: c->_float = a->_int != b->_int; ! 508: break; ! 509: case OP_NE_FNC: ! 510: c->_float = a->function != b->function; ! 511: break; ! 512: ! 513: //================== ! 514: case OP_STORE_F: ! 515: case OP_STORE_ENT: ! 516: case OP_STORE_FLD: // integers ! 517: case OP_STORE_S: ! 518: case OP_STORE_FNC: // pointers ! 519: b->_int = a->_int; ! 520: break; ! 521: case OP_STORE_V: ! 522: b->vector[0] = a->vector[0]; ! 523: b->vector[1] = a->vector[1]; ! 524: b->vector[2] = a->vector[2]; ! 525: break; ! 526: ! 527: case OP_STOREP_F: ! 528: case OP_STOREP_ENT: ! 529: case OP_STOREP_FLD: // integers ! 530: case OP_STOREP_S: ! 531: case OP_STOREP_FNC: // pointers ! 532: ptr = (eval_t *)((byte *)sv.edicts + b->_int); ! 533: ptr->_int = a->_int; ! 534: break; ! 535: case OP_STOREP_V: ! 536: ptr = (eval_t *)((byte *)sv.edicts + b->_int); ! 537: ptr->vector[0] = a->vector[0]; ! 538: ptr->vector[1] = a->vector[1]; ! 539: ptr->vector[2] = a->vector[2]; ! 540: break; ! 541: ! 542: case OP_ADDRESS: ! 543: ed = PROG_TO_EDICT(a->edict); ! 544: #ifdef PARANOID ! 545: NUM_FOR_EDICT(ed); // make sure it's in range ! 546: #endif ! 547: if (ed == (edict_t *)sv.edicts && sv.state == ss_active) ! 548: PR_RunError ("assignment to world entity"); ! 549: c->_int = (byte *)((int *)&ed->v + b->_int) - (byte *)sv.edicts; ! 550: break; ! 551: ! 552: case OP_LOAD_F: ! 553: case OP_LOAD_FLD: ! 554: case OP_LOAD_ENT: ! 555: case OP_LOAD_S: ! 556: case OP_LOAD_FNC: ! 557: ed = PROG_TO_EDICT(a->edict); ! 558: #ifdef PARANOID ! 559: NUM_FOR_EDICT(ed); // make sure it's in range ! 560: #endif ! 561: a = (eval_t *)((int *)&ed->v + b->_int); ! 562: c->_int = a->_int; ! 563: break; ! 564: ! 565: case OP_LOAD_V: ! 566: ed = PROG_TO_EDICT(a->edict); ! 567: #ifdef PARANOID ! 568: NUM_FOR_EDICT(ed); // make sure it's in range ! 569: #endif ! 570: a = (eval_t *)((int *)&ed->v + b->_int); ! 571: c->vector[0] = a->vector[0]; ! 572: c->vector[1] = a->vector[1]; ! 573: c->vector[2] = a->vector[2]; ! 574: break; ! 575: ! 576: //================== ! 577: ! 578: case OP_IFNOT: ! 579: if (!a->_int) ! 580: s += st->b - 1; // offset the s++ ! 581: break; ! 582: ! 583: case OP_IF: ! 584: if (a->_int) ! 585: s += st->b - 1; // offset the s++ ! 586: break; ! 587: ! 588: case OP_GOTO: ! 589: s += st->a - 1; // offset the s++ ! 590: break; ! 591: ! 592: case OP_CALL0: ! 593: case OP_CALL1: ! 594: case OP_CALL2: ! 595: case OP_CALL3: ! 596: case OP_CALL4: ! 597: case OP_CALL5: ! 598: case OP_CALL6: ! 599: case OP_CALL7: ! 600: case OP_CALL8: ! 601: pr_argc = st->op - OP_CALL0; ! 602: if (!a->function) ! 603: PR_RunError ("NULL function"); ! 604: ! 605: newf = &pr_functions[a->function]; ! 606: ! 607: if (newf->first_statement < 0) ! 608: { // negative statements are built in functions ! 609: i = -newf->first_statement; ! 610: if (i >= pr_numbuiltins) ! 611: PR_RunError ("Bad builtin call number"); ! 612: pr_builtins[i] (); ! 613: break; ! 614: } ! 615: ! 616: s = PR_EnterFunction (newf); ! 617: break; ! 618: ! 619: case OP_DONE: ! 620: case OP_RETURN: ! 621: pr_globals[OFS_RETURN] = pr_globals[st->a]; ! 622: pr_globals[OFS_RETURN+1] = pr_globals[st->a+1]; ! 623: pr_globals[OFS_RETURN+2] = pr_globals[st->a+2]; ! 624: ! 625: s = PR_LeaveFunction (); ! 626: if (pr_depth == exitdepth) ! 627: return; // all done ! 628: break; ! 629: ! 630: case OP_STATE: ! 631: ed = PROG_TO_EDICT(pr_global_struct->self); ! 632: ed->v.nextthink = pr_global_struct->time + 0.1; ! 633: if (a->_float != ed->v.frame) ! 634: { ! 635: ed->v.frame = a->_float; ! 636: } ! 637: ed->v.think = b->function; ! 638: break; ! 639: ! 640: default: ! 641: PR_RunError ("Bad opcode %i", st->op); ! 642: } ! 643: } ! 644: ! 645: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.