]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - prvm_execprogram.h
r_showsurfaces 3 "eeepc mode": support blend funcs
[xonotic/darkplaces.git] / prvm_execprogram.h
index aa79fdb3648c4966f3e7dda0d79c8bbd866aa597..38a13859ea42779380240e0373ae71a65313c7ce 100644 (file)
                                OPC->vector[2] = OPB->_float * OPA->vector[2];
                                break;
                        case OP_DIV_F:
-                               OPC->_float = OPA->_float / OPB->_float;
+                               if( OPB->_float != 0.0f )
+                               {
+                                       OPC->_float = OPA->_float / OPB->_float;
+                               }
+                               else
+                               {
+                                       if( developer.integer >= 1 )
+                                       {
+                                               prog->xfunction->profile += (st - startst);
+                                               startst = st;
+                                               prog->xstatement = st - prog->statements;
+                                               VM_Warning( "Attempted division by zero in %s\n", PRVM_NAME );
+                                       }
+                                       OPC->_float = 0.0f;
+                               }
                                break;
                        case OP_BITAND:
                                OPC->_float = (int)OPA->_float & (int)OPB->_float;
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("%s attempted to write to an out of bounds edict (%i)", PRVM_NAME, OPB->_int);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ptr = (prvm_eval_t *)((unsigned char *)prog->edictsfields + OPB->_int);
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("%s attempted to write to an out of bounds edict (%i)", PRVM_NAME, OPB->_int);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ptr = (prvm_eval_t *)((unsigned char *)prog->edictsfields + OPB->_int);
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("%s attempted to address an invalid field (%i) in an edict", PRVM_NAME, OPB->_int);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                if (OPA->edict == 0 && !prog->allowworldwrites)
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("forbidden assignment to null/world entity in %s", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                OPC->_int = (unsigned char *)((int *)ed->fields.vp + OPB->_int) - (unsigned char *)prog->edictsfields;
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("%s attempted to read an invalid field in an edict (%i)", PRVM_NAME, OPB->_int);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR("%s attempted to read an invalid field in an edict (%i)", PRVM_NAME, OPB->_int);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                        prog->xfunction->profile += (st - startst);
                                        st += st->b - 1;        // offset the s++
                                        startst = st;
-                                       if (++jumpcount> 1000000)
+                                       if (++jumpcount == 10000000)
                                        {
                                                prog->xstatement = st - prog->statements;
-                                               PRVM_ERROR("runaway loop counter hit limit of %d jumps\ntip: if having trouble identifying the problem, try typing profile now in %s", jumpcount, PRVM_NAME);
+                                               PRVM_Profile(1<<30, 1000000);
+                                               PRVM_ERROR("%s runaway loop counter hit limit of %d jumps\ntip: read above for list of most-executed functions", PRVM_NAME, jumpcount);
                                        }
                                }
                                break;
                                        prog->xfunction->profile += (st - startst);
                                        st += st->b - 1;        // offset the s++
                                        startst = st;
-                                       if (++jumpcount> 1000000)
+                                       if (++jumpcount == 10000000)
                                        {
                                                prog->xstatement = st - prog->statements;
-                                               PRVM_ERROR("runaway loop counter hit limit of %d jumps\ntip: if having trouble identifying the problem, try typing profile now in %s", jumpcount, PRVM_NAME);
+                                               PRVM_Profile(1<<30, 1000000);
+                                               PRVM_ERROR("%s runaway loop counter hit limit of %d jumps\ntip: read above for list of most-executed functions", PRVM_NAME, jumpcount);
                                        }
                                }
                                break;
                                prog->xfunction->profile += (st - startst);
                                st += st->a - 1;        // offset the s++
                                startst = st;
-                               if (++jumpcount> 1000000)
+                               if (++jumpcount == 10000000)
                                {
                                        prog->xstatement = st - prog->statements;
-                                       PRVM_ERROR("runaway loop counter hit limit of %d jumps\ntip: if having trouble identifying the problem, try typing profile now in %s", jumpcount, PRVM_NAME);
+                                       PRVM_Profile(1<<30, 1000000);
+                                       PRVM_ERROR("%s runaway loop counter hit limit of %d jumps\ntip: read above for list of most-executed functions", PRVM_NAME, jumpcount);
                                }
                                break;
 
                                        if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
                                                prog->builtins[builtinnumber]();
                                        else
-                                               PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
+                                               PRVM_ERROR("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, PRVM_NAME);
                                }
                                else
                                        st = prog->statements + PRVM_EnterFunction(newf);
                                st = prog->statements + PRVM_LeaveFunction();
                                startst = st;
                                if (prog->depth <= exitdepth)
-                                       return;         // all done
+                                       goto cleanup; // all done
                                if (prog->trace != cachedpr_trace)
                                        goto chooseexecprogram;
                                break;
                        case OP_STATE:
                                if(prog->flag & PRVM_OP_STATE)
                                {
-                                       ed = PRVM_PROG_TO_EDICT(PRVM_G_INT(prog->self->ofs));
-                                       PRVM_E_FLOAT(ed,PRVM_ED_FindField ("nextthink")->ofs) = *prog->time + 0.1;
-                                       PRVM_E_FLOAT(ed,PRVM_ED_FindField ("frame")->ofs) = OPA->_float;
-                                       *(func_t *)((float*)ed->fields.vp + PRVM_ED_FindField ("think")->ofs) = OPB->function;
+                                       ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict);
+                                       PRVM_EDICTFIELDVALUE(ed,prog->fieldoffsets.nextthink)->_float = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.time)->_float + 0.1;
+                                       PRVM_EDICTFIELDVALUE(ed,prog->fieldoffsets.frame)->_float = OPA->_float;
+                                       PRVM_EDICTFIELDVALUE(ed,prog->fieldoffsets.think)->function = OPB->function;
                                }
                                else
                                {
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to write to an out of bounds edict", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ptr = (prvm_eval_t *)((unsigned char *)prog->edictsfields + OPB->_int);
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to read an out of bounds edict number", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
                                if (OPB->_int < 0 || OPB->_int >= progs->entityfields)
                                {
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to read an invalid field in an edict", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to write to an invalid indexed global", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                pr_globals[OPB->_int] = OPA->_float;
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to write to an invalid indexed global", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                pr_globals[OPB->_int  ] = OPA->vector[0];
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to address an out of bounds global", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                OPC->_float = pr_globals[i];
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to read an invalid indexed global", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                OPC->_float = pr_globals[OPA->_int];
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs attempted to read an invalid indexed global", PRVM_NAME);
-                                       return;
+                                       goto cleanup;
                                }
 #endif
                                OPC->vector[0] = pr_globals[OPA->_int  ];
                                        prog->xfunction->profile += (st - startst);
                                        prog->xstatement = st - prog->statements;
                                        PRVM_ERROR ("%s Progs boundcheck failed at line number %d, value is < 0 or >= %d", PRVM_NAME, st->b, st->c);
-                                       return;
+                                       goto cleanup;
                                }
                                break;
 
                                prog->xfunction->profile += (st - startst);
                                prog->xstatement = st - prog->statements;
                                PRVM_ERROR ("Bad opcode %i in %s", st->op, PRVM_NAME);
+                               goto cleanup;
                        }
                }