Was genau maches Dateibefehle?

[iphi]

Hallo,

ich möchte gerne genau verstehen, was die folgenden Dateibefehle machen:

1.

Delphi-Quellcode:

...
var
  F: Textfile;
...
AssignFile(F,'myfile.txt');

Hier wird der Variablen F irgendetwas zugewiesen, korrekt?
Wird hier dynamisch Speicher zugewiesen, der zu einem Memoryleck führen könnte, wenn das Programm nach diesem Befehl beendet wird?
Die Datei selbst wird hier noch nicht geöffnet, korrekt?
Noch könnten andere Programme in die Datei schreiben, korrekt?

2.
ReWrite(F); Hier wird die Datei für Schreibzugriff geöffnet, korrekt?
Ab jetzt ist die Datei für andere Programme schreibgeschützt, korrekt?
Darf man rewrite mehrfach hintereinander ausführen?

3.
CloseFile(F); Hier wird die Datei geschlossen und wieder freigegeben, richtig?
Passiert hier irgendwas mit der Variablen F?

[himitsu]

Ich mach's mir Mal einfach ... schau doch selber nach ...
Grobe Zusammenfassung der Befehle/Typen:

Delphi-Quellcode:

const
{ File mode magic numbers }

  fmClosed = $D7B0;
  fmInput  = $D7B1;
  fmOutput = $D7B2;
  fmInOut  = $D7B3;

{ Text file flags         }
  tfCRLF   = $1;    // Dos compatibility flag, for CR+LF line breaks and EOF checks

type
  { Typed-file record }

{ Text file record structure used for Text files }
  TTextBuf = array[0..127] of AnsiChar;
  TTextRec = packed record (* must match the size the compiler generates: 720 bytes *)
    Handle: Integer;  // FileHandle, wenn Datei geöffnet
    Mode: Word;  // fmClosed..fmInOut
    Flags: Word;  // Set of (tfCRLF, ...)
    BufSize: Cardinal;  // = SizeOf(Self.Buffer)
    BufPos: Cardinal;
    BufEnd: Cardinal;
    BufPtr: PAnsiChar;  // = @Self.Buffer[0] oder SetTextBuf
    OpenFunc: Pointer;   // OpenFile (Reset+Rewrite+Append)
    InOutFunc: Pointer;  // Write/WriteLn/Read/ReadLn - Schreib/-Lesefunktion, je nach Self.Mode (Reset/Rewrite/Append)
    FlushFunc: Pointer;  // Flush
    CloseFunc: Pointer;  // CloseFile
    UserData: array[1..32] of Byte;  // nicht verwendet
    Name: array[0..259] of Char;  // dateiname
    Buffer: TTextBuf;  // Lese-/Schreibpuffer
  end;

function AssignFile(var t: TTextRec; const FileName: PChar): Integer;
var
  Len: Integer;
begin
  FillChar(t, SizeOf(TFileRec), 0);
  t.BufPtr := @t.Buffer;
  t.Mode := fmClosed;
  t.Flags := tfCRLF * Byte(DefaultTextLineBreakStyle);
  t.BufSize := SizeOf(t.Buffer);
  t.OpenFunc := @TextOpen;
  t.Name := FileName;
end;

function OpenText(var t: TTextRec; Mode: Word): Integer;
begin
  if t.Mode <> fmClosed then CloseFile(t);
  ...
end;

function Reset(var t: TTextRec): Integer;
begin
  Result := OpenText(t, fmInput);
end;

function Rewrite(var t: TTextRec): Integer;
begin
  Result := OpenText(t, fmOutput);
end;

function Append(var t: TTextRec): Integer;
begin
  Result := OpenText(t, fmInOut);
end;

function CloseFile(var t: TTextRec): Integer;
begin
  Flush;
  t.Mode := fmClosed;
  Result := CloseHandle(t.Handle);
end;

AssignFile initialisiert den Record und setzt den Dateinamen
Reset/Rewrite/Append öffnen die Datei

1. Standardmäßig kann kein Speicherleck entstehen, außer man ruft AssignFile auf eine geöffnete Dateivariable auf.
Denn AssignFile kann den Status einer Datei-Variable nicht prüfen, vorallem wenn sie auch noch nicht initialisiert sein könnte.
Das Dateihandle bliebe dann geöffnet.

PS: Wird in WinNT und Nachfahren ein Programm beendet, würde Windows den Arbeitsspeicher (weitgehenst) aufräumen und Dateihandles schließen, selbst wenn noch was offen wäre.
Tipp: Selber ausprobieren? Datei öffnen ... fremdes Programm kann nicht lesen ... eigenes Programm abschießen (Taskmanager) oder Programm beenden und Datei dabei nicht schließen ... kann fremdes Program jetzt lesen?

2. Wie wäre es mal mit selber ausprobieren?
Nein, eigentlich nicht ... mehrere aufeinanderfolgene Offnenbefehle werden aber "ignoroert" (if open then exit).

3. Siehe Code.


PS:
TextFile = TTextRec (auch wenn man es so nicht gleich erkennt, aber man könnte es einfach mal casten)
File of ... = TFileRec
TFileRec = TTextRec ohne .Buffer und ohne .BufSize bis .BufPtr

[iphi]

Danke für die Info!

Wie komme ich denn an system.pas? Bei meinem Delphi6 Personal sind nur die DCUs dabei.

Noch eine Frage zu Blockwrite:

Bei ReWrite(F,size) kann ich die Einheitsgröße des zu schreibenden Datenblocks über size einstellen.
Kann ich die Blockgröße unterwegs ändern ohne den Dateizeiger wieder auf den Dateianfang zu setzen, d.h. gibt es sowas wie Append(F,size) ?
Bin in der Hilfe nicht fündig geworden.

[fkerber]

Hi,

die Personal-Versionen erlauben leider keinen Zugriff auf den Source.
Der ist jeweils erst ab der Pro-Version dabei.


LG, Frederic

[himitsu]

Zitat von iphi:

Wie komme ich denn an system.pas? Bei meinem Delphi6 Personal sind nur die DCUs dabei.

Indem man sich eine Professional oder höher kauft.

Die Size sollte kann (?) man nur bei einem "typelosen" var f: File; verwenden.
Bei var f: File of XYZ; wird automatisch SizeOf(XYZ) verwendet.

Blockwrite schreibt keine "Bytes" sondern "Count", also eine Mehrzahl an ganzen Blöcken, so wie es in der OH auch geschrieben steht.
geschrieben Bytes = Count * RecSize (RecSize z.b. siehe Parameter des Rewrite oder siehe File-Typ)

Du kannst also ein typloses File erstellen (RecSize = 1), bzw. ein File of Byte und dann über BlockWrite quasi die Bytes/Blockgröße angeben.
Ich würde hier aber eher zu einem TFileStream raten.

PS: BlockWrite, Seek und Co. gibt es für Textdateien (TextFile) nicht.

[Bjoerk]

BTW, himitsu, mit welchen Befehl kann man nochmal den Puffer vergrößern, hab’s vergessen ?

[himitsu]

Zitat von Bjoerk:

BTW, himitsu, mit welchen Befehl kann man nochmal den Puffer vergrößern, hab’s vergessen ?

Das hatte ich "im" Quellcode mit erwähnt. BufPtr
Aber nur bei Textdateien ... die anderen haben keinen Puffer (abgesehn von der WindowsFileCache)

[Bjoerk]

Okay, hab’s gefunden, die dazugehörige Procedure heißt SetTextBuf. Wo kommt eigentlich der Alias AssignFile her, in meiner System.pas steht nur _Assign?

[himitsu]

Compilermagic ... du wirst dort auch kein Length drin finden, sondern stattdessen z.b. soein komisches _LStrLen.

Die sind im Compiler verbaut und stehen quasi nur als Dummy in der System.pas drin.
Oder der Compiler baut entsprechende Umleitungen zur eigentlichen Funktion auf, inkl. eventueller Parameterkonvertierungen. (es gibt z.B. auch kein WriteLn mit mehreren Parametern)

Die System und SysInit darfst du also nicht immer wort-wörtlich interpretieren.

[Bummi]

Nutzt man diese Dinosaurier eigentlich noch?