Index: trunk/src/lib/event/command_chain.h
===================================================================
--- trunk/src/lib/event/command_chain.h	(revision 5460)
+++ trunk/src/lib/event/command_chain.h	(revision 5461)
@@ -1,9 +1,9 @@
 /*!
- * @file shell_command.h
+ * @file command_chain.h
  * Definition of a on-screen-shell
  */
 
-#ifndef _SHELL_COMMAND_H
-#define _SHELL_COMMAND_H
+#ifndef _COMMAND_CHAIN_H
+#define _COMMAND_CHAIN_H
 
 #include "base_object.h"
@@ -15,5 +15,5 @@
 #include <stdarg.h>
 
-#define     SHELL_COMMAND_MAX_SIZE      //!< The maximum size of a Shell Command
+#define     COMMAND_CHAIN_MAX_SIZE      //!< The maximum size of a Shell Command
 
 
@@ -29,12 +29,12 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
- *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
+ *  CommandChainBase* someUniqueVarName =
+ *       CommandChain<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
  * In the Shell you would call this Command using:
  * $ ClassName [ObjectName] commandNameInShell [parameters]
  */
-#define SHELL_COMMAND(command, class, function) \
-        ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
+#define COMMAND_CHAIN(command, class, function) \
+        CommandChainBase* command_chain_##class##_##command = CommandChain<class>::registerCommand(#command, #class, &class::function)
 /**
  * an easy to use Macro to create a Command
@@ -44,38 +44,38 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
- *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
+ *  CommandChainBase* someUniqueVarName =
+ *       CommandChain<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
  * In the Shell you would call this Command using:
  * $ ClassName [ObjectName] commandNameInShell [parameters]
  */
-#define SHELL_COMMAND_STATIC(command, class, function) \
-                         ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)
+#define COMMAND_CHAIN_STATIC(command, class, function) \
+                         CommandChainBase* command_chain_##class##_##command = CommandChainStatic<class>::registerCommand(#command, #class, function)
 
 
 //! an enumerator for the definition of the Type.
 typedef enum {
-  ShellCommand_Objective = 1,
-  ShellCommand_Static    = 2,
-} ShellCommand_Type;
+  CommandChain_Objective = 1,
+  CommandChain_Static    = 2,
+} CommandChain_Type;
 
 ////////////////
 // BASE CLASS //
 ////////////////
-class ShellCommandBase;
-class ShellCommandAlias;
+class CommandChainBase;
+class CommandChainAlias;
 
 //! A class to hold all Classes that have (once) registered Commands.
-class ShellCommandClass : public BaseObject
+class CommandChainClass : public BaseObject
 {
-  friend class ShellCommandBase;
+  friend class CommandChainBase;
 
   public:
     /** @returns the CommandClassList */
-    static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };
+    static const tList<CommandChainClass>* getCommandClassList() { return CommandChainClass::commandClassList; };
     static bool getCommandListOfClass(const char* className, tList<const char>* stringList);
     static bool getCommandListOfAlias(tList<const char>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static CommandChainClass* getCommandClass(const char* className);
     static void unregisterAllCommands();
 
@@ -83,8 +83,8 @@
 
   private:
-    ShellCommandClass(const char* className);
-    ~ShellCommandClass();
-
-    static const ShellCommandClass* isRegistered(const char* className);
+    CommandChainClass(const char* className);
+    ~CommandChainClass();
+
+    static const CommandChainClass* isRegistered(const char* className);
     static void initCommandClassList();
 
@@ -92,20 +92,20 @@
     const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                             classID;                   //!< The classID of this Class
-    tList<ShellCommandBase>*         commandList;               //!< A list of Commands from this Class
-    static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
-    static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
+    tList<CommandChainBase>*         commandList;               //!< A list of Commands from this Class
+    static tList<CommandChainClass>* commandClassList;          //!< A list of Classes
+    static tList<CommandChainAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
 };
 
 
-//! a baseClass for all possible ShellCommands
-class ShellCommandBase : public BaseObject
+//! a baseClass for all possible CommandChains
+class CommandChainBase : public BaseObject
 {
-  friend class ShellCommandClass;
+  friend class CommandChainClass;
   public:
     static bool execute (const char* executionString);
 
-    ShellCommandBase* describe(const char* description);
-    ShellCommandBase* setAlias(const char* alias);
-    ShellCommandBase* defaultValues(unsigned int count, ...);
+    CommandChainBase* describe(const char* description);
+    CommandChainBase* setAlias(const char* alias);
+    CommandChainBase* defaultValues(unsigned int count, ...);
 
     /** @returns the CommandList of the Shell */
@@ -115,9 +115,9 @@
 
   protected:
-    ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);
-    ~ShellCommandBase();
+    CommandChainBase(const char* commandName, const char* className, unsigned int paramCount, ...);
+    ~CommandChainBase();
 
     /** @returns the Type of this Function (either static or objective) */
