← Back to branch summary

~ubuntu-branches/ubuntu/wily/geany/wily

« back to all changes in this revision

Viewing changes to scintilla/LexLua.cxx

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2011-12-10 07:43:26 UTC
  • mfrom: (3.3.7 sid)
  • Revision ID: package-import@ubuntu.com-20111210074326-s8yqbew5i20h33tf
Tags: 0.21-1ubuntu1
* Merge from Debian Unstable, remaining changes:
  - debian/patches/20_use_evince_viewer.patch:
     + use evince as viewer for pdf and dvi files
  - debian/patches/20_use_x_terminal_emulator.patch:
     + use x-terminal-emulator as terminal
  - debian/control
     + Add breaks on geany-plugins-common << 0.20
* Also fixes bugs:
  - Filter for MATLAB/Octave files filters everythign (LP: 885505)

Show diffs side-by-side

added added

removed removed

Lines of Context:
scintilla/LexLua.cxx
1
 
// Scintilla source code edit control
2
 
/** @file LexLua.cxx
3
 
 ** Lexer for Lua language.
4
 
 **
5
 
 ** Written by Paul Winwood.
6
 
 ** Folder by Alexey Yutkin.
7
 
 ** Modified by Marcos E. Wurzius & Philippe Lhoste
8
 
 **/
9
 
 
10
 
#include <stdlib.h>
11
 
#include <string.h>
12
 
#include <ctype.h>
13
 
#include <stdarg.h>
14
 
#include <stdio.h>
15
 
 
16
 
#include "Platform.h"
17
 
 
18
 
#include "PropSet.h"
19
 
#include "Accessor.h"
20
 
#include "StyleContext.h"
21
 
#include "KeyWords.h"
22
 
#include "Scintilla.h"
23
 
#include "SciLexer.h"
24
 
#include "CharacterSet.h"
25
 
 
26
 
#ifdef SCI_NAMESPACE
27
 
using namespace Scintilla;
28
 
#endif
29
 
 
30
 
// Test for [=[ ... ]=] delimiters, returns 0 if it's only a [ or ],
31
 
// return 1 for [[ or ]], returns >=2 for [=[ or ]=] and so on.
32
 
// The maximum number of '=' characters allowed is 254.
33
 
static int LongDelimCheck(StyleContext &sc) {
34
 
        int sep = 1;
35
 
        while (sc.GetRelative(sep) == '=' && sep < 0xFF)
36
 
                sep++;
37
 
        if (sc.GetRelative(sep) == sc.ch)
38
 
                return sep;
39
 
        return 0;
40
 
}
41
 
 
42
 
