Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/shell/shell_command.cc @ 5351

Last change on this file since 5351 was 5329, checked in by bensch, 19 years ago

orxonox/trunk: executing static commands work

File size: 20.1 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Benjamin Grauer
13   co-programmer: ...
14*/
15
16//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_
17
18#include "shell_command.h"
19
20#include "list.h"
21#include "debug.h"
22#include "class_list.h"
23
24#include "key_names.h"
25#include <stdarg.h>
26#include <stdio.h>
27#include <string.h>
28
29using namespace std;
30
31/**
32 * creates a new ShellCommandClass
33 * @param className the Name of the command-class to create
34 */
35ShellCommandClass::ShellCommandClass(const char* className)
36{
37  this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
38  this->setName(className);
39
40  this->className = className;
41  this->classID = CL_NULL;
42  this->commandList = new tList<ShellCommandBase>;
43
44  ShellCommandClass::commandClassList->add(this);
45}
46
47/**
48 * destructs the shellCommandClass again
49 */
50ShellCommandClass::~ShellCommandClass()
51{
52  tIterator<ShellCommandBase>* iterator = this->commandList->getIterator();
53  ShellCommandBase* elem = iterator->firstElement();
54  while(elem != NULL)
55  {
56    delete elem;
57    elem = iterator->nextElement();
58  }
59  delete iterator;
60  delete this->commandList;
61}
62
63/**
64 * collects the Commands registered to some class.
65 * @param className the name of the Class to collect the Commands from.
66 * @param stringList a List to paste the Commands into.
67 * @returns true on success, false otherwise
68 */
69bool ShellCommandClass::getCommandListOfClass(const char* className, tList<const char>* stringList)
70{
71  if (stringList == NULL || className == NULL)
72    return false;
73
74  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
75  ShellCommandClass* elem = iterator->firstElement();
76  while(elem != NULL)
77  {
78    if (!strcmp (elem->getName(), className))
79    {
80      tIterator<ShellCommandBase>* itFkt = elem->commandList->getIterator();
81      ShellCommandBase* command = itFkt->firstElement();
82      while (command != NULL)
83      {
84        stringList->add(command->getName());
85        command = itFkt->nextElement();
86      }
87      delete itFkt;
88    }
89
90    elem = iterator->nextElement();
91  }
92  delete iterator;
93  return true;
94}
95
96/**
97 * collects the Aliases registered to the ShellCommands
98 * @param stringList a List to paste the Aliases into.
99 * @returns true on success, false otherwise
100 */
101bool ShellCommandClass::getCommandListOfAlias(tList<const char>* stringList)
102{
103  if (stringList == NULL || ShellCommandClass::aliasList == NULL)
104    return false;
105
106  tIterator<ShellCommandAlias>* iterator = ShellCommandClass::aliasList->getIterator();
107   ShellCommandAlias* elem = iterator->firstElement();
108   while(elem != NULL)
109   {
110     stringList->add(elem->getName());
111     elem = iterator->nextElement();
112   }
113   delete iterator;
114   return true;
115}
116
117/**
118 * unregisters all Commands that exist
119 */
120void ShellCommandClass::unregisterAllCommands()
121{
122  // unregister all commands
123  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
124  ShellCommandClass* elem = iterator->firstElement();
125  while(elem != NULL)
126  {
127    delete elem;
128
129    elem = iterator->nextElement();
130  }
131  delete iterator;
132
133  delete ShellCommandClass::commandClassList;
134  ShellCommandClass::commandClassList = NULL;
135
136  // unregister all aliases (there should be nothing to do here :))
137  if (ShellCommandClass::aliasList != NULL)
138  {
139    tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
140    ShellCommandAlias* elemAL = itAL->firstElement();
141    while(elemAL != NULL)
142    {
143      delete elemAL;
144      elemAL = itAL->nextElement();
145    }
146    delete itAL;
147    delete ShellCommandClass::aliasList;
148    ShellCommandClass::aliasList = NULL;
149  }
150}
151
152/**
153 * checks if a Class is already registered to the Commands' class-stack
154 * @param className the Name of the Class to check for
155 * @returns the CommandClass if found, NULL otherwise
156 */
157const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
158{
159  if (ShellCommandClass::commandClassList == NULL)
160    initCommandClassList();
161
162  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
163  ShellCommandClass* elem = iterator->firstElement();
164  while(elem != NULL)
165  {
166    if (!strcmp(className, elem->className))
167    {
168      if (elem->classID == CL_NULL)
169        elem->classID = ClassList::StringToID(className);
170
171      delete iterator;
172      return elem;
173    }
174    elem = iterator->nextElement();
175  }
176  delete iterator;
177  return NULL;
178}
179
180/**
181 * searches for a CommandClass
182 * @param className the name of the CommandClass
183 * @returns the CommandClass if found, or a new CommandClass if not
184 */
185ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
186{
187  if (ShellCommandClass::commandClassList == NULL)
188    initCommandClassList();
189
190  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
191  ShellCommandClass* elem = iterator->firstElement();
192  while(elem != NULL)
193  {
194    if (!strcmp(className, elem->className))
195    {
196      delete iterator;
197      return elem;
198    }
199    elem = iterator->nextElement();
200  }
201  delete iterator;
202  return new ShellCommandClass(className);
203}
204
205/**
206 * initializes the CommandList (if it is NULL)
207 */
208void ShellCommandClass::initCommandClassList()
209{
210  if (ShellCommandClass::commandClassList == NULL)
211  {
212    ShellCommandClass::commandClassList = new tList<ShellCommandClass>;
213    ShellCommandStatic<ShellCommandBase>::registerCommand("debug", "ShellCommand", ShellCommandBase::debug);
214  }
215}
216
217void ShellCommandClass::help(const char* className)
218{
219  if (className == NULL)
220    return;
221  if (likely(ShellCommandClass::commandClassList != NULL))
222  {
223    tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
224    ShellCommandClass* elemCL = itCL->firstElement();
225    while(elemCL != NULL)
226    {
227      if (elemCL->className && !strcasecmp(className, elemCL->className))
228      {
229        PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
230        tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
231        const ShellCommandBase* elem = iterator->firstElement();
232        while(elem != NULL)
233        {
234          PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
235          for (unsigned int i = 0; i< elem->paramCount; i++)
236            PRINT(0)("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
237          if (elem->description != NULL)
238            PRINT(0)("- %s", elem->description);
239          PRINT(0)("\n");
240          elem = iterator->nextElement();
241        }
242        delete iterator;
243
244        delete itCL;
245        return;
246      }
247      elemCL = itCL->nextElement();
248    }
249    delete itCL;
250    PRINTF(3)("Class %s not found in Command's classes\n", className);
251  }
252  else
253  {
254    PRINTF(1)("List of commandClasses does not exist");
255  }
256}
257
258tList<ShellCommandClass>* ShellCommandClass::commandClassList = NULL;
259tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
260
261/**
262 * constructs and registers a new Command
263 * @param commandName the name of the Command
264 * @param className the name of the class to apply this command to
265 * @param paramCount the count of parameters this command takes
266 * @return self
267 */
268ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)
269{
270  this->setClassID(CL_SHELL_COMMAND, "ShellCommand");
271  this->setName(commandName);
272  this->description = NULL;
273  this->alias = NULL;
274
275//  this->classID = classID;
276  this->shellClass = ShellCommandClass::getCommandClass(className); //ClassList::IDToString(classID);
277  if (this->shellClass != NULL)
278    this->shellClass->commandList->add(this);
279  // handling parameters, and storing them:
280  if (paramCount > FUNCTOR_MAX_ARGUMENTS)
281    paramCount = FUNCTOR_MAX_ARGUMENTS;
282  this->paramCount = paramCount;
283  this->parameters = new unsigned int[paramCount];
284
285  va_list parameterList;
286  va_start(parameterList, paramCount);
287
288  for (unsigned int i = 0; i < paramCount; i++)
289  {
290    this->parameters[i] = va_arg(parameterList, int);
291
292    switch (this->parameters[i])
293    {
294      case ParameterBool:
295        this->defaultBools[i] = va_arg(parameterList, int);
296        break;
297      case ParameterChar:
298        this->defaultStrings[i] = new char[2];
299        sprintf(this->defaultStrings[0], "%c",  va_arg(parameterList, int));
300        break;
301      case ParameterString:
302        this->defaultStrings[i] = va_arg(parameterList, char*);
303        break;
304      case ParameterInt:
305        this->defaultInts[i] = va_arg(parameterList, int);
306        break;
307      case ParameterUInt:
308        this->defaultInts[i] = va_arg(parameterList, unsigned int);
309        break;
310      case ParameterFloat:
311        this->defaultFloats[i] = va_arg(parameterList, double);
312        break;
313      case ParameterLong:
314        this->defaultInts[i] = va_arg(parameterList, long);
315        break;
316      default:
317        break;
318    }
319  }
320}
321
322/**
323 * deconstructs a ShellCommand
324 * @return
325 */
326ShellCommandBase::~ShellCommandBase()
327{
328  delete[] this->parameters;
329  if (this->alias != NULL && ShellCommandClass::aliasList != NULL)
330  {
331    ShellCommandClass::aliasList->remove(this->alias);
332    delete this->alias;
333  }
334}
335
336/**
337 * unregister an existing commandName
338 * @param className the name of the Class the command belongs to.
339 * @param commandName the name of the command itself
340 */
341void ShellCommandBase::unregisterCommand(const char* commandName, const char* className)
342{
343  if (ShellCommandClass::commandClassList == NULL)
344    ShellCommandClass::initCommandClassList();
345
346 const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);
347
348 if (checkClass != NULL)
349  {
350    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
351    ShellCommandBase* elem = iterator->firstElement();
352    while(elem != NULL)
353    {
354      if (!strcmp(commandName, elem->getName()))
355      {
356        checkClass->commandList->remove(elem);
357        delete elem;
358        break;
359      }
360      elem = iterator->nextElement();
361    }
362    delete iterator;
363
364    if (checkClass->commandList->getSize() == 0)
365    {
366      ShellCommandClass::commandClassList->remove(checkClass);
367      delete checkClass;
368    }
369  }
370}
371
372/**
373 * checks if a command has already been registered.
374 * @param commandName the name of the Command
375 * @param className the name of the Class the command should apply to.
376 * @param paramCount how many arguments the Command takes
377 * @returns true, if the command is registered/false otherwise
378 *
379 * This is used internally, to see, if we have multiple command subscriptions.
380 * This is checked in the registerCommand-function.
381 */
382bool ShellCommandBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
383{
384  if (ShellCommandClass::commandClassList == NULL)
385  {
386    ShellCommandClass::initCommandClassList();
387    return false;
388  }
389
390  const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);
391  if (checkClass != NULL)
392  {
393    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
394    ShellCommandBase* elem = iterator->firstElement();
395    while(elem != NULL)
396   {
397     if (!strcmp(commandName, elem->getName()))
398     {
399       PRINTF(2)("Command already registered\n");
400       delete iterator;
401       return true;
402      }
403     elem = iterator->nextElement();
404   }
405   delete iterator;
406   return false;
407  }
408  else
409    return false;
410}
411
412
413/**
414 * executes commands
415 * @param executionString the string containing the following input
416 * ClassName [ObjectName] functionName [parameter1[,parameter2[,...]]]
417 * @return true on success, false otherwise.
418 */
419#include  "stdlibincl.h"
420bool ShellCommandBase::execute(const char* executionString)
421{
422  if (ShellCommandClass::commandClassList == NULL)
423    return false;
424
425  long classID = CL_NULL;                 //< the classID retrieved from the Class.
426  ShellCommandClass* commandClass = NULL; //< the command class this command applies to.
427  tList<BaseObject>* objectList = NULL;   //< the list of Objects stored in classID
428  BaseObject* objectPointer = NULL;       //< a pointer to th Object to Execute the command on
429  bool emptyComplete = false;             //< if the completion input is empty string. e.g ""
430  unsigned int fktPos = 1;                //< the position of the function (needed for finding it)
431//  long completeType = SHELLC_NONE;      //< the Type we'd like to complete.
432  SubString inputSplits(executionString, true);
433
434  if (inputSplits.getCount() == 0)
435    return false;
436  if (inputSplits.getCount() >= 1)
437  {
438    // CHECK FOR ALIAS
439    if (ShellCommandClass::aliasList != NULL)
440    {
441      tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
442      ShellCommandAlias* elemAL = itAL->firstElement();
443      while(elemAL != NULL)
444      {
445        if (elemAL->getName() != NULL && !strcmp(elemAL->getName(), inputSplits.getString(0)) && elemAL->getCommand() != NULL &&
446            elemAL->getCommand()->shellClass != NULL )
447        {
448          objectList = ClassList::getList(elemAL->getCommand()->shellClass->getName());
449          if (objectList != NULL)
450          {
451            if (inputSplits.getCount() > 1)
452              elemAL->getCommand()->executeCommand(objectList->firstElement(), executionString+inputSplits.getOffset(1));
453            else
454              elemAL->getCommand()->executeCommand(objectList->firstElement(), "");
455            delete itAL;
456            return true;
457          }
458        }
459        elemAL = itAL->nextElement();
460      }
461      delete itAL;
462    }
463    // looking for a Matching Class
464    if (likely(ShellCommandClass::commandClassList != NULL))
465    {
466      tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
467      ShellCommandClass* elemCL = itCL->firstElement();
468      while(elemCL != NULL)
469      {
470        if (elemCL->getName() && !strcasecmp(inputSplits.getString(0), elemCL->getName()))
471        {
472          //elemCL->getName();
473          classID = ClassList::StringToID(elemCL->getName());
474          commandClass = elemCL;
475          objectList = ClassList::getList(classID);
476          break;
477        }
478        elemCL = itCL->nextElement();
479      }
480      delete itCL;
481    }
482
483    if (commandClass != NULL && inputSplits.getCount() >= 2)
484    {
485      if (objectList != NULL)
486      {
487        // Checking for a Match in the Objects of classID (else take the first)
488        tIterator<BaseObject>* itBO = objectList->getIterator();
489        BaseObject* enumBO = itBO->firstElement();
490        while(enumBO)
491        {
492          if (enumBO->getName() != NULL && !strcasecmp(enumBO->getName(), inputSplits.getString(1)))
493          {
494            objectPointer = enumBO;
495            fktPos = 2;
496            break;
497          }
498          enumBO = itBO->nextElement();
499         }
500         delete itBO;
501
502      //
503        if (objectPointer == NULL)
504          objectPointer = objectList->firstElement();
505      }
506      printf("test\n");
507      // match a function.
508      if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
509      {
510        tIterator<ShellCommandBase>* itCMD = commandClass->commandList->getIterator();
511        ShellCommandBase* enumCMD = itCMD->firstElement();
512        while (enumCMD != NULL)
513        {
514          if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))
515          {
516            if (objectPointer == NULL && enumCMD->functorType == ShellCommand_Objective)
517            {
518              delete itCMD;
519              return false;
520            }
521            if (inputSplits.getCount() > fktPos+1)
522              enumCMD->executeCommand(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
523            else
524              enumCMD->executeCommand(objectPointer, "");
525            delete itCMD;
526            return true;
527          }
528
529          enumCMD = itCMD->nextElement();
530        }
531        delete itCMD;
532      }
533    }
534  }
535}
536
537/**
538 * lets a command be described
539 * @param description the description of the Given command
540 */
541ShellCommandBase* ShellCommandBase::describe(const char* description)
542{
543  if (this == NULL)
544    return NULL;
545 else
546 {
547   this->description = description;
548   return this;
549 }
550}
551
552/**
553 * adds an Alias to this Command
554 * @param alias the name of the Alias to set
555 * @returns itself
556 */
557ShellCommandBase* ShellCommandBase::setAlias(const char* alias)
558{
559  if (this == NULL)
560    return NULL;
561
562  if (this->alias != NULL)
563  {
564    PRINTF(2)("not more than one Alias allowed for functions (%s::%s)\n", this->getName(), this->shellClass->getName());
565  }
566  else
567  {
568    if (ShellCommandClass::aliasList == NULL)
569      ShellCommandClass::aliasList = new tList<ShellCommandAlias>;
570
571    ShellCommandAlias* aliasCMD = new ShellCommandAlias(alias, this);
572    ShellCommandClass::aliasList->add(aliasCMD);
573    this->alias = aliasCMD;
574  }
575  return this;
576}
577
578/**
579 * sets default Values of the Commands
580 * @param count how many default Values to set.
581 * @param ... the default Values in order. They will be cast to the right type
582 * @returns itself
583 *
584 * Be aware, that when you use this Function, you !!MUST!! match the input as
585 * count, [EXACTLY THE SAME AS IF YOU WOULD CALL THE FUNCTION UP TO count ARGUMENTS]
586 */
587ShellCommandBase* ShellCommandBase::defaultValues(unsigned int count, ...)
588{
589  if (this == NULL)
590    return NULL;
591  if (count == 0)
592    return this;
593  if (count > this->paramCount)
594    count = this->paramCount;
595
596  va_list defaultList;
597  va_start(defaultList, count);
598
599  for (unsigned int i = 0; i < count; i++)
600  {
601    switch (this->parameters[i])
602    {
603      case ParameterBool:
604        this->defaultBools[i] = va_arg(defaultList, int);
605        break;
606      case ParameterChar:
607        this->defaultStrings[i] = new char[2];
608        sprintf(this->defaultStrings[0], "%c",  va_arg(defaultList, int));
609        break;
610      case ParameterString:
611        this->defaultStrings[i] = va_arg(defaultList, char*);
612        break;
613      case ParameterInt:
614        this->defaultInts[i] = va_arg(defaultList, int);
615        break;
616      case ParameterUInt:
617        this->defaultInts[i] = va_arg(defaultList, unsigned int);
618        break;
619      case ParameterFloat:
620        this->defaultFloats[i] = va_arg(defaultList, double);
621        break;
622      case ParameterLong:
623        this->defaultInts[i] = va_arg(defaultList, long);
624        break;
625      default:
626        break;
627    }
628  }
629
630  return this;
631}
632
633/**
634 * prints out nice information about the Shells Commands
635 */
636void ShellCommandBase::debug()
637{
638  if (ShellCommandClass::commandClassList == NULL)
639  {
640    PRINT(0)("No Command registered.\n");
641    return;
642  }
643
644  tIterator<ShellCommandClass>* iteratorCL = ShellCommandClass::commandClassList->getIterator();
645  ShellCommandClass* elemCL = iteratorCL->firstElement();
646  while(elemCL != NULL)
647  {
648    PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
649    tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
650    const ShellCommandBase* elem = iterator->firstElement();
651    while(elem != NULL)
652    {
653      PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
654      for (unsigned int i = 0; i< elem->paramCount; i++)
655       printf("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
656      if (elem->description != NULL)
657       printf("- %s", elem->description);
658      printf("\n");
659
660      elem = iterator->nextElement();
661    }
662    delete iterator;
663    elemCL = iteratorCL->nextElement();
664  }
665  delete iteratorCL;
666}
667
668/**
669 * converts a Parameter to a String
670 * @param parameter the Parameter we have.
671 * @returns the Name of the Parameter at Hand
672 */
673const char* ShellCommandBase::paramToString(long parameter)
674{
675  switch (parameter)
676  {
677    case ParameterBool:
678      return "BOOL";
679      break;
680    case ParameterChar:
681      return "CHAR";
682      break;
683    case ParameterString:
684      return "STRING";
685      break;
686    case ParameterInt:
687      return "INT";
688      break;
689    case ParameterUInt:
690      return "UINT";
691      break;
692    case ParameterFloat:
693      return "FLOAT";
694      break;
695    case ParameterLong:
696      return "LONG";
697      break;
698    default:
699      return "NULL";
700      break;
701  }
702}
Note: See TracBrowser for help on using the repository browser.