-    inline ShellCommand_Type getType() { return this->functorType; };
+    inline CommandChain_Type getType() { return this->functorType; };
 
     static bool isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...);
@@ -129,5 +129,5 @@
 
   protected:
-    ShellCommand_Type                functorType;                          //!< The type of Function we've got (either static or objective).
+    CommandChain_Type                functorType;                          //!< The type of Function we've got (either static or objective).
     void*                            functionPointer;                      //!< The pointeer to the function of the Class (or static pointer if ClassID == CL_NULL )
     unsigned int                     paramCount;                           //!< the count of parameters.
@@ -140,6 +140,6 @@
 
   private:
-    ShellCommandClass*               shellClass;                           //!< A Pointer to the Shell-Class this Command belongs to.
-    ShellCommandAlias*               alias;                                //!< An Alias for the Class.
+    CommandChainClass*               shellClass;                           //!< A Pointer to the Shell-Class this Command belongs to.
+    CommandChainAlias*               alias;                                //!< An Alias for the Class.
 
     const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
@@ -168,10 +168,10 @@
 // COMMAND REGISTRATION //
 //////////////////////////
-// SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic
+// SHELLCOMMAND can be redefined as CommandChain or CommandChainStatic
 // SHELLCOMMANDEXECUTER can be redefined too.
 // SHELLCOMMANDINCLASS
 // SHELLCOMMANDTYPE
 //! registers a command without any parameters
-#define ShellCommandRegister0() \
+#define CommandChainRegister0() \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
   { \
@@ -182,5 +182,5 @@
 
 //! registers a command with 1 parameter
-#define ShellCommandRegister1(t1) \
+#define CommandChainRegister1(t1) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
   { \
@@ -191,5 +191,5 @@
 
 //! registers a command with 2 parameters
-#define ShellCommandRegister2(t1,t2) \
+#define CommandChainRegister2(t1,t2) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
   { \
@@ -200,5 +200,5 @@
 
 //! registers a command with 3 parameters
-#define ShellCommandRegister3(t1,t2,t3) \
+#define CommandChainRegister3(t1,t2,t3) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
   { \
@@ -209,5 +209,5 @@
 
 //! registers a command with 4 parameters
-#define ShellCommandRegister4(t1,t2,t3,t4) \
+#define CommandChainRegister4(t1,t2,t3,t4) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
   { \
@@ -218,10 +218,10 @@
 
 //! registers a command with 5 parameters
-#define ShellCommandRegister5(t1,t2,t3,t4,t5) \
+#define CommandChainRegister5(t1,t2,t3,t4,t5) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT, t5##_TYPE d5 = t5##_DEFAULT) \
   { \
     if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
       return NULL; \
-    return new ShellCommand<T>(commandName, className, function, d1, d2, d3, d4, d5); \
+    return new CommandChain<T>(commandName, className, function, d1, d2, d3, d4, d5); \
   }
 
@@ -230,8 +230,8 @@
 /////////////////
 //! creates a command that takes no parameters
-#define ShellCommandConstructor0() \
+#define CommandChainConstructor0() \
   void SHELLCOMMANDINCLASS(*functionPointer_0)(); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
-  : ShellCommandBase(commandName, className, 0) \
+  : CommandChainBase(commandName, className, 0) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -240,8 +240,8 @@
 
 //! creates a command that takes one parameter
-#define ShellCommandConstructor1(t1) \
+#define CommandChainConstructor1(t1) \
   void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1) \
-  : ShellCommandBase(commandName, className, 1, t1##_PARAM, d1) \
+  : CommandChainBase(commandName, className, 1, t1##_PARAM, d1) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -250,8 +250,8 @@
 
 //! creates a command that takes two parameters
-#define ShellCommandConstructor2(t1,t2) \
+#define CommandChainConstructor2(t1,t2) \
   void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1, t2##_TYPE d2) \
-  : ShellCommandBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
+  : CommandChainBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -260,8 +260,8 @@
 
 //! creates a command that takes three parameter
-#define ShellCommandConstructor3(t1,t2,t3) \
+#define CommandChainConstructor3(t1,t2,t3) \
   void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3) \
-  : ShellCommandBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
+  : CommandChainBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -270,8 +270,8 @@
 
 //! creates a command that takes four parameter
-#define ShellCommandConstructor4(t1,t2,t3,t4) \
+#define CommandChainConstructor4(t1,t2,t3,t4) \
   void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4) \
-  : ShellCommandBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
+  : CommandChainBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -280,8 +280,8 @@
 
 //! creates a command that takes five parameter
-#define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
+#define CommandChainConstructor5(t1,t2,t3,t4,t5) \
   void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4, t5##_TYPE d5) \
-  : ShellCommandBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
+  : CommandChainBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -293,36 +293,36 @@
 ///////////////
 //! execute-macro for functions with no parameters
-#define ShellCommandExecute0() \
+#define CommandChainExecute0() \
   if (this->paramCount == 0) \
     SHELLCOMMANDEXECUTER(_0)()
 
 //! execute-macro for functions with one parameter
-#define ShellCommandExecute1(t1) \
+#define CommandChainExecute1(t1) \
    else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
     SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
 
 //! execute-macro for functions with two parameters
-#define ShellCommandExecute2(t1,t2) \
+#define CommandChainExecute2(t1,t2) \
    else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
     SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
 
 //! execute-macro for functions with three parameters
-#define ShellCommandExecute3(t1,t2,t3) \
+#define CommandChainExecute3(t1,t2,t3) \
    else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
     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)))
 
 //! execute-macro for functions with four parameters
-#define ShellCommandExecute4(t1,t2,t3,t4) \
+#define CommandChainExecute4(t1,t2,t3,t4) \
    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) \
     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)))
 
 //! execute-macro for functions with five parameters
-#define ShellCommandExecute5(t1,t2,t3,t4,t5) \
+#define CommandChainExecute5(t1,t2,t3,t4,t5) \
    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) \
     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)))
 
 
-//! keeps information about a ShellCommand
-template<class T> class ShellCommand : public ShellCommandBase
+//! keeps information about a CommandChain
+template<class T> class CommandChain : public CommandChainBase
 {
   public:
@@ -333,5 +333,5 @@
 #undef SHELLCOMMAND
 #endif
-#define SHELLCOMMAND                       ShellCommand
+#define SHELLCOMMAND                       CommandChain
 #ifdef SHELLCOMMANDEXECUTER
 #undef SHELLCOMMANDEXECUTER
@@ -345,7 +345,7 @@
 #undef SHELLCOMMANDTYPE
 #endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Objective
+#define SHELLCOMMANDTYPE                   CommandChain_Objective
 //! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
+#define FUNCTOR_LIST(x) CommandChainRegister ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -354,5 +354,5 @@
   private:
 //! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
+#define FUNCTOR_LIST(x) CommandChainConstructor ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -362,5 +362,5 @@
       SubString sub(parameters, true);
 //! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
+#define FUNCTOR_LIST(x) CommandChainExecute ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -368,6 +368,6 @@
 };
 
-//! keeps information about a ShellCommand, that points to a Static Function
-template<class T> class ShellCommandStatic : public ShellCommandBase
+//! keeps information about a CommandChain, that points to a Static Function
+template<class T> class CommandChainStatic : public CommandChainBase
 {
   public:
@@ -378,5 +378,5 @@
 #undef SHELLCOMMAND
 #endif
-#define SHELLCOMMAND                      ShellCommandStatic
+#define SHELLCOMMAND                      CommandChainStatic
 #ifdef SHELLCOMMANDEXECUTER
 #undef SHELLCOMMANDEXECUTER
@@ -390,8 +390,8 @@
 #undef SHELLCOMMANDTYPE
 #endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Static
+#define SHELLCOMMANDTYPE                   CommandChain_Static
 
 //! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
+#define FUNCTOR_LIST(x) CommandChainRegister ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -399,5 +399,5 @@
   private:
 //! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
+#define FUNCTOR_LIST(x) CommandChainConstructor ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -407,5 +407,5 @@
   SubString sub(parameters, true);
 //! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
+#define FUNCTOR_LIST(x) CommandChainExecute ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -414,21 +414,21 @@
 
 //! A Class, that handles aliases.
-class ShellCommandAlias
+class CommandChainAlias
 {
-  friend class ShellCommandBase;
+  friend class CommandChainBase;
   public:
     /** @returns the Name of the Alias. */
     const char* getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
-    ShellCommandBase* getCommand() const { return this->command; };
+    CommandChainBase* getCommand() const { return this->command; };
 
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommandBase* command) { this->aliasName = aliasName; this->command = command; };
+    CommandChainAlias(const char* aliasName, CommandChainBase* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
     const char*         aliasName;       //!< the name of the Alias
-    ShellCommandBase*   command;         //!< a pointer to the command, this alias executes.
+    CommandChainBase*   command;         //!< a pointer to the command, this alias executes.
 };
 
-#endif /* _SHELL_COMMAND_H */
+#endif /* _COMMAND_CHAIN_H */
