for Schleife mit if, else if und else

[Chaka]

hi,
ich schau mir gerade eine Methode eines Konstruktors an und eigentlich sollte nach der Klassenbeschreibung folgendes geschehen:

Class argList
Sequences with "(" ... ")" are transformed into a stringList. For example,
    program -listFiles \( *.txt \)
would create a stringList:
    ( "file1.txt" "file2.txt" ... "fileN.txt" )
The backslash-escaping is required to avoid interpretation by the shell.

Wenn ich nun aber in den Konstruktor gehe und mir die Methode herausnehme welche oben genannte Beschreibung durchfuehren soll wie ich denke, ist das Ergebnis bei Annahme eines erdachten Terminalbefehls (siehe unter A) bei mir ein anderes:

bool Foam::argList::regroupArgv(int& argc, char**& argv)
  259 {
  260     int nArgs = 0;
  261     int listDepth = 0;
  262     string tmpString;
  263 
  264     // note: we also re-write directly into args_
  265     // and use a second pass to sort out args/options
  266     for (int argI = 0; argI < argc; ++argI)        //A
  267     {
  268         if (strcmp(argv[argI], "(") == 0)          //B
  269         {
  270             ++listDepth;
  271             tmpString += "(";
  272         }
  273         else if (strcmp(argv[argI], ")") == 0)     //C
  274         {
  275             if (listDepth)                         //D
  276             {
  277                 --listDepth;
  278                 tmpString += ")";
  279                 if (listDepth == 0)
  280                 {
  281                     args_[nArgs++] = tmpString;
  282                     tmpString.clear();
  283                 }
  284             }
  285             else                                   //E
  286             {
  287                 args_[nArgs++] = argv[argI];
  288             }
  289         }
  290         else if (listDepth)                        //F
  291         {
  292             // quote each string element
  293             tmpString += "\"";
  294             tmpString += argv[argI];
  295             tmpString += "\"";
  296         }
  297         else                                       //G
  298         {
  299             args_[nArgs++] = argv[argI];
  300         }
  301     }
  302 
  303     if (tmpString.size())                          //H
  304     {
  305         args_[nArgs++] = tmpString;
  306     }
  307 
  308     args_.setSize(nArgs);                          //I
  309 
  310     return nArgs < argc;
  311 }

mit den Ergebnissen:

A
//Annahme argc = 2 mit Programmaufruf dann (_File.txt_), Leerstelle _ wichtig
//1.erster Durchgang, argI=0
//2.zweiter Durchgang, argI=1, nArgs=1 //3.dritter Durchgang, argI=2,nArgs=2
B
//1.nicht erfuellt da erstes Argument Programmaufruf
//2.erfuellt da zweites Argument mit ( beginnt sprich nur ( ist, listDepth wird 1, tmpString wird (
//3. nicht erfuellt
C
//1.nicht erfuellt da erstes Argument Programmaufruf weiter mit 289
//2.nicht erfuellt weiter mit 289
//3. erfuellt
D
//3. nochmal erfuellt da listDepth immernoch 1
//3.listDepth=0 und tmpString wird zu (“argv[1]“)
//3. nochmal erfuellt, da listDepth nun 0
E
kein Eintrag
F
//1.waere 0, also false weiter mit 298
//2.erfuellt listDepth=1
//2. tmpString wird letzlich (“argv[1]“ , weiter mit 304
G
//1.args_[1] wird argv[argI] sprich argv[0]
H
//1.waere 0, also false
//2.erfuellt, da groese ungleich 0
//2. args_[2] wird zu (“argv[1]“ , nArgs wird 2
//3. nicht erfuell da tmpString nun leer
I
//1.Ergebnis args_ bekommt kurzzeitig die groese 1, nArgs ist 1, args_[1] wird argv[argI] sprich argv[0]
//2.Ergebnis args_ bekommt kurzzeitig die groese 2, nArgs ist 2, args_[2] wird zu (“argv[1]“
//3.Ergebnis: args_[3] wird zu (“argv[1]“), args_ bekommt groese 3, nArgs=3

ich bin jetzt schon mehremals die Schleife durchgegangen und komme immer wieder auf die Ergebnisse unter I insbesondere fuer die stringList args_. Diese sind ja recht seltsam, da nach ihnen unter args[2] (“argv[1]“ und unter args[3] (“argv[1]“) abgelegt werden wuerde. Vielleicht kann jemand mal drueber schaun und findet einen Fehler (in meiner Analyse )?