/* Run Info: Persistant information of the callgrind run */
static Int dump_info(Int fd)
{
Char* buf = outbuf;
int i;
if ( (fd = createRes(fd)) <0) return fd;
/* creator */
VG_(sprintf)(buf, "creator: callgrind-" VERSION "\n");
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* version */
VG_(sprintf)(buf, "version: " COMMAND_VERSION "\n");
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* "pid:" line */
VG_(sprintf)(buf, "pid: %d\n", VG_(getpid)());
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* "base:" line */
WRITE_STR3(fd, "base: ", out_file, "\n");
/* "cmd:" line */
WRITE_STR2(fd, "cmd: ", VG_(args_the_exename));
for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
HChar* arg = * (HChar**)VG_(indexXA)( VG_(args_for_client), i );
if (!arg) continue;
WRITE_STR2(fd, " ", arg);
}
VG_(write)(fd, "\n", 1);
return fd;
}
void Map::moveObj(int x, int y, ResType res, int nb)
{
unsigned int i;
Player *p;
bool ok;
GameObject *obj;
ok = false;
i = 0;
while (i < _players.size() && ok == false)
{
p = dynamic_cast<Player *>(_players[i]);
if (p)
{
if (p->getNb() == nb)
ok = true;
}
i++;
}
if (ok == true)
{
obj = createRes(res, x, y);
p->addObj(obj);
if ((*_spots[x])[y]->delRes(res))
std::cout << "Player " << nb << " took res n°" << res << std::endl;
else
std::cout << "Player " << nb << " tried to took res n°" << res << ", but he failed." << std::endl;
}
}
void CLG_(check_command)()
{
/* check for dumps needed */
static Char buf[512];
static Char cmdBuffer[512];
Char *cmdPos = 0, *cmdNextLine = 0;
Int fd, bytesRead = 0, do_kill = 0;
SysRes res;
Int currentPID;
static Int check_counter = 0;
/* Check for PID change, i.e. whether we run as child after a fork.
* If yes, we setup interactive control for the new process
*/
currentPID = VG_(getpid)();
if (thisPID != currentPID) {
thisPID = currentPID;
setup_control();
}
/* Toggle between 2 command files, with/without ".pid" postfix
* (needed for compatibility with KCachegrind, which wants to trigger
* a dump by writing into a command file without the ".pid" postfix)
*/
check_counter++;
if (check_counter % 2) {
current_command_file = command_file;
current_result_file = result_file;
}
else {
current_command_file = command_file2;
current_result_file = result_file2;
}
res = VG_(open)(current_command_file, VKI_O_RDONLY,0);
if (!res.isError) {
fd = (Int) res.res;
bytesRead = VG_(read)(fd,cmdBuffer,500);
cmdBuffer[500] = 0; /* no command overrun please */
VG_(close)(fd);
/* don't delete command file on read error (e.g. EAGAIN) */
if (bytesRead>0) {
cmdPos = cmdBuffer;
}
}
/* force creation of result file if needed */
fd = -2;
while((bytesRead>0) && *cmdPos) {
/* Calculate pointer for next line */
cmdNextLine = cmdPos+1;
while((bytesRead>0) && *cmdNextLine && (*cmdNextLine != '\n')) {
cmdNextLine++;
bytesRead--;
}
if ((bytesRead>0) && (*cmdNextLine == '\n')) {
*cmdNextLine = 0;
cmdNextLine++;
bytesRead--;
}
/* Command with integer option */
if ((*cmdPos >= '0') && (*cmdPos <='9')) {
int value = *cmdPos-'0';
cmdPos++;
while((*cmdPos >= '0') && (*cmdPos <='9')) {
value = 10*value + (*cmdPos-'0');
cmdPos++;
}
while((*cmdPos == ' ') || (*cmdPos == '\t')) cmdPos++;
switch(*cmdPos) {
#if CLG_ENABLE_DEBUG
/* verbosity */
case 'V':
case 'v':
CLG_(clo).verbose = value;
break;
#endif
default:
break;
}
cmdPos = cmdNextLine;
continue;
}
/* Command with boolean/switch option */
if ((*cmdPos=='+') ||
(*cmdPos=='-')) {
int value = (cmdPos[0] == '+');
cmdPos++;
while((*cmdPos == ' ') || (*cmdPos == '\t')) cmdPos++;
switch(*cmdPos) {
case 'I':
case 'i':
CLG_(set_instrument_state)("Command", value);
break;
default:
break;
}
cmdPos = cmdNextLine;
continue;
}
/* regular command */
switch(*cmdPos) {
case 'D':
case 'd':
/* DUMP */
/* skip command */
while(*cmdPos && (*cmdPos != ' ')) cmdPos++;
if (*cmdPos)
VG_(sprintf)(buf, "Dump Command:%s", cmdPos);
else
VG_(sprintf)(buf, "Dump Command");
CLG_(dump_profile)(buf, False);
break;
case 'Z':
case 'z':
CLG_(zero_all_cost)(False);
break;
case 'K':
case 'k':
/* Kill: Delay to be able to remove command file before. */
do_kill = 1;
break;
case 'I':
case 'i':
fd = dump_info(fd);
break;
case 's':
case 'S':
fd = dump_state(fd);
break;
case 'O':
case 'o':
/* Options Info */
if ( (fd = createRes(fd)) <0) break;
VG_(sprintf)(buf, "\ndesc: Option: --skip-plt=%s\n",
CLG_(clo).skip_plt ? "yes" : "no");
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "desc: Option: --collect-jumps=%s\n",
CLG_(clo).collect_jumps ? "yes" : "no");
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "desc: Option: --separate-recs=%d\n",
CLG_(clo).separate_recursions);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "desc: Option: --separate-callers=%d\n",
CLG_(clo).separate_callers);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
break;
default:
break;
}
cmdPos = cmdNextLine;
}
/* If command executed, delete command file */
if (cmdPos) VG_(unlink)(current_command_file);
if (fd>=0) VG_(close)(fd);
if (do_kill) {
VG_(message)(Vg_UserMsg,
"Killed because of command from %s", current_command_file);
CLG_(fini)(0);
VG_(exit)(1);
}
}
/* Dump info on current callgrind state */
static Int dump_state(Int fd)
{
Char* buf = outbuf;
thread_info** th;
int t, p;
Int orig_tid = CLG_(current_tid);
if ( (fd = createRes(fd)) <0) return fd;
VG_(sprintf)(buf, "instrumentation: %s\n",
CLG_(instrument_state) ? "on":"off");
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
if (!CLG_(instrument_state)) return fd;
VG_(sprintf)(buf, "executed-bbs: %llu\n", CLG_(stat).bb_executions);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "executed-calls: %llu\n", CLG_(stat).call_counter);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "distinct-bbs: %d\n", CLG_(stat).distinct_bbs);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "distinct-calls: %d\n", CLG_(stat).distinct_jccs);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "distinct-functions: %d\n", CLG_(stat).distinct_fns);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(sprintf)(buf, "distinct-contexts: %d\n", CLG_(stat).distinct_contexts);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* "events:" line. Given here because it will be dynamic in the future */
p = VG_(sprintf)(buf, "events: ");
CLG_(sprint_eventmapping)(buf+p, CLG_(dumpmap));
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
VG_(write)(fd, "\n", 1);
/* "part:" line (number of last part. Is 0 at start */
VG_(sprintf)(buf, "\npart: %d\n", CLG_(get_dump_counter)());
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* threads */
th = CLG_(get_threads)();
p = VG_(sprintf)(buf, "threads:");
for(t=1;t<VG_N_THREADS;t++) {
if (!th[t]) continue;
p += VG_(sprintf)(buf+p, " %d", t);
}
p += VG_(sprintf)(buf+p, "\n");
VG_(write)(fd, (void*)buf, p);
VG_(sprintf)(buf, "current-tid: %d\n", orig_tid);
VG_(write)(fd, (void*)buf, VG_(strlen)(buf));
/* current event counters */
dump_fd = fd;
CLG_(forall_threads)(dump_state_of_thread);
return fd;
}
