4. E:StackOverflow

E:StackOverflow

  • S

    Ich bekomme oben genannte Fehlermeldung wenn ich die #defines erhöhe. Brauche aber bei #define ZEICHEN 2400000 und bei #define MAX_ZEILEN 30000 diese größen, weil relativ große eingangsdateien habe und diese automatisch weiterverarbeitet werden müssen.

    Danke schonmal für die Hilfe ...

    /********************************************************************************
Autor: Daniel Michele
Abteilung: QI-Lbs1/Le
Letze Aktualisierung: 28.09.04
Name: sheet.c

Funktion:

Dieses Programm öffnet eine Vorher in txt convertierte Excel Tabelle nach Format:

| TTNR | VSTK in Cent*100 |

Danach werden alle Erforderlichen Angaben abgefragt und angehängt. Danach folgt
eine Ausgabe in ein in Excel portabeles Dateiformat (vorzugsweise *.txt ).

*********************************************************************************

Kleine Info:

const unsigned char AE = unsigned char ( 142 );
const unsigned char ae = unsigned char ( 132 ); 
const unsigned char OE = unsigned char ( 153 ); 
const unsigned char oe = unsigned char ( 148 ); 
const unsigned char UE = unsigned char ( 154 ); 
const unsigned char ue = unsigned char ( 129 ); 
const unsigned char ss = unsigned char ( 225 );

********************************************************************************/

/* -------------------- INCLUDES ----------------- */
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <string.h>

/* -------------------- DEFINES ------------------ */

#define PFAD_LEN 255
#define ZEICHEN 2400000
#define MAX_ZEILEN 30000
#define ZEILE_LEN 200

/* ---------- TABELLENSTRUKTUR ----------- */

struct sTabelle
{
 char preis[11];
 char TTNr[11];
 char zeile[ZEILE_LEN];
 char string[ZEILE_LEN];

} ;

/* --------- BEGINN DER FKTNEN ---------- */

void wait4key(void);
void eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2]);
int lesen_datei(FILE *source, char array[ZEICHEN],char source_pfad[PFAD_LEN]);
void write_table(struct sTabelle tabelle[MAX_ZEILEN],char array[ZEICHEN],char ka[3],char lfw[7],FILE* target,char target_pfad[PFAD_LEN],char gueltigkeit[2]);
void datum_calc(char datum[7]);
int show_eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2]);
void test_eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2]);

/* --------- Wartefunktion --------- */

void wait4key(void){

   printf("\n\n\n\t\t");
   system("PAUSE");

}

/* --------- Eingabe der Werte (Pfad, Konstante, Lieferwerk) ---------- */

void eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2]){

    printf("\nGeben Sie den Ort / Namen der Startdatei an (name.txt):_ ");
    gets(source_pfad);
    printf("\nGeben Sie die Zieldatei an (name), Endung wird automatisch hinzugef%cgt:_ ",(129));
    gets(target_pfad);
    printf("\nGeben Sie die Konstante ein:_ ");
    gets(ka);
    printf("\nGeben Sie das Lieferwerk ein:_ ");
    gets(lfw);
    printf("\nGeben Sie die G%cltigkeit an (0=gueltig, 9=stillgelegt, 6=storniert):_ ",(129));
    gets(gueltigkeit);
    strcat(target_pfad,".txt");
}

   /* Datei auslesen und in Variable schreiben */

int lesen_datei(FILE *source, char array[ZEICHEN],char source_pfad[PFAD_LEN]){

  char cZeichen;
  int a;
    source=fopen(source_pfad, "r");      // Datei zum lesen öffnen

    if (source==NULL){
        printf("\n\nNicht existierendes Quellverzeichnis");
        printf("\n\nDas Programm wird beendet");
        fclose(source);
        return 1;
        }

    else{
          for(a=0;(cZeichen = getc(source))!=EOF;a++){    // Array mit dem DateiInhalt füllen
            array[a]=cZeichen;
          }
          array[a]='\0';         // Ende des Arrays bestimmen
          fclose(source);
          return 0;
        }

}