static void ColouriseLuaDoc(
43
 
        unsigned int startPos,
44
 
        int length,
45
 
        int initStyle,
46
 
        WordList *keywordlists[],
47
 
        Accessor &styler) {
48
 
 
49
 
        WordList &keywords = *keywordlists[0];
50
 
        WordList &keywords2 = *keywordlists[1];
51
 
        WordList &keywords3 = *keywordlists[2];
52
 
        WordList &keywords4 = *keywordlists[3];
53
 
        WordList &keywords5 = *keywordlists[4];
54
 
        WordList &keywords6 = *keywordlists[5];
55
 
        WordList &keywords7 = *keywordlists[6];
56
 
        WordList &keywords8 = *keywordlists[7];
57
 
 
58
 
        // Accepts accented characters
59
 
        CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
60
 
        CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
61
 
        // Not exactly following number definition (several dots are seen as OK, etc.)
62
 
        // but probably enough in most cases.
63
 
        CharacterSet setNumber(CharacterSet::setDigits, ".-+abcdefABCDEF");
64
 
        CharacterSet setLuaOperator(CharacterSet::setNone, "*/-+()={}~[];<>,.^%:#");
65
 
        CharacterSet setEscapeSkip(CharacterSet::setNone, "\"'\\");
66
 
 
67
 
        int currentLine = styler.GetLine(startPos);
68
 
        // Initialize long string [[ ... ]] or block comment --[[ ... ]] nesting level,
69
 
        // if we are inside such a string. Block comment was introduced in Lua 5.0,
70
 
        // blocks with separators [=[ ... ]=] in Lua 5.1.
71
 
        int nestLevel = 0;
72
 
        int sepCount = 0;
73
 
        if (initStyle == SCE_LUA_LITERALSTRING || initStyle == SCE_LUA_COMMENT) {
74
 
                int lineState = styler.GetLineState(currentLine - 1);
75
 
                nestLevel = lineState >> 8;
76
 
                sepCount = lineState & 0xFF;
77
 
        }
78
 
 
79
 
        // Do not leak onto next line
80
 
        if (initStyle == SCE_LUA_STRINGEOL || initStyle == SCE_LUA_COMMENTLINE || initStyle == SCE_LUA_PREPROCESSOR) {
81
 
                initStyle = SCE_LUA_DEFAULT;
82
 
        }
83
 
 
84
 
        StyleContext sc(startPos, length, initStyle, styler);
85
 
        if (startPos == 0 && sc.ch == '#') {
86
 
                // shbang line: # is a comment only if first char of the script
87
 
                sc.SetState(SCE_LUA_COMMENTLINE);
88
 
        }
89
 
        for (; sc.More(); sc.Forward()) {
90
 
                if (sc.atLineEnd) {
91
 
                        // Update the line state, so it can be seen by next line
92
 
                        currentLine = styler.GetLine(sc.currentPos);
93
 
                        switch (sc.state) {
94
 
                        case SCE_LUA_LITERALSTRING:
95
 
                        case SCE_LUA_COMMENT:
96
 
                                // Inside a literal string or block comment, we set the line state
97
 
                                styler.SetLineState(currentLine, (nestLevel << 8) | sepCount);
98
 
                                break;
99
 
                        default:
100
 
                                // Reset the line state
101
 
                                styler.SetLineState(currentLine, 0);
102
 
                                break;
103
 
                        }
104
 
                }
105
 
                if (sc.atLineStart && (sc.state == SCE_LUA_STRING)) {
106
 
                        // Prevent SCE_LUA_STRINGEOL from leaking back to previous line
107
 
                        sc.SetState(SCE_LUA_STRING);
108
 
                }
109
 
 
110
 
                // Handle string line continuation
111
 
                if ((sc.state == SCE_LUA_STRING || sc.state == SCE_LUA_CHARACTER) &&
112
 
                                sc.ch == '\\') {
113
 
                        if (sc.chNext == '\n' || sc.chNext == '\r') {
114
 
                                sc.Forward();
115
 
                                if (sc.ch == '\r' && sc.chNext == '\n') {
116
 
                                        sc.Forward();
117
 
                                }
118
 
                                continue;
119
 
                        }
120
 
                }
121
 
 
122
 
                // Determine if the current state should terminate.
123
 
                if (sc.state == SCE_LUA_OPERATOR) {
124
 
                        sc.SetState(SCE_LUA_DEFAULT);
125
 
                } else if (sc.state == SCE_LUA_NUMBER) {
126
 
                        // We stop the number definition on non-numerical non-dot non-eE non-sign non-hexdigit char
127
 
                        if (!setNumber.Contains(sc.ch)) {
128
 
                                sc.SetState(SCE_LUA_DEFAULT);
129
 
                        } else if (sc.ch == '-' || sc.ch == '+') {
130
 
                                if (sc.chPrev != 'E' && sc.chPrev != 'e')
131
 
                                        sc.SetState(SCE_LUA_DEFAULT);
132
 
                        }
133
 
                } else if (sc.state == SCE_LUA_IDENTIFIER) {
134
 
                        if (!setWord.Contains(sc.ch) || sc.Match('.', '.')) {
135
 
                                char s[100];
136
 
                                sc.GetCurrent(s, sizeof(s));
137
 
                                if (keywords.InList(s)) {
138
 
                                        sc.ChangeState(SCE_LUA_WORD);
139
 
                                } else if (keywords2.InList(s)) {
140
 
                                        sc.ChangeState(SCE_LUA_WORD2);
141
 
                                } else if (keywords3.InList(s)) {
142
 
                                        sc.ChangeState(SCE_LUA_WORD3);
143
 
                                } else if (keywords4.InList(s)) {
144
 
                                        sc.ChangeState(SCE_LUA_WORD4);
145
 
                                } else if (keywords5.InList(s)) {
146
 
                                        sc.ChangeState(SCE_LUA_WORD5);
147
 
                                } else if (keywords6.InList(s)) {
148
 
                                        sc.ChangeState(SCE_LUA_WORD6);
149
 
                                } else if (keywords7.InList(s)) {
150
 
                                        sc.ChangeState(SCE_LUA_WORD7);
151
 
                                } else if (keywords8.InList(s)) {
152
 
                                        sc.ChangeState(SCE_LUA_WORD8);
153
 
                                }
154
 
                                sc.SetState(SCE_LUA_DEFAULT);
155
 
                        }
156
 
                } else if (sc.state == SCE_LUA_COMMENTLINE || sc.state == SCE_LUA_PREPROCESSOR) {
157
 
                        if (sc.atLineEnd) {
158
 
                                sc.ForwardSetState(SCE_LUA_DEFAULT);
159
 
                        }
160
 
                } else if (sc.state == SCE_LUA_STRING) {
161
 
                        if (sc.ch == '\\') {
162
 
                                if (setEscapeSkip.Contains(sc.chNext)) {
163
 
                                        sc.Forward();
164
 
                                }
165
 
                        } else if (sc.ch == '\"') {
166
 
                                sc.ForwardSetState(SCE_LUA_DEFAULT);
167
 
                        } else if (sc.atLineEnd) {
168
 
                                sc.ChangeState(SCE_LUA_STRINGEOL);
169
 
                                sc.ForwardSetState(SCE_LUA_DEFAULT);
170
 
                        }
171
 
                } else if (sc.state == SCE_LUA_CHARACTER) {
172
 
                        if (sc.ch == '\\') {
173
 
                                if (setEscapeSkip.Contains(sc.chNext)) {
174
 
                                        sc.Forward();
175
 
                                }
176
 
                        } else if (sc.ch == '\'') {
177
 
                                sc.ForwardSetState(SCE_LUA_DEFAULT);
178
 
                        } else if (sc.atLineEnd) {
179
 
                                sc.ChangeState(SCE_LUA_STRINGEOL);
180
 
                                sc.ForwardSetState(SCE_LUA_DEFAULT);
181
 
                        }
182
 
                } else if (sc.state == SCE_LUA_LITERALSTRING || sc.state == SCE_LUA_COMMENT) {
183
 
                        if (sc.ch == '[') {
184
 
                                int sep = LongDelimCheck(sc);
185
 
                                if (sep == 1 && sepCount == 1) {    // [[-only allowed to nest
186
 
                                        nestLevel++;
187
 
                                        sc.Forward();
188
 
                                }
189
 
                        } else if (sc.ch == ']') {
190
 
                                int sep = LongDelimCheck(sc);
191
 
                                if (sep == 1 && sepCount == 1) {    // un-nest with ]]-only
192
 
                                        nestLevel--;
193
 
                                        sc.Forward();
194
 
                                        if (nestLevel == 0) {
195
 
                                                sc.ForwardSetState(SCE_LUA_DEFAULT);
196
 
                                        }
197
 
                                } else if (sep > 1 && sep == sepCount) {   // ]=]-style delim
198
 
                                        sc.Forward(sep);
199
 
                                        sc.ForwardSetState(SCE_LUA_DEFAULT);
200
 
                                }
201
 
                        }
202
 
                }
203
 
 
204
 
                // Determine if a new state should be entered.
205
 
                if (sc.state == SCE_LUA_DEFAULT) {
206
 
                        if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
207
 
                                sc.SetState(SCE_LUA_NUMBER);
208
 
                                if (sc.ch == '0' && toupper(sc.chNext) == 'X') {
209
 
                                        sc.Forward();
210
 
                                }
211
 
                        } else if (setWordStart.Contains(sc.ch)) {
212
 
                                sc.SetState(SCE_LUA_IDENTIFIER);
213
 
                        } else if (sc.ch == '\"') {
214
 
                                sc.SetState(SCE_LUA_STRING);
215
 
                        } else if (sc.ch == '\'') {
216
 
                                sc.SetState(SCE_LUA_CHARACTER);
217
 
                        } else if (sc.ch == '[') {
218
 
                                sepCount = LongDelimCheck(sc);
219
 
                                if (sepCount == 0) {
220
 
                                        sc.SetState(SCE_LUA_OPERATOR);
221
 
                                } else {
222
 
                                        nestLevel = 1;
223
 
                                        sc.SetState(SCE_LUA_LITERALSTRING);
224
 
                                        sc.Forward(sepCount);
225
 
                                }
226
 
                        } else if (sc.Match('-', '-')) {
227
 
                                sc.SetState(SCE_LUA_COMMENTLINE);
228
 
                                if (sc.Match("--[")) {
229
 
                                        sc.Forward(2);
230
 
                                        sepCount = LongDelimCheck(sc);
231
 
                                        if (sepCount > 0) {
232
 
                                                nestLevel = 1;
233
 
                                                sc.ChangeState(SCE_LUA_COMMENT);
234
 
                                                sc.Forward(sepCount);
235
 
                                        }
236
 
                                } else {
237
 
                                        sc.Forward();
238
 
                                }
239
 
                        } else if (sc.atLineStart && sc.Match('$')) {
240
 
                                sc.SetState(SCE_LUA_PREPROCESSOR);      // Obsolete since Lua 4.0, but still in old code
241
 
                        } else if (setLuaOperator.Contains(sc.ch)) {
242
 
                                sc.SetState(SCE_LUA_OPERATOR);
243
 
                        }
244
 
                }
245
 
        }
