caosVM_debug.cpp

   1 /*
   2  *  caosVM_debug.cpp
   3  *  openc2e
   4  *
   5  *  Created by Alyssa Milburn on Sun Oct 24 2004.
   6  *  Copyright (c) 2004 Alyssa Milburn. All rights reserved.
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  */
  19
  20 #include "caosVM.h"
  21 #include "openc2e.h"
  22 #include "Agent.h"
  23 #include "World.h"
  24 #include <iostream>
  25 #include "cmddata.h"
  26 #include <cctype>
  27 #include "dialect.h"
  28 #include <algorithm>
  29 #include "caosScript.h"
  30
  31 // #include "malloc.h" <- unportable horror!
  32 #include <sstream>
  33 #include <boost/format.hpp>
  34
  35 using std::cerr;
  36 using std::cout;
  37
  38 /**
  39  DBG: OUTS (command) val (string)
  40  %status maybe
  41  %pragma variants all
  42
  43  Outputs a string to the debug log.
  44 */
  45 void caosVM::c_DBG_OUTS() {
  46         VM_PARAM_STRING(val)
  47
  48         cout << val << std::endl;
  49 }
  50
  51 /**
  52  DBGM (command) val (bareword)
  53  %status maybe
  54  %pragma variants c1 c2
  55  %pragma implementation caosVM::c_DBG_OUTS
  56 */
  57
  58 /**
  59  DBG: OUTV (command) val (decimal)
  60  %status maybe
  61  %pragma variants all
  62
  63  Outputs a decimal value to the debug log.
  64 */
  65 void caosVM::c_DBG_OUTV() {
  66         VM_VERIFY_SIZE(1)
  67         VM_PARAM_VALUE(val)
  68
  69         if (val.hasFloat()) {
  70                 cout << boost::format("%0.06f") % val.getFloat();
  71         } else if (val.hasInt()) {
  72                 cout << val.getInt();
  73         } else if (val.hasVector()) {
  74                 const Vector<float> &v = val.getVector();
  75                 cout << boost::format("(%0.6f, %0.6f)") % v.x % v.y;
  76         } else throw badParamException();
  77
  78         cout << std::endl;
  79 }
  80
  81 /**
  82  DBGV (command) val (integer)
  83  %status maybe
  84  %pragma variants c1 c2
  85  %pragma implementation caosVM::c_DBG_OUTV
  86 */
  87
  88 /**
  89  DBUG (command) val (integer)
  90  %status maybe
  91  %pragma variants c1 c2
  92 */
  93 void caosVM::c_DBUG() {
  94         inst = true;
  95         c_DBG_OUTV();
  96 }
  97
  98 /**
  99  UNID (integer)
 100  %status maybe
 101  %pragma variants c3 cv sm
 102
 103  Returns the unique ID of the target agent.
 104  This is currently no good for persisting.
 105
 106 XXX: when serialization support works, this might well become good for
 107          persisting :)
 108 */
 109 void caosVM::v_UNID() {
 110         VM_VERIFY_SIZE(0)
 111         valid_agent(targ);
 112         result.setInt(targ->getUNID());
 113 }
 114
 115 /**
 116  UNID (agent)
 117  %status maybe
 118  %pragma variants c2
 119  %pragma implementation caosVM::v_UNID_c2
 120
 121  Returns the unique ID of the target agent.
 122  This is currently no good for persisting.
 123 */
 124 void caosVM::v_UNID_c2() {
 125         VM_VERIFY_SIZE(0)
 126         valid_agent(targ);
 127         result.setAgent(targ);
 128 }
 129
 130 /**
 131  AGNT (agent) id (integer)
 132  %status maybe
 133
 134  Returns the agent with the given UNID, or NULL if agent has been deleted.
 135 */
 136 void caosVM::v_AGNT() {
 137         VM_VERIFY_SIZE(1)
 138         VM_PARAM_INTEGER(id)
 139
 140         result.setAgent(world.lookupUNID(id));
 141 }
 142
 143 /**
 144  DBG: MALLOC (command)
 145  %status stub
 146
 147  Dumps some random memory stats to stderr.
 148 */
 149 void caosVM::c_DBG_MALLOC() {
 150         VM_VERIFY_SIZE(0)
 151
 152         // more unportable horror!
 153 /*      struct mallinfo mi = mallinfo();
 154 #define MPRINT(name) \
 155         fprintf(stderr, "%10s = %d\n", #name, mi. name)
 156         MPRINT(arena);
 157         MPRINT(ordblks);
 158         MPRINT(smblks);
 159         MPRINT(hblks);
 160         MPRINT(hblkhd);
 161         MPRINT(usmblks);
 162         MPRINT(fsmblks);
 163         MPRINT(uordblks);
 164         MPRINT(fordblks);
 165         MPRINT(keepcost);
 166         malloc_stats(); */
 167
 168         /*std::cerr << "caosSlab free=" << caosVarSlab.free_elements() <<
 169                                  " used=" << caosVarSlab.used_elements() <<
 170                                  " total=" << caosVarSlab.total_elements() <<
 171                                  std::endl;*/
 172 }
 173
 174 /**
 175  DBG: DUMP (command)
 176  %status ok
 177  %pragma variants all
 178
 179  Dumps the current script's bytecode to stderr.
 180 */
 181 void caosVM::c_DBG_DUMP() {
 182         std::cerr << vm->currentscript->dump();
 183 }
 184
 185 /**
 186  DBG: TRACE (command) level (integer)
 187  %status ok
 188  %pragma variants all
 189
 190  Sets opcode trace level. Zero disables.
 191 */
 192 void caosVM::c_DBG_TRACE() {
 193         VM_PARAM_INTEGER(en)
 194
 195         std::cerr << "trace: " << en << std::endl;
 196         vm->trace = en;
 197         if (vm->trace < 0)
 198                 vm->trace = 0;
 199 }
 200
 201 /**
 202  MANN (command) cmd (string)
 203  %status stub
 204
 205  Looks up documentation on the given command and spits it on the current output stream.
 206 */
 207 void caosVM::c_MANN() {
 208         VM_PARAM_STRING(cmd)
 209
 210         caos_assert(outputstream);
 211
 212         std::transform(cmd.begin(), cmd.end(), cmd.begin(), toupper);
 213         const cmdinfo *i = currentscript->dialect->cmdbase();
 214
 215         bool found = false;
 216         while (i->lookup_key) {
 217                 // TODO: this doesn't work for FACE at the moment due to hack elsewhere
 218                 if (cmd == i->fullname) {
 219                         found = true;
 220                         std::string d = i->docs;
 221                         // TODO: docs should always include name/parameters/etc, so should never be empty
 222                         if (d.size())
 223                                 *outputstream << std::string(i->docs) << std::endl;
 224                         else
 225                                 *outputstream << "no documentation for " << cmd << std::endl << std::endl;
 226                 }
 227
 228                 i++;
 229         }
 230
 231         if (!found) {
 232                 *outputstream << "didn't find " << cmd << std::endl;
 233                 return;
 234         }
 235 }
 236
 237 /**
 238  DBG: DISA (command) family (integer) genus (integer) species (integer) event (integer)
 239  %pragma variants all
 240  %status ok
 241
 242  Dumps the "bytecode" of the indicated script to the current output channel.
 243  Note that this isn't really bytecode yet (though that's a possible future
 244  improvement).
 245
 246  If the script is not found no output will be generated.
 247  */
 248 void caosVM::c_DBG_DISA() {
 249         VM_PARAM_INTEGER(event)
 250         VM_PARAM_INTEGER(species)
 251         VM_PARAM_INTEGER(genus)
 252         VM_PARAM_INTEGER(family)
 253
 254         caos_assert(outputstream);
 255
 256         shared_ptr<script> s = world.scriptorium.getScript(family, genus, species, event);
 257         if (s) {
 258                 if (s->fmly != family || s->gnus != genus || s->spcs != species) {
 259                         *outputstream << "warning: search resulted in script from " << s->fmly << ", " << s->gnus << ", " << s->spcs << " script" << std::endl;
 260                 }
 261                 *outputstream << s->dump();
 262         } else
 263                 *outputstream << "no such script" << std::endl;
 264 }
 265
 266 /**
 267  DBG: ASRT (command) condition (condition)
 268  %pragma parser new AssertParser()
 269  %pragma variants all
 270  %status maybe
 271
 272  Blows up unless the given condition is true.
 273 */
 274 void caosVM::c_DBG_ASRT() {
 275         throw caosException("DBG: ASRT condition failed");
 276 }
 277
 278 /**
 279  DBG: IDNT (string) agent (agent)
 280  %status ok
 281  %pragma variants all
 282
 283  (openc2e-only)
 284  Return a nicely-formatted string identifying the classifier of the agent,
 285  using the catalogue to find the name if possible.
 286 */
 287 void caosVM::v_DBG_IDNT() {
 288         VM_PARAM_AGENT(a)
 289
 290         if (!a)
 291                 result.setString("(null)");
 292         else
 293                 result.setString(a->identify());
 294 }
 295
 296 /**
 297  DBG: PROF (command)
 298  %status stub
 299
 300  Dumps the current agent profiling information to the output stream, in CSV format.
 301 */
 302 void caosVM::c_DBG_PROF() {
 303         // TODO
 304 }
 305
 306 /**
 307  DBG: CPRO (command)
 308  %status stub
 309
 310  Clears the current agent profiling information.
 311 */
 312 void caosVM::c_DBG_CPRO() {
 313         // TODO
 314 }
 315
 316 /**
 317  DBG: STOK (string) bareword (bareword)
 318  %status ok
 319  %pragma variants all
 320
 321  Returns the bare token in 'bareword' as a string.
 322 */
 323 void caosVM::v_DBG_STOK() {
 324         VM_PARAM_STRING(bareword)
 325
 326         result.setString(bareword);
 327 }
 328
 329 /**
 330  DBG: TSLC (command) timeslice (integer)
 331  %status ok
 332  %pragma variants all
 333  %cost 0
 334
 335  Sets the currently executing script's remaining timeslice value. This command
 336  affects only the current timeslice; future slices use the normal amount for
 337  the dialect in question.
 338 */
 339 void caosVM::c_DBG_TSLC() {
 340         VM_PARAM_INTEGER(tslc);
 341         timeslice = tslc;
 342 }
 343
 344 /**
 345  DBG: TSLC (integer)
 346  %status ok
 347  %pragma variants all
 348
 349  Returns the number of ticks left in the current script's remaining timeslice.
 350 */
 351 void caosVM::v_DBG_TSLC() {
 352         result.setInt(timeslice);
 353 }
 354
 355
 356 /* vim: set noet: */