void write_table(struct sTabelle tabelle[MAX_ZEILEN],char array[ZEICHEN],char ka[3],char lfw[7],FILE *target,char target_pfad[PFAD_LEN],char gueltigkeit[2]){

  int a,b,d;         //laufvariable
  int zeilen=0;      //laufvariable
  int c=0;           //laufvariable
  char datum[7];     //Datumsvariable

  target=fopen(target_pfad, "a");

  datum_calc(datum);  //datum ermitteln

      for(a=0;array[a]!='\0';a++){
        tabelle[zeilen].zeile[c]=array[a];
       // printf("%c",tabelle[zeilen].zeile[c]);  // Ausgabe ob richtig eingelesen wurde
        c++;
        if (array[a]=='\n'){      //wenn eine neue Zeile beginnt, zeilen hochzählen
           zeilen++;
           c=0;
           }

      }
      for(a=0;a!=zeilen;a++){
      c=0;                    // Zählvariable 'c' nach jedem Durchlauf auf NULL setzen

         for(b=0;c<10;b++){
            tabelle[a].TTNr[b]=tabelle[a].zeile[c];    //TTNr in struct einlesen
            c++;
         }

         for(b=0;c>=10 && c<19;b++){
            if (tabelle[a].zeile[c]=='\t')             //Wenn Tabulator kommt,
               c++;                                    //diesen überspringen

            tabelle[a].preis[b]=tabelle[a].zeile[c];   //preis in struct einlesen
            c++;
         }

           /* Zusammenfügen der Informationen und Ausgeben */

               strcpy(tabelle[a].string,ka);
               strcat(tabelle[a].string,tabelle[a].TTNr);
               strcat(tabelle[a].string,lfw);
               strcat(tabelle[a].string,"  04");
               strcat(tabelle[a].preis,"00");
               strcat(tabelle[a].string,tabelle[a].preis);

                   for(d=0;d<23;d++){
                      strcat(tabelle[a].string," ");    //23 leerstellen hinzufügen
                   }

               strcat(tabelle[a].string,datum);

                   for(d=0;d<15;d++){
                      strcat(tabelle[a].string," ");    //15 leerstellen hinzufügen
                   }

               strcat(tabelle[a].string,gueltigkeit);   //Gültigkeitsnummer einfügen
               strcat(tabelle[a].string,"  ");          //79 && 80 Bit leer
         //-------------------------------------
               fputs(tabelle[a].string,target);         // Zeilenweise ausgeben in datei
               fprintf(target,"\n");
         //-------------------------------------
      }
      fclose(target);
}

 /* Datum ermitteln und in das richtige Format bringen */

void datum_calc(char datum[7]){

 int len,a;
 char day[3],month[3],year[5],convert[5];
 struct date d;

  getdate(&d);       //Datum einlesen

  a=0;

  /* Tag ermitteln und in day einlesen */

  itoa(d.da_day,convert,10);
    if ((len=strlen(convert))==1){     //wenn Tag einstellig, null davorsetzen
       strcpy(day,"0");
       a++;
       day[a]=convert[0];
    }

    else {
          strcpy(day,convert);
          a++;
         }

    day[a+1]='\0';                     //String abschließen

  a=0;

  /* Monat ermitteln und in month einlesen */

  itoa(d.da_mon,convert,10);
    if ((len=strlen(convert))==1){     //wenn Monat einstellig, null davorsetzen
       strcpy(month,"0");
       a++;
       month[a]=convert[0];
    }

    else {
         strcpy(month,convert);
         a++;
         }

    month[a+1]='\0';                   //String abschließen

  /* Jahr einlesen und auf die letzten beiden Stellen abschneiden (Format JJ anstatt JJJJ) */

  itoa(d.da_year,convert,10);

  for(a=0;a<2;a++){                    //letzten beiden Stellen übertragen
     year[a]=convert[a+2];
     }

  /* Datum zusammenfügen TTMMJJ */

  year[a]='\0';                        //String abschließen

  strcpy(datum,day);
  strcat(datum,month);
  strcat(datum,year);

}

