Text aus Textdatei

[Tobi_]

Hi Leute,

kann mir jemand von euch auf die Sprünge helfen?

Ich habe die Datei anscheinend erfolgreich eingelesen. Jetzt würde ich gerne überprüfen, ob das auch wirklich erfolgreich war, indem ich mir den Text aus der .asm-Datei ausgeben lasse. Wie mache ich das denn?


Gruß Tobi

[fetzer]

http://de.wikibooks.org/wiki/C-Programm ... nd_Ausgabe

So?

[Tobi_]

Danke erstmal für die Hilfe, aber ne, das meinte ich nicht.

Also, ich bin momentan soweit, dass ich die Datei erfolgreich einlesen kann und mir die erste Zeile der Datei ausgeben kann.

Nun, damit ich den MIPS-Interpreter erfolgreich programmieren kann, muss ich doch an die einzelnen Tokens irgendwie dran kommen oder?

Dazu würde ich gerne die Funktion strtok(…) benutzen, habe aber noch nicht ganz verstanden, wie diese funktioniert.

Mit folgendem Code:

FILE *Data;
if(!(Data = fopen("Pfad", "r"))) {
printf("Fehler beim Datei öffnen \n");
}
Data = fopen("Pfad", "r");
printf("Datei erfolgreich eingelesen \n");
char Ausgabe[256];
fgets(Ausgabe, 256, Data);
printf("%s", Ausgabe);

char trennzeichen[] = " ";
char *wort;
wort = strtok(Ausgabe, trennzeichen);
printf("%s", wort);
fclose(Data);
return Ausgabe;

kann ich mir das erste Wort bis zum ersten Leerzeichen ausgeben lassen. Aber wie komme ich dann aber an das nächste Token alleine?
Oder habe ich da jetzt einen Denkfehler?

[fetzer]

Wenn ich das richtig verstanden habe müsste es so gehen:

Code: Alles auswählen

char *wort;
while((wort = strtok(Ausgabe, trennzeichen))!=NULL) {
      printf("%s", wort);
      wort = strtok(NULL, trennzeichen); 
}

edit: korrigiert

edit: .. und damit völlig falsch gemacht. Siehe korrekte Version von m_stoica

[.jar Head]

wenn wir nach "," trennen wollen, bekommen wir eine Fehlermeldung, weil Integers in der Zeichenkette sind.

[m_stoica]

@fetzer
hast du das auch mal ausprobiert? Ich kann mir nicht vorstellen, dass das so klappen kann, aufgrund der Zuweisung die du ja immer wieder machst in der schleifen-bedinung.
Das erstemal würdest du ja den String zerhacken (wird durch nullen getrennt). Nach dem Zweiten durchlauf startest du das ganze wieder von vorne aber nur mit dem ersten "getokten" String.
Ich hätte es so gemacht:

Code: Alles auswählen

char *wort;
wort = strtok(Ausgabe, trennzeichen);
while(wort!=NULL) {
      printf("%s", wort);
      wort = strtok(NULL, trennzeichen);
}

[fetzer]

Ja, du hast Recht, das funktioniert so nicht.

[mazbu]

ich benutze de Method strtok auch ....aber ich bekomme immer Segmentation fault oder Bus error beim MacOX .... ich möchte alle Argumente ins eine Array schieben und habe dafür schon malloc benutzt , es geht trotztdem nicht

Code: Alles auswählen

char **code_part;
code_part = malloc (4 * sizeof(char *) ) ;

char delimeter[] = "  ," ;
for( k = 0 ; k < 4 ; k ++) {
           code_part [k]= malloc (80 * sizeof(char *) ) ;
     }
int k = 0 ; 
char *token;
token = malloc (sizeof(char *)) ;
token = strtok(prog1.code[0] , delimeter ) ;
while (token != NULL){
      strcpy ( code_part[k] , token ) ;
      token = strtok(prog1.code[0] , delimeter ) ;
      free(code_part[k]);
      k++;
    }

[m_stoica]

puh ich blicke da nicht so ganz durch erlich gesagt:

Code: Alles auswählen

char **code_part;
code_part = malloc (4 * sizeof(char *) ) ; //ein cast könnte hier nicht schaden

char delimeter[] = "  ," ;
for( k = 0 ; k < 4 ; k ++) {
           code_part [k]= malloc (80 * sizeof(char *) ) ; // auch hier casten, aber warum (80 * sizeof(char *)? 
                                                                  //wozu die 80-Pointer an dieser stelle? Du meinst wohl
                                                                  //(80 * sizeof(char )
     }
int k = 0 ;
char *token;
token = malloc (sizeof(char *)) ; // Die Zeile ist unnötig. Das macht in dem Fall C schon selbst.
                                    // (genau wie bei int, char, usw.)
