mirror of
https://github.com/moparisthebest/Simba
synced 2024-11-11 11:55:02 -05:00
6d499620f6
git-svn-id: http://www.villavu.com/repositories/merlijn/mufasa@26 3f818213-9676-44b0-a9b4-5e4c4e03d09d
452 lines
10 KiB
ObjectPascal
452 lines
10 KiB
ObjectPascal
unit files;
|
|
|
|
{$mode objfpc}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, SysUtils;
|
|
|
|
type
|
|
TMufasaFile = record
|
|
Path: String;
|
|
FS: TFileStream;
|
|
BytesRead, Mode: Integer;
|
|
end;
|
|
|
|
TMufasaFilesArray = Array Of TMufasaFile;
|
|
|
|
TMFiles = class(TObject)
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
public
|
|
function CreateFile(Path: string): Integer;
|
|
function OpenFile(Path: string; Shared: Boolean): Integer;
|
|
function RewriteFile(Path: string; Shared: Boolean): Integer;
|
|
procedure CloseFile(FileNum: Integer);
|
|
function EndOfFile(FileNum: Integer): Boolean;
|
|
function FileSizeMuf(FileNum: Integer): LongInt;
|
|
function ReadFileString(FileNum: Integer; var s: string; x: Integer): Boolean;
|
|
function WriteFileString(FileNum: Integer; s: string): Boolean;
|
|
Function SetFileCharPointer(FileNum, cChars, Origin: Integer): Integer;
|
|
function FilePointerPos(FileNum: Integer): Integer;
|
|
protected
|
|
MFiles: TMufasaFilesArray;
|
|
FreeSpots: Array Of Integer;
|
|
private
|
|
procedure FreeFileList;
|
|
function AddFileToManagedList(Path: string; FS: TFileStream; Mode: Integer): Integer;
|
|
|
|
end;
|
|
|
|
implementation
|
|
uses
|
|
{$IFDEF MSWINDOWS}Windows,{$ENDIF} IniFiles;
|
|
|
|
constructor TMFiles.Create;
|
|
begin
|
|
inherited Create;
|
|
SetLength(Self.MFiles, 0);
|
|
SetLength(Self.FreeSpots, 0);
|
|
end;
|
|
|
|
procedure TMFiles.FreeFileList;
|
|
var
|
|
I : integer;
|
|
begin;
|
|
//WriteLn('Freeing all open Files.');
|
|
For I := 0 To High(MFiles) Do
|
|
If MFiles[i].FS <> nil Then
|
|
Begin
|
|
WriteLn('You forgot to free a file...');
|
|
Try
|
|
MFiles[I].FS.Free;
|
|
Except
|
|
WriteLn('FreeFileList - Exception when freeing');
|
|
End;
|
|
//FileClose(Files[i].Handle);
|
|
End;
|
|
SetLength(MFiles, 0);
|
|
SetLength(FreeSpots, 0);
|
|
//WriteLn('Done Freeing all Files');
|
|
end;
|
|
|
|
destructor TMFiles.Destroy;
|
|
begin
|
|
FreeFileList;
|
|
inherited;
|
|
end;
|
|
|
|
Function TMFiles.AddFileToManagedList(Path: String; FS: TFileStream; Mode: Integer): Integer;
|
|
Var
|
|
tFile: TMufasaFile;
|
|
Begin
|
|
tFile.Path := Path;
|
|
tFile.FS := FS;
|
|
tFile.Mode := Mode;
|
|
tFile.BytesRead := 0;
|
|
|
|
If Length(FreeSpots) > 0 Then
|
|
Begin
|
|
//WriteLn('There is a free spot: ' + IntToStr(FreeSpots[High(FreeSpots)]));
|
|
MFiles[FreeSpots[High(FreeSpots)]] := tFile;
|
|
Result := FreeSpots[High(FreeSpots)];
|
|
SetLength(FreeSpots, High(FreeSpots));
|
|
End Else
|
|
Begin
|
|
// Increase by * 2.
|
|
//WriteLn('No Free Spot. Increasing the size');
|
|
SetLength(MFiles, Length(MFiles) + 1);
|
|
//Writeln('Length of Files: ' + IntToStr(Length(Files)));
|
|
MFiles[High(MFiles)] := tFile;
|
|
Result := High(MFiles);
|
|
End;
|
|
End;
|
|
|
|
{/\
|
|
Copies content of the file into the result (if no errors occur).
|
|
/\}
|
|
Function TMFiles.SetFileCharPointer(FileNum, cChars, Origin: Integer): Integer;
|
|
Begin
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
|
|
{If Files[FileNum].Handle = -1 Then
|
|
Begin
|
|
WriteLn('SetFileCharPointer: Invalid Internal Handle');
|
|
Result := -1;
|
|
Exit;
|
|
End;}
|
|
|
|
case Origin of
|
|
fsFromBeginning:
|
|
If(cChars < 0) Then
|
|
Begin
|
|
Writeln('fsFromBeginning takes no negative cChars.');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
fsFromCurrent:
|
|
;
|
|
fsFromEnd:
|
|
If(cChars > 0) Then
|
|
Begin
|
|
Writeln('fsFromEnd takes no positive cChars.');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
else
|
|
Begin
|
|
WriteLn('Invalid Origin: ' + IntToStr(Origin));
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
End;
|
|
|
|
Try
|
|
Result := MFiles[FileNum].FS.Seek(cChars, Origin);
|
|
Except
|
|
WriteLn('SetFileCharPointer - Exception Occured.');
|
|
End;
|
|
//Result := FileSeek(Files[FileNum].Handle, cChars, Origin);
|
|
End;
|
|
{/\
|
|
Opens a file for reading.
|
|
Returns the handle (index) to the File Array.
|
|
Returns -1 if unsuccesfull.
|
|
/\}
|
|
|
|
function TMFiles.CreateFile(Path: string): Integer;
|
|
|
|
Var
|
|
FS: TFileStream;
|
|
|
|
begin
|
|
Try
|
|
FS := TFileStream.Create(Path, fmCreate);
|
|
Except
|
|
Result := -1;
|
|
WriteLn('CreateFile - Exception. Could not create file. Returning -1');
|
|
Exit;
|
|
End;
|
|
|
|
Result := AddFileToManagedList(Path, FS, fmCreate);
|
|
end;
|
|
|
|
{/\
|
|
Opens a file for reading.
|
|
Returns the handle (index) to the File Array.
|
|
Returns -1 if unsuccesfull.
|
|
/\}
|
|
|
|
function TMFiles.OpenFile(Path: string; Shared: Boolean): Integer;
|
|
|
|
Var
|
|
FS: TFileStream;
|
|
fMode: Integer;
|
|
|
|
begin
|
|
If Shared Then
|
|
fMode := fmOpenRead or fmShareDenyNone
|
|
Else
|
|
fMode := fmOpenRead or fmShareExclusive;
|
|
|
|
Try
|
|
FS := TFileStream.Create(Path, fMode)
|
|
Except
|
|
Result := -1;
|
|
WriteLn('OpenFile - Exception. Could not create file. Returning -1');
|
|
Exit;
|
|
End;
|
|
|
|
Result := AddFileToManagedList(Path, FS, fMode);
|
|
|
|
{Result := FileOpen(Path, fmOpenRead);
|
|
If Result <> -1 Then
|
|
Begin
|
|
//WriteLn('File was successfully opened');
|
|
Result := AddFileToManagedList(Path, Result, fmOpenRead);
|
|
{If Result <> -1 Then
|
|
WriteLn('File was successfully added: ' + IntToStr(Result));}
|
|
End Else
|
|
Begin
|
|
WriteLn('Could not open file. Returning -1');
|
|
End; }
|
|
end;
|
|
|
|
{/\
|
|
Opens a file for writing.
|
|
Returns the handle (index) to the File Array.
|
|
Returns -1 if unsuccesfull.
|
|
/\}
|
|
|
|
function TMFiles.RewriteFile(Path: string; Shared: Boolean): Integer;
|
|
|
|
Var
|
|
FS: TFileStream;
|
|
fMode: Integer;
|
|
begin
|
|
If Shared Then
|
|
fMode := fmOpenReadWrite or fmShareDenyNone or fmCreate
|
|
Else
|
|
fMode := fmOpenReadWrite or fmShareDenyWrite or fmShareDenyRead or fmCreate;
|
|
|
|
Try
|
|
FS := TFileStream.Create(Path, fMode);
|
|
Except
|
|
Result := -1;
|
|
WriteLn('ReWriteFile - Exception. Could not create file. Returning -1');
|
|
Exit;
|
|
End;
|
|
|
|
Result := AddFileToManagedList(Path, FS, fMode);
|
|
|
|
{Result := FileOpen(Path, fmOpenReadWrite);
|
|
If Result <> -1 Then
|
|
Begin
|
|
//WriteLn('File was successfully opened.');
|
|
Result := AddFileToManagedList(Path, Result, fmOpenReadWrite);
|
|
{If Result <> -1 Then
|
|
WriteLn('File was successfully added: ' + IntToStr(Result)); }
|
|
End Else
|
|
Begin
|
|
WriteLn('Could not open file. Returning -1');
|
|
End; }
|
|
end;
|
|
|
|
{/\
|
|
Free's the given File at the given index.
|
|
/\}
|
|
procedure TMFiles.CloseFile(FileNum: Integer);
|
|
|
|
begin
|
|
//Writeln('Length of Files: ' + IntToStr(Length(Files)));
|
|
If (FileNum >= Length(MFiles)) or (FileNum < 0) Then
|
|
Begin
|
|
WriteLn('CloseFile. Invalid FileNum: ' + IntToStr(FileNum));
|
|
Exit;
|
|
End;
|
|
|
|
Try
|
|
MFiles[FileNum].FS.Free;
|
|
Except
|
|
WriteLn('CloseFile, exception when freeing the file...');
|
|
Exit;
|
|
End;
|
|
|
|
MFiles[FileNum].FS := nil;
|
|
SetLength(FreeSpots, Length(FreeSpots) + 1);
|
|
FreeSpots[High(FreeSpots)] := FileNum;
|
|
|
|
{If Files[FileNum].Handle = -1 Then
|
|
Begin
|
|
WriteLn('CloseFile: Invalid Internal Handle');
|
|
Exit;
|
|
End;
|
|
FileClose(Files[FileNum].Handle); }
|
|
|
|
end;
|
|
|
|
{/\
|
|
Returns true if the BytesRead of the given FileNum (Index) has been reached.
|
|
Also returns true if the FileNum is not valid.
|
|
/\}
|
|
|
|
function TMFiles.EndOfFile(FileNum: Integer): Boolean;
|
|
begin
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := True;
|
|
Exit;
|
|
End;
|
|
If MFiles[FileNum].FS = nil Then
|
|
Begin
|
|
WriteLn('EndOfFile: Invalid Internal Handle');
|
|
Result := True;
|
|
Exit;
|
|
End;
|
|
|
|
Result := FilePointerPos(FileNum) >= FileSizeMuf(FileNum);
|
|
end;
|
|
|
|
{/\
|
|
Returns the FileSize of the given index (FileNum)
|
|
/\}
|
|
|
|
function TMFiles.FileSizeMuf(FileNum: Integer): LongInt;
|
|
Var
|
|
tempPos: Integer;
|
|
begin
|
|
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
|
|
If MFiles[FileNum].FS = nil Then
|
|
Begin
|
|
WriteLn('FileSize: Invalid Internal Handle');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
|
|
Result := MFiles[FileNum].FS.Size;
|
|
|
|
{
|
|
If Files[FileNum].Handle = -1 Then
|
|
Begin
|
|
WriteLn('FileSize: Invalid Internal Handle');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
// Get our current position.
|
|
tempPos := FileSeek(Files[FileNum].Handle, 0, fsFromCurrent);
|
|
|
|
// End of the file.
|
|
Result := FileSeek(Files[FileNum].Handle, 0, fsFromEnd);
|
|
|
|
// Reset the position.
|
|
FileSeek(Files[FileNum].Handle, tempPos, fsFromBeginning); }
|
|
end;
|
|
|
|
function TMFiles.FilePointerPos(FileNum: Integer): Integer;
|
|
begin
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
If MFiles[FileNum].FS = nil Then
|
|
Begin
|
|
WriteLn('FileSize: Invalid Internal Handle');
|
|
Result := -1;
|
|
Exit;
|
|
End;
|
|
|
|
try
|
|
Result := MFiles[FileNum].FS.Seek(0, fsFromCurrent);
|
|
Except
|
|
WriteLn('Exception in FilePointerPos');
|
|
End;
|
|
//Result := FileSeek(Files[FileNum].FS, 0, fsFromCurrent);
|
|
end;
|
|
|
|
{/\
|
|
Reads x numbers of characters from a file, and stores it into s.
|
|
/\}
|
|
|
|
function TMFiles.ReadFileString(FileNum: Integer; var s: string; x: Integer): Boolean;
|
|
|
|
begin
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := False;
|
|
Exit;
|
|
End;
|
|
If MFiles[FileNum].FS = nil Then
|
|
Begin
|
|
WriteLn('ReadFileString: Invalid Internal Handle');
|
|
Exit;
|
|
End;
|
|
|
|
SetLength(S, 0);
|
|
SetLength(S, X);
|
|
MFiles[FileNum].FS.Read(S[1], x);
|
|
|
|
{Files[FileNum].BytesRead := Files[FileNum].BytesRead + X;
|
|
FileRead(Files[FileNum].Handle, S[1], X);
|
|
SetLength(S, X); }
|
|
end;
|
|
|
|
{/\
|
|
Writes s in the given File.
|
|
/\}
|
|
|
|
function TMFiles.WriteFileString(FileNum: Integer; s: string): Boolean;
|
|
var
|
|
BytesRead : DWord;
|
|
begin
|
|
If(FileNum < 0) or (FileNum >= Length(MFiles)) Then
|
|
Begin
|
|
WriteLn('Invalid File Num');
|
|
Result := False;
|
|
Exit;
|
|
End;
|
|
If(MFiles[FileNum].FS = nil) Then
|
|
Begin
|
|
WriteLn('WriteFileString: Invalid Internal Handle');
|
|
Result := False;
|
|
Exit;
|
|
End;
|
|
|
|
{If((Files[FileNum].Mode and fmOpenWrite) = 0) Then
|
|
Begin
|
|
WriteLn('This file may not write');
|
|
Exit;
|
|
End; }
|
|
|
|
try
|
|
Result := MFiles[FileNum].FS.Write(S[1], Length(S)) <> 1;
|
|
except
|
|
WriteLn('Exception - WriteFileString.');
|
|
Result := False;
|
|
end;
|
|
|
|
{If(FileWrite(Files[FileNum].Handle, S[1], Length(S)) <> -1) Then
|
|
Result := True
|
|
Else
|
|
Result := False; }
|
|
end;
|
|
|
|
end.
|
|
|