/* Überprüfung der Eingabe mit returnwert  1 oder 0 wieder zurückgeben*/

int show_eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2])
{
int ctrl_cor,ctrl_ret;
system("cls");
printf("1. Quelldatei: %s\n", source_pfad);
printf("2. Zieldatei: %s\n", target_pfad);
printf("3. Konstante: %s\n", ka);
printf("4. Lieferwerk %s\n", lfw);
printf("5. G%cltigkeit %s\n", (129), gueltigkeit);

printf("\nAlle Angaben Korrekt??? (ja: '0' / nein: '1')_: ");
  do{
     scanf("%i", &ctrl_cor);
     fflush(stdin);

     if (ctrl_cor!=0 && ctrl_cor!=1){
        printf ("Fehlerhafte Eingabe ... bitte nochmal wiederholen!_: ");
        ctrl_ret=1;
     }

     else (ctrl_ret=0);
  }

  while (ctrl_ret==1);

return ctrl_cor;
}

/* Falsch gemachte Eingabe kann geändert werdem */

void test_eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2])
{
int auswahl;
printf("Geben Sie den zu %cndernden Wert ein:_ ", (132));
scanf("%i",&auswahl);
fflush(stdin);

 switch(auswahl){

   case 1:
        puts("Geben Sie die Quelldatei an:_ ");
        gets(source_pfad);
        break;
   case 2:
        printf("Geben Sie die Zieldatei an (name), Endung wird automatisch hinzugef%cgt:_ \n", (129));
        gets(target_pfad);
        break;
   case 3:
        puts("\nGeben Sie die Konstante ein:_ ");
        gets(ka);
        break;
   case 4:
        puts("Geben Sie das Lieferwek ein: ");
        gets(lfw);
        break;
   case 5:
        printf("\nGeben Sie die G%cltigkeit an (0=gueltig, 9=stillgelegt, 6=storniert):_ \n", (129));
        gets(gueltigkeit);
        break;
   default:
        printf("Falsche Eingabe!, Beliebige Taste druecken um fortzufahren");
        getch();
        break;
}
}

int main(int argc, char* argv[])
{
      	FILE *source;      // Dateipointer
      	FILE *target;

	int a,b,test;
	char source_pfad[PFAD_LEN],target_pfad[PFAD_LEN],cZeichen,ka[3],lfw[7];
        char array[ZEICHEN];
        struct sTabelle tabelle[MAX_ZEILEN];
        char gueltigkeit[2];

        eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit);
    /* Korrektheit der Eingaben überprüfen */

          while (show_eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit)==1){
              test_eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit);
              }

    /* Überprüfen, ob Datei zum öffnen vorhanden ist */

        test=lesen_datei(source,array,source_pfad);

        if (test==1){
           wait4key();     //wenn nicht, programm beenden, und main mit 1 beenden
           return 1;
        }

        else {

    /* wenn vorhanden, write_table starten und main mit 0 beenden */

        write_table(tabelle,array,ka,lfw,target,target_pfad,gueltigkeit);
        wait4key();
        return 0;
        }
}

//------------------------------ Programmende ---------------------------------
    0
  • D

    und -äeh- wo ist der Absturz???

    0
  • S

    Der Absturz ist direkt bei int main (...

    0

  • nein

    der absturz liegt ab dieser zeile:
    eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit);

    kommentiere mal alles in der main aus.

    du wirst (mein djgpp nimmt den code, da dos 😉 ) erst an dieser stelle, nachdem du wieder einkommentierst, den absturz bekommen.

    also: schau in die funktion rein.

    auch hier mein tip: schön auskommentieren, und zeile für zeile wieder einkommentieren.

    wenn du zu einem absturz kommst, den du nicht verstehst, den teilausschnitt posten, dann kann dir geholfen werden.

    so long

    0
  • S

    der absturz liegt ab dieser zeile:
    eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit);

    Wieso denn dort??? Diese Funktion wird doch von den Änderungen gar nicht berührt!

    0
  • D

    Vielleicht überschreibst du irgendwo speicher, die hier dann die Auswirkung Absturz zeigen..

    Manchmal stirbt man tagelang an einer Stelle und der Fehler liegt ganz woanders..

    0

  • nun schaun wir uns mal dieses abgespeckte programm an:
    nur, damit du mal siehst, wie du an fehler rankommst: auskommentieren.
    wenn du den funktionsaufruf auskommentierst, geht dein programm.
    wenn du ihn einkommentierst, nicht.

    klar, es hängt an deiner vergrößerung deiner defines.
    aber den fehler musst du nun selber beheben. dafür: versuche mal, dein programm in debugschritten durchzugehen, und an die stelle des absturzes zu kommen.

    nur so als vorgehensweise.

    #include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <string.h>

#define PFAD_LEN 255
#define ZEICHEN 2400000
#define MAX_ZEILEN 30000   //<-ein problem
#define ZEILE_LEN 200

struct sTabelle
{
 char preis[11];
 char TTNr[11];
 char zeile[ZEILE_LEN];
 char string[ZEILE_LEN];

} ;

void eingabe(char source_pfad[PFAD_LEN],char target_pfad[PFAD_LEN],char ka[3],char lfw[7],char gueltigkeit[2]){
/*	//Auskommentiert, damit alles klar ist ;)

    printf("\nGeben Sie den Ort / Namen der Startdatei an (name.txt):_ ");
    gets(source_pfad);
    printf("\nGeben Sie die Zieldatei an (name), Endung wird automatisch hinzugef%cgt:_ ",(129));
    gets(target_pfad);
    printf("\nGeben Sie die Konstante ein:_ ");
    gets(ka);
    printf("\nGeben Sie das Lieferwerk ein:_ ");
    gets(lfw);
    printf("\nGeben Sie die G%cltigkeit an (0=gueltig, 9=stillgelegt, 6=storniert):_ ",(129));
    gets(gueltigkeit);
    strcat(target_pfad,".txt");*/
}

int main(int argc, char* argv[])
{
	FILE *source;      // Dateipointer
    FILE *target;

    int a,b,test;
    char source_pfad[PFAD_LEN],target_pfad[PFAD_LEN],cZeichen,ka[3],lfw[7];
    char array[ZEICHEN];
    struct sTabelle tabelle[MAX_ZEILEN];   //<-hier problem
    char gueltigkeit[2];

    eingabe(source_pfad,target_pfad,ka,lfw,gueltigkeit); //<--hier fängt der fehler "offiziell" an, 
    													//ob er sich dann in anderen auch so verhält, 
    													//musst du dann prüfen
	return 0;
}
    0
  • Z

    das problem liegt hier.

    char array[ZEICHEN];

    damit reservierst du 2400000 bytes am stack da wirds shon eng.
    doch spätestens beim aufruf

    write_table(tabelle,array,ka,lfw,target,target_pfad,gueltigkeit);

    krachts denn dann reservierst du noch einmal 2400000 bytes am stack da die parameter der funktion write_table(...) by-value übergeben werden.

    du solltest das array dynamisch mit malloc erzeugen.
    und die funktion write_table folgendermassen deklarieren

    void write_table(struct sTabelle tabelle[MAX_ZEILEN],char * array, char ka[3],char lfw[7],FILE* target,char target_pfad[PFAD_LEN],char gueltigkeit[2]);

    dann sollte es funktionieren.
    K.

    0
Anmelden zum Antworten