token = strtok(prog1.code[0] , delimeter ) ;
while (token != NULL){
      strcpy ( code_part[k] , token ) ;
      token = strtok(prog1.code[0] , delimeter ) ;  //hier meinst du wohl: token = strtok(NULL, delimeter ) ;
      free(code_part[k]); //das kann ich nicht nachvollziehen. Du kopierst das token da rein, um es wieder zu löschen?
      k++;
    }

[mazbu]

also, am Anfang habe ich so gemach:

Code: Alles auswählen

char *token;
char code_part[4][80];
char delimeter[] = "  ," ;
int k=0;
token = strtok(prog1.code[1], delimeter);
while(token !=NULL){
       strcpy(code_part[k], token);
       token = strtok(NULL, delimeter);
      k++;
}

und habe diese Fehlermeldung bekommen: Segmentation fault. Danach habe ich mit Malloc versucht aber es geht trotzdem nicht. Ich habe jetzt die Fehler korrigiert, die du mir gezeigt hast. Troztdem bekomme ich noch immer diese Fehler.

Code: Alles auswählen

char **code_part;
code_part = (char*)malloc (4 * sizeof(char) ) ;

char delimeter[] = "  ," ;
for( k = 0 ; k < 4 ; k ++) {
           code_part [k]= (char*)malloc (80 * sizeof(char) ) ;
     }
int k = 0 ;
char *token;
token = strtok(prog1.code[0] , delimeter ) ;
while (token != NULL){
      strcpy ( code_part[k] , token ) ;
      token = strtok(NULL , delimeter ) ;
      k++;
    }

woran kann es liegen?

[m_stoica]

so klappt es:

Code: Alles auswählen

#include <stdio.h>
#include <stdlib.h>


int main(void){
char **code_part;
code_part = (char**)malloc (4 * sizeof(char*) ) ;

char *delimeter = "  ," ;
int k = 0;
code_part[0] = (char*)strtok("Hello World!,What's up?" , delimeter ) ;

while (code_part[k]){
k++;
      code_part[k] =(char*) strtok(NULL , delimeter ) ;
      
    }
printf("%s\n", code_part[0]); //Hello
printf("%s\n", code_part[1]); //World!

return 0;

}

[mazbu]

ich habe schone mit deine Vorschlag geschafft , Zeile auszuführen aber das Problem erscheint wieder nach dem es 4-5 Zeilen ausgeführt hat , ich habe versucht Malloc in loop reinzulegen und danach frei es (nach dem Zeile ausgeführt wurde ).....

[m_stoica]

ich weiß ja nicht was du da so anstellst, in deiner loop

[mazbu]

so habe ich gemacht

Code: Alles auswählen

 
 i :  Anzahle der  Zeile in file 
char **code_part;
code_part = (char**)malloc (4 * sizeof(char*) ) ;

char *delimeter = "  ," ;
int k = 0;
 
while (zeile < i ){
     k = 0 ;
          token = strtok(prog1.code[zeile], delimeter);
      strcpy(code_part[k], token);
      k++;
      while(token != NULL){
         token = strtok(prog1.code[zeile], delimeter);
         strcpy(code_part[k], token);
         k++;
      }
      char *befehl_array[11]={"add", "addi", "beq", "lw", "sw", "j", "jr", "jal", "lui", "ori", "syscall"};
      int index=-1;
      char *a1,*a2;
      for(k =0; k<11;k++){
	  a1= code_part[0];
          a2= befehl_array[k];
          if(strcmp(a1,a2)==0) index=k;
      }
// danach Code für Bearbeitung des MIPS Zeile
//zeile wurde natürlich schon verändert
}  

ich weiße nicht wo das Problem liegen kann

[Jonathan]

Code: Alles auswählen

 
char **code_part;
code_part = (char**)malloc (4 * sizeof(char*) ) ;
.
.
.
      strcpy(code_part[k], token);

Ich hab deinen Code noch nicht ganz durchgelesen und nachvollzogen, aber das hier ist mir gleich ins Auge gesprungen.
Du hast zwar code_part selber allokiert, aber die einzelnen Array-Einträge zeigen nicht auf gültige Speicherbereiche. Du müsstest also noch alle code_part mit einem char* initialisieren, der auf einen ausreichend großen Buffer zeigt.
Alternativ kannst du strdup() verwenden, das sieht dann etwa so aus:

Code: Alles auswählen

code_part[k] = strdup(token);

strdup ruft intern malloc auf, du musst hinterher also auch wieder free aufrufen.

Die nachfolgende while-Schleife hat auch ein paar Probleme:

Code: Alles auswählen

 
      while(token != NULL){
         token = strtok(prog1.code[zeile], delimeter);
         strcpy(code_part[k], token);
         k++;
      }

Nach dem ersten Aufruf von strtok muss das erste Argument NULL sein, nur so weiß strtok dass der String schon teliweise geparst ist und verwendet die intern gespeicherten Zwischendaten. Ausserdem funktioniert die Behandlung des Abbruchfalls nicht, wenn strtok NULL zurückgegeben hat, wird noch einmal strcpy mit NULL aufgerufen, das kann nicht gutgehen.