Changeset 5636 in orxonox.OLD for trunk/src/lib/shell
- Timestamp:
- Nov 18, 2005, 6:55:18 PM (19 years ago)
- Location:
- trunk/src/lib/shell
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/lib/shell/shell_command.cc
r5634 r5636 40 40 this->className = className; 41 41 this->classID = CL_NULL; 42 this->commandList = new tList<ShellCommand Base>;42 this->commandList = new tList<ShellCommand>; 43 43 44 44 ShellCommandClass::commandClassList->add(this); … … 50 50 ShellCommandClass::~ShellCommandClass() 51 51 { 52 tIterator<ShellCommand Base>* iterator = this->commandList->getIterator();53 ShellCommand Base* elem = iterator->firstElement();52 tIterator<ShellCommand>* iterator = this->commandList->getIterator(); 53 ShellCommand* elem = iterator->firstElement(); 54 54 while(elem != NULL) 55 55 { … … 78 78 if (!strcmp (elem->getName(), className)) 79 79 { 80 tIterator<ShellCommand Base>* itFkt = elem->commandList->getIterator();81 ShellCommand Base* command = itFkt->firstElement();80 tIterator<ShellCommand>* itFkt = elem->commandList->getIterator(); 81 ShellCommand* command = itFkt->firstElement(); 82 82 while (command != NULL) 83 83 { … … 120 120 void ShellCommandClass::unregisterAllCommands() 121 121 { 122 // unregister all commands 122 if (ShellCommandClass::commandClassList != NULL) 123 { 124 // unregister all commands 125 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator(); 126 ShellCommandClass* elem = iterator->firstElement(); 127 while(elem != NULL) 128 { 129 delete elem; 130 131 elem = iterator->nextElement(); 132 } 133 delete iterator; 134 135 delete ShellCommandClass::commandClassList; 136 ShellCommandClass::commandClassList = NULL; 137 } 138 139 // unregister all aliases (there should be nothing to do here :)) 140 if (ShellCommandClass::aliasList != NULL) 141 { 142 tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator(); 143 ShellCommandAlias* elemAL = itAL->firstElement(); 144 while(elemAL != NULL) 145 { 146 delete elemAL; 147 elemAL = itAL->nextElement(); 148 } 149 delete itAL; 150 delete ShellCommandClass::aliasList; 151 ShellCommandClass::aliasList = NULL; 152 } 153 } 154 155 /** 156 * checks if a Class is already registered to the Commands' class-stack 157 * @param className the Name of the Class to check for 158 * @returns the CommandClass if found, NULL otherwise 159 */ 160 const ShellCommandClass* ShellCommandClass::isRegistered(const char* className) 161 { 162 if (ShellCommandClass::commandClassList == NULL) 163 initCommandClassList(); 164 123 165 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator(); 124 166 ShellCommandClass* elem = iterator->firstElement(); 125 167 while(elem != NULL) 126 168 { 127 delete elem; 128 169 if (!strcmp(className, elem->className)) 170 { 171 if (elem->classID == CL_NULL) 172 elem->classID = ClassList::StringToID(className); 173 174 delete iterator; 175 return elem; 176 } 129 177 elem = iterator->nextElement(); 130 178 } 131 179 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 */ 157 const ShellCommandClass* ShellCommandClass::isRegistered(const char* className) 180 return NULL; 181 } 182 183 /** 184 * searches for a CommandClass 185 * @param className the name of the CommandClass 186 * @returns the CommandClass if found, or a new CommandClass if not 187 */ 188 ShellCommandClass* ShellCommandClass::getCommandClass(const char* className) 158 189 { 159 190 if (ShellCommandClass::commandClassList == NULL) … … 166 197 if (!strcmp(className, elem->className)) 167 198 { 168 if (elem->classID == CL_NULL)169 elem->classID = ClassList::StringToID(className);170 171 199 delete iterator; 172 200 return elem; … … 175 203 } 176 204 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 */ 185 ShellCommandClass* ShellCommandClass::getCommandClass(const char* className) 205 return new ShellCommandClass(className); 206 } 207 208 /** 209 * initializes the CommandList (if it is NULL) 210 */ 211 void ShellCommandClass::initCommandClassList() 186 212 { 187 213 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 */208 void ShellCommandClass::initCommandClassList()209 {210 if (ShellCommandClass::commandClassList == NULL)211 214 { 212 215 ShellCommandClass::commandClassList = new tList<ShellCommandClass>; 213 ShellCommand Static<ShellCommandBase>::registerCommand("debug", "ShellCommand", ShellCommandBase::debug);216 ShellCommand::registerCommand("debug", "ShellCommand", new ExecutorStatic<ShellCommand>(ShellCommand::debug)); 214 217 } 215 218 } … … 228 231 { 229 232 PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize()); 230 tIterator<ShellCommand Base>* iterator = elemCL->commandList->getIterator();231 const ShellCommand Base* elem = iterator->firstElement();233 tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator(); 234 const ShellCommand* elem = iterator->firstElement(); 232 235 while(elem != NULL) 233 236 { 234 237 PRINT(0)(" command:'%s' : params:%d: ", elem->getName(), elem->paramCount); 235 238 for (unsigned int i = 0; i< elem->paramCount; i++) 236 PRINT(0)("%s ", ShellCommand Base::paramToString(elem->parameters[i]));239 PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i])); 237 240 if (elem->description != NULL) 238 241 PRINT(0)("- %s", elem->description); … … 277 280 * @param paramCount the count of parameters this command takes 278 281 */ 279 ShellCommand Base::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)282 ShellCommand::ShellCommand(const char* commandName, const char* className, unsigned int paramCount, ...) 280 283 { 281 284 this->setClassID(CL_SHELL_COMMAND, "ShellCommand"); … … 306 309 * deconstructs a ShellCommand 307 310 */ 308 ShellCommand Base::~ShellCommandBase()311 ShellCommand::~ShellCommand() 309 312 { 310 313 delete[] this->parameters; … … 318 321 319 322 /** 323 * registers a new ShellCommand 324 */ 325 ShellCommand* ShellCommand::registerCommand(const char* commandName, const char* className, Executor* executor) 326 { 327 return NULL; 328 329 } 330 331 332 333 334 /** 320 335 * unregister an existing commandName 321 336 * @param className the name of the Class the command belongs to. 322 337 * @param commandName the name of the command itself 323 338 */ 324 void ShellCommand Base::unregisterCommand(const char* commandName, const char* className)339 void ShellCommand::unregisterCommand(const char* commandName, const char* className) 325 340 { 326 341 if (ShellCommandClass::commandClassList == NULL) … … 331 346 if (checkClass != NULL) 332 347 { 333 tIterator<ShellCommand Base>* iterator = checkClass->commandList->getIterator();334 ShellCommand Base* elem = iterator->firstElement();348 tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator(); 349 ShellCommand* elem = iterator->firstElement(); 335 350 while(elem != NULL) 336 351 { … … 363 378 * This is checked in the registerCommand-function. 364 379 */ 365 bool ShellCommand Base::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)380 bool ShellCommand::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...) 366 381 { 367 382 if (ShellCommandClass::commandClassList == NULL) … … 374 389 if (checkClass != NULL) 375 390 { 376 tIterator<ShellCommand Base>* iterator = checkClass->commandList->getIterator();377 ShellCommand Base* elem = iterator->firstElement();391 tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator(); 392 ShellCommand* elem = iterator->firstElement(); 378 393 while(elem != NULL) 379 394 { … … 400 415 * @return true on success, false otherwise. 401 416 */ 402 bool ShellCommand Base::execute(const char* executionString)417 bool ShellCommand::execute(const char* executionString) 403 418 { 404 419 if (ShellCommandClass::commandClassList == NULL) … … 489 504 if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3))) 490 505 { 491 tIterator<ShellCommand Base>* itCMD = commandClass->commandList->getIterator();492 ShellCommand Base* enumCMD = itCMD->firstElement();506 tIterator<ShellCommand>* itCMD = commandClass->commandList->getIterator(); 507 ShellCommand* enumCMD = itCMD->firstElement(); 493 508 while (enumCMD != NULL) 494 509 { … … 520 535 * @param description the description of the Given command 521 536 */ 522 ShellCommand Base* ShellCommandBase::describe(const char* description)537 ShellCommand* ShellCommand::describe(const char* description) 523 538 { 524 539 if (this == NULL) … … 536 551 * @returns itself 537 552 */ 538 ShellCommand Base* ShellCommandBase::setAlias(const char* alias)553 ShellCommand* ShellCommand::setAlias(const char* alias) 539 554 { 540 555 if (this == NULL) … … 566 581 * count, [EXACTLY THE SAME AS IF YOU WOULD CALL THE FUNCTION UP TO count ARGUMENTS] 567 582 */ 568 ShellCommand Base* ShellCommandBase::defaultValues(unsigned int count, ...)583 ShellCommand* ShellCommand::defaultValues(unsigned int count, ...) 569 584 { 570 585 if (this == NULL) … … 615 630 * prints out nice information about the Shells Commands 616 631 */ 617 void ShellCommand Base::debug()632 void ShellCommand::debug() 618 633 { 619 634 if (ShellCommandClass::commandClassList == NULL) … … 628 643 { 629 644 PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize()); 630 tIterator<ShellCommand Base>* iterator = elemCL->commandList->getIterator();631 const ShellCommand Base* elem = iterator->firstElement();645 tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator(); 646 const ShellCommand* elem = iterator->firstElement(); 632 647 while(elem != NULL) 633 648 { 634 649 PRINT(0)(" command:'%s' : params:%d: ", elem->getName(), elem->paramCount); 635 650 for (unsigned int i = 0; i< elem->paramCount; i++) 636 printf("%s ", ShellCommand Base::paramToString(elem->parameters[i]));651 printf("%s ", ShellCommand::paramToString(elem->parameters[i])); 637 652 if (elem->description != NULL) 638 653 printf("- %s", elem->description); … … 652 667 * @returns the Name of the Parameter at Hand 653 668 */ 654 const char* ShellCommand Base::paramToString(long parameter)669 const char* ShellCommand::paramToString(long parameter) 655 670 { 656 671 return MultiType::MultiTypeToString((MT_Type)parameter); -
trunk/src/lib/shell/shell_command.h
r5552 r5636 13 13 #include "substring.h" 14 14 #include "functor_list.h" 15 15 #include "executor/executor.h" 16 16 #include <stdarg.h> 17 17 … … 30 30 * 31 31 * MEANING: 32 * ShellCommand Base* someUniqueVarName =32 * ShellCommand* someUniqueVarName = 33 33 * ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall); 34 34 * … … 36 36 * $ ClassName [ObjectName] commandNameInShell [parameters] 37 37 */ 38 //#define SHELL_COMMAND(command, class, function) \ 39 // ShellCommand* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function) 38 40 #define SHELL_COMMAND(command, class, function) \ 39 ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function) 41 ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorObjective<class>(&class::function)) 42 40 43 /** 41 44 * an easy to use Macro to create a Command … … 45 48 * 46 49 * MEANING: 47 * ShellCommand Base* someUniqueVarName =50 * ShellCommand* someUniqueVarName = 48 51 * ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall); 49 52 * … … 52 55 */ 53 56 #define SHELL_COMMAND_STATIC(command, class, function) \ 54 ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)57 ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorStatic<class>(function)) 55 58 56 59 … … 64 67 // BASE CLASS // 65 68 //////////////// 66 class ShellCommand Base;69 class ShellCommand; 67 70 class ShellCommandAlias; 68 71 … … 70 73 class ShellCommandClass : public BaseObject 71 74 { 72 friend class ShellCommand Base;75 friend class ShellCommand; 73 76 74 77 public: … … 93 96 const char* className; //!< The Name of the Class. This should match the ClassName of the Commands Class. 94 97 long classID; //!< The classID of this Class 95 tList<ShellCommand Base>* commandList; //!< A list of Commands from this Class98 tList<ShellCommand>* commandList; //!< A list of Commands from this Class 96 99 static tList<ShellCommandClass>* commandClassList; //!< A list of Classes 97 100 static tList<ShellCommandAlias>* aliasList; //!< An Alias to A Command. (only for classes with one Instance) … … 100 103 101 104 //! a baseClass for all possible ShellCommands 102 class ShellCommand Base: public BaseObject105 class ShellCommand : public BaseObject 103 106 { 104 107 friend class ShellCommandClass; … … 106 109 static bool execute (const char* executionString); 107 110 108 ShellCommand Base* describe(const char* description);109 ShellCommand Base* setAlias(const char* alias);110 ShellCommand Base* defaultValues(unsigned int count, ...);111 ShellCommand* describe(const char* description); 112 ShellCommand* setAlias(const char* alias); 113 ShellCommand* defaultValues(unsigned int count, ...); 111 114 112 /** @returns the CommandList of the Shell */ 115 static ShellCommand* registerCommand(const char* commandName, const char* className, Executor* executor); 116 113 117 static void unregisterCommand(const char* commandName, const char* className); 114 118 … … 116 120 117 121 protected: 118 ShellCommand Base(const char* commandName, const char* className, unsigned int paramCount, ...);119 ~ShellCommand Base();122 ShellCommand(const char* commandName, const char* className, unsigned int paramCount, ...); 123 ~ShellCommand(); 120 124 121 125 /** @returns the Type of this Function (either static or objective) */ … … 141 145 142 146 const char* description; //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla"); 143 };147 Executor* executor; 144 148 145 ///////////////////////////////////////////////////146 ///////////////////////////////////////////////////147 148 /////////////////////////////////149 // MACRO DEFINITION EXTENSIONS //150 /////////////////////////////////151 //! where to chek for default BOOL values152 #define l_BOOL_DEFGRAB(i) this->defaultValue[i].getBool()153 //! where to chek for default INT values154 #define l_INT_DEFGRAB(i) this->defaultValue[i].getInt()155 //! where to chek for default UINT values156 #define l_UINT_DEFGRAB(i) (unsigned int)this->defaultValue[i].getInt()157 //! where to chek for default LONG values158 #define l_LONG_DEFGRAB(i) (long)this->defaultValue[i].getInt()159 //! where to chek for default FLOAT values160 #define l_FLOAT_DEFGRAB(i) this->defaultValue[i].getFloat()161 //! where to chek for default STRING values162 #define l_STRING_DEFGRAB(i) this->defaultValue[i].getString()163 164 //////////////////////////165 // COMMAND REGISTRATION //166 //////////////////////////167 // SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic168 // SHELLCOMMANDEXECUTER can be redefined too.169 // SHELLCOMMANDINCLASS170 // SHELLCOMMANDTYPE171 //! registers a command without any parameters172 #define ShellCommandRegister0() \173 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \174 { \175 if (isRegistered(commandName, className, 0)== true) \176 return NULL; \177 return new SHELLCOMMAND<T>(commandName, className, function); \178 }179 180 //! registers a command with 1 parameter181 #define ShellCommandRegister1(t1) \182 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \183 { \184 if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \185 return NULL; \186 return new SHELLCOMMAND<T>(commandName, className, function); \187 }188 189 //! registers a command with 2 parameters190 #define ShellCommandRegister2(t1,t2) \191 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \192 { \193 if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \194 return NULL; \195 return new SHELLCOMMAND<T>(commandName, className, function); \196 }197 198 //! registers a command with 3 parameters199 #define ShellCommandRegister3(t1,t2,t3) \200 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \201 { \202 if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \203 return NULL; \204 return new SHELLCOMMAND<T>(commandName, className, function); \205 }206 207 //! registers a command with 4 parameters208 #define ShellCommandRegister4(t1,t2,t3,t4) \209 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \210 { \211 if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \212 return NULL; \213 return new SHELLCOMMAND<T>(commandName, className, function); \214 }215 216 //! registers a command with 5 parameters217 #define ShellCommandRegister5(t1,t2,t3,t4,t5) \218 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \219 { \220 if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \221 return NULL; \222 return new ShellCommand<T>(commandName, className, function); \223 }224 225 ///////////////////////226 // FUNCTION POINTERS //227 ///////////////////////228 #define ShellCommandFunctionPoiter0() \229 void SHELLCOMMANDINCLASS(*functionPointer_0)();230 231 #define ShellCommandFunctionPoiter1(t1) \232 void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE);233 234 #define ShellCommandFunctionPoiter2(t1, t2) \235 void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE);236 237 238 #define ShellCommandFunctionPoiter3(t1, t2, t3) \239 void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE);240 241 #define ShellCommandFunctionPoiter4(t1, t2, t3, t4) \242 void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE);243 244 245 #define ShellCommandFunctionPoiter5(t1, t2, t3, t4, t5) \246 void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \247 248 249 //////////////////250 // CONSTRUCTORS //251 /////////////////252 //! creates a command that takes no parameters253 #define ShellCommandConstructor0() \254 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \255 : ShellCommandBase(commandName, className, 0) \256 { \257 this->functorType = SHELLCOMMANDTYPE; \258 this->fp.functionPointer_0 = function; \259 }260 261 //! creates a command that takes one parameter262 #define ShellCommandConstructor1(t1) \263 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \264 : ShellCommandBase(commandName, className, 1, t1##_PARAM) \265 { \266 this->functorType = SHELLCOMMANDTYPE; \267 this->fp.functionPointer_1_##t1 = function; \268 }269 270 //! creates a command that takes two parameters271 #define ShellCommandConstructor2(t1,t2) \272 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \273 : ShellCommandBase(commandName, className, 2, t1##_PARAM, t2##_PARAM) \274 { \275 this->functorType = SHELLCOMMANDTYPE; \276 this->fp.functionPointer_2_##t1##_##t2 = function; \277 }278 279 //! creates a command that takes three parameter280 #define ShellCommandConstructor3(t1,t2,t3) \281 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \282 : ShellCommandBase(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \283 { \284 this->functorType = SHELLCOMMANDTYPE; \285 this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \286 }287 288 //! creates a command that takes four parameter289 #define ShellCommandConstructor4(t1,t2,t3,t4) \290 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \291 : ShellCommandBase(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \292 { \293 this->functorType = SHELLCOMMANDTYPE; \294 this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \295 }296 297 //! creates a command that takes five parameter298 #define ShellCommandConstructor5(t1,t2,t3,t4,t5) \299 SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \300 : ShellCommandBase(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \301 { \302 this->functorType = SHELLCOMMANDTYPE; \303 this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \304 }305 306 ///////////////307 // EXECUTION //308 ///////////////309 //! execute-macro for functions with no parameters310 #define ShellCommandExecute0() \311 if (this->paramCount == 0) \312 SHELLCOMMANDEXECUTER(_0)()313 314 //! execute-macro for functions with one parameter315 #define ShellCommandExecute1(t1) \316 else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \317 SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))318 319 //! execute-macro for functions with two parameters320 #define ShellCommandExecute2(t1,t2) \321 else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \322 SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))323 324 //! execute-macro for functions with three parameters325 #define ShellCommandExecute3(t1,t2,t3) \326 else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \327 SHELLCOMMANDEXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)))328 329 //! execute-macro for functions with four parameters330 #define ShellCommandExecute4(t1,t2,t3,t4) \331 else if (this->paramCount == 4 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM) \332 SHELLCOMMANDEXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)))333 334 //! execute-macro for functions with five parameters335 #define ShellCommandExecute5(t1,t2,t3,t4,t5) \336 else if (this->paramCount == 5 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM && this->parameters[4] == t5##_PARAM) \337 SHELLCOMMANDEXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)), t5##_FUNC(sub.getString(4), t5##_DEFGRAB(4)))338 339 340 //! keeps information about a ShellCommand341 template<class T> class ShellCommand : public ShellCommandBase342 {343 public:344 #ifdef FUNCTOR_LIST345 #undef FUNCTOR_LIST346 #endif347 #ifdef SHELLCOMMAND348 #undef SHELLCOMMAND349 #endif350 #define SHELLCOMMAND ShellCommand351 #ifdef SHELLCOMMANDEXECUTER352 #undef SHELLCOMMANDEXECUTER353 #endif354 #define SHELLCOMMANDEXECUTER(nameExt) (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt))355 #ifdef SHELLCOMMANDINCLASS356 #undef SHELLCOMMANDINCLASS357 #endif358 #define SHELLCOMMANDINCLASS(FUNCTION) (T::FUNCTION)359 #ifdef SHELLCOMMANDTYPE360 #undef SHELLCOMMANDTYPE361 #endif362 #define SHELLCOMMANDTYPE ShellCommand_Objective363 //! FUNCTOR_LIST is the List of command-registerers364 #define FUNCTOR_LIST(x) ShellCommandRegister ## x365 #include "functor_list.h"366 #undef FUNCTOR_LIST367 368 369 private:370 //! FUNCTOR_LIST is the List of FunctionPointers371 union FunctionPointers {372 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x373 #include "functor_list.h"374 #undef FUNCTOR_LIST375 } fp;376 377 //! FUNCTOR_LIST is the List of CommandConstructors378 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x379 #include "functor_list.h"380 #undef FUNCTOR_LIST381 382 virtual void executeCommand (BaseObject* object, const char* parameters)383 {384 SubString sub(parameters, true);385 //! FUNCTOR_LIST is the List of Executive Functions386 #define FUNCTOR_LIST(x) ShellCommandExecute ## x387 #include "functor_list.h"388 #undef FUNCTOR_LIST389 }390 };391 392 //! keeps information about a ShellCommand, that points to a Static Function393 template<class T> class ShellCommandStatic : public ShellCommandBase394 {395 public:396 #ifdef FUNCTOR_LIST397 #undef FUNCTOR_LIST398 #endif399 #ifdef SHELLCOMMAND400 #undef SHELLCOMMAND401 #endif402 #define SHELLCOMMAND ShellCommandStatic403 #ifdef SHELLCOMMANDEXECUTER404 #undef SHELLCOMMANDEXECUTER405 #endif406 #define SHELLCOMMANDEXECUTER(nameExt) fp.functionPointer##nameExt407 #ifdef SHELLCOMMANDINCLASS408 #undef SHELLCOMMANDINCLASS409 #endif410 #define SHELLCOMMANDINCLASS(FUNCTION) (FUNCTION)411 #ifdef SHELLCOMMANDTYPE412 #undef SHELLCOMMANDTYPE413 #endif414 #define SHELLCOMMANDTYPE ShellCommand_Static415 416 //! FUNCTOR_LIST is the List of command-registerers417 #define FUNCTOR_LIST(x) ShellCommandRegister ## x418 #include "functor_list.h"419 #undef FUNCTOR_LIST420 421 private:422 //! FUNCTOR_LIST is the List of FunctionPointers423 union FunctionPointers {424 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x425 #include "functor_list.h"426 #undef FUNCTOR_LIST427 } fp;428 429 //! FUNCTOR_LIST is the List of CommandConstructors430 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x431 #include "functor_list.h"432 #undef FUNCTOR_LIST433 434 virtual void executeCommand (BaseObject* object, const char* parameters)435 {436 SubString sub(parameters, true);437 //! FUNCTOR_LIST is the List of Executive Functions438 #define FUNCTOR_LIST(x) ShellCommandExecute ## x439 #include "functor_list.h"440 #undef FUNCTOR_LIST441 }442 149 }; 443 150 … … 445 152 class ShellCommandAlias 446 153 { 447 friend class ShellCommand Base;154 friend class ShellCommand; 448 155 public: 449 156 /** @returns the Name of the Alias. */ 450 157 const char* getName() const { return this->aliasName; }; 451 158 /** @returns the Command, this Alias is asociated with */ 452 ShellCommand Base* getCommand() const { return this->command; };159 ShellCommand* getCommand() const { return this->command; }; 453 160 454 161 private: 455 162 /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */ 456 ShellCommandAlias(const char* aliasName, ShellCommand Base* command) { this->aliasName = aliasName; this->command = command; };163 ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; }; 457 164 458 165 private: 459 166 const char* aliasName; //!< the name of the Alias 460 ShellCommand Base* command; //!< a pointer to the command, this alias executes.167 ShellCommand* command; //!< a pointer to the command, this alias executes. 461 168 }; 462 169 -
trunk/src/lib/shell/shell_input.cc
r5369 r5636 214 214 strcpy(newCommand, this->inputLine); 215 215 216 ShellCommand Base::execute(newCommand);216 ShellCommand::execute(newCommand); 217 217 218 218 // removing the eventually added Entry (from scrolling) to the List
Note: See TracChangeset
for help on using the changeset viewer.