New idea for a QC debug tool

[Cobalt]

This is an idea to assign a .string to an ent such as a player, which will enlarge via strcat(), and represent from start to finish - all the functions the entity runs from prethink to postthink....for purposes of debugging.

I had been using the .message default string for this during my tests, for example, if we are doing CheckPowerups () , the .message is something like "Checkpowerups()". However when we go to the next call, the string got overwritten bu the new function.

I am very bad with strzone (I forget to unzone) , and I know this would be using a combo of that + strcat , and in Darkplaces we have some ability to check a string for matching text etc. Im also unsure how long a .string is allowed to be in QC, if there is a limit or whatever? I am vaguely aware of what some other similar built ins like trace_on can do, but Im not aware of any that are entity specific...

any comments / ideas / feedback?

[frag.machine]

strzone/strunzone, while really useful, are a pain in the arse to work.
The safest way I found to work if this duo was this:

Code: Select all

void (char text) appendToMessage =
{
  local string mesg;

  if (self.message)
  {
    mesg = strzone (strcat (self.message, text));
    strunzone (self.message);
    self.message = mesg;
  }
  else
  {
    self.message = strzone (text);
  }
};


By default, strings are limited to 8k in Darkplaces (not sure if this values applies to FTE too). You may find this a really small limit for trace functions called from inside a loop, for example.

EDIT: a really nice feature would be a stack trace printing in the same way you find in the Java VM. Something like this, for example:

Code: Select all

Assignment to world entity
  at PutClientInServer (client.qc:389)
  at foobarFunction1 (foobar.qc:1234)
  at foobarFunction2 (foobar.qc:4321)


But I suppose this would also require changes in the progs.dat file format to store more metadata.

[Spike]

void (char text) appendToMessage =
{
text = strzone(strcat(self.message, text));
if (self.message) strunzone (self.message);
self.message = text;
};

actually, due to a few fte quirks, you could actually write it like this in fte:
void (char text) appendToMessage =
{
strunzone (self.message);
self.message = strzone(self.message, text);
};
but hey... use-after-free is kinda evil even if its (currently) reliable, so I don't really recommend shortening it like that.
on the plus side, combining the strzone and strcat avoids the tempstring memory explosion...
side note: strzone, strcat, strstrofs, substring have no length limit in fte. This doesn't apply to all builtins, so you might need to use substring to chop them up first before using other builtins. :s

fteqcc generates .lno files. these files contain a statement->line number lookup table for more usable stack traces.
the 'error' builtin will print out a stack trace including these line numbers if they are available.

trace_on can be entity specific in that your QC can explicitly enable it via code as the first part of each function, and can call trace_off before calling code relevent only to other entities.
(FTE will present its line-by-line debugger if you use the trace_on command, as it does with certain other debug events, so long as the debugger cvar is set).