Changeset 7221 in orxonox.OLD for trunk/src/lib/shell

Timestamp:

Mar 15, 2006, 3:10:45 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the std-branche back, it runs on windows and Linux

svn merge ​https://svn.orxonox.net/orxonox/branches/std . -r7202:HEAD

Location:

trunk/src/lib/shell

Files:

• shell.cc (modified) (10 diffs)
• shell.h (modified) (4 diffs)
• shell_command.cc (modified) (10 diffs)
• shell_command.h (modified) (4 diffs)
• shell_command_class.cc (modified) (12 diffs)
• shell_command_class.h (modified) (1 diff)
• shell_completion.cc (modified) (11 diffs)
• shell_completion.h (modified) (1 diff)
• shell_input.cc (modified) (14 diffs)
• shell_input.h (modified) (3 diffs)

trunk/src/lib/shell/shell.cc

@@ -85 +85 @@
   this->lineSpacing = 0;
   this->bActive = true;
-  this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
-  strcpy(this->fontFile, SHELL_DEFAULT_FONT);
+  this->fontFile = SHELL_DEFAULT_FONT;
 
 
@@ -110 +109 @@
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
@@ -139 +137 @@
     if (!top)
     {
-      this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
@@ -167 +165 @@
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
     {
-      this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
     }
@@ -181 +179 @@
  * (be aware that within orxonox fontFile is relative to the Data-Dir)
  */
-void Shell::setFont(const char* fontFile)
+void Shell::setFont(const std::string& fontFile)
 {
 //   if (!ResourceManager::isInDataDir(fontFile))
 //     return false;
 
-  if (this->fontFile != NULL)
-    delete[] this->fontFile;
-
-  this->fontFile = new char[strlen(fontFile)+1];
-  strcpy(this->fontFile, fontFile);
+  this->fontFile = fontFile;
 
   this->rebuildText();
@@ -245 +239 @@
  * @param fileName the filename of the Image to load
  */
-void Shell::setBackgroundImage(const char* fileName)
+void Shell::setBackgroundImage(const std::string& fileName)
 {
   this->backgroundMaterial->setDiffuseMap(fileName);
@@ -340 +334 @@
     for (int i = 0; i < this->bufferDisplaySize; i++)
     {
-      this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
     }
 
@@ -351 +345 @@
  * @param text the text to output.
  */
-void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
 {
   if(likely(bufferText != NULL))
@@ -382 +376 @@
     this->bufferText[0] = lastText;
 
-    this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
   }
 }
@@ -427 +421 @@
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
   {
-    this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
   }

trunk/src/lib/shell/shell.h

@@ -53 +53 @@
     inline bool isActive() const { return this->bActive; };
 
-    void setFont(const char* fontFile);
+    void setFont(const std::string& fontFile);
     void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
     void setTextColor(float r, float g, float b, float a);
     void setBackgroundColor(float r, float g, float b, float a);
-    void setBackgroundImage(const char* fileName);
+    void setBackgroundImage(const std::string& fileName);
 
     void resetValues();
@@ -64 +64 @@
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
-    void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 
@@ -83 +83 @@
 
     //     void testI (int i);
-    //     void testS (const char* s);
+    //     void testS (const std::string& s);
     //     void testB (bool b);
     //     void testF (float f);
-    //     void testSF (const char* s, float f);
+    //     void testSF (const std::string& s, float f);
 
   private:
@@ -95 +95 @@
     unsigned int                textSize;               //!< The size of the text.
     float                       textColor[4];           //!< The text's color [r,g,b,a].
-    char*                       fontFile;               //!< The file containing the font.
+    std::string                 fontFile;               //!< The file containing the font.
     Material*                   backgroundMaterial;     //!< A material for the background.
 

trunk/src/lib/shell/shell_command.cc

@@ -41 +41 @@
   PRINTF(5)("create shellcommand %s %s\n", commandName, className);
   this->setName(commandName);
-  this->description = NULL;
-  this->alias = NULL;
   this->executor = executor.clone();
   this->executor->setName(commandName);
@@ -153 +151 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -177 +175 @@
       for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
       {
-        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+        if (inputSplits.getString(0) == (*alias)->getName() && (*alias)->getCommand() != NULL &&
             (*alias)->getCommand()->shellClass != NULL )
         {
@@ -184 +182 @@
           {
             if (inputSplits.getCount() > 1)
-              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
+            {
+
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1))); /// TODO CHECK IF OK
+            }
             else
               (*alias)->getCommand()->executor->execute(objectList->front(), "");
@@ -198 +199 @@
       for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
       {
-        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        if ((*commandClassIT)->getName() && inputSplits.getString(0) == (*commandClassIT)->getName())
         {
           //elemCL->getName();
@@ -217 +218 @@
         for (object = objectList->begin(); object != objectList->end(); object++)
         {
-          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          if ((*object)->getName() != NULL && inputSplits.getString(1) == (*object)->getName() )
           {
             objectPointer = (*object);
@@ -235 +236 @@
         for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
         {
-          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          if (inputSplits.getString(fktPos) == (*cmdIT)->getName())
           {
             if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
               return false;
             if (inputSplits.getCount() > fktPos+1)
-              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1))); /// TODO CHECK IF OK
             else
               (*cmdIT)->executor->execute(objectPointer, "");
@@ -255 +256 @@
  * @param description the description of the Given command
  */
-ShellCommand* ShellCommand::describe(const char* description)
+ShellCommand* ShellCommand::describe(const std::string& description)
 {
   if (this == NULL)
@@ -326 +327 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
 
     list<ShellCommand*>::iterator cmdIT;
@@ -335 +336 @@
       /*      for (unsigned int i = 0; i< elem->paramCount; i++)
        printf("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-      if ((*cmdIT)->description != NULL)
-       printf("- %s", (*cmdIT)->description);
+      if (!(*cmdIT)->description.empty())
+        printf("- %s", (*cmdIT)->description.c_str());
       printf("\n");
 

trunk/src/lib/shell/shell_command.h

@@ -61 +61 @@
   friend class ShellCommandClass;
   public:
-    static bool execute (const char* executionString);
+    static bool execute (const std::string& executionString);
 
-    ShellCommand* describe(const char* description);
+    ShellCommand* describe(const std::string& description);
     ShellCommand* setAlias(const char* alias);
     ShellCommand* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
@@ -89 +89 @@
     ShellCommandAlias*               alias;                                //!< An Alias for the Class.
 
-    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
+    std::string                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
     Executor*                        executor;                             //!< The Executor, that really executes the Function.
 
@@ -100 +100 @@
   public:
     /** @returns the Name of the Alias. */
-    const char* getName() const { return this->aliasName; };
+    const std::string& getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
     ShellCommand* getCommand() const { return this->command; };
@@ -106 +106 @@
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
+    ShellCommandAlias(const std::string& aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
-    const char*     aliasName;       //!< the name of the Alias
+    std::string     aliasName;       //!< the name of the Alias
     ShellCommand*   command;         //!< a pointer to the command, this alias executes.
 };

trunk/src/lib/shell/shell_command_class.cc

@@ -36 +36 @@
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
+ShellCommandClass::ShellCommandClass(const std::string& className)
+  : className(className)
 {
   this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
   this->setName(className);
 
-  this->className = className;
   this->classID = CL_NULL;
 
@@ -65 +65 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
-{
-  if (stringList == NULL || className == NULL)
+bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
+{
+  if (stringList == NULL)
     return false;
 
@@ -73 +73 @@
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
   {
-    if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
     {
       list<ShellCommand*>::iterator command;
@@ -88 +88 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
@@ -130 +130 @@
  * @returns the CommandClass if found, NULL otherwise
  */
-const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
+const ShellCommandClass* ShellCommandClass::isRegistered(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -138 +138 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       if ((*classIT)->classID == CL_NULL)
@@ -154 +154 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -162 +162 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       return (*classIT);
@@ -186 +186 @@
  * @param className: the Class of Commands to show help about
  */
-void ShellCommandClass::help(const char* className)
-{
-  if (className == NULL)
-    return;
+void ShellCommandClass::help(const std::string& className)
+{
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
@@ -195 +193 @@
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
     {
-      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
+      if (className == (*classIT)->className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
         list<ShellCommand*>::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
@@ -205 +203 @@
           /*          for (unsigned int i = 0; i< elem->paramCount; i++)
             PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-          if ((*cmdIT)->description != NULL)
-            PRINT(0)("- %s", (*cmdIT)->description);
+          if (!(*cmdIT)->description.empty())
+            PRINT(0)("- %s", (*cmdIT)->description.c_str());
           PRINT(0)("\n");
         }
@@ -212 +210 @@
       }
     }
-    PRINTF(3)("Class %s not found in Command's classes\n", className);
+    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
   }
   else

trunk/src/lib/shell/shell_command_class.h

@@ -27 +27 @@
     /** @returns the CommandClassList */
     static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
-    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
+    static bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
+    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static ShellCommandClass* getCommandClass(const std::string& className);
     static void unregisterAllCommands();
 
-    static void help (const char* className);
+    static void help (const std::string& className);
 
   private:
-    ShellCommandClass(const char* className);
+    ShellCommandClass(const std::string& className);
     virtual ~ShellCommandClass();
 
-    static const ShellCommandClass* isRegistered(const char* className);
+    static const ShellCommandClass* isRegistered(const std::string& className);
     static void initCommandClassList();
 
   private:
-    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                                   classID;                   //!< The classID of this Class
     std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class

trunk/src/lib/shell/shell_completion.cc

@@ -76 +76 @@
 
   // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
-  if (this->input->getInput() != NULL &&
-      strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
+  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
   {
     emptyComplete = true;
@@ -83 +82 @@
 
   // CREATE INPUTS
-  if (this->input->getInput() == NULL)
-    completionLine = "";
-  else
-    completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
-  SubString inputSplits(completionLine, " \t\n,");
+  SubString inputSplits(this->input->getInput(), " \t\n,");
 
   // What String will be completed
@@ -93 +88 @@
     completeString = "";
   else
-    completeString = inputSplits.getString(inputSplits.getCount()-1);
+    completeString = inputSplits.getString(inputSplits.getCount()-1).c_str();
 
   // CLASS COMPLETION
@@ -111 +106 @@
             (inputSplits.getCount() == 2 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0).c_str()); //FIXME
     objectList = ClassList::getList((ClassID)classID);
     if (classID != CL_NULL)
@@ -121 +116 @@
             (inputSplits.getCount() == 3 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0) .c_str()); // FIXME
     if (classID == CL_NULL)
       return false;
@@ -133 +128 @@
     this->objectComplete(completeString, classID);
   if (completeType & SHELLC_FUNCTION)
-    this->functionComplete(completeString, inputSplits.getString(0));
+    this->functionComplete(completeString, inputSplits.getString(0).c_str()); // FIXME
   if (completeType & SHELLC_ALIAS)
     this->aliasComplete(completeString);
@@ -151 +146 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const std::list<const char*>* clList = ClassList::getClassNames();
+  const std::list<std::string>* clList = ClassList::getClassNames();
   if (clList != NULL)
   {
@@ -195 +190 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  std::list<const char*> fktList;
+  std::list<std::string> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -212 +207 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  std::list<const char*> aliasList;
+  std::list<std::string> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -295 +290 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -301 +296 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  list<const char*>::const_iterator string;
+  list<std::string>::const_iterator string;
   for (string = inputList->begin(); string != inputList->end(); string++)
   {
-    if (strlen(*string) >= searchLength &&
-        !strncasecmp(*string, completionBegin, searchLength))
+    if ((*string).size() >= searchLength &&
+          !strncasecmp((*string).c_str(), completionBegin, searchLength))
     {
       ShellC_Element newElem;
-      newElem.name = *string;
+      newElem.name = (*string).c_str();
       newElem.type = type;
       this->completionList.push_back(newElem);

trunk/src/lib/shell/shell_completion.h

@@ -52 +52 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
   bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();

trunk/src/lib/shell/shell_input.cc

@@ -41 +41 @@
  * this also generates a ShellCompletion automatically.
 */
-ShellInput::ShellInput () : Text ((const char*)NULL)
+ShellInput::ShellInput () : Text ("")
 {
   this->pressedKey = SDLK_FIRST;
   this->setClassID(CL_SHELL_INPUT, "ShellInput");
 
-  this->inputLine = new char[1];
-  this->inputLine[0] = '\0';
+  this->inputLine = "";
   this->historyIT = this->history.begin();
   this->setHistoryLength(50);
@@ -70 +69 @@
 {
   // delete what has to be deleted here
-  delete[] this->inputLine;
   delete this->completion;
 
   while (!this->history.empty())
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -96 +93 @@
 void ShellInput::flush()
 {
-  if (likely(this->inputLine != NULL))
-  {
-    delete[] this->inputLine;
-  }
-  this->inputLine = new char[1];
-  *this->inputLine = '\0';
-  this->setText(this->inputLine, true);
+  this->inputLine.clear();
+  this->setText(this->inputLine);
 }
 
@@ -109 +101 @@
  * @param text the new Text to set as InputLine
  */
-void ShellInput::setInputText(const char* text)
-{
-  delete[] this->inputLine;
-  if (text == NULL)
-  {
-    this->inputLine = new char[1];
-    this->inputLine[0] = '\0';
-  }
-  else
-  {
-    this->inputLine = new char[strlen(text)+1];
-    strcpy(this->inputLine, text);
-  }
-  this->setText(this->inputLine, true);
+void ShellInput::setInputText(const std::string& text)
+{
+  this->inputLine = text;
+  this->setText(this->inputLine);
 }
 
@@ -134 +116 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+2];
-
-  sprintf(addCharLine, "%s%c", this->inputLine, character);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += character;
+  this->setText(this->inputLine);
 }
 
@@ -151 +128 @@
  * @param characters a \\0 terminated char-array to add to the InputLine
  */
-void ShellInput::addCharacters(const char* characters)
+void ShellInput::addCharacters(const std::string& characters)
 {
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
-
-  sprintf(addCharLine, "%s%s", this->inputLine, characters);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += characters;
+  this->setText(this->inputLine);
 }
 
@@ -176 +148 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
-
-  if (strlen(this->inputLine) == 0)
-    return;
-
-  if (characterCount > strlen(this->inputLine))
-    characterCount = strlen(this->inputLine);
-
-  char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
-
-  strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
-  removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
-  delete[] this->inputLine;
-  this->inputLine = removeCharLine;
-  this->setText(this->inputLine, true);
+  if (this->inputLine.size() < characterCount)
+    characterCount = this->inputLine.size();
+
+  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
+  this->setText(this->inputLine);
 }
 
@@ -202 +164 @@
 bool ShellInput::executeCommand()
 {
-  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
-
-  if (strlen(this->inputLine) == 0)
+  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+
+  if (this->inputLine.empty())
     return false;
 
-  char* newCommand = new char[strlen(this->inputLine)+1];
-  strcpy(newCommand, this->inputLine);
-
-  ShellCommand::execute(newCommand);
+  ShellCommand::execute(this->inputLine);
 
   // removing the eventually added Entry (from scrolling) to the List
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
@@ -221 +179 @@
 
   // adding the new Command to the History
-  this->history.push_back(newCommand);
+  this->history.push_back(this->inputLine);
   if (this->history.size() > this->historyLength)
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -241 +198 @@
   if (!this->historyScrolling)
   {
-    char* currentText = new char[strlen(this->inputLine)+1];
-    strcpy(currentText, this->inputLine);
-    this->history.push_back(currentText);
+    this->history.push_back(this->inputLine);
     this->historyScrolling = true;
     this->historyIT = --this->history.end();
@@ -250 +205 @@
   if(this->historyIT != this->history.begin())
   {
-    char* prevElem = *(--this->historyIT);
-    if (prevElem == NULL)
+    std::string prevElem = *(--this->historyIT);
+    /*if (prevElem == NULL) /// TODO STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -270 +225 @@
   if (this->historyIT != this->history.end())
   {
-    char* nextElem = *(++this->historyIT);
-    if (nextElem == NULL)
+    std::string nextElem = *(++this->historyIT);
+    /*    if (nextElem == NULL) /// TODO FIX STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -285 +240 @@
  * prints out some nice help about the Shell
  */
-void ShellInput::help(const char* className, const char* functionName)
-{
-  printf("%s::%s\n", className, functionName);
-
-  if (strlen(className) == 0)
+void ShellInput::help(const std::string& className, const std::string& functionName)
+{
+  printf("%s::%s\n", className.c_str(), functionName.c_str());
+
+  if (className.empty())
   {
     PRINT(0)("Help for the most important Shell-commands\n");
@@ -298 +253 @@
     PRINT(0)("- Also try 'help className'");
   }
-  else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
   {
     ShellCommandClass::help(className);

trunk/src/lib/shell/shell_input.h

@@ -31 +31 @@
 
   /** @returns the inputLine */
-  const char* getInput() const { return this->inputLine; };
+  const std::string& getInput() const { return this->inputLine; };
 
   // InputLine
   void flush();
-  void setInputText(const char* text);
+  void setInputText(const std::string& text);
   void addCharacter(char character);
-  void addCharacters(const char* characters);
+  void addCharacters(const std::string& characters);
   void removeCharacters(unsigned int characterCount = 1);
   void setRepeatDelay(float repeatDelay, float repeatRate);
@@ -47 +47 @@
   void historyMoveDown();
 
-  void help(const char* className = "", const char* function = "");
+  void help(const std::string& className = "", const std::string& function = "");
 
   virtual void tick(float dt);
@@ -54 +54 @@
  private:
     // HANDLING TEXT INPUT
-   ShellCompletion*            completion;             //!< The Completion Interface.
+   ShellCompletion*                  completion;       //!< The Completion Interface.
 
-   char*                       inputLine;              //!< the Char-Array of the Buffer
-   float                       repeatRate;             //!< The Repeat-Delay.
-   float                       repeatDelay;            //!< The delay of the first Character of a given Character.
-   float                       delayed;                //!< how much of the delay is remaining.
-   Uint16                      pressedKey;             //!< the pressed key that will be repeated.
+   std::string                       inputLine;        //!< the Char-Array of the Buffer
+   float                             repeatRate;       //!< The Repeat-Delay.
+   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
+   float                             delayed;          //!< how much of the delay is remaining.
+   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
 
-   std::list<char*>            history;                //!< The history of given commands.
-   std::list<char*>::iterator  historyIT;
-   unsigned int                historyLength;          //!< The maximum length of the InputHistory.
-   bool                        historyScrolling;       //!< true if we are scrolling through the history.
+   std::list<std::string>            history;          //!< The history of given commands.
+   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
+   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
+   bool                              historyScrolling; //!< true if we are scrolling through the history.
 };