WebSVN – Kolibri OS – Diff – /programs/develop/cedit/SRC/Languages.ob07


﻿(*
    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 .
*)
 
MODULE Languages;
 
IMPORT Lines;
 
 
CONST
 
    langNone* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;
    langFasm* = 4; langLua* = 5; langIni* = 6;
 
TYPE
 
    tLine = Lines.tLine;
 
    tKeyWords = RECORD
        words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER
    END;
 
    procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);
 
 
VAR
 
    oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW: ARRAY 3 OF tKeyWords;
 
 
PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;
VAR
    i: INTEGER;
BEGIN
    i := KW.cnt - 1;
    WHILE (i >= 0) & (s # KW.words[i]) DO
        DEC(i)
    END
    RETURN i >= 0
END checkKW;
 
 
PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;
VAR
    res: BOOLEAN;
BEGIN
    res := FALSE;
    CASE lang OF
    |langC:      res := checkKW(s, cKW[kwSet - 1])
    |langOberon: res := checkKW(s, oberonKW[kwSet - 1])
    |langPascal: res := checkKW(s, pascalKW[kwSet - 1])
    |langLua:    res := checkKW(s, luaKW[kwSet - 1])
    |langIni:    res := checkKW(s, iniKW[kwSet - 1])
    |langFasm:   res := checkKW(s, fasmKW[kwSet - 1])
    END
    RETURN res
END isKey;
 
 
PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);
VAR
    quot: WCHAR;
BEGIN
    quot := Lines.getChar(line, pos);
    REPEAT
        INC(pos)
    UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)
END SkipString;
 
 
PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "/" THEN
            IF cond = 0 THEN
                cond := 1
            ELSE
                cond := 0;
                pos := n
            END
        ELSIF (c = "*") & (cond = 1) THEN
            depth := 1;
            cond := 0
        ELSIF (c = "'") OR (c = '"') THEN
            SkipString(line, pos, n);
            cond := 0
        ELSE
            cond := 0
        END
    ELSIF depth = 1 THEN
        IF c = "*" THEN
            cond := 1
        ELSIF (c = "/") & (cond = 1) THEN
            cond := 0;
            depth := 0
        ELSE
            cond := 0
        END
    END
END C;
 
 
PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
VAR
    res: WCHAR;
BEGIN
    IF i >= line.length THEN
        res := 0X
    ELSE
        res := Lines.getChar(line, i)
    END
    RETURN res
END getChar;
 
 
PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;
VAR
    res: INTEGER;
BEGIN
    res := -1;
    IF getChar(line, pos) = "[" THEN
        INC(pos);
        WHILE getChar(line, pos) = "=" DO
            INC(res);
            INC(pos)
        END;
        IF getChar(line, pos) = "[" THEN
            INC(res)
        ELSE
            res := -1
        END
    END
    RETURN res
END LuaLong;
 
 
PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
    k: INTEGER;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "-" THEN
            IF cond = 0 THEN
                cond := 1
            ELSE
                cond := 0;
                k := LuaLong(line, pos + 1);
                IF k >= 0 THEN
                    depth := k*2 + 1
                ELSE
                    pos := n
                END
            END
        ELSIF c = "[" THEN
            cond := 0;
            k := LuaLong(line, pos);
            IF k >= 0 THEN
                depth := (k + 1)*2
            END
        ELSIF (c = "'") OR (c = '"') THEN
            SkipString(line, pos, n);
            cond := 0
        ELSE
            cond := 0
        END
    ELSIF depth > 0 THEN
        IF (cond = 0) & (c = "]") THEN
            cond := 1
        ELSIF (cond >= 1) & (c = "=") THEN
            INC(cond)
        ELSIF (cond >= 1) & (c = "]") & (cond*2 - depth MOD 2 = depth) THEN
            depth := 0;
            cond := 0
        ELSE
            cond := 0
        END
    END
END Lua;
 
 
PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "(" THEN
            cond := 1
        ELSIF c = "/" THEN
            IF cond = 2 THEN
                cond := 0;
                pos := n
            ELSE
                cond := 2
            END
        ELSIF (c = "*") & (cond = 1) THEN
            depth := 2;
            cond := 0
        ELSIF c = "'" THEN
            SkipString(line, pos, n);
            cond := 0
        ELSIF c = "{" THEN
            IF Lines.getChar(line, pos + 1) = "$" THEN
                depth := 3
            ELSE
                depth := 1
            END;
            cond := 0
        ELSE
            cond := 0
        END
    ELSIF depth IN {1, 3} THEN
        IF c = "}" THEN
            depth := 0
        END
    ELSIF depth = 2 THEN
        IF c = "*" THEN
            cond := 1
        ELSIF (c = ")") & (cond = 1) THEN
            depth := 0;
            cond := 0
        ELSE
            cond := 0
        END
    END
END Pascal;
 
 
PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF (depth = 0) & (c = "/") THEN
        IF cond = 3 THEN
            cond := 0;
            pos := n
        ELSE
            cond := 3
        END
    ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN
        SkipString(line, pos, n);
        cond := 0
    ELSIF c = "(" THEN
        cond := 1
    ELSIF c = "*" THEN
        IF cond = 1 THEN
            INC(depth);
            cond := 0
        ELSE
            cond := 2
        END
    ELSIF c = ")" THEN
        IF cond = 2 THEN
            IF depth > 0 THEN
                DEC(depth)
            END
        END;
        cond := 0
    ELSE
        cond := 0
    END;
END Oberon;
 
 
PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    cond := 0;
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = ";" THEN
            pos := n
        ELSIF c = '"' THEN
            SkipString(line, pos, n)
        ELSIF c = "[" THEN
            depth := 1
        END
    ELSIF depth = 1 THEN
        IF c = "]" THEN
            depth := 0
        END
    END
END Ini;
 
 
PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);
BEGIN
    CASE lang OF
    |langNone:
    |langFasm:
    |langC:       C(line, depth, cond, pos, n)
    |langOberon:  Oberon(line, depth, cond, pos, n)
    |langPascal:  Pascal(line, depth, cond, pos, n)
    |langLua:     Lua(line, depth, cond, pos, n)
    |langIni:     Ini(line, depth, cond, pos, n)
    END
END comments;
 
 
PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords; CPrep: BOOLEAN);
CONST
    SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";
VAR
    i, j, k: INTEGER;
 
    PROCEDURE delim (c: CHAR): BOOLEAN;
        RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)
    END delim;
 
BEGIN
    k := KW.cnt;
    i := 0;
    REPEAT
        KW.words[k, 0] := "#";
        j := ORD(CPrep);
        WHILE (s[i] # 0X) & ~delim(s[i]) DO
            KW.words[k, j] := WCHR(ORD(s[i]));
            INC(i);
            INC(j)
        END;
        KW.words[k, j] := 0X;
        INC(k);
        WHILE delim(s[i]) DO
            INC(i)
        END
    UNTIL s[i] = 0X;
    KW.cnt := k
END EnterKW;
 
 
PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);
VAR
    s: ARRAY 16*1024 OF CHAR;
    key: ARRAY 4 OF CHAR;
    i: INTEGER;
BEGIN
    key := "KW1";
    FOR i := 0 TO 2 DO
        KW[i].cnt := 0;
        key[2] := CHR(ORD("1") + i);
        getStr(lang, key, s);
        EnterKW(s, KW[i], (lang = "lang_C") & (i = 1))
    END
END loadKW;
 
 
PROCEDURE init* (getStr: procGetStr);
BEGIN
    loadKW(oberonKW, getStr, "lang_Oberon");
    loadKW(cKW,      getStr, "lang_C");
    loadKW(pascalKW, getStr, "lang_Pascal");
    loadKW(luaKW,    getStr, "lang_Lua");
    loadKW(iniKW,    getStr, "lang_Ini");
    loadKW(fasmKW,   getStr, "lang_Fasm");
END init;
 
 
END Languages.

Rev 8728	Rev 8762
1	(*	1	(*
2	Copyright 2021 Anton Krotov	2	Copyright 2021 Anton Krotov
3		3
4	This file is part of CEdit.	4	This file is part of CEdit.
5		5
6	CEdit is free software: you can redistribute it and/or modify	6	CEdit is free software: you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation, either version 3 of the License, or	8	the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	CEdit is distributed in the hope that it will be useful,	11	CEdit is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with CEdit. If not, see .	17	along with CEdit. If not, see .
18	*)	18	*)
19		19
20	MODULE Languages;	20	MODULE Languages;
21		21
22	IMPORT Lines;	22	IMPORT Lines;
23		23
24		24
25	CONST	25	CONST
26		26
27	langNone* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;	27	langNone* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;
28	langFasm* = 4; langLua* = 5; langIni* = 6;	28	langFasm* = 4; langLua* = 5; langIni* = 6;
29		29
30	TYPE	30	TYPE
31		31
32	tLine = Lines.tLine;	32	tLine = Lines.tLine;
33		33
34	tKeyWords = RECORD	34	tKeyWords = RECORD
35	words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER	35	words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER
36	END;	36	END;
37		37
38	procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);	38	procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);
39		39
40		40
41	VAR	41	VAR
42		42
43	oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW: ARRAY 3 OF tKeyWords;	43	oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW: ARRAY 3 OF tKeyWords;
44		44
45		45
46	PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;	46	PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;
47	VAR	47	VAR
48	i: INTEGER;	48	i: INTEGER;
49	BEGIN	49	BEGIN
50	i := KW.cnt - 1;	50	i := KW.cnt - 1;
51	WHILE (i >= 0) & (s # KW.words[i]) DO	51	WHILE (i >= 0) & (s # KW.words[i]) DO
52	DEC(i)	52	DEC(i)
53	END	53	END
54	RETURN i >= 0	54	RETURN i >= 0
55	END checkKW;	55	END checkKW;
56		56
57		57
58	PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;	58	PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;
59	VAR	59	VAR
60	res: BOOLEAN;	60	res: BOOLEAN;
61	BEGIN	61	BEGIN
62	res := FALSE;	62	res := FALSE;
63	CASE lang OF	63	CASE lang OF
64	\|langC: res := checkKW(s, cKW[kwSet - 1])	64	\|langC: res := checkKW(s, cKW[kwSet - 1])
65	\|langOberon: res := checkKW(s, oberonKW[kwSet - 1])	65	\|langOberon: res := checkKW(s, oberonKW[kwSet - 1])
66	\|langPascal: res := checkKW(s, pascalKW[kwSet - 1])	66	\|langPascal: res := checkKW(s, pascalKW[kwSet - 1])
67	\|langLua: res := checkKW(s, luaKW[kwSet - 1])	67	\|langLua: res := checkKW(s, luaKW[kwSet - 1])
68	\|langIni: res := checkKW(s, iniKW[kwSet - 1])	68	\|langIni: res := checkKW(s, iniKW[kwSet - 1])
69	\|langFasm: res := checkKW(s, fasmKW[kwSet - 1])	69	\|langFasm: res := checkKW(s, fasmKW[kwSet - 1])
70	END	70	END
71	RETURN res	71	RETURN res
72	END isKey;	72	END isKey;
73		73
74		74
75	PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);	75	PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);
76	VAR	76	VAR
77	quot: WCHAR;	77	quot: WCHAR;
78	BEGIN	78	BEGIN
79	quot := Lines.getChar(line, pos);	79	quot := Lines.getChar(line, pos);
80	REPEAT	80	REPEAT
81	INC(pos)	81	INC(pos)
82	UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)	82	UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)
83	END SkipString;	83	END SkipString;
84		84
85		85
86	PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	86	PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
87	VAR	87	VAR
88	c: WCHAR;	88	c: WCHAR;
89	BEGIN	89	BEGIN
90	c := Lines.getChar(line, pos);	90	c := Lines.getChar(line, pos);
91	IF depth = 0 THEN	91	IF depth = 0 THEN
92	IF c = "/" THEN	92	IF c = "/" THEN
93	IF cond = 0 THEN	93	IF cond = 0 THEN
94	cond := 1	94	cond := 1
95	ELSE	95	ELSE
96	cond := 0;	96	cond := 0;
97	pos := n	97	pos := n
98	END	98	END
99	ELSIF (c = "*") & (cond = 1) THEN	99	ELSIF (c = "*") & (cond = 1) THEN
100	depth := 1;	100	depth := 1;
101	cond := 0	101	cond := 0
102	ELSIF (c = "'") OR (c = '"') THEN	102	ELSIF (c = "'") OR (c = '"') THEN
103	SkipString(line, pos, n);	103	SkipString(line, pos, n);
104	cond := 0	104	cond := 0
105	ELSE	105	ELSE
106	cond := 0	106	cond := 0
107	END	107	END
108	ELSIF depth = 1 THEN	108	ELSIF depth = 1 THEN
109	IF c = "*" THEN	109	IF c = "*" THEN
110	cond := 1	110	cond := 1
111	ELSIF (c = "/") & (cond = 1) THEN	111	ELSIF (c = "/") & (cond = 1) THEN
112	cond := 0;	112	cond := 0;
113	depth := 0	113	depth := 0
114	ELSE	114	ELSE
115	cond := 0	115	cond := 0
116	END	116	END
117	END	117	END
118	END C;	118	END C;
119		119
120		120
121	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;	121	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
122	VAR	122	VAR
123	res: WCHAR;	123	res: WCHAR;
124	BEGIN	124	BEGIN
125	IF i >= line.length THEN	125	IF i >= line.length THEN
126	res := 0X	126	res := 0X
127	ELSE	127	ELSE
128	res := Lines.getChar(line, i)	128	res := Lines.getChar(line, i)
129	END	129	END
130	RETURN res	130	RETURN res
131	END getChar;	131	END getChar;
132		132
133		133
134	PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;	134	PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;
135	VAR	135	VAR
136	res: INTEGER;	136	res: INTEGER;
137	BEGIN	137	BEGIN
138	res := -1;	138	res := -1;
139	IF getChar(line, pos) = "[" THEN	139	IF getChar(line, pos) = "[" THEN
140	INC(pos);	140	INC(pos);
141	WHILE getChar(line, pos) = "=" DO	141	WHILE getChar(line, pos) = "=" DO
142	INC(res);	142	INC(res);
143	INC(pos)	143	INC(pos)
144	END;	144	END;
145	IF getChar(line, pos) = "[" THEN	145	IF getChar(line, pos) = "[" THEN
146	INC(res)	146	INC(res)
147	ELSE	147	ELSE
148	res := -1	148	res := -1
149	END	149	END
150	END	150	END
151	RETURN res	151	RETURN res
152	END LuaLong;	152	END LuaLong;
153		153
154		154
155	PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	155	PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
156	VAR	156	VAR
157	c: WCHAR;	157	c: WCHAR;
158	k: INTEGER;	158	k: INTEGER;
159	BEGIN	159	BEGIN
160	c := Lines.getChar(line, pos);	160	c := Lines.getChar(line, pos);
161	IF depth = 0 THEN	161	IF depth = 0 THEN
162	IF c = "-" THEN	162	IF c = "-" THEN
163	IF cond = 0 THEN	163	IF cond = 0 THEN
164	cond := 1	164	cond := 1
165	ELSE	165	ELSE
166	cond := 0;	166	cond := 0;
167	k := LuaLong(line, pos + 1);	167	k := LuaLong(line, pos + 1);
168	IF k >= 0 THEN	168	IF k >= 0 THEN
169	depth := k*2 + 1	169	depth := k*2 + 1
170	ELSE	170	ELSE
171	pos := n	171	pos := n
172	END	172	END
173	END	173	END
174	ELSIF c = "[" THEN	174	ELSIF c = "[" THEN
175	cond := 0;	175	cond := 0;
176	k := LuaLong(line, pos);	176	k := LuaLong(line, pos);
177	IF k >= 0 THEN	177	IF k >= 0 THEN
178	depth := (k + 1)*2	178	depth := (k + 1)*2
179	END	179	END
180	ELSIF (c = "'") OR (c = '"') THEN	180	ELSIF (c = "'") OR (c = '"') THEN
181	SkipString(line, pos, n);	181	SkipString(line, pos, n);
182	cond := 0	182	cond := 0
183	ELSE	183	ELSE
184	cond := 0	184	cond := 0
185	END	185	END
186	ELSIF depth > 0 THEN	186	ELSIF depth > 0 THEN
187	IF (cond = 0) & (c = "]") THEN	187	IF (cond = 0) & (c = "]") THEN
188	cond := 1	188	cond := 1
189	ELSIF (cond >= 1) & (c = "=") THEN	189	ELSIF (cond >= 1) & (c = "=") THEN
190	INC(cond)	190	INC(cond)
191	ELSIF (cond >= 1) & (c = "]") & (cond*2 - depth MOD 2 = depth) THEN	191	ELSIF (cond >= 1) & (c = "]") & (cond*2 - depth MOD 2 = depth) THEN
192	depth := 0;	192	depth := 0;
193	cond := 0	193	cond := 0
194	ELSE	194	ELSE
195	cond := 0	195	cond := 0
196	END	196	END
197	END	197	END
198	END Lua;	198	END Lua;
199		199
200		200
201	PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	201	PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
202	VAR	202	VAR
203	c: WCHAR;	203	c: WCHAR;
204	BEGIN	204	BEGIN
205	c := Lines.getChar(line, pos);	205	c := Lines.getChar(line, pos);
206	IF depth = 0 THEN	206	IF depth = 0 THEN
207	IF c = "(" THEN	207	IF c = "(" THEN
208	cond := 1	208	cond := 1
209	ELSIF c = "/" THEN	209	ELSIF c = "/" THEN
210	IF cond = 2 THEN	210	IF cond = 2 THEN
211	cond := 0;	211	cond := 0;
212	pos := n	212	pos := n
213	ELSE	213	ELSE
214	cond := 2	214	cond := 2
215	END	215	END
216	ELSIF (c = "*") & (cond = 1) THEN	216	ELSIF (c = "*") & (cond = 1) THEN
217	depth := 2;	217	depth := 2;
218	cond := 0	218	cond := 0
219	ELSIF c = "'" THEN	219	ELSIF c = "'" THEN
220	SkipString(line, pos, n);	220	SkipString(line, pos, n);
221	cond := 0	221	cond := 0
222	ELSIF c = "{" THEN	222	ELSIF c = "{" THEN
223	IF Lines.getChar(line, pos + 1) = "$" THEN	223	IF Lines.getChar(line, pos + 1) = "$" THEN
224	depth := 3	224	depth := 3
225	ELSE	225	ELSE
226	depth := 1	226	depth := 1
227	END;	227	END;
228	cond := 0	228	cond := 0
229	ELSE	229	ELSE
230	cond := 0	230	cond := 0
231	END	231	END
232	ELSIF depth IN {1, 3} THEN	232	ELSIF depth IN {1, 3} THEN
233	IF c = "}" THEN	233	IF c = "}" THEN
234	depth := 0	234	depth := 0
235	END	235	END
236	ELSIF depth = 2 THEN	236	ELSIF depth = 2 THEN
237	IF c = "*" THEN	237	IF c = "*" THEN
238	cond := 1	238	cond := 1
239	ELSIF (c = ")") & (cond = 1) THEN	239	ELSIF (c = ")") & (cond = 1) THEN
240	depth := 0;	240	depth := 0;
241	cond := 0	241	cond := 0
242	ELSE	242	ELSE
243	cond := 0	243	cond := 0
244	END	244	END
245	END	245	END
246	END Pascal;	246	END Pascal;
247		247
248		248
249	PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	249	PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
250	VAR	250	VAR
251	c: WCHAR;	251	c: WCHAR;
252	BEGIN	252	BEGIN
253	c := Lines.getChar(line, pos);	253	c := Lines.getChar(line, pos);
254	IF (depth = 0) & (c = "/") THEN	254	IF (depth = 0) & (c = "/") THEN
255	IF cond = 3 THEN	255	IF cond = 3 THEN
256	cond := 0;	256	cond := 0;
257	pos := n	257	pos := n
258	ELSE	258	ELSE
259	cond := 3	259	cond := 3
260	END	260	END
261	ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN	261	ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN
262	SkipString(line, pos, n);	262	SkipString(line, pos, n);
263	cond := 0	263	cond := 0
264	ELSIF c = "(" THEN	264	ELSIF c = "(" THEN
265	cond := 1	265	cond := 1
266	ELSIF c = "*" THEN	266	ELSIF c = "*" THEN
267	IF cond = 1 THEN	267	IF cond = 1 THEN
268	INC(depth);	268	INC(depth);
269	cond := 0	269	cond := 0
270	ELSE	270	ELSE
271	cond := 2	271	cond := 2
272	END	272	END
273	ELSIF c = ")" THEN	273	ELSIF c = ")" THEN
274	IF cond = 2 THEN	274	IF cond = 2 THEN
275	IF depth > 0 THEN	275	IF depth > 0 THEN
276	DEC(depth)	276	DEC(depth)
277	END	277	END
278	END;	278	END;
279	cond := 0	279	cond := 0
280	ELSE	280	ELSE
281	cond := 0	281	cond := 0
282	END;	282	END;
283	END Oberon;	283	END Oberon;
284		284
285		285
286	PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	286	PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
287	VAR	287	VAR
288	c: WCHAR;	288	c: WCHAR;
289	BEGIN	289	BEGIN
290	cond := 0;	290	cond := 0;
291	c := Lines.getChar(line, pos);	291	c := Lines.getChar(line, pos);
292	IF depth = 0 THEN	292	IF depth = 0 THEN
293	IF c = ";" THEN	293	IF c = ";" THEN
294	pos := n	294	pos := n
295	ELSIF c = '"' THEN	295	ELSIF c = '"' THEN
296	SkipString(line, pos, n)	296	SkipString(line, pos, n)
297	ELSIF c = "[" THEN	297	ELSIF c = "[" THEN
298	depth := 1	298	depth := 1
299	END	299	END
300	ELSIF depth = 1 THEN	300	ELSIF depth = 1 THEN
301	IF c = "]" THEN	301	IF c = "]" THEN
302	depth := 0	302	depth := 0
303	END	303	END
304	END	304	END
305	END Ini;	305	END Ini;
306		306
307		307
308	PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);	308	PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);
309	BEGIN	309	BEGIN
310	CASE lang OF	310	CASE lang OF
311	\|langNone:	311	\|langNone:
312	\|langFasm:	312	\|langFasm:
313	\|langC: C(line, depth, cond, pos, n)	313	\|langC: C(line, depth, cond, pos, n)
314	\|langOberon: Oberon(line, depth, cond, pos, n)	314	\|langOberon: Oberon(line, depth, cond, pos, n)
315	\|langPascal: Pascal(line, depth, cond, pos, n)	315	\|langPascal: Pascal(line, depth, cond, pos, n)
316	\|langLua: Lua(line, depth, cond, pos, n)	316	\|langLua: Lua(line, depth, cond, pos, n)
317	\|langIni: Ini(line, depth, cond, pos, n)	317	\|langIni: Ini(line, depth, cond, pos, n)
318	END	318	END
319	END comments;	319	END comments;
320		320
321		321
322	PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords);	322	PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords; CPrep: BOOLEAN);
323	CONST	323	CONST
324	SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";	324	SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";
325	VAR	325	VAR
326	i, j, k: INTEGER;	326	i, j, k: INTEGER;
327		327
328	PROCEDURE delim (c: CHAR): BOOLEAN;	328	PROCEDURE delim (c: CHAR): BOOLEAN;
329	RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)	329	RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)
330	END delim;	330	END delim;
331		331
332	BEGIN	332	BEGIN
333	k := KW.cnt;	333	k := KW.cnt;
334	i := 0;	334	i := 0;
335	REPEAT	335	REPEAT
-		336	KW.words[k, 0] := "#";
336	j := 0;	337	j := ORD(CPrep);
337	WHILE (s[i] # 0X) & ~delim(s[i]) DO	338	WHILE (s[i] # 0X) & ~delim(s[i]) DO
338	KW.words[k, j] := WCHR(ORD(s[i]));	339	KW.words[k, j] := WCHR(ORD(s[i]));
339	INC(i);	340	INC(i);
340	INC(j)	341	INC(j)
341	END;	342	END;
342	KW.words[k, j] := 0X;	343	KW.words[k, j] := 0X;
343	INC(k);	344	INC(k);
344	WHILE delim(s[i]) DO	345	WHILE delim(s[i]) DO
345	INC(i)	346	INC(i)
346	END	347	END
347	UNTIL s[i] = 0X;	348	UNTIL s[i] = 0X;
348	KW.cnt := k	349	KW.cnt := k
349	END EnterKW;	350	END EnterKW;
350		351
351		352
352	PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);	353	PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);
353	VAR	354	VAR
354	s: ARRAY 16*1024 OF CHAR;	355	s: ARRAY 16*1024 OF CHAR;
355	key: ARRAY 4 OF CHAR;	356	key: ARRAY 4 OF CHAR;
356	i: INTEGER;	357	i: INTEGER;
357	BEGIN	358	BEGIN
358	key := "KW1";	359	key := "KW1";
359	FOR i := 0 TO 2 DO	360	FOR i := 0 TO 2 DO
360	KW[i].cnt := 0;	361	KW[i].cnt := 0;
361	key[2] := CHR(ORD("1") + i);	362	key[2] := CHR(ORD("1") + i);
362	getStr(lang, key, s);	363	getStr(lang, key, s);
363	EnterKW(s, KW[i])	364	EnterKW(s, KW[i], (lang = "lang_C") & (i = 1))
364	END;	365	END
365	END loadKW;	366	END loadKW;
366		367
367		368
368	PROCEDURE init* (getStr: procGetStr);	369	PROCEDURE init* (getStr: procGetStr);
369	BEGIN	370	BEGIN
370	loadKW(oberonKW, getStr, "lang_Oberon");	371	loadKW(oberonKW, getStr, "lang_Oberon");
371	loadKW(cKW, getStr, "lang_C");	372	loadKW(cKW, getStr, "lang_C");
372	loadKW(pascalKW, getStr, "lang_Pascal");	373	loadKW(pascalKW, getStr, "lang_Pascal");
373	loadKW(luaKW, getStr, "lang_Lua");	374	loadKW(luaKW, getStr, "lang_Lua");
374	loadKW(iniKW, getStr, "lang_Ini");	375	loadKW(iniKW, getStr, "lang_Ini");
375	loadKW(fasmKW, getStr, "lang_Fasm");	376	loadKW(fasmKW, getStr, "lang_Fasm");
376	END init;	377	END init;
377		378
378		379
379	END Languages.	380	END Languages.

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/Languages.ob07 – Rev 8728 → 8762