246
 
 
247
 
        if (setWord.Contains(sc.chPrev)) {
248
 
                char s[100];
249
 
                sc.GetCurrent(s, sizeof(s));
250
 
                if (keywords.InList(s)) {
251
 
                        sc.ChangeState(SCE_LUA_WORD);
252
 
                } else if (keywords2.InList(s)) {
253
 
                        sc.ChangeState(SCE_LUA_WORD2);
254
 
                } else if (keywords3.InList(s)) {
255
 
                        sc.ChangeState(SCE_LUA_WORD3);
256
 
                } else if (keywords4.InList(s)) {
257
 
                        sc.ChangeState(SCE_LUA_WORD4);
258
 
                } else if (keywords5.InList(s)) {
259
 
                        sc.ChangeState(SCE_LUA_WORD5);
260
 
                } else if (keywords6.InList(s)) {
261
 
                        sc.ChangeState(SCE_LUA_WORD6);
262
 
                } else if (keywords7.InList(s)) {
263
 
                        sc.ChangeState(SCE_LUA_WORD7);
264
 
                } else if (keywords8.InList(s)) {
265
 
                        sc.ChangeState(SCE_LUA_WORD8);
266
 
                }
267
 
        }
268
 
 
269
 
        sc.Complete();
270
 
}
271
 
 
272
 
