Contributor: CAMERON CLARK
{
The following 3 messages will include two units [files,freebuff] and one
driver program [CTP]. The purpose of CTP is to reformate you source code's
case use, Exampe: change 'writeln' to 'WriteLn'. It includes all reserved
words.
FREEBUFF is where most of the speed increase comes from. It is a free
read buffer styled much like blockRead and BlockWrite. It does the job of a
disk cache by NOT writing until the write buffer is full, and NOT reading
until the read buffer is empty. It can be used for any program in place of
blockread&write where small pieces of information need to be extracted.
remeber memory is fast, drives are slow.
CTP still needs some optimizing [and inclusion of the (* *) comments
Words in quotes '' or Comments { WILL be skipped. If you can speed it up,
re-post the optimized version.
}
UNIT FILES;
INTERFACE
USES DOS;
FUNCTION FileExists(FileName: String): Boolean;
FUNCTION OpenFile(VAR f: file; fileName:string): Boolean;
FUNCTION FileExistsWild(FileName: String): Boolean;
IMPLEMENTATION
FUNCTION FileExists(FileName: String): Boolean;
VAR F: file;
begin
{$I-}
Assign(F, FileName);
Reset(F);
Close(F);
{$I+}
FileExists:=(IOResult = 0) and (FileName <> '')
end; { FileExists }
FUNCTION OpenFile(VAR f: file; fileName:string): Boolean;
BEGIN
IF fileExists(FileName) then BEGIN
Assign(f,filename);
Reset(f,1);
Openfile:=True;
END
ELSE OpenFile:=False;
END;
FUNCTION FileExistsWild(FileName: String): Boolean;
VAR Fil: SearchRec;
begin
FindFirst(FileName,anyFile,Fil);
FileExistsWild:=(DosError=0) and (FileName <> '');
end; { FileExists }
BEGIN
END.
{UNIT FREEBUFF}
{12/7/94}
{v4.0 ... Changing into a unit }
Unit FreeBuff;
INTERFACE
VAR TrueFileEnd : Boolean;
PROCEDURE B_Read( var F: file; var userObject;
ObjSize: Word; VAR bytesREAD: Word);
PROCEDURE B_Write( var FW: file; var userObject; ObjSize: Word);
PROCEDURE B_Skip( var F: File; SkipSize: Integer);
{user may skip any size}
PROCEDURE InitBuffers(Var F: File; Var FW : File);
PROCEDURE FlushWRITEBuffer(Var FW : File);
IMPLEMENTATION
CONST rBufSize=8192; {buffer size for B_read}
wBufSize=8192; {buffer size for B_write}
VAR rBuffer: array [1..rBufSize] of char; {buffer for B_read}
rCurrent: word; {8192 < word max} {current position in rBuffer}
rEnd: Integer; {Logical end of buffer}
FileEnd: Boolean; {Actual file end}
wBuffer: array [1..wBufSize] of char; {buffer for B_Write}
wCurrent: word; {current position in wBuffer}
Function WhatsLeft : Word;
BEGIN
If rEnd> (rCurrent -1) THEN BEGIN
WhatsLeft:= rEnd - (rCurrent - 1); {last position - (Current-1) }
END ELSE BEGIN
WhatsLeft:=0;
END;
END;
FUNCTION WhatsLeftinWRITE: Word;
BEGIN
WhatsLeftinWRITE:=wBufSize - (wCurrent - 1);
END;
PROCEDURE ReadBuffer(Var f: file; Var UserObject;
ObjSize: Word; VAR BytesRead: word);
BEGIN
BLockRead(F,UserObject,ObjSize,BytesRead);
rEnd:=(rCurrent-1) + BytesRead;
IF (BytesRead <> ObjSize) Then BEGIN
FileEnd:=True;
END;
END;
PROCEDURE WriteBuffer(Var FW: File; var UserObject; ObjSize: word);
VAR wDummy: Word;
BEGIN
BlockWrite(FW,UserObject,ObjSize,wDummy);
END;
PROCEDURE InitReadBuffer(Var F: File);
VAR Dummy: Word;
BEGIN
rCurrent:=1;
ReadBuffer(F,rBuffer[1],rBufSize,Dummy);
END;
PROCEDURE InitWRITEBuffer;
BEGIN
wCurrent:=1;
END;
PROCEDURE InitBuffers(Var F: File; Var FW : File);
BEGIN
FileEnd:=False;
TrueFileEnd:=False;
InitReadBuffer(F);
InitWriteBuffer;
END;
PROCEDURE FlushWRITEBuffer(Var FW : File);
BEGIN
WriteBuffer(FW, wBuffer[1], wCurrent-1);
initWriteBuffer;
END;
PROCEDURE B_Read( var F: file; var userObject;
ObjSize: Word; VAR bytesREAD:Word);
VAR LeftInBuf: Word; Temp: Word; BytesMoved: Word;
BEGIN
LeftInBuf:= WhatsLeft;
IF ObjSize < LeftInBuf then BEGIN {Same case for if FileEnd}
{CASE 1 MOST COMMON}
Move(rBuffer[rCurrent], UserObject, ObjSize);
rCurrent:=rCurrent+ ObjSize;
BytesRead:=ObjSize;
END ELSE IF ObjSize > LeftInBuf then BEGIN
{CASE 2 SECOND MOST COMMON}
IF FileEnd then BEGIN
LeftInBuf:=WhatsLeft;
Move(rBuffer[rCurrent], UserObject, LeftInBuf);
BytesRead:=LeftInBuf;
TrueFileEnd:=true;
END ELSE BEGIN
LeftInBuf:=WhatsLeft;
BytesMoved:=LeftInBuf;
Move(rBuffer[rCurrent], rBuffer[1], LeftInBuf);
rCurrent:=LeftInBuf+1; rEnd:= rBufSize;
LeftInBuf:=WhatsLeft;
ReadBuffer(F, rBuffer[rCurrent], LeftInBuf, BytesRead);
IF FIleEnd Then BEGIN
BytesRead:=BytesRead+BytesMoved;
IF BytesRead < ObjSize THEN BEGIN
move(rBuffer[1],UserObject, BytesRead);
TrueFileEnd:=True;
END ELSE BEGIN
move(rBuffer[1],UserObject, ObjSize);
rCurrent:=ObjSize+1;
BytesRead:=ObjSize;
END;
END ELSE BEGIN
move(rBuffer[1],UserObject, ObjSize);
BytesRead:=ObjSize;
rCurrent:=ObjSize+1;
END;
END;
END ELSE IF ObjSize = LeftInBuf then BEGIN
{CASE 3 MOST UNCOMMON}
IF FileEnd then BEGIN
move(rBuffer[rCurrent], UserObject, objSize);
BytesRead:=ObjSize;
TrueFileEnd:=True;
END ELSE BEGIN
move(rBuffer[rCurrent], UserObject, objSize);
InitReadBuffer(f);
BytesREad:=ObjSize;
END;
END;
END;
PROCEDURE B_Skip( var F: File; SkipSize: Integer); {user may skip any size}
var LeftInBuffer :Word;
BEGIN
LeftInBuffer:= WhatsLeft;
IF LeftInBuffer > SkipSize THEN BEGIN
Seek(F, FilePos(F) + ( SkipSize - LeftINBuffer));
InitREADBuffer(F);
END ELSE BEGIN
IF LeftINBuffer = SkipSize THEN BEGIN
InitREADBuffer(F);
END ELSE BEGIN
rCurrent:=rCurrent + SkipSize;
END;
END;
END;
PROCEDURE B_Write( var FW: file; var userObject; ObjSize: Word);
var LeftINBuffer: Word;
BEGIN
LeftInBuffer:=WhatsLeftinWRITE;
IF ObjSize < LeftInBuffer THEN BEGIN
move(UserObject, wBuffer[wCurrent], ObjSize);
wCurrent:=wCurrent+ ObjSize;
END ELSE BEGIN
IF ObjSize=LeftInbuffer THEN BEGIN
move(UserObject, wBuffer[wCurrent], ObjSize);
wCurrent := wCurrent + ObjSize;
FlushWriteBuffer(FW);
END ELSE BEGIN
FlushWriteBuffer(FW);
move(UserObject, wBuffer[wCurrent], ObjSize);
wCurrent:=wCurrent+ ObjSize;
END;
END;
END;
BEGIN
END.
{PROGRAM C-TP-format} {SLOWWWWWWWW}
{$A+,B-,D+,E-,F-,G-,I-,K-,L-,N-,P-,R+,S-,T-,V-,W-,X+,Y-}
{12/07/94 FIXED FreeBuff : and used it as a unit!!!!!!!!!!!!!!!}
{ Passes Dos's comp test for a 200k file }
Uses crt,dos,FREEbuff,FILES;
CONST BufSize=8192;
ResSize=53;{Words to Reformat}
{Edit these to fit personal capital & lowerCase mixture preferences}
TYPE rWords = array[1..ResSize] OF String;
{Crt,Graph,Graph3,Overlay,Printer,Strings,System,Turbo3,WinAPI,WinCrt
WinDOS,WinPrn,WinProcs,WinTypes ...}
{BOOCOOS of typing!!}
CONST Reserved : rWords =(
'ABSOLUTE','AND','ASM','ARRAY','BEGIN','CASE','CONST','CONSTRUTOR',
'DESTRUCTOR','DIV','DO','DOWNTO','ELSE','END','EXPORTS','FILE','FOR',
'FUNCTION','GOTO','IF','IMPLEMENTATION','IN','INHERITED','INLINE',
'INTERFACE','LABEL','LIBRARY','MOD','NIL','NOT','OBJECT','OF','OR','PACKED',
'PROCEDURE','PROGRAM','RECORD','REPEAT','SET','SHL','SHR','STRING','THEN',
'TO','TYPE','UNIT','UNTIL','USES','VAR','WHILE','WriteLN','WITH','XOR');
VAR F,OUTf : file;
tB : array[1..BufSize] of CHAR;
{I, J : integer;}
Quote : Boolean; {temp boolean use to skip quoted material}
Path,Name,Ext : String; {used for opening input file}
Look : SearchRec; {used for opening input file}
Dummy : String; {Built string to search for}
TB1 : Char; {Temp B_READ byte}
tb2 : integer; {Counter}
BytesRead : Word; {Dummy: not used in logic}
INPUTsize, { used to compare final sizes}
OUTPUTsize : LongInt;
Capitals : rWords; {used to capitalize all reserved words for}
{Speed efficient ONLY comparison }
PROCEDURE Announce;
BEGIN
Writeln('C-TP-Format v1.0 coded by şMr. Krinkleş');
Writeln('Property of Clark Enterprizes. Sept 5 1994');
WriteLN;
END;
PROCEDURE NEEDhelp;
BEGIN
WriteLN('Usage: CTP [FileName.in] [FileName.out]');
WriteLN('Example: CTP Onefile.pas NewOne.pas');
HALT;
END;
PROCEDURE INITcapitals;
{Make a Capitalized array of reserved word}
VAR I,J :integer;
BEGIN
FOR I:=1 to ResSize DO BEGIN
Capitals[I][0]:=Reserved[i][0]; {init lengths}
FOR J:=1 to ORD(Reserved[I][0]) {LENGTH} DO
Capitals[I][j]:= UPCASE(Reserved[I][J]);
END;
END;
FUNCTION Sfind( Name : string; Dum:String): boolean;
VAR k : integer; ch: char;
BEGIN
IF Name[0] = Dum[0] THEN BEGIN {Size Check :Speed Efficient}
FOR k:=1 To ord(Dum[0]) DO BEGIN {CHar by CHar comparison}
IF not ( Name[k] = Dum[k] ) Then BEGIN
Sfind:=False; {When FIRST FALSE CASE}
EXIT; {Speed Efficient}
END;
END;
END ELSE BEGIN
SFINd:=FALSE; {Failed Size Check}
EXIT;
END;
SFind:=True; {The Two are the Same}
END;
FUNCTION SCANandUPdate(Dummy:String) : String;
{needs to be changed to boyerMoore type search string tech}
VAR J : integer;
Dummy2 : string;
BEGIN
Dummy2[0]:=Dummy[0]; {length}
FOR J:=1 to ord(Dummy[0]) DO Dummy2[J]:=UpCase( Dummy[j] ); {Capitalize}
FOR j:=1 to ResSize DO BEGIN
IF Sfind(Capitals[j], Dummy2) then BEGIN {check with Capitals array}
SCANandUpdate:=Reserved[j];
exit;
END;{IF}
END;
SCANandUPdate:=Dummy; {Return original if not found}
END;
BEGIN {MAIN SKELETION}
Announce;
IF ParamStr(1)='' then NEEdhelp;
IF ParamStr(2)='' then NEEDhelp;
IF ParamStr(1)=ParamStr(2) then NEEDhelp;
Fsplit(ParamStr(1), Path, name, ext);
If path<>'' then path:=path+'\'; {writeln(path,' ',name,' ',ext);}
FINDFIRST(ParamStr(1), AnyFile, LOOK);
IF dosError<>0 then NeedHelp;
IF not OpenFile(F,path+Look.Name) THEN BEGIN
WriteLN('Unable to open ',Look.Name,' : Halting.'); HALT;
END;
INITcapitals;
Assign(OUTf,ParamStr(2)); {open and write output}
ReWrite(OUTf,1); {NO preExistance check
done}
WRITeLN('=< C-TP-Formating ',Look.name,' >=');
InitBuffers(F,OUTf); {MUST Initialize the READ and WRITE buffers}
b_READ(F,TB1,1,BytesREAD); {initialize tb1}
REPEAT
REPEAT
IF (tb1=#39) THEN BEGIN {ignore initial quote}
Quote:=FALSE;
WHILE (not Quote) and (not TrueFileEnd) do BEGIN
b_write(OUTf,tb1,1); {NO need to check for reserved}
b_read(f, tb1, 1,BytesREAD);
IF tb1=#39 THEN Quote:=Not Quote;
END;
b_write(OUTf,tb1,1); {write the closing quote}
b_read(f, tb1, 1,BytesREAD); {re-init tb1}
END else IF ( tb1 ='{') THEN BEGIN
WHILE (tb1<> '}') and (not TrueFileEnd) do BEGIN {spit
out info until nex comment}
b_write(OUTf,tb1,1); {NO need to check for reserved}
b_read(f, tb1, 1,BytesREAD);
END;
b_write(OUTf,tb1,1); {write the closing comment}
b_read(f, tb1, 1,BytesREAD); {re-init tb1}
END;
UNTIL (tb1 <> #39) and (TB1<> '{') or TrueFileEnd; {tb1 might be
another Q or C}
IF (tb1 in ['A'..'Z','a'..'z']) THEN BEGIN {build String}
Dummy:='';
While (tb1 in ['A'..'Z','a'..'z']) and (not TrueFileEnd) DO
BEGIN
Dummy:=Dummy+tb1;
b_READ(f,tb1,1,BytesREAD);
END;
Dummy:=SCANandUPDATE(DUMMY); {Scan for reserved}
{ gotoXY(1,25);
CLReol;
write(Dummy,' '); }
b_WRITE(OUTf,DUMMY[1],ord(DUMMY[0]));
END ELSE BEGIN
b_write(OUTf,tb1,1);
b_read(F,tb1,1,BytesREAD);
END; {IF}
INC(tb2);
CASE TB2 of
1 : BEGIN
write(#8#8); Write('.');END;
400 : BEGIN
write(#8#8);Write('*');END;
700 : BEGIN
write(#8#8);Write(#127);END;
1000 : BEGIN
write(#8#8);Write(#30);END;
1300 : BEGIN
write(#8#8);write(#254);END;
1600 : tb2:=0;
END;
UNTIL TrueFileEnd;
b_WRite(OUTf,TB1,1); {hopefully spit out the last char}
FLushWriteBuffer(OUTf);
INPUTsize:= FileSize(F);
OUTPUTsize:= FileSize(OUTf);
Close(OUTf);
Close(F);
IF INPUTsize <> OUTPUTsize THEN BEGIN
write(#8#8);
WriteLN('ERROR (1): Finished file sizes do not match.');
END Else BEGIN
write(#8#8);
Writeln('Done.');
END;
END.
(*
The previous sources are to format the Case of you TP code.
It will skip all words within Quotes '' or Comments {}.
The two units are FILES and FREEbuff.
The FREEbuff unit is my attempt to uses disk cache logic in my programs.
The logic is simple: don't read until read buffer empty
don't write until write buffer full.
To use FREEbuff do the following
INITbuffer( INfile, OUTfile) [must be opened]
repeat
b_read( INfile, buffer[1], sizeOF(buffer), bytesRead);
b_write( OUTfile, buffer[1], BytesRead);
until TrueFileEnd;
FlushWriteBuffer(Outfile);
set it all up
Flush empties the write buffer before the file is closed.
Syntax is very clock to BlockRead&write.
BytesRead is the amount of bytes actually moved to the Buffer [or object]
Instead of using blockRead for one byte reading, B_Read will fill the
buffer with 8192 bytes and then only give the object one byte. This
is extremely efficient when you only need small part of a file.
*)