nel/src/misc/command.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010-2019  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21
  22 #include "nel/misc/command.h"
  23 #include "nel/misc/algo.h"
  24
  25 using namespace std;
  26 using namespace NLMISC;
  27
  28 #ifdef DEBUG_NEW
  29         #define new DEBUG_NEW
  30 #endif
  31
  32 namespace NLMISC {
  33
  34 //ICommand::TCategorySet* ICommand::_Categories;
  35 ICommand::TCommand *ICommand::LocalCommands = NULL;
  36 bool ICommand::LocalCommandsInit = false;
  37 //set<std::string>              ICommand::_CommandsDisablingControlChar;
  38
  39 NLMISC_SAFE_SINGLETON_IMPL(CCommandRegistry);
  40
  41 ICommand::ICommand(const char *categoryName, const char *commandName, const char *commandHelp, const char *commandArgs)
  42 {
  43         // self registration
  44
  45         if (!LocalCommandsInit)
  46         {
  47                 LocalCommands = new TCommand;
  48                 LocalCommandsInit = true;
  49         }
  50
  51         TCommand::iterator comm = LocalCommands->find(commandName);
  52
  53         if (comm != LocalCommands->end ())
  54         {
  55                 nlinfo("command with same name: %s", commandName);
  56                 // 2 commands have the same name
  57                 // nlstopex (("There are 2 commands that have the same name in the project (command name '%s'), skip the second definition", commandName));
  58         }
  59         else
  60         {
  61                 // insert the new command in the map
  62                 //nlinfo ("add command '%s'", commandName);
  63                 CategoryName = categoryName;
  64                 HelpString = commandHelp;
  65                 CommandArgs = commandArgs;
  66                 _CommandName = commandName;
  67                 Type = Command;
  68                 (*LocalCommands)[commandName] = this;
  69         }
  70
  71         if (INelContext::isContextInitialised())
  72         {
  73                 // directly register this command
  74                 CCommandRegistry::getInstance().registerCommand(this);
  75         }
  76 }
  77
  78 ICommand::~ICommand()
  79 {
  80         // self deregistration
  81
  82         // find the command
  83
  84         for (TCommand::iterator comm = LocalCommands->begin(); comm != LocalCommands->end(); comm++)
  85         {
  86                 if ((*comm).second == this)
  87                 {
  88                         //printf("remove command\n");
  89                         LocalCommands->erase (comm);
  90
  91                         // delete local commands if all gone
  92                         if (!LocalCommands->size())
  93                         {
  94                                 delete LocalCommands;
  95                                 LocalCommands = NULL;
  96                                 LocalCommandsInit = false;
  97                         }
  98
  99                         // Yoyo: if no nlinfo()/nlwarning() (thus no createDebug(), thus no new CApplicationContext)
 100                         // done in the .dll, it is possible that the nel context is never initialized
 101                         if (INelContext::isContextInitialised())
 102                         {
 103                                 CCommandRegistry::getInstance().unregisterCommand(this);
 104                         }
 105
 106
 107                         return;
 108                 }
 109         }
 110         // commands is not found
 111 //      nlstop;
 112 }
 113
 114 void CCommandRegistry::registerCommand(ICommand *command)
 115 {
 116         if (_Commands.find(command->getName()) != _Commands.end())
 117         {
 118 //              nlwarning("There are 2 commands that have the same name in the project (command name '%s'), skip the second definition", command->getName().c_str());
 119                 return;
 120         }
 121         _Commands[command->getName()] = command;
 122         _Categories.insert(command->CategoryName);
 123 }
 124
 125 void CCommandRegistry::unregisterCommand(ICommand *command)
 126 {
 127         for (TCommand::iterator comm = _Commands.begin(); comm != _Commands.end(); ++comm)
 128         {
 129                 if (comm->second == command)
 130                 {
 131                         //printf("remove command\n");
 132                         _Commands.erase (comm);
 133                         return;
 134                 }
 135         }
 136         //nlwarning("CCommandRegistry::unregisterCommand : the command '%s' is not registered", command->getName().c_str());
 137 }
 138
 139 void CCommandRegistry::registerNamedCommandHandler(ICommandsHandler *handler, const std::string &className)
 140 {
 141         const std::string &name = handler->getCommandHandlerName();
 142         if (_CommandsHandlers.getB(name) != NULL)
 143         {
 144                 nlwarning("CCommandRegistry : a commands handler with the name '%s' already exist, ignoring new candidat", name.c_str());
 145                 return;
 146         }
 147         _CommandsHandlers.add(name, handler);
 148
 149         TCommandsHandlersClass::iterator it = _CommandsHandlersClass.find(className);
 150
 151         if (it == _CommandsHandlersClass.end())
 152         {
 153                 nlinfo("CCommandRegistry : adding commands handler for class '%s'", className.c_str());
 154         }
 155
 156         // register the class and commands name
 157         TCommandHandlerClassInfo &chci = _CommandsHandlersClass[className];
 158
 159         // add an instance to the counter
 160         ++chci.InstanceCount;
 161         // store the command list
 162         TCommandHandlerClassInfo::TCommandsInfo commands;
 163         handler->fillCommandsHandlerList(commands);
 164         nlassert(chci._Commands.empty() || chci._Commands == commands);
 165
 166         if (chci._Commands.empty())
 167                 std::swap(chci._Commands, commands);
 168
 169 }
 170
 171 void CCommandRegistry::unregisterNamedCommandHandler(ICommandsHandler *handler, const std::string &className)
 172 {
 173         if (_CommandsHandlers.getA(handler) == NULL)
 174                 return;
 175
 176         _CommandsHandlers.removeWithB(handler);
 177
 178         // update the handler class commands tables
 179         TCommandsHandlersClass::iterator it = _CommandsHandlersClass.find(className);
 180         if (it != _CommandsHandlersClass.end())
 181         {
 182                 --(it->second.InstanceCount);
 183
 184                 if (it->second.InstanceCount == 0)
 185                 {
 186                         nlinfo("CCommandRegistry : removing commands handler for class '% s'", className.c_str());
 187                         _CommandsHandlersClass.erase(it);
 188                 }
 189         }
 190 }
 191
 192
 193 bool ICommand::execute (const std::string &commandWithArgs, CLog &log, bool quiet, bool human)
 194 {
 195         try
 196         {
 197                 return CCommandRegistry::getInstance().execute(commandWithArgs, log, quiet, human);
 198         }
 199         catch(const exception &e)
 200         {
 201                 log.displayNL("Command '%s' thrown an exception :", commandWithArgs.c_str());
 202                 log.displayNL(e.what());
 203
 204                 return false;
 205         }
 206 }
 207
 208 struct TCommandParams
 209 {
 210         string                  CommandName;
 211         string                  RawCommandString;
 212         vector<string>  CommandArgs;
 213 };
 214
 215 bool CCommandRegistry::execute (const std::string &commandWithArgs, CLog &log, bool quiet, bool human)
 216 {
 217         if (!quiet)
 218         {
 219                 log.displayNL ("Executing command : '%s'", commandWithArgs.c_str());
 220         }
 221
 222         // true to indicate that '"', ';' and '\' are special character sequence control
 223         bool allowControlChar= true;
 224         // Start of each command in the command line
 225         string::size_type commandBegin = 0;
 226
 227         // convert the buffer into string vector
 228         vector<TCommandParams>  commands;
 229         bool firstArg = true;
 230         uint i = 0;
 231         for(;;)
 232         {
 233                 // skip whitespace
 234                 for(;;)
 235                 {
 236                         if (i == commandWithArgs.size())
 237                         {
 238                                 goto end;
 239                         }
 240                         if (commandWithArgs[i] != ' ' && commandWithArgs[i] != '\t' && commandWithArgs[i] != '\n' && commandWithArgs[i] != '\r')
 241                         {
 242                                 break;
 243                         }
 244                         i++;
 245                 }
 246
 247                 // get param
 248                 string arg;
 249                 if (allowControlChar && commandWithArgs[i] == '\"')
 250                 {
 251                         // starting with a quote "
 252                         i++;
 253                         for(;;)
 254                         {
 255                                 if (i == commandWithArgs.size())
 256                                 {
 257                                         if (!quiet) log.displayNL ("Missing end quote character \"");
 258                                         return false;
 259                                 }
 260                                 if (commandWithArgs[i] == '"')
 261                                 {
 262                                         i++;
 263                                         break;
 264                                 }
 265                                 if (commandWithArgs[i] == '\\')
 266                                 {
 267                                         // manage escape char backslash
 268                                         i++;
 269                                         if (i == commandWithArgs.size())
 270                                         {
 271                                                 if (!quiet) log.displayNL ("Missing character after the backslash \\ character");
 272                                                 return false;
 273                                         }
 274                                         switch (commandWithArgs[i])
 275                                         {
 276                                                 case '\\':      arg += '\\'; break; // double backslash
 277                                                 case 'n':       arg += '\n'; break; // new line
 278                                                 case '"':       arg += '"'; break; // "
 279                                                 default:
 280                                                         if (!quiet) log.displayNL ("Unknown escape code '\\%c'", commandWithArgs[i]);
 281                                                         return false;
 282                                         }
 283                                         i++;
 284                                 }
 285                                 else
 286                                 {
 287                                         arg += commandWithArgs[i++];
 288                                 }
 289                         }
 290                 }
 291                 else
 292                 {
 293                         // normal word
 294                         for(;;)
 295                         {
 296                                 if (allowControlChar && commandWithArgs[i] == '\\')
 297                                 {
 298                                         // manage escape char backslash
 299                                         i++;
 300                                         if (i == commandWithArgs.size())
 301                                         {
 302                                                 if (!quiet) log.displayNL ("Missing character after the backslash \\ character");
 303                                                 return false;
 304                                         }
 305                                         switch (commandWithArgs[i])
 306                                         {
 307                                                 case '\\':      arg += '\\'; break; // double backslash
 308                                                 case 'n':       arg += '\n'; break; // new line
 309                                                 case '"':       arg += '"'; break; // "
 310                                                 case ';':       arg += ';'; break; // ;
 311                                                 default:
 312                                                         if (!quiet) log.displayNL ("Unknown escape code '\\%c'", commandWithArgs[i]);
 313                                                         return false;
 314                                         }
 315                                 }
 316                                 else if (allowControlChar && commandWithArgs[i] == ';')
 317                                 {
 318                                         // command separator
 319                                         break;
 320                                 }
 321                                 else
 322                                 {
 323                                         arg += commandWithArgs[i];
 324                                 }
 325
 326                                 i++;
 327
 328                                 if (i == commandWithArgs.size() || commandWithArgs[i] == ' ' || commandWithArgs[i] == '\t' || commandWithArgs[i] == '\n' || commandWithArgs[i] == '\r')
 329                                 {
 330                                         break;
 331                                 }
 332                         }
 333                 }
 334
 335                 if (!arg.empty())
 336                 {
 337                         if (firstArg)
 338                         {
 339                                 // the first arg is the command
 340                                 TCommandParams cp;
 341                                 cp.CommandName = arg;
 342                                 commands.push_back(cp);
 343                                 firstArg = false;
 344
 345                                 // does this command disable control char for remaining params?
 346                                 if(!isControlCharForCommandEnabled(arg))
 347                                         allowControlChar= false;
 348                         }
 349                         else
 350                         {
 351                                 commands[commands.size()-1].CommandArgs.push_back (arg);
 352                         }
 353                 }
 354
 355                 // separator
 356                 if (i < commandWithArgs.size() && allowControlChar && commandWithArgs[i] == ';')
 357                 {
 358                         // store the raw command
 359                         if (!commands.empty() && commands.back().RawCommandString.empty())
 360                                 commands.back().RawCommandString = string(commandWithArgs.begin()+commandBegin, commandWithArgs.begin()+i);
 361                         firstArg = true;
 362                         i++;
 363                         commandBegin = i;
 364                 }
 365         }
 366 end:
 367         // store the last raw command string
 368         if (!commands.empty() && commands.back().RawCommandString.empty())
 369                 commands.back().RawCommandString = string(commandWithArgs.begin()+commandBegin, commandWithArgs.begin()+i);
 370
 371         bool ret = true;
 372
 373         for (uint u = 0; u < commands.size (); u++)
 374         {
 375                 TCommandParams &cp = commands[u];
 376                 // find the command
 377                 // check for object name
 378                 string::size_type pos = cp.CommandName.find(".");
 379                 if (pos != string::npos)
 380                 {
 381                         // there is an object name, separate it and look in the object registry
 382                         string objectName = cp.CommandName.substr(0, pos);
 383                         string commandName = cp.CommandName.substr(pos+1);
 384                         ICommandsHandler *const *ppch = _CommandsHandlers.getB(objectName);
 385                         if (ppch != NULL)
 386                         {
 387                                 // ok, we found the object
 388                                 ret = ret && (*ppch)->execute(commands[u].RawCommandString, commandName, commands[u].CommandArgs, log, quiet, human);
 389                         }
 390                         else
 391                         {
 392                                 if (!quiet)
 393                                         log.displayNL("Command '%s' : can't found object named '%s'",
 394                                                 cp.CommandName.c_str(),
 395                                                 objectName.c_str());
 396                         }
 397                 }
 398                 else
 399                 {
 400                         // this is a global command
 401                         TCommand::iterator comm = _Commands.find(commands[u].CommandName);
 402                         if (comm == _Commands.end ())
 403                         {
 404                                 // the command doesn't exist
 405                                 ret = false;
 406                                 if (!quiet)
 407                                         log.displayNL("Command '%s' not found, try 'help'", commands[u].CommandName.c_str());
 408                         }
 409                         else
 410                         {
 411                                 bool res = comm->second->execute (commands[u].RawCommandString, commands[u].CommandArgs, log, quiet, human);
 412                                 ret = ret & res;
 413                                 if (!res)
 414                                 {
 415                                         if (!quiet)
 416                                                 log.displayNL("Bad command usage, try 'help %s'", commands[u].CommandName.c_str());
 417                                 }
 418                         }
 419                 }
 420         }
 421
 422         // false if at least one command returned false
 423         return ret;
 424 }
 425
 426
 427 /*
 428  * Command name completion.
 429  * Case-sensitive. Displays the list after two calls with the same non-unique completion.
 430  * Completes commands used with prefixes (such as "help " for example) as well.
 431  */
 432 void ICommand::expand (std::string &commandName, NLMISC::CLog &log)
 433 {
 434         // forward to command registry
 435         CCommandRegistry::getInstance().expand(commandName, log);
 436 }
 437
 438 void CCommandRegistry::expand (std::string &commandName, NLMISC::CLog &log)
 439 {
 440         // Take out the string before the last separator and remember it as a prefix
 441         string objectName;
 442         string::size_type lastseppos = commandName.find_last_of( " " );
 443         {
 444                 // eventually use the last dot as separator
 445                 string::size_type lastDot = commandName.find_last_of( "." );
 446                 if (lastDot != string::npos
 447                         && (lastseppos == string::npos || lastDot > lastseppos))
 448                 {
 449                         lastseppos = lastDot;
 450                         // store the object name to limit the matching scope
 451                         string::size_type spcPos = commandName.find_last_of(" ", lastDot);
 452                         if (spcPos == string::npos)
 453                                 spcPos = 0;
 454                         else
 455                                 spcPos++;
 456                         objectName = commandName.substr(spcPos, lastDot-spcPos);
 457                 }
 458         }
 459         string prefix;
 460         bool useprefix;
 461         if ( lastseppos != string::npos )
 462         {
 463                 prefix = commandName.substr( 0, lastseppos+1 );
 464                 commandName.erase( 0, lastseppos+1 );
 465                 useprefix = true;
 466         }
 467         else
 468         {
 469                 useprefix = false;
 470         }
 471
 472         string lowerCommandName = toLowerAscii(commandName);
 473         // Build the list of matching command names
 474         vector<string> matchingnames;
 475         {
 476                 if (objectName.empty())
 477                 {
 478                         // list of global commands
 479                         for (TCommand::iterator comm = _Commands.begin(); comm != _Commands.end(); comm++)
 480                         {
 481                                 string first = toLowerAscii((*comm).first);
 482                                 if (first.find( lowerCommandName ) == 0)
 483                                 {
 484                                         matchingnames.push_back( (*comm).first );
 485                                 }
 486                         }
 487
 488                         // list of object instance
 489                         for (TCommandsHandlers::TAToBMap::const_iterator it(_CommandsHandlers.getAToBMap().begin()); it != _CommandsHandlers.getAToBMap().end(); ++it)
 490                         {
 491                                 string first = toLowerAscii(it->first);
 492                                 if (first.find( lowerCommandName ) == 0)
 493                                 {
 494                                         matchingnames.push_back( it->first );
 495                                 }
 496                         }
 497                 }
 498                 else
 499                 {
 500                         ICommandsHandler *const *pch = _CommandsHandlers.getB(objectName);
 501                         if (pch != NULL)
 502                         {
 503                                 // ok, an object of this name exist, lookup the class
 504                                 TCommandsHandlersClass::iterator it = _CommandsHandlersClass.find((*pch)->getCommandHandlerClassName());
 505
 506                                 // list of class commands
 507                                 if (it != _CommandsHandlersClass.end())
 508                                 {
 509                                         TCommandHandlerClassInfo &chci = it->second;
 510
 511                                         for (TCommandHandlerClassInfo::TCommandsInfo::iterator it(chci._Commands.begin()); it != chci._Commands.end(); ++it)
 512                                         {
 513                                                 string first = toLowerAscii(it->first);
 514                                                 if (first.find( lowerCommandName ) == 0)
 515                                                 {
 516                                                         matchingnames.push_back( it->first );
 517                                                 }
 518                                         }
 519                                 }
 520                         }
 521                 }
 522
 523         }
 524
 525         // Do not complete if there is no result
 526         if ( matchingnames.empty() )
 527         {
 528                 log.displayNL( "No matching command" );
 529                 goto returnFromExpand;
 530         }
 531
 532         // Complete if there is a single result
 533         if ( matchingnames.size() == 1 )
 534         {
 535                 if (_CommandsHandlers.getAToBMap().find(matchingnames.front()) != _CommandsHandlers.getAToBMap().end())
 536                 {
 537                         // this is an object, complete with '.'
 538                         commandName = matchingnames.front() + ".";
 539                 }
 540                 else
 541                         commandName = matchingnames.front() + " ";
 542                 goto returnFromExpand;
 543         }
 544
 545         // Try to complete to the common part if there are several results
 546         {
 547                 // Stop loop when a name size is i or names[i] are different
 548                 string commonstr = commandName;
 549                 size_t i = commandName.size();
 550                 while ( true )
 551                 {
 552                         char letter = 0;
 553                         vector<string>::iterator imn;
 554                         for ( imn=matchingnames.begin(); imn!=matchingnames.end(); ++imn )
 555                         {
 556                                 // Return common string if the next letter is not the same in all matching names
 557                                 if ( ((*imn).size() == i) || ( (letter!=0) && ((*imn)[i] != letter) ) )
 558                                 {
 559                                         log.displayNL( "(Matching command not unique)" );
 560                                         static string lastCommandName;
 561                                         commandName = commonstr;
 562                                         if ( lastCommandName == commandName )
 563                                         {
 564                                                 // Display all the matching names
 565                                                 vector<string>::iterator imn2;
 566                                                 //stringstream ss;
 567                                                 string str;
 568                                                 //ss << "Matching commands:" << endl;
 569                                                 str += "Matching commands:\n";
 570                                                 for ( imn2=matchingnames.begin(); imn2!=matchingnames.end(); ++imn2 )
 571                                                 {
 572                                                         //ss << " " << (*imn2);
 573                                                         str += " " + (*imn2);
 574                                                 }
 575                                                 log.displayNL( "%s", str.c_str() );
 576                                         }
 577                                         lastCommandName = commandName;
 578                                         goto returnFromExpand;
 579                                 }
 580                                 // Add the next letter to the common string if it is the same in all matching names
 581                                 else if ( letter == 0 )
 582                                 {
 583                                         letter = (*imn)[i];
 584                                 }
 585                         }
 586                         commonstr += letter;
 587                         ++i;
 588                 }
 589         }
 590
 591 returnFromExpand:
 592
 593         // Put back the prefix
 594         if ( useprefix )
 595         {
 596                 commandName = prefix + commandName;
 597         }
 598 }
 599
 600
 601 void ICommand::serialCommands (IStream &f)
 602 {
 603         CCommandRegistry::getInstance().serialCommands(f);
 604 }
 605
 606 void CCommandRegistry::serialCommands (IStream &f)
 607 {
 608         vector<CSerialCommand> cmd;
 609         for (TCommand::iterator comm = _Commands.begin(); comm != _Commands.end(); comm++)
 610         {
 611                 cmd.push_back (CSerialCommand ((*comm).first, (*comm).second->Type));
 612         }
 613         f.serialCont (cmd);
 614 }
 615
 616 bool ICommand::exists (std::string const &commandName)
 617 {
 618         return CCommandRegistry::getInstance().exists(commandName);
 619 }
 620 bool CCommandRegistry::exists (std::string const &commandName)
 621 {
 622         return (_Commands.find(commandName) != _Commands.end ());
 623 }
 624
 625 bool CCommandRegistry::isNamedCommandHandler(const std::string &handlerName)
 626 {
 627         return _CommandsHandlers.getB(handlerName) != NULL;
 628 }
 629
 630 bool ICommand::isCommand (const std::string &str)
 631 {
 632         return CCommandRegistry::getInstance().isCommand(str);
 633 }
 634
 635 bool CCommandRegistry::isCommand (const std::string &str)
 636 {
 637         if (str.empty())
 638                 return false;
 639
 640         return isupper(str[0]) == 0;
 641 }
 642
 643 ICommand *ICommand::getCommand(const std::string &commandName)
 644 {
 645         return CCommandRegistry::getInstance().getCommand(commandName);
 646 }
 647
 648 ICommand *CCommandRegistry::getCommand(const std::string &commandName)
 649 {
 650         TCommand::iterator it(_Commands.find(commandName));
 651
 652         if (it == _Commands.end())
 653                 return NULL;
 654         else
 655                 return it->second;
 656 }
 657
 658
 659 NLMISC_CATEGORISED_COMMAND(nel,help,"display help on a specific variable/commands or on all variables and commands", "[<variable>|<command>]")
 660 {
 661         nlunreferenced(rawCommandString);
 662         nlunreferenced(quiet);
 663         nlunreferenced(human);
 664 //      nlassert (_Commands != NULL);
 665
 666         // make sure we have a valid number of parameters
 667         if (args.size()>1)
 668                 return false;
 669
 670         CCommandRegistry &cr = CCommandRegistry::getInstance();
 671
 672         // treat the case where we have no parameters
 673         if (args.empty())
 674         {
 675                 // display a list of all command categories
 676                 log.displayNL("Help commands:");
 677                 log.displayNL("- help all");
 678                 for (CCommandRegistry::TCategorySet::iterator it=cr._Categories.begin();it!=cr._Categories.end();++it)
 679                 {
 680                         log.displayNL("- help %s",it->c_str());
 681                 }
 682                 log.displayNL("- help <wildcard>");
 683                 log.displayNL("- help <command name>");
 684                 return true;
 685         }
 686
 687         // treat the case where the supplied parameter is "all"
 688         if (args[0]=="all")
 689         {
 690                 // display all commands
 691                 log.displayNL("Displaying all %d variables and commands: ", cr._Commands.size());
 692                 uint i = 0;
 693                 for (TCommand::iterator comm = cr._Commands.begin(); comm != cr._Commands.end(); ++comm, i++)
 694                 {
 695                         log.displayNL("%2d %-15s: %s", i, comm->first.c_str(), comm->second->HelpString.c_str());
 696                 }
 697
 698                 // display the class commands
 699                 {
 700                         CCommandRegistry::TCommandsHandlersClass::iterator first(cr._CommandsHandlersClass.begin()), last(cr._CommandsHandlersClass.end());
 701                         for (; first != last; ++first)
 702                         {
 703                                 log.displayNL("%-15s :", first->first.c_str());
 704                                 TCommandHandlerClassInfo &chci = first->second;
 705                                 {
 706                                         TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 707                                         for (;first != last; ++first)
 708                                         {
 709                                                 log.displayNL("  %-15s: %s", first->first.c_str(), first->second.CommandHelp.c_str());
 710                                         }
 711                                 }
 712                         }
 713                 }
 714
 715                 // display the named instance instance
 716                 {
 717                         log.displayNL("Listing named object instance : <name> : <className>");
 718                         CCommandRegistry::TCommandsHandlers::TAToBMap::const_iterator first(cr._CommandsHandlers.getAToBMap().begin()), last(cr._CommandsHandlers.getAToBMap().end());
 719                         for (; first != last; ++first)
 720                         {
 721                                 log.displayNL(" %-15s: %s",
 722                                         first->first.c_str(),
 723                                         first->second->getCommandHandlerClassName().c_str());
 724                         }
 725                 }
 726                 return true;
 727         }
 728
 729         // treat the case where the supplied parameter is a category name
 730         {
 731                 if (cr._Categories.find(args[0])!=cr._Categories.end())
 732                 {
 733                         log.displayNL("Displaying commands and variables from category: %s", args[0].c_str());
 734                         uint i = 0;
 735                         for (TCommand::iterator comm = cr._Commands.begin(); comm != cr._Commands.end(); ++comm)
 736                         {
 737                                 if (comm->second->CategoryName == args[0])
 738                                 {
 739                                         log.displayNL("%2d %-15s: %s", i, comm->first.c_str(), comm->second->HelpString.c_str());
 740                                         i++;
 741                                 }
 742                         }
 743                         return true;
 744                 }
 745         }
 746         // treat the case where the supplied parameter is a class name
 747         {
 748                 string className = args[0].substr(0, args[0].find("."));
 749                 if (cr._CommandsHandlersClass.find(className) != cr._CommandsHandlersClass.end())
 750                 {
 751                         TCommandHandlerClassInfo &chci = cr._CommandsHandlersClass[className];
 752                         if (className != args[0])
 753                         {
 754                                 string cmdName = args[0].substr(className.size()+1);
 755                                 // we are looking for a particular command in this class
 756                                 TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 757                                 for (;first != last; ++first)
 758                                 {
 759                                         if (first->first == cmdName)
 760                                         {
 761                                                 log.displayNL("%s::%s", className.c_str(), cmdName.c_str());
 762                                                 log.displayNL("usage: <instanceName>.%s %s : %s",
 763                                                         cmdName.c_str(),
 764                                                         first->second.CommandArgs.c_str(),
 765                                                         first->second.CommandHelp.c_str());
 766 //                                              log.displayNL("  %s::%-15s: %s", className.c_str(), cmdName.c_str(), first->second.CommandHelp.c_str());
 767                                                 return true;
 768                                         }
 769                                 }
 770
 771                         }
 772                         else
 773                         {
 774                                 log.displayNL("%-15s :", args[0].c_str());
 775                                 {
 776                                         TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 777                                         for (;first != last; ++first)
 778                                         {
 779                                                 log.displayNL("  %-15s: %s", first->first.c_str(), first->second.CommandHelp.c_str());
 780                                         }
 781                                 }
 782
 783                                 // list the instance of this class
 784                                 log.displayNL(" Here is a list of the %u named instance of this class", chci.InstanceCount);
 785                                 for (CCommandRegistry::TCommandsHandlers::TAToBMap::const_iterator it=cr._CommandsHandlers.getAToBMap().begin(); it != cr._CommandsHandlers.getAToBMap().end(); ++it)
 786                                 {
 787                                         if (it->second->getCommandHandlerClassName() == args[0])
 788                                         {
 789                                                 log.displayNL("  %-15s", it->first.c_str());
 790                                         }
 791                                 }
 792                                 return true;
 793                         }
 794                 }
 795         }
 796         // treat the case where the supplied parameter is an object name
 797         {
 798                 string objName = args[0].substr(0, args[0].find("."));
 799
 800                 if (cr._CommandsHandlers.getB(objName) != NULL)
 801                 {
 802                         const string &className = (*(cr._CommandsHandlers.getB(objName)))->getCommandHandlerClassName();
 803                         if (cr._CommandsHandlersClass.find(className) != cr._CommandsHandlersClass.end())
 804                         {
 805                                 TCommandHandlerClassInfo &chci = cr._CommandsHandlersClass[className];
 806                                 if (objName != args[0])
 807                                 {
 808                                         // only display a particular command of this class instance
 809                                         string cmdName = args[0].substr(objName.size()+1);
 810                                         TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 811                                         for (;first != last; ++first)
 812                                         {
 813                                                 if (first->first == cmdName)
 814                                                 {
 815                                                         log.displayNL("%s.%s", objName.c_str(), cmdName.c_str());
 816                                                         log.displayNL("usage: %s.%s %s : %s",
 817                                                                 objName.c_str(),
 818                                                                 cmdName.c_str(),
 819                                                                 first->second.CommandArgs.c_str(),
 820                                                                 first->second.CommandHelp.c_str());
 821 //                                                      log.displayNL("  %s.%-15s: %s", className.c_str(), cmdName.c_str(), first->second.CommandHelp.c_str());
 822                                                         return true;
 823                                                 }
 824                                         }
 825                                 }
 826                                 else
 827                                 {
 828                                         TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 829                                         for (;first != last; ++first)
 830                                         {
 831                                                 log.displayNL("  %-15s: %s", first->first.c_str(), first->second.CommandHelp.c_str());
 832                                         }
 833
 834                                         return true;
 835                                 }
 836                         }
 837                 }
 838         }
 839
 840         // treat the case where the supplied parameter is a wildcard
 841         if (args[0].find('*')!=std::string::npos || args[0].find('?')!=std::string::npos)
 842         {
 843                 log.displayNL("Displaying commands, variables and objects matching wildcard: '%s'", args[0].c_str());
 844                 log.displayNL(" Global commands and variables :");
 845                 uint i = 0;
 846                 for (TCommand::iterator comm = cr._Commands.begin(); comm != cr._Commands.end(); ++comm)
 847                 {
 848                         if (testWildCard(comm->first,args[0]))
 849                         {
 850                                 log.displayNL("%2d %-15s: %s", i, comm->first.c_str(), comm->second->HelpString.c_str());
 851                                 i++;
 852                         }
 853                 }
 854
 855                 // display the named instance instance that match
 856                 {
 857                         log.displayNL(" Named objects instances : <name> : <className>");
 858                         CCommandRegistry::TCommandsHandlers::TAToBMap::const_iterator first(cr._CommandsHandlers.getAToBMap().begin()), last(cr._CommandsHandlers.getAToBMap().end());
 859                         for (; first != last; ++first)
 860                         {
 861                                 if (testWildCard(first->first, args[0]))
 862                                 {
 863                                         log.displayNL("  %-15s: '%s'",
 864                                                 first->first.c_str(),
 865                                                 first->second->getCommandHandlerClassName().c_str());
 866                                 }
 867                         }
 868                 }
 869
 870                 // display the class commands that match
 871                 {
 872                         log.displayNL(" Class commands :");
 873                         CCommandRegistry::TCommandsHandlersClass::iterator first(cr._CommandsHandlersClass.begin()), last(cr._CommandsHandlersClass.end());
 874                         for (; first != last; ++first)
 875                         {
 876                                 const string &className = first->first;
 877                                 TCommandHandlerClassInfo &chci = first->second;
 878                                 {
 879                                         TCommandHandlerClassInfo::TCommandsInfo::iterator first(chci._Commands.begin()), last(chci._Commands.end());
 880                                         for (;first != last; ++first)
 881                                         {
 882                                                 if (testWildCard(first->first, args[0]))
 883                                                 {
 884                                                         log.displayNL("  %s::%-15s: %s",
 885                                                                 className.c_str(),
 886                                                                 first->first.c_str(),
 887                                                                 first->second.CommandHelp.c_str());
 888                                                 }
 889                                         }
 890                                 }
 891                         }
 892                 }
 893
 894                 return true;
 895         }
 896
 897         // treat the case where we're looking at help on a given command
 898         {
 899                 // look in global commands
 900                 if (cr._Commands.find(args[0]) != cr._Commands.end())
 901                 {
 902                         TCommand::iterator comm = cr._Commands.find(args[0]);
 903                         log.displayNL("%s", comm->second->HelpString.c_str());
 904
 905                         std::vector<std::string> commandArgs;
 906                         splitString(comm->second->CommandArgs, "\n", commandArgs);
 907
 908                         log.displayNL("usage: %s %s",
 909                                 comm->first.c_str(),
 910                                 commandArgs.empty() ? "":commandArgs.front().c_str());
 911
 912                         for(uint i = 1; i < commandArgs.size(); ++i)
 913                                 log.displayNL("%s", commandArgs[i].c_str());
 914
 915                         return true;
 916                 }
 917                 // look in the class commands
 918                 {
 919                         CCommandRegistry::TCommandsHandlersClass::iterator first(cr._CommandsHandlersClass.begin()), last(cr._CommandsHandlersClass.end());
 920                         for (; first != last; ++first)
 921                         {
 922                                 TCommandHandlerClassInfo &chci = first->second;
 923                                 {
 924                                         TCommandHandlerClassInfo::TCommandsInfo::iterator it = chci._Commands.find(args[0]);
 925                                         if (it != chci._Commands.end())
 926                                         {
 927                                                 log.displayNL("%s", it->second.CommandHelp.c_str());
 928
 929                                                 std::vector<std::string> commandArgs;
 930                                                 splitString(it->second.CommandArgs, "\n", commandArgs);
 931
 932                                                 log.displayNL("usage: %s %s",
 933                                                         it->first.c_str(),
 934                                                         commandArgs.empty() ? "":commandArgs.front().c_str());
 935
 936                                                 for(uint i = 1; i < commandArgs.size(); ++i)
 937                                                         log.displayNL("%s", commandArgs[i].c_str());
 938
 939                                                 return true;
 940                                         }
 941                                 }
 942                         }
 943                 }
 944         }
 945
 946
 947         // we've failed to find a case that works so display an error message and prompt the player
 948         log.displayNL("'%s' is not a command, category or wildcard. Type 'help' for more information", args[0].c_str());
 949         return true;
 950 }
 951
 952 // ***************************************************************************
 953 void    ICommand::enableControlCharForCommand(const std::string &commandName, bool state)
 954 {
 955         CCommandRegistry::getInstance().enableControlCharForCommand(commandName, state);
 956 }
 957 void    CCommandRegistry::enableControlCharForCommand(const std::string &commandName, bool state)
 958 {
 959         if(state)
 960                 // allow, so erase from the set of those who disable
 961                 _CommandsDisablingControlChar.erase(commandName);
 962         else
 963                 // disable, so insert in the set of those who disable
 964                 _CommandsDisablingControlChar.insert(commandName);
 965 }
 966
 967 // ***************************************************************************
 968 bool    ICommand::isControlCharForCommandEnabled(const std::string &commandName)
 969 {
 970         return CCommandRegistry::getInstance().isControlCharForCommandEnabled(commandName);
 971 }
 972 bool    CCommandRegistry::isControlCharForCommandEnabled(const std::string &commandName)
 973 {
 974         // true if not in the set
 975         return _CommandsDisablingControlChar.find(commandName)==_CommandsDisablingControlChar.end();
 976 }
 977
 978 ICommandsHandler::ICommandsHandler()
 979 : _ClassName(NULL)
 980 {
 981 }
 982
 983 void ICommandsHandler::registerCommandsHandler()
 984 {
 985         if (_ClassName == NULL)
 986         {
 987                 // store the class name for unregistering during destruction
 988                 _ClassName = &getCommandHandlerClassName();
 989                 CCommandRegistry::getInstance().registerNamedCommandHandler(this, *_ClassName);
 990         }
 991 }
 992
 993 void ICommandsHandler::unregisterCommandsHandler()
 994 {
 995         if (_ClassName != NULL)
 996         {
 997                 CCommandRegistry::getInstance().unregisterNamedCommandHandler(this, *_ClassName);
 998                 _ClassName = NULL;
 999         }
1000 }
1001
1002
1003 ICommandsHandler::~ICommandsHandler()
1004 {
1005         unregisterCommandsHandler();
1006 }
1007
1008
1009 } // NLMISC