static void FoldLuaDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
273
 
                       Accessor &styler) {
274
 
        unsigned int lengthDoc = startPos + length;
275
 
        int visibleChars = 0;
276
 
        int lineCurrent = styler.GetLine(startPos);
277
 
        int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
278
 
        int levelCurrent = levelPrev;
279
 
        char chNext = styler[startPos];
280
 
        bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
281
 
        int styleNext = styler.StyleAt(startPos);
282
 
        char s[10];
283
 
 
284
 
        for (unsigned int i = startPos; i < lengthDoc; i++) {
285
 
                char ch = chNext;
286
 
                chNext = styler.SafeGetCharAt(i + 1);
287
 
                int style = styleNext;
288
 
                styleNext = styler.StyleAt(i + 1);
289
 
                bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
290
 
                if (style == SCE_LUA_WORD) {
291
 
                        if (ch == 'i' || ch == 'd' || ch == 'f' || ch == 'e' || ch == 'r' || ch == 'u') {
292
 
                                for (unsigned int j = 0; j < 8; j++) {
293
 
                                        if (!iswordchar(styler[i + j])) {
294
 
                                                break;
295
 
                                        }
296
 
                                        s[j] = styler[i + j];
297
 
                                        s[j + 1] = '\0';
298
 
                                }
299
 
 
300
 
                                if ((strcmp(s, "if") == 0) || (strcmp(s, "do") == 0) || (strcmp(s, "function") == 0) || (strcmp(s, "repeat") == 0)) {
301
 
                                        levelCurrent++;
302
 
                                }
303
 
                                if ((strcmp(s, "end") == 0) || (strcmp(s, "elseif") == 0) || (strcmp(s, "until") == 0)) {
304
 
                                        levelCurrent--;
305
 
                                }
306
 
                        }
307
 
                } else if (style == SCE_LUA_OPERATOR) {
308
 
                        if (ch == '{' || ch == '(') {
309
 
                                levelCurrent++;
310
 
                        } else if (ch == '}' || ch == ')') {
311
 
                                levelCurrent--;
312
 
                        }
313
 
                } else if (style == SCE_LUA_LITERALSTRING || style == SCE_LUA_COMMENT) {
314
 
                        if (ch == '[') {
315
 
                                levelCurrent++;
316
 
                        } else if (ch == ']') {
317
 
                                levelCurrent--;
318
 
                        }
319
 
                }
320
 
 
321
 
                if (atEOL) {
322
 
                        int lev = levelPrev;
323
 
                        if (visibleChars == 0 && foldCompact) {
324
 
                                lev |= SC_FOLDLEVELWHITEFLAG;
325
 
                        }
326
 
                        if ((levelCurrent > levelPrev) && (visibleChars > 0)) {
327
 
                                lev |= SC_FOLDLEVELHEADERFLAG;
328
 
                        }
329
 
                        if (lev != styler.LevelAt(lineCurrent)) {
330
 
                                styler.SetLevel(lineCurrent, lev);
331
 
                        }
332
 
                        lineCurrent++;
333
 
                        levelPrev = levelCurrent;
334
 
                        visibleChars = 0;
335
 
                }
336
 
                if (!isspacechar(ch)) {
337
 
                        visibleChars++;
338
 
                }
339
 
        }
340
 
        // Fill in the real level of the next line, keeping the current flags as they will be filled in later
341
 
 
342
 
        int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
343
 
        styler.SetLevel(lineCurrent, levelPrev | flagsNext);
344
 
}
345
 
 
346
 
static const char * const luaWordListDesc[] = {
347
 
        "Keywords",
348
 
        "Basic functions",
349
 
        "String, (table) & math functions",
350
 
        "(coroutines), I/O & system facilities",
351
 
        "user1",
352
 
        "user2",
353
 
        "user3",
354
 
        "user4",
355
 
        0
356
 
};
357
 
 
358
 
LexerModule lmLua(SCLEX_LUA, ColouriseLuaDoc, "lua", FoldLuaDoc, luaWordListDesc);