forked from KolibriOS/kolibrios
578 lines
13 KiB
Plaintext
578 lines
13 KiB
Plaintext
(*
|
|
Copyright 2021, 2022 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;
|
|
|
|
BUF_SIZE = 65536;
|
|
|
|
NAME_LEN = 1024;
|
|
|
|
|
|
TYPE
|
|
|
|
tFileName* = ARRAY NAME_LEN OF CHAR;
|
|
|
|
tInput* = POINTER TO RECORD
|
|
buffer: INTEGER;
|
|
strBuf: Lines.tLine;
|
|
pos, cnt: 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: E.tEOL;
|
|
putChar: PROCEDURE (file: tOutput; code: INTEGER);
|
|
error: BOOLEAN
|
|
END;
|
|
|
|
|
|
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
|
|
ELSE
|
|
n := -1
|
|
(* 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 getCharCP1251 (file: tInput): INTEGER;
|
|
RETURN E.cp1251[getByte(file)]
|
|
END getCharCP1251;
|
|
|
|
|
|
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; tabs: BOOLEAN; VAR eol: BOOLEAN): INTEGER;
|
|
VAR
|
|
c: WCHAR;
|
|
i, k, n: INTEGER;
|
|
BEGIN
|
|
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 = Lines.TAB1 THEN
|
|
c := SPACE
|
|
ELSIF c = 0X THEN
|
|
c := Lines.NUL
|
|
END;
|
|
|
|
IF c = CR THEN
|
|
eol := TRUE;
|
|
file.CR := TRUE
|
|
ELSIF c = LF THEN
|
|
IF ~file.CR THEN
|
|
eol := TRUE
|
|
END;
|
|
file.CR := FALSE
|
|
ELSIF c = TAB THEN
|
|
k := Lines.tab - i MOD Lines.tab;
|
|
IF tabs THEN
|
|
Lines.setChar(file.strBuf, i, TAB)
|
|
ELSE
|
|
Lines.setChar(file.strBuf, i, SPACE)
|
|
END;
|
|
INC(i);
|
|
DEC(k);
|
|
WHILE k > 0 DO
|
|
IF tabs THEN
|
|
Lines.setChar(file.strBuf, i, Lines.TAB1)
|
|
ELSE
|
|
Lines.setChar(file.strBuf, i, SPACE)
|
|
END;
|
|
INC(i);
|
|
DEC(k)
|
|
END;
|
|
file.CR := FALSE
|
|
ELSIF c = BOM THEN
|
|
file.CR := FALSE
|
|
ELSE
|
|
Lines.setChar(file.strBuf, i, c);
|
|
INC(i);
|
|
file.CR := FALSE
|
|
END
|
|
END;
|
|
IF i >= 0 THEN
|
|
Lines.setChar(file.strBuf, i, 0X);
|
|
file.strBuf.length := i;
|
|
Lines._insert2(line, 0, file.strBuf)
|
|
END;
|
|
INC(n, i)
|
|
RETURN n
|
|
END getString;
|
|
|
|
|
|
PROCEDURE detectEncoding (text: tInput): INTEGER;
|
|
VAR
|
|
pos, cnt, res: INTEGER;
|
|
continue, bom: BOOLEAN;
|
|
b: BYTE;
|
|
cp866, cp1251: 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;
|
|
cp1251 := 0;
|
|
WHILE text.cnt > 0 DO
|
|
b := getByte(text);
|
|
IF b > 127 THEN
|
|
IF b >= 192 THEN
|
|
INC(cp1251)
|
|
ELSE
|
|
INC(cp866)
|
|
END
|
|
END
|
|
END;
|
|
IF cp1251 > cp866 THEN
|
|
res := E.CP1251
|
|
ELSE
|
|
res := E.CP866
|
|
END
|
|
END;
|
|
text.cnt := cnt;
|
|
text.pos := pos
|
|
END
|
|
RETURN res
|
|
END detectEncoding;
|
|
|
|
|
|
PROCEDURE detectEOL (text: tInput): INTEGER;
|
|
VAR
|
|
pos, cnt, c, res: INTEGER;
|
|
BEGIN
|
|
res := -1;
|
|
pos := text.pos;
|
|
cnt := text.cnt;
|
|
WHILE (text.cnt > 0) & (res = -1) DO
|
|
c := text.getChar(text);
|
|
IF c = ORD(LF) THEN
|
|
res := E.EOL_LF
|
|
ELSIF c = ORD(CR) THEN
|
|
IF text.getChar(text) = ORD(LF) THEN
|
|
res := E.EOL_CRLF
|
|
ELSE
|
|
res := E.EOL_CR
|
|
END
|
|
END
|
|
END;
|
|
text.cnt := cnt;
|
|
text.pos := pos;
|
|
IF res = -1 THEN
|
|
res := E.EOL_CRLF
|
|
END
|
|
RETURN res
|
|
END detectEOL;
|
|
|
|
|
|
PROCEDURE getMaxLength (file: tInput): INTEGER;
|
|
VAR
|
|
res, cur, cnt: INTEGER;
|
|
c: WCHAR;
|
|
BEGIN
|
|
res := 0;
|
|
cur := 0;
|
|
cnt := file.cnt;
|
|
WHILE file.cnt > 0 DO
|
|
c := WCHR(file.getChar(file) MOD 65536);
|
|
IF (c = CR) OR (c = LF) THEN
|
|
cur := 0
|
|
ELSIF c = TAB THEN
|
|
INC(cur, Lines.tab - cur MOD Lines.tab)
|
|
ELSE
|
|
INC(cur)
|
|
END;
|
|
IF cur > res THEN
|
|
res := cur
|
|
END
|
|
END;
|
|
file.cnt := cnt;
|
|
file.pos := 0
|
|
RETURN res
|
|
END getMaxLength;
|
|
|
|
|
|
PROCEDURE createStrBuf (file: tInput);
|
|
BEGIN
|
|
file.strBuf := Lines.create(TRUE);
|
|
Lines.resize(file.strBuf, MAX(2048, getMaxLength(file) + 1))
|
|
END createStrBuf;
|
|
|
|
|
|
PROCEDURE _loadFromMem (ptr, size: INTEGER; cp866: BOOLEAN; VAR enc, eol: INTEGER): tInput;
|
|
VAR
|
|
res: tInput;
|
|
BEGIN
|
|
NEW(res);
|
|
res.pos := 0;
|
|
res.CR := FALSE;
|
|
res.getChar := NIL;
|
|
res.clipbrd := FALSE;
|
|
res.buffer := ptr;
|
|
res.cnt := size;
|
|
IF res.buffer = 0 THEN
|
|
DISPOSE(res)
|
|
ELSE
|
|
enc := detectEncoding(res);
|
|
IF enc IN {E.UTF8BOM, E.UTF8} THEN
|
|
res.getChar := getCharUTF8
|
|
ELSIF enc = E.CP866 THEN
|
|
res.getChar := getCharCP866
|
|
ELSIF enc = E.CP1251 THEN
|
|
IF cp866 THEN
|
|
enc := E.CP866;
|
|
res.getChar := getCharCP866
|
|
ELSE
|
|
res.getChar := getCharCP1251
|
|
END
|
|
END;
|
|
eol := detectEOL(res);
|
|
createStrBuf(res)
|
|
END
|
|
RETURN res
|
|
END _loadFromMem;
|
|
|
|
|
|
PROCEDURE loadFromMem* (ptr, size: INTEGER; VAR enc, eol: INTEGER): tInput;
|
|
RETURN _loadFromMem(ptr, size, TRUE, enc, eol)
|
|
END loadFromMem;
|
|
|
|
|
|
PROCEDURE loadFromFile* (name: tFileName; VAR enc, eol: INTEGER): tInput;
|
|
VAR
|
|
ptr, size: INTEGER;
|
|
BEGIN
|
|
size := File.FileSize(name);
|
|
IF size = 0 THEN
|
|
ptr := KOSAPI.malloc(4096)
|
|
ELSE
|
|
ptr := File.Load(name, size)
|
|
END
|
|
RETURN _loadFromMem(ptr, size, FALSE, enc, eol)
|
|
END loadFromFile;
|
|
|
|
|
|
PROCEDURE clipboard* (): tInput;
|
|
VAR
|
|
res: tInput;
|
|
BEGIN
|
|
NEW(res);
|
|
res.pos := 0;
|
|
res.CR := FALSE;
|
|
res.clipbrd := TRUE;
|
|
res.getChar := NIL;
|
|
res.getChar := getCharCP866;
|
|
res.buffer := CB.get(res.cnt);
|
|
IF res.buffer = 0 THEN
|
|
DISPOSE(res)
|
|
ELSE
|
|
createStrBuf(res)
|
|
END
|
|
RETURN res
|
|
END clipboard;
|
|
|
|
|
|
PROCEDURE putByte (file: tOutput; b: BYTE);
|
|
BEGIN
|
|
IF file.pos = BUF_SIZE THEN
|
|
IF File.Write(file.handle, SYSTEM.ADR(file.buffer[0]), BUF_SIZE) # BUF_SIZE THEN
|
|
file.error := TRUE
|
|
END;
|
|
file.pos := 0
|
|
END;
|
|
file.buffer[file.pos] := b;
|
|
INC(file.pos)
|
|
END putByte;
|
|
|
|
|
|
PROCEDURE putString* (file: tOutput; line: Lines.tLine; n: INTEGER);
|
|
VAR
|
|
i: INTEGER;
|
|
c: WCHAR;
|
|
BEGIN
|
|
FOR i := 0 TO n - 1 DO
|
|
c := Lines.getChar(line, i);
|
|
IF c = Lines.NUL THEN
|
|
file.putChar(file, 0)
|
|
ELSIF c # Lines.TAB1 THEN
|
|
file.putChar(file, ORD(c))
|
|
END
|
|
END
|
|
END putString;
|
|
|
|
|
|
PROCEDURE newLine* (file: tOutput);
|
|
VAR
|
|
i: INTEGER;
|
|
BEGIN
|
|
i := 0;
|
|
WHILE file.eol[i] # 0X DO
|
|
file.putChar(file, ORD(file.eol[i]));
|
|
INC(i)
|
|
END
|
|
END newLine;
|
|
|
|
|
|
PROCEDURE putCharUTF8 (file: tOutput; code: INTEGER);
|
|
BEGIN
|
|
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
|
|
putByte(file, ORD("?"))
|
|
END
|
|
END putCharUTF8;
|
|
|
|
|
|
PROCEDURE putCharCP (file: tOutput; code, cp: INTEGER);
|
|
VAR
|
|
n: INTEGER;
|
|
BEGIN
|
|
n := E.UNI[code, cp];
|
|
IF n # E.UNDEF THEN
|
|
putByte(file, n)
|
|
ELSE
|
|
putByte(file, ORD("?"))
|
|
END
|
|
END putCharCP;
|
|
|
|
|
|
PROCEDURE putCharCP1251 (file: tOutput; code: INTEGER);
|
|
BEGIN
|
|
putCharCP(file, code, E.CP1251)
|
|
END putCharCP1251;
|
|
|
|
|
|
PROCEDURE putCharCP866 (file: tOutput; code: INTEGER);
|
|
BEGIN
|
|
putCharCP(file, code, E.CP866)
|
|
END putCharCP866;
|
|
|
|
(*
|
|
PROCEDURE putCharUTF16LE (file: tOutput; code: INTEGER);
|
|
BEGIN
|
|
IF ~((0 <= code) & (code <= 65535)) THEN
|
|
code := ORD("?")
|
|
END;
|
|
putByte(file, code MOD 256);
|
|
putByte(file, code DIV 256)
|
|
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;
|
|
res := res & ~file.error;
|
|
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 := E.eol[nl];
|
|
res.putChar := NIL;
|
|
IF enc IN {E.UTF8BOM, E.UTF8} THEN
|
|
IF enc = E.UTF8BOM THEN
|
|
putCharUTF8(res, ORD(BOM))
|
|
END;
|
|
res.putChar := putCharUTF8
|
|
(*ELSIF enc = E.UTF16LE THEN
|
|
res.putChar := putCharUTF16LE*)
|
|
ELSIF enc = E.CP1251 THEN
|
|
res.putChar := putCharCP1251
|
|
ELSIF enc = E.CP866 THEN
|
|
res.putChar := putCharCP866
|
|
END;
|
|
ASSERT(res.putChar # NIL);
|
|
res.handle := File.Create(name);
|
|
res.error := FALSE;
|
|
IF res.handle = NIL THEN
|
|
DISPOSE(res)
|
|
END
|
|
RETURN res
|
|
END create;
|
|
|
|
|
|
PROCEDURE destroy* (VAR file: tInput);
|
|
VAR
|
|
null: INTEGER;
|
|
BEGIN
|
|
IF file # NIL THEN
|
|
IF file.buffer # 0 THEN
|
|
null := KOSAPI.free(file.buffer - 12*ORD(file.clipbrd))
|
|
END;
|
|
IF file.strBuf # NIL THEN
|
|
Lines.resize(file.strBuf, 0)
|
|
END;
|
|
DISPOSE(file)
|
|
END
|
|
END destroy;
|
|
|
|
|
|
END RW. |