Memory leak durch funktion readln

[danieldelphi]

Zitat von Mavarik:

Zitat von danieldelphi:

Delphi-Quellcode:

procedure sterb_schleife;
var
  quell_dat, grossdatei: text;  // ??????? C++

    flush(quell_dat); // ??????

end;

hmm Welche Delphi Version soll das den sein?
Flush auf die Quelle?

Also ich denke nicht das ein ReadLn/Writeln ein MemoryLeak produziert.

Bist Du sicher, dass Du uns "genug" Sourcecode gepostet hast?

Mavarik

das ist delphi 6. ich bin eig sicher dass ich euch genug gepostet habe, ich kann aber gern noch mehr raus hauen, also hier das problem im großen

Delphi-Quellcode:

{$O-}
unit sterb;

interface

uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, deklara, plausi, struktur, Zaehler;

procedure sterb_schleife;


implementation

procedure sterb_schleife;
var
  autodatei, quell_dat, plausidatei, mrdatei, toddatei, hilfdatei, grossdatei: text;
  kette, plausikette: string;
  fehler, i, j, zaehler, plausibele, unplausibel, position: integer;

begin
  meldung.add('Gesellschaftskennzeichen: ' + gesell);
  {autodatei = Steuerdatei für ausgewählte Gesellschaft,
    enthält Liste der gelieferten Dateien}
  assign(autodatei, pfad_ein + gesell + 'inp.txt');
  reset(autodatei);
  //##########################
  //VU Ordner selbst anlegen
  //#############################
  if not DirectoryExists(pfad_aus+gesell) then
   ForceDirectories(pfad_aus+gesell);
  //##########################
  //alle dateipfade geändert, +gesell+'\' + hinzugefügt
  //#############################

  {mrdatei = Datei für Münchener Rück. Wird aber scheinbar nicht mehr gebraucht}
  assign(mrdatei, pfad_aus +gesell+'\' + gesell + 'mr.txt');
  rewrite(mrdatei);
  {toddatei: Wenn satz.zustand[1] = 'T' dann Datensatz rausschreiben.}
  assign(toddatei, pfad_aus +gesell+'\' + gesell + 'tod.txt');
  rewrite(toddatei);
  {grossdatei: Immer Datensatz rausschreiben.}
  assign(grossdatei, pfad_aus +gesell+'\' + gesell + 'big.txt');
  rewrite(grossdatei);

  assign(hilfdatei, pfad_aus +gesell+'\' +gesell + 'hilf.txt');
  rewrite(hilfdatei);

  meldung.add('Initialisieren der Variablen');
  zaehler_gesamt := 0; zaehler_nicht_verarbeitet := 0;
  for i := 1 to mwcount do
    for j := 1 to nwcount do wcount[i, j] := 0;

  struktur_insp(false); //Strukturtabellen initialisieren

  meldung.add(' Lesen der Versicherungsdaten.');
  readln(autodatei, kette);


  while kette <> 'ende' do
  begin
    quell_dat_name := kette;
    {quelldat= ausgewählte gelieferte Datei der ausgewählten Gesellschaft}
    meldung.add('***' + kette + '***');
    assign(quell_dat, pfad_ein + gesell + '\' + quell_dat_name);
    reset(quell_dat);

    position := length(kette);
    plausikette := kette;
    plausikette[position - 3] := kette[position - 2];
    plausikette[position - 2] := kette[position - 1];
    plausikette[position - 1] := kette[position];
    plausikette[position] := '.';
    assign(plausidatei, pfad_aus + gesell + '\plausi_' + plausikette + 'txt');
    rewrite(plausidatei);

    //Für Datei spezifiziertes Meldejahr in datmelde_jahr einlesen:
    readln(autodatei, kette);
    val(kette, datmelde_jahr, fehler);

    //Entscheiden, ob neues oder altes Datenformat verwendet wird
    // alt = Datenformat bis 2004 ohne neue Felder
    // uebergang = Datenformat bis 2004, neue Felder am Ende angehängt
    // neu = Ab 2005 vorgeschlagener einheitlicher Datensatz für alle Pools
    readln(autodatei, kette);
    if kette = 'neu' then datenformat := 2
    else if kette = 'uebergang' then datenformat := 1
    else if kette = 'alt' then datenformat := 0
    else messagedlg('Keine gültige Spezifikation des Datenformats in der Steuerdatei!', mtinformation, [mbOk], 0);


    zaehler := 0;
    plausibele := 0;
    unplausibel := 0;


    //in Daten von Quelle-Versicherung erste Zeile =Überschrift überlesen
    if gesell = 'QU' then readln(quell_dat, zeile);

    {Datensätze in quell_dat einlesen und auswerten}
    while not eof(quell_dat) do
    begin

      umfehler := false;       
      sterb_fehler := false;
      istrente := true;
      /////////////////////////

       readln(quell_dat, zeile);
      if ioresult <> 0 then begin
        messagedlg('Fehler beim Lesen der Datei!', mtError, [mbOk], 0);
        break;
      end;

      //BG2010: Wenn Zeile mit Hochkomma beginnt, dann Einlesevorgang abbrechen...
      if zeile[0] = '''' then break;
       inc(zaehler);
      va2i := 1;

      if gesell = 'QU' then umwandel_quelle(datenformat)
        {else if gesell = 'MA' then umwandel_mannheimer}
        //else if gesell = 'MR' then umwandel_mr
      ////////////////////////////
      else umwandel(datenformat);                
      ////////////////////////////
      //if satz.gesellschaft = 'EU' then writeln(mrdatei, zeile);
      if umfehler then begin
        writeln(plausidatei, zaehler, ';100;Umwandelfehler');
        inc(unplausibel);
      end;
      if (not umfehler) and istrente then begin
        if satz.vers_art[2] = 'L' then va2i := 2;
        plausibel(plausidatei, zaehler);
        if sterb_fehler then inc(unplausibel);
        if not sterb_fehler then begin
          inc(plausibele);
          codieren(zaehler); //Werte in Strukturtabellenindizes übersetzen
          struktur_zaehlen(zaehler); //Strukturtabellen belegen
          //val(copy(satz.geb_datum, 1, 4), gebjahr, fehler);
          {if (code.geschlecht = 2) and ((gebjahr = 1936) or (gebjahr = 1937)) then}
          ////////////////////////////////
          sterb_zaehlen(hilfdatei, zaehler, steuerung_ausgabe); //Sterblichkeits-Zaehlertabelle belegen
          ////////////////////////////////
          schreibe_grossdatei(grossdatei);
          ////////////////////////////////
        end;
        if abbruch then exit;
        if umfehler or sterb_fehler then inc(zaehler_nicht_verarbeitet);
        inc(zaehler_gesamt); str(zaehler_gesamt, kette);
        if ((zaehler_gesamt mod 1000) = 0) then dsnr.strings[1] := kette;
      end;

    end;

    flush(quell_dat);
    close(quell_dat);
    writeln(plausidatei, zaehler, ';Datensätze');
    writeln(plausidatei, unplausibel, '; unplausible Datensätze');
    writeln(plausidatei, plausibele, '; plausible Datensätze');
    flush(plausidatei);
    close(plausidatei);

    //close(mrdatei);
    readln(autodatei, kette);
  end; {*kette='ende' in autodatei*}

  meldung.add('Speichern der Struktur-Tabellen');
  struktur_insp(true); //Strukturtabellen speichern
  flush(mrdatei);
  close(mrdatei);
  flush(toddatei);
  close(toddatei);
  flush(grossdatei);
  close(grossdatei);
  flush(hilfdatei);
  close(hilfdatei);
  meldung.add(' ');
  str(zaehler_gesamt, kette);
   meldung.add('Datensätze gesamt: ' + kette);
  str(zaehler_nicht_verarbeitet, kette);
  meldung.add(' davon nicht verarbeitet: ' + kette);
  str(plausibele, kette);
  meldung.add('Datensätze plausibel: ' + kette);
  meldung.add(' ');

  zaehler_ausgabe(wcount);

end;

end.

[Union]

Wann wird die Stringliste meldung geleert?

[danieldelphi]

Zitat von Union:

Wann wird die Stringliste meldung geleert?

die wird gar nicht geleert, bzw beim beenden des programms, aber da kommen nur ein paar zeilen rein, die auf dem form angezeigt werden

[mm1256]

Speichermäßig ist das doch am einfachsten mit zeilenweiser String-Bearbeitung, oder?

Delphi-Quellcode:

procedure Die_Schleife_Stirbt_Nicht(Von,Nach: string);
var
  T1, T2: TextFile;
  Zeile: string;
begin
  AssignFile(T1,Von); // bzw. Assign(T1,Von); in D6
  Reset(t1);
  AssignFile(T2,Nach);
  Rewrite(T2);
  while not EOF(T1) do begin
    ReadLn(T1,Zeile);
    // Zeileninhalt bearbeiten
    WriteLn(T2,Zeile);
  end;
  CloseFile(T1); // bzw. Close(T1) in D6
  CloseFile(T2);
end;

[danieldelphi]

Zitat von mm1256:

Speichermäßig ist das doch am einfachsten mit zeilenweiser String-Bearbeitung, oder?

Delphi-Quellcode:

procedure Die_Schleife_Stirbt_Nicht(Von,Nach: string);
var
  T1, T2: TextFile;
  Zeile: string;
begin
  AssignFile(T1,Von); // bzw. Assign(T1,Von); in D6
  Reset(t1);
  AssignFile(T2,Nach);
  Rewrite(T2);
  while not EOF(T1) do begin
    ReadLn(T1,Zeile);
    // Zeileninhalt bearbeiten
    WriteLn(T2,Zeile);
  end;
  CloseFile(T1); // bzw. Close(T1) in D6
  CloseFile(T2);
end;

gebnau das ist ja der ausgangspunkt, so ist am ende der arbeitsspeicher mit der einzulesesnden datei gefüllt.

[mm1256]

Zitat von danieldelphi:

gebnau das ist ja der ausgangspunkt, so ist am ende der arbeitsspeicher mit der einzulesesnden datei gefüllt.

Aber genauso mach ich das schon jahrelang mit großen Textdateien ohne Probleme. Schau dir deinen Code genauer an, da musst du ein Problem haben.

Was soll z.B. das...wenn angenommen "Zeile" eine Stringvariable ist:

Delphi-Quellcode:

//BG2010: Wenn Zeile mit Hochkomma beginnt, dann Einlesevorgang abbrechen...
      if zeile[0] = '''' then break;

[Mavarik]

Zitat von danieldelphi:

das ist delphi 6.

hmm cool

Unter Delphi 6 ist ein String immer ein Shortstring... Oder verwechsele ich da gerade etwas? Ist zu lange her...

Bist Du sicher, das Deine Zeilen in den Textdateien kürzer als 255 Zeichen sind?

Mavarik

[DeddyH]

Du bist anscheinend bei Delphi 1 stehengeblieben, in Delphi 2 bis 2007 ist ein String ein AnsiString.

[Mavarik]

Zitat von deddyh:

du bist anscheinend bei delphi 1 stehengeblieben, in delphi 2 bis 2007 ist ein string ein ansistring.

ok ok...

[danieldelphi]

Zitat von Mavarik:

Zitat von danieldelphi:

das ist delphi 6.

hmm cool

Unter Delphi 6 ist ein String immer ein Shortstring... Oder verwechsele ich da gerade etwas? Ist zu lange her...

Bist Du sicher, das Deine Zeilen in den Textdateien kürzer als 255 Zeichen sind?

Mavarik

ich bin mir nicht sicher, bzw ich weiß, dass die zeieln teilweise über 300 zeichen haben, aber zeile ist bei mir auch ein char array mit 500 zeichen den ich dann in der procedure in einen string umwandel, siehst du da ein problem dass ich nicht sehe?