Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Newer
Older
100644 446 lines (384 sloc) 13.95 kB
f858c4b @djs Import Scintilla 2.11
authored
1 // Scintilla source code edit control
2 /**
3 * @file LexMagik.cxx
4 * Lexer for GE(r) Smallworld(tm) MagikSF
5 */
6 // Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
7 // The License.txt file describes the conditions under which this software may be distributed.
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <ctype.h>
12 #include <stdio.h>
13 #include <stdarg.h>
14
15 #include "Platform.h"
16
17 #include "PropSet.h"
18 #include "Accessor.h"
19 #include "StyleContext.h"
20 #include "KeyWords.h"
21 #include "Scintilla.h"
22 #include "SciLexer.h"
23
24 #ifdef SCI_NAMESPACE
25 using namespace Scintilla;
26 #endif
27
28 /**
29 * Is it a core character (C isalpha(), exclamation and question mark)
30 *
31 * \param ch The character
32 * \return True if ch is a character, False otherwise
33 */
34 static inline bool IsAlphaCore(int ch) {
35 return (isalpha(ch) || ch == '!' || ch == '?');
36 }
37
38 /**
39 * Is it a character (IsAlphaCore() and underscore)
40 *
41 * \param ch The character
42 * \return True if ch is a character, False otherwise
43 */
44 static inline bool IsAlpha(int ch) {
45 return (IsAlphaCore(ch) || ch == '_');
46 }
47
48 /**
49 * Is it a symbolic character (IsAlpha() and colon)
50 *
51 * \param ch The character
52 * \return True if ch is a character, False otherwise
53 */
54 static inline bool IsAlphaSym(int ch) {
55 return (IsAlpha(ch) || ch == ':');
56 }
57
58 /**
59 * Is it a numerical character (IsAlpha() and 0 - 9)
60 *
61 * \param ch The character
62 * \return True if ch is a character, False otherwise
63 */
64 static inline bool IsAlNum(int ch) {
65 return ((ch >= '0' && ch <= '9') || IsAlpha(ch));
66 }
67
68 /**
69 * Is it a symbolic numerical character (IsAlNum() and colon)
70 *
71 * \param ch The character
72 * \return True if ch is a character, False otherwise
73 */
74 static inline bool IsAlNumSym(int ch) {
75 return (IsAlNum(ch) || ch == ':');
76 }
77
78 /**
79 * The lexer function
80 *
81 * \param startPos Where to start scanning
82 * \param length Where to scan to
83 * \param initStyle The style at the initial point, not used in this folder
84 * \param keywordslists The keywordslists, currently, number 5 is used
85 * \param styler The styler
86 */
87 static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
88 WordList *keywordlists[], Accessor &styler) {
89 styler.StartAt(startPos);
90
91 WordList &keywords = *keywordlists[0];
92 WordList &pragmatics = *keywordlists[1];
93 WordList &containers = *keywordlists[2];
94 WordList &flow = *keywordlists[3];
95 WordList &characters = *keywordlists[4];
96
97 StyleContext sc(startPos, length, initStyle, styler);
98
99
100 for (; sc.More(); sc.Forward()) {
101
102 repeat:
103
104 if(sc.ch == '#') {
105 if (sc.chNext == '#') sc.SetState(SCE_MAGIK_HYPER_COMMENT);
106 else sc.SetState(SCE_MAGIK_COMMENT);
107 for(; sc.More() && !(sc.atLineEnd); sc.Forward());
108 sc.SetState(SCE_MAGIK_DEFAULT);
109 goto repeat;
110 }
111
112 if(sc.ch == '"') {
113 sc.SetState(SCE_MAGIK_STRING);
114
115 if(sc.More())
116 {
117 sc.Forward();
118 for(; sc.More() && sc.ch != '"'; sc.Forward());
119 }
120
121 sc.ForwardSetState(SCE_MAGIK_DEFAULT);
122 goto repeat;
123 }
124
125 // The default state
126 if(sc.state == SCE_MAGIK_DEFAULT) {
127
128 // A certain keyword has been detected
129 if (sc.ch == '_' && (
130 sc.currentPos == 0 || !IsAlNum(sc.chPrev))) {
131 char keyword[50];
132 memset(keyword, '\0', 50);
133
134 for(
135 int scanPosition = 0;
136 scanPosition < 50;
137 scanPosition++) {
138 char keywordChar = static_cast<char>(
139 tolower(styler.SafeGetCharAt(
140 scanPosition +
141 static_cast<int>(sc.currentPos+1), ' ')));
142 if(IsAlpha(keywordChar)) {
143 keyword[scanPosition] = keywordChar;
144 } else {
145 break;
146 }
147 }
148
149 // It is a pragma
150 if(pragmatics.InList(keyword)) {
151 sc.SetState(SCE_MAGIK_PRAGMA);
152 }
153
154 // it is a normal keyword like _local, _self, etc.
155 else if(keywords.InList(keyword)) {
156 sc.SetState(SCE_MAGIK_KEYWORD);
157 }
158
159 // It is a container keyword, such as _method, _proc, etc.
160 else if(containers.InList(keyword)) {
161 sc.SetState(SCE_MAGIK_CONTAINER);
162 }
163
164 // It is a flow keyword, such as _for, _if, _try, etc.
165 else if(flow.InList(keyword)) {
166 sc.SetState(SCE_MAGIK_FLOW);
167 }
168
169 // Interpret as unknown keyword
170 else {
171 sc.SetState(SCE_MAGIK_UNKNOWN_KEYWORD);
172 }
173 }
174
175 // Symbolic expression
176 else if(sc.ch == ':' && !IsAlNum(sc.chPrev)) {
177 sc.SetState(SCE_MAGIK_SYMBOL);
178 bool firstTrip = true;
179 for(sc.Forward(); sc.More(); sc.Forward()) {
180 if(firstTrip && IsAlphaSym(sc.ch));
181 else if(!firstTrip && IsAlNumSym(sc.ch));
182 else if(sc.ch == '|') {
183 for(sc.Forward();
184 sc.More() && sc.ch != '|';
185 sc.Forward());
186 }
187 else break;
188
189 firstTrip = false;
190 }
191 sc.SetState(SCE_MAGIK_DEFAULT);
192 goto repeat;
193 }
194
195 // Identifier (label) expression
196 else if(sc.ch == '@') {
197 sc.SetState(SCE_MAGIK_IDENTIFIER);
198 bool firstTrip = true;
199 for(sc.Forward(); sc.More(); sc.Forward()) {
200 if(firstTrip && IsAlphaCore(sc.ch)) {
201 firstTrip = false;
202 }
203 else if(!firstTrip && IsAlpha(sc.ch));
204 else break;
205 }
206 sc.SetState(SCE_MAGIK_DEFAULT);
207 goto repeat;
208 }
209
210 // Start of a character
211 else if(sc.ch == '%') {
212 sc.SetState(SCE_MAGIK_CHARACTER);
213 sc.Forward();
214 char keyword[50];
215 memset(keyword, '\0', 50);
216
217 for(
218 int scanPosition = 0;
219 scanPosition < 50;
220 scanPosition++) {
221 char keywordChar = static_cast<char>(
222 tolower(styler.SafeGetCharAt(
223 scanPosition +
224 static_cast<int>(sc.currentPos), ' ')));
225 if(IsAlpha(keywordChar)) {
226 keyword[scanPosition] = keywordChar;
227 } else {
228 break;
229 }
230 }
231
232 if(characters.InList(keyword)) {
233 sc.Forward(strlen(keyword));
234 } else {
235 sc.Forward();
236 }
237
238 sc.SetState(SCE_MAGIK_DEFAULT);
239 goto repeat;
240 }
241
242 // Operators
243 else if(
244 sc.ch == '>' ||
245 sc.ch == '<' ||
246 sc.ch == '.' ||
247 sc.ch == ',' ||
248 sc.ch == '+' ||
249 sc.ch == '-' ||
250 sc.ch == '/' ||
251 sc.ch == '*' ||
252 sc.ch == '~' ||
253 sc.ch == '$' ||
254 sc.ch == '=') {
255 sc.SetState(SCE_MAGIK_OPERATOR);
256 }
257
258 // Braces
259 else if(sc.ch == '(' || sc.ch == ')') {
260 sc.SetState(SCE_MAGIK_BRACE_BLOCK);
261 }
262
263 // Brackets
264 else if(sc.ch == '{' || sc.ch == '}') {
265 sc.SetState(SCE_MAGIK_BRACKET_BLOCK);
266 }
267
268 // Square Brackets
269 else if(sc.ch == '[' || sc.ch == ']') {
270 sc.SetState(SCE_MAGIK_SQBRACKET_BLOCK);
271 }
272
273
274 }
275
276 // It is an operator
277 else if(
278 sc.state == SCE_MAGIK_OPERATOR ||
279 sc.state == SCE_MAGIK_BRACE_BLOCK ||
280 sc.state == SCE_MAGIK_BRACKET_BLOCK ||
281 sc.state == SCE_MAGIK_SQBRACKET_BLOCK) {
282 sc.SetState(SCE_MAGIK_DEFAULT);
283 goto repeat;
284 }
285
286 // It is the pragma state
287 else if(sc.state == SCE_MAGIK_PRAGMA) {
288 if(!IsAlpha(sc.ch)) {
289 sc.SetState(SCE_MAGIK_DEFAULT);
290 goto repeat;
291 }
292 }
293
294 // It is the keyword state
295 else if(
296 sc.state == SCE_MAGIK_KEYWORD ||
297 sc.state == SCE_MAGIK_CONTAINER ||
298 sc.state == SCE_MAGIK_FLOW ||
299 sc.state == SCE_MAGIK_UNKNOWN_KEYWORD) {
300 if(!IsAlpha(sc.ch)) {
301 sc.SetState(SCE_MAGIK_DEFAULT);
302 goto repeat;
303 }
304 }
305 }
306
307 sc.Complete();
308 }
309
310 /**
311 * The word list description
312 */
313 static const char * const magikWordListDesc[] = {
314 "Accessors (local, global, self, super, thisthread)",
315 "Pragmatic (pragma, private)",
316 "Containers (method, block, proc)",
317 "Flow (if, then, elif, else)",
318 "Characters (space, tab, newline, return)",
319 "Fold Containers (method, proc, block, if, loop)",
320 0};
321
322 /**
323 * This function detects keywords which are able to have a body. Note that it
324 * uses the Fold Containers word description, not the containers description. It
325 * only works when the style at that particular position is set on Containers
326 * or Flow (number 3 or 4).
327 *
328 * \param keywordslist The list of keywords that are scanned, they should only
329 * contain the start keywords, not the end keywords
330 * \param The actual keyword
331 * \return 1 if it is a folding start-keyword, -1 if it is a folding end-keyword
332 * 0 otherwise
333 */
334 static inline int IsFoldingContainer(WordList &keywordslist, char * keyword) {
335 if(
336 strlen(keyword) > 3 &&
337 keyword[0] == 'e' && keyword[1] == 'n' && keyword[2] == 'd') {
338 if (keywordslist.InList(keyword + 3)) {
339 return -1;
340 }
341
342 } else {
343 if(keywordslist.InList(keyword)) {
344 return 1;
345 }
346 }
347
348 return 0;
349 }
350
351 /**
352 * The folding function
353 *
354 * \param startPos Where to start scanning
355 * \param length Where to scan to
356 * \param keywordslists The keywordslists, currently, number 5 is used
357 * \param styler The styler
358 */
359 static void FoldMagikDoc(unsigned int startPos, int length, int,
360 WordList *keywordslists[], Accessor &styler) {
361
362 bool compact = styler.GetPropertyInt("fold.compact") != 0;
363
364 WordList &foldingElements = *keywordslists[5];
365 int endPos = startPos + length;
366 int line = styler.GetLine(startPos);
367 int level = styler.LevelAt(line) & SC_FOLDLEVELNUMBERMASK;
368 int flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
369
370 for(
371 int currentPos = startPos;
372 currentPos < endPos;
373 currentPos++) {
374 char currentState = styler.StyleAt(currentPos);
375 char c = styler.SafeGetCharAt(currentPos, ' ');
376 int prevLine = styler.GetLine(currentPos - 1);
377 line = styler.GetLine(currentPos);
378
379 // Default situation
380 if(prevLine < line) {
381 styler.SetLevel(line, (level|flags) & ~SC_FOLDLEVELHEADERFLAG);
382 flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
383 }
384
385 if(
386 (
387 currentState == SCE_MAGIK_CONTAINER ||
388 currentState == SCE_MAGIK_FLOW
389 ) &&
390 c == '_') {
391
392 char keyword[50];
393 memset(keyword, '\0', 50);
394
395 for(
396 int scanPosition = 0;
397 scanPosition < 50;
398 scanPosition++) {
399 char keywordChar = static_cast<char>(
400 tolower(styler.SafeGetCharAt(
401 scanPosition +
402 currentPos + 1, ' ')));
403 if(IsAlpha(keywordChar)) {
404 keyword[scanPosition] = keywordChar;
405 } else {
406 break;
407 }
408 }
409
410 if(IsFoldingContainer(foldingElements, keyword) > 0) {
411 styler.SetLevel(
412 line,
413 styler.LevelAt(line) | SC_FOLDLEVELHEADERFLAG);
414 level++;
415 } else if(IsFoldingContainer(foldingElements, keyword) < 0) {
416 styler.SetLevel(line, styler.LevelAt(line));
417 level--;
418 }
419 }
420
421 if(
422 compact && (
423 currentState == SCE_MAGIK_BRACE_BLOCK ||
424 currentState == SCE_MAGIK_BRACKET_BLOCK ||
425 currentState == SCE_MAGIK_SQBRACKET_BLOCK)) {
426 if(c == '{' || c == '[' || c == '(') {
427 styler.SetLevel(
428 line,
429 styler.LevelAt(line) | SC_FOLDLEVELHEADERFLAG);
430 level++;
431 } else if(c == '}' || c == ']' || c == ')') {
432 styler.SetLevel(line, styler.LevelAt(line));
433 level--;
434 }
435 }
436 }
437
438 }
439
440 /**
441 * Injecting the module
442 */
443 LexerModule lmMagikSF(
444 SCLEX_MAGIK, ColouriseMagikDoc, "magiksf", FoldMagikDoc, magikWordListDesc);
445
Something went wrong with that request. Please try again.