508 lines
11 KiB
Plaintext
508 lines
11 KiB
Plaintext
(*
|
|
Copyright 2021 Anton Krotov
|
|
|
|
This file is part of CEdit.
|
|
|
|
CEdit is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
CEdit is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with CEdit. If not, see <http://www.gnu.org/licenses/>.
|
|
*)
|
|
|
|
MODULE RW;
|
|
|
|
IMPORT
|
|
File, SYSTEM, KOSAPI, E := Encodings,
|
|
CB := Clipboard, Lines;
|
|
|
|
|
|
CONST
|
|
|
|
CR = 0DX; LF = 0AX; TAB = 9X; SPACE = 20X;
|
|
BOM = 0FEFFX;
|
|
|
|
TAB_SIZE* = 4;
|
|
|
|
BUF_SIZE = 65536;
|
|
|
|
NAME_LEN = 1024;
|
|
|
|
EOL_LF* = 0; EOL_CRLF* = 1; EOL_CR* = 2;
|
|
|
|
|
|
TYPE
|
|
|
|
tFileName* = ARRAY NAME_LEN OF CHAR;
|
|
|
|
tEOL = ARRAY 3 OF WCHAR;
|
|
|
|
tInput* = POINTER TO RECORD
|
|
buffer: INTEGER;
|
|
pos, cnt: INTEGER;
|
|
enc: INTEGER;
|
|
CR: BOOLEAN;
|
|
clipbrd: BOOLEAN;
|
|
getChar: PROCEDURE (file: tInput): INTEGER
|
|
END;
|
|
|
|
tOutput* = POINTER TO RECORD
|
|
handle: File.FS;
|
|
buffer: ARRAY BUF_SIZE OF BYTE;
|
|
pos: INTEGER;
|
|
eol: tEOL;
|
|
putChar: PROCEDURE (file: tOutput; code: INTEGER): BOOLEAN
|
|
END;
|
|
|
|
|
|
VAR
|
|
|
|
eol*: ARRAY 3 OF tEOL;
|
|
|
|
|
|
PROCEDURE getByte (file: tInput): BYTE;
|
|
VAR
|
|
res: BYTE;
|
|
BEGIN
|
|
IF file.cnt > 0 THEN
|
|
SYSTEM.GET8(file.buffer + file.pos, res);
|
|
INC(file.pos);
|
|
DEC(file.cnt)
|
|
ELSE
|
|
res := 0
|
|
END
|
|
RETURN res
|
|
END getByte;
|
|
|
|
|
|
PROCEDURE peakByte (file: tInput): BYTE;
|
|
VAR
|
|
res: BYTE;
|
|
BEGIN
|
|
IF file.cnt > 0 THEN
|
|
SYSTEM.GET8(file.buffer + file.pos, res)
|
|
ELSE
|
|
res := 0
|
|
END
|
|
RETURN res
|
|
END peakByte;
|
|
|
|
|
|
PROCEDURE getCharUTF8 (file: tInput): INTEGER;
|
|
VAR
|
|
code, n: INTEGER;
|
|
b: BYTE;
|
|
BEGIN
|
|
b := getByte(file);
|
|
IF b <= 07FH THEN
|
|
n := 0
|
|
ELSIF (0C0H <= b) & (b <= 0DFH) THEN
|
|
DEC(b, 0C0H);
|
|
n := 1
|
|
ELSIF (0E0H <= b) & (b <= 0EFH) THEN
|
|
DEC(b, 0E0H);
|
|
n := 2
|
|
ELSIF (0F0H <= b) & (b <= 0F7H) THEN
|
|
DEC(b, 0F0H);
|
|
n := 3
|
|
ELSIF (0F8H <= b) & (b <= 0FBH) THEN
|
|
DEC(b, 0F8H);
|
|
n := 4
|
|
ELSIF (0FCH <= b) & (b <= 0FDH) THEN
|
|
DEC(b, 0FCH);
|
|
n := 5
|
|
ELSIF b = 0FEH THEN
|
|
b := 0;
|
|
n := 6
|
|
ELSIF b = 0FFH THEN
|
|
n := -1
|
|
ELSIF (080H <= b) & (b <= 0BFH) THEN
|
|
n := -1
|
|
END;
|
|
|
|
code := b;
|
|
|
|
IF n > 2 THEN
|
|
n := -1
|
|
END;
|
|
|
|
WHILE n > 0 DO
|
|
DEC(n);
|
|
b := peakByte(file);
|
|
IF (080H <= b) & (b <= 0BFH) THEN
|
|
code := code*64 + getByte(file) - 080H
|
|
ELSE
|
|
n := -1
|
|
END
|
|
END;
|
|
|
|
IF n = -1 THEN
|
|
code := E.UNDEF
|
|
END
|
|
|
|
RETURN code
|
|
END getCharUTF8;
|
|
|
|
|
|
PROCEDURE getCharW1251 (file: tInput): INTEGER;
|
|
RETURN E.cpW1251[getByte(file)]
|
|
END getCharW1251;
|
|
|
|
|
|
PROCEDURE getCharCP866 (file: tInput): INTEGER;
|
|
RETURN E.cp866[getByte(file)]
|
|
END getCharCP866;
|
|
|
|
|
|
PROCEDURE getCharUTF16LE (file: tInput): INTEGER;
|
|
RETURN getByte(file) + getByte(file) * 256
|
|
END getCharUTF16LE;
|
|
|
|
|
|
PROCEDURE getString* (file: tInput; line: Lines.tLine; VAR eol: BOOLEAN): INTEGER;
|
|
VAR
|
|
c: WCHAR;
|
|
i, L, k, n: INTEGER;
|
|
s: ARRAY 1000 OF WCHAR;
|
|
BEGIN
|
|
L := LEN(s);
|
|
eol := FALSE;
|
|
n := 0;
|
|
i := ORD(file.cnt > 0) - 1;
|
|
WHILE (file.cnt > 0) & ~eol DO
|
|
c := WCHR(file.getChar(file) MOD 65536);
|
|
IF c = CR THEN
|
|
eol := TRUE;
|
|
file.CR := TRUE
|
|
ELSIF (c = LF) OR (c = 0X) THEN
|
|
IF ~file.CR THEN
|
|
eol := TRUE
|
|
END;
|
|
file.CR := FALSE
|
|
ELSIF c = TAB THEN
|
|
k := TAB_SIZE - i MOD TAB_SIZE;
|
|
WHILE k > 0 DO
|
|
s[i] := SPACE;
|
|
INC(i);
|
|
IF i = L THEN
|
|
Lines.concat(line, s);
|
|
INC(n, i);
|
|
i := 0
|
|
END;
|
|
DEC(k)
|
|
END;
|
|
file.CR := FALSE
|
|
ELSIF c = BOM THEN
|
|
file.CR := FALSE
|
|
ELSE
|
|
s[i] := c;
|
|
INC(i);
|
|
IF i = L THEN
|
|
Lines.concat(line, s);
|
|
INC(n, i);
|
|
i := 0
|
|
END;
|
|
file.CR := FALSE
|
|
END
|
|
END;
|
|
IF i >= 0 THEN
|
|
s[i] := 0X;
|
|
Lines.concat(line, s);
|
|
END;
|
|
INC(n, i)
|
|
RETURN n
|
|
END getString;
|
|
|
|
|
|
PROCEDURE detectEncoding (text: tInput): INTEGER;
|
|
VAR
|
|
pos, cnt, res: INTEGER;
|
|
continue, bom: BOOLEAN;
|
|
b: BYTE;
|
|
cp866, w1251: INTEGER;
|
|
BEGIN
|
|
pos := text.pos;
|
|
cnt := text.cnt;
|
|
continue := TRUE;
|
|
WHILE (text.cnt > 0) & continue DO
|
|
IF getByte(text) > 127 THEN
|
|
continue := FALSE
|
|
END
|
|
END;
|
|
text.cnt := cnt;
|
|
text.pos := pos;
|
|
IF continue THEN
|
|
res := E.CP866
|
|
ELSE
|
|
bom := getCharUTF8(text) = ORD(BOM);
|
|
continue := TRUE;
|
|
text.cnt := cnt;
|
|
text.pos := pos;
|
|
WHILE (text.cnt > 0) & continue DO
|
|
IF getCharUTF8(text) = E.UNDEF THEN
|
|
continue := FALSE
|
|
END
|
|
END;
|
|
IF continue THEN
|
|
IF bom THEN
|
|
res := E.UTF8BOM
|
|
ELSE
|
|
res := E.UTF8
|
|
END
|
|
ELSE
|
|
text.cnt := cnt;
|
|
text.pos := pos;
|
|
cp866 := 0;
|
|
w1251 := 0;
|
|
WHILE text.cnt > 0 DO
|
|
b := getByte(text);
|
|
IF b > 127 THEN
|
|
IF b >= 192 THEN
|
|
INC(w1251)
|
|
ELSE
|
|
INC(cp866)
|
|
END
|
|
END
|
|
END;
|
|
IF w1251 > cp866 THEN
|
|
res := E.W1251
|
|
ELSE
|
|
res := E.CP866
|
|
END
|
|
END;
|
|
text.cnt := cnt;
|
|
text.pos := pos
|
|
END
|
|
RETURN res
|
|
END detectEncoding;
|
|
|
|
|
|
PROCEDURE load* (name: tFileName; VAR enc: INTEGER): tInput;
|
|
VAR
|
|
res: tInput;
|
|
fsize: INTEGER;
|
|
BEGIN
|
|
NEW(res);
|
|
res.pos := 0;
|
|
res.CR := FALSE;
|
|
res.getChar := NIL;
|
|
res.clipbrd := FALSE;
|
|
fsize := File.FileSize(name);
|
|
IF fsize = 0 THEN
|
|
res.buffer := KOSAPI.malloc(4096);
|
|
ASSERT(res.buffer # 0);
|
|
res.cnt := 0
|
|
ELSE
|
|
res.buffer := File.Load(name, res.cnt)
|
|
END;
|
|
IF res.buffer = 0 THEN
|
|
DISPOSE(res)
|
|
ELSE
|
|
enc := detectEncoding(res);
|
|
IF (enc = E.UTF8BOM) OR (enc = E.UTF8) THEN
|
|
res.getChar := getCharUTF8
|
|
ELSIF enc = E.CP866 THEN
|
|
res.getChar := getCharCP866
|
|
ELSIF enc = E.W1251 THEN
|
|
res.getChar := getCharW1251
|
|
END;
|
|
res.enc := enc
|
|
END
|
|
RETURN res
|
|
END load;
|
|
|
|
|
|
PROCEDURE clipboard* (): tInput;
|
|
VAR
|
|
res: tInput;
|
|
BEGIN
|
|
NEW(res);
|
|
res.pos := 0;
|
|
res.CR := FALSE;
|
|
res.clipbrd := TRUE;
|
|
res.getChar := NIL;
|
|
res.enc := E.CP866;
|
|
res.getChar := getCharCP866;
|
|
res.buffer := CB.get(res.cnt);
|
|
IF res.buffer = 0 THEN
|
|
DISPOSE(res)
|
|
END
|
|
RETURN res
|
|
END clipboard;
|
|
|
|
|
|
PROCEDURE putByte (file: tOutput; b: BYTE);
|
|
VAR
|
|
c: INTEGER;
|
|
BEGIN
|
|
IF file.pos = BUF_SIZE THEN
|
|
c := File.Write(file.handle, SYSTEM.ADR(file.buffer[0]), BUF_SIZE);
|
|
file.pos := 0
|
|
END;
|
|
file.buffer[file.pos] := b;
|
|
INC(file.pos)
|
|
END putByte;
|
|
|
|
|
|
PROCEDURE putString* (file: tOutput; line: Lines.tLine; n: INTEGER): INTEGER;
|
|
VAR
|
|
i: INTEGER;
|
|
BEGIN
|
|
i := 0;
|
|
WHILE (i < n) & file.putChar(file, ORD(Lines.getChar(line, i))) DO
|
|
INC(i)
|
|
END
|
|
RETURN i
|
|
END putString;
|
|
|
|
|
|
PROCEDURE newLine* (file: tOutput): BOOLEAN;
|
|
VAR
|
|
i: INTEGER;
|
|
BEGIN
|
|
i := 0;
|
|
WHILE (file.eol[i] # 0X) & file.putChar(file, ORD(file.eol[i])) DO
|
|
INC(i)
|
|
END
|
|
RETURN i = LENGTH(file.eol)
|
|
END newLine;
|
|
|
|
|
|
PROCEDURE putCharUTF8 (file: tOutput; code: INTEGER): BOOLEAN;
|
|
VAR
|
|
res: BOOLEAN;
|
|
BEGIN
|
|
res := TRUE;
|
|
IF code <= 7FH THEN
|
|
putByte(file, code)
|
|
ELSIF (80H <= code) & (code <= 7FFH) THEN
|
|
putByte(file, code DIV 64 + 0C0H);
|
|
putByte(file, code MOD 64 + 080H)
|
|
ELSIF (800H <= code) & (code <= 0FFFFH) THEN
|
|
putByte(file, code DIV 4096 + 0E0H);
|
|
putByte(file, (code DIV 64) MOD 64 + 080H);
|
|
putByte(file, code MOD 64 + 080H)
|
|
ELSE
|
|
res := FALSE
|
|
END
|
|
RETURN res
|
|
END putCharUTF8;
|
|
|
|
|
|
PROCEDURE putCharW1251 (file: tOutput; code: INTEGER): BOOLEAN;
|
|
VAR
|
|
n: INTEGER;
|
|
res: BOOLEAN;
|
|
BEGIN
|
|
res := TRUE;
|
|
n := E.UNI[code, E.W1251];
|
|
IF n # E.UNDEF THEN
|
|
putByte(file, n)
|
|
ELSE
|
|
res := FALSE
|
|
END
|
|
RETURN res
|
|
END putCharW1251;
|
|
|
|
|
|
PROCEDURE putCharCP866 (file: tOutput; code: INTEGER): BOOLEAN;
|
|
VAR
|
|
n: INTEGER;
|
|
res: BOOLEAN;
|
|
BEGIN
|
|
res := TRUE;
|
|
n := E.UNI[code, E.CP866];
|
|
IF n # E.UNDEF THEN
|
|
putByte(file, n)
|
|
ELSE
|
|
res := FALSE
|
|
END
|
|
RETURN res
|
|
END putCharCP866;
|
|
|
|
|
|
PROCEDURE putCharUTF16LE (file: tOutput; code: INTEGER): BOOLEAN;
|
|
VAR
|
|
res: BOOLEAN;
|
|
BEGIN
|
|
IF (0 <= code) & (code <= 65535) THEN
|
|
res := TRUE;
|
|
putByte(file, code MOD 256);
|
|
putByte(file, code DIV 256)
|
|
ELSE
|
|
res := FALSE
|
|
END
|
|
RETURN res
|
|
END putCharUTF16LE;
|
|
|
|
|
|
PROCEDURE close* (VAR file: tOutput): BOOLEAN;
|
|
VAR
|
|
res: BOOLEAN;
|
|
BEGIN
|
|
res := TRUE;
|
|
IF file # NIL THEN
|
|
IF file.handle # NIL THEN
|
|
IF file.pos > 0 THEN
|
|
res := File.Write(file.handle, SYSTEM.ADR(file.buffer[0]), file.pos) = file.pos
|
|
END;
|
|
File.Close(file.handle)
|
|
END;
|
|
DISPOSE(file)
|
|
END
|
|
RETURN res
|
|
END close;
|
|
|
|
|
|
PROCEDURE create* (name: tFileName; enc, nl: INTEGER): tOutput;
|
|
VAR
|
|
res: tOutput;
|
|
BEGIN
|
|
NEW(res);
|
|
res.pos := 0;
|
|
res.eol := eol[nl];
|
|
res.putChar := NIL;
|
|
IF (enc = E.UTF8) OR (enc = E.UTF8BOM) THEN
|
|
res.putChar := putCharUTF8;
|
|
IF enc = E.UTF8BOM THEN
|
|
ASSERT(res.putChar(res, ORD(BOM)))
|
|
END
|
|
ELSIF enc = E.UTF16LE THEN
|
|
res.putChar := putCharUTF16LE;
|
|
ELSIF enc = E.W1251 THEN
|
|
res.putChar := putCharW1251
|
|
ELSIF enc = E.CP866 THEN
|
|
res.putChar := putCharCP866
|
|
END;
|
|
ASSERT(res.putChar # NIL);
|
|
res.handle := File.Create(name);
|
|
IF res.handle = NIL THEN
|
|
DISPOSE(res)
|
|
END
|
|
RETURN res
|
|
END create;
|
|
|
|
|
|
PROCEDURE destroy* (VAR file: tInput);
|
|
BEGIN
|
|
IF file # NIL THEN
|
|
IF file.buffer # 0 THEN
|
|
file.buffer := KOSAPI.free(file.buffer - 12*ORD(file.clipbrd))
|
|
END;
|
|
DISPOSE(file)
|
|
END
|
|
END destroy;
|
|
|
|
|
|
BEGIN
|
|
eol[EOL_LF] := LF;
|
|
eol[EOL_CRLF] := CR + LF;
|
|
eol[EOL_CR] := CR
|
|
END RW. |