← Back to branch summary

~ubuntu-branches/ubuntu/trusty/presage/trusty-proposed

« back to all changes in this revision

Viewing changes to apps/gtk/gprompter/scintilla/lexers/LexAPDL.cxx

  • Committer: Bazaar Package Importer
  • Author(s): Matteo Vescovi
  • Date: 2011-08-06 09:26:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110806092615-0wvhajaht9974ncx
Tags: upstream-0.8.6
Import upstream version 0.8.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
apps/gtk/gprompter/scintilla/lexers/LexAPDL.cxx
 
1
// Scintilla source code edit control
 
2
/** @file LexAPDL.cxx
 
3
 ** Lexer for APDL. Based on the lexer for Assembler by The Black Horus.
 
4
 ** By Hadar Raz.
 
5
 **/
 
6
// Copyright 1998-2003 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 <stdio.h>
 
12
#include <stdarg.h>
 
13
#include <assert.h>
 
14
#include <ctype.h>
 
15
 
 
16
#include "ILexer.h"
 
17
#include "Scintilla.h"
 
18
#include "SciLexer.h"
 
19
 
 
20
#include "WordList.h"
 
21
#include "LexAccessor.h"
 
22
#include "Accessor.h"
 
23
#include "StyleContext.h"
 
24
#include "CharacterSet.h"
 
25
#include "LexerModule.h"
 
26
 
 
27
#ifdef SCI_NAMESPACE
 
28
using namespace Scintilla;
 
29
#endif
 
30
 
 
31
static inline bool IsAWordChar(const int ch) {
 
32
        return (ch < 0x80 && (isalnum(ch) || ch == '_'));
 
33
}
 
34
 
 
35
static inline bool IsAnOperator(char ch) {
 
36
        // '.' left out as it is used to make up numbers
 
37
        if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
 
38
                ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
 
39
                ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
 
40
                ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
 
41
                ch == '$' || ch == ':' || ch == '%')
 
42
                return true;
 
43
        return false;
 
44
}
 
45
 
 
46
static void ColouriseAPDLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
 
47
                            Accessor &styler) {
 
48
 
 
49
        int stringStart = ' ';
 
50
 
 
51
        WordList &processors = *keywordlists[0];
 
52
        WordList &commands = *keywordlists[1];
 
53
        WordList &slashcommands = *keywordlists[2];
 
54
        WordList &starcommands = *keywordlists[3];
 
55
        WordList &arguments = *keywordlists[4];
 
56
        WordList &functions = *keywordlists[5];
 
57
 
 
58
        // Do not leak onto next line
 
59
        initStyle = SCE_APDL_DEFAULT;
 
60
        StyleContext sc(startPos, length, initStyle, styler);
 
61
 
 
62
        for (; sc.More(); sc.Forward()) {
 
63
                // Determine if the current state should terminate.
 
64
                if (sc.state == SCE_APDL_NUMBER) {
 
65
                        if (!(IsADigit(sc.ch) || sc.ch == '.' || (sc.ch == 'e' || sc.ch == 'E') ||
 
66
                                ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) {
 
67
                                sc.SetState(SCE_APDL_DEFAULT);
 
68
                        }
 
69
                } else if (sc.state == SCE_APDL_COMMENT) {
 
70
                        if (sc.atLineEnd) {
 
71
                                sc.SetState(SCE_APDL_DEFAULT);
 
72
                        }
 
73
                } else if (sc.state == SCE_APDL_COMMENTBLOCK) {
 
74
                        if (sc.atLineEnd) {
 
75
                                if (sc.ch == '\r') {
 
76
                                sc.Forward();
 
77
                                }
 
78
                                sc.ForwardSetState(SCE_APDL_DEFAULT);
 
79
                        }
 
80
                } else if (sc.state == SCE_APDL_STRING) {
 
81
                        if (sc.atLineEnd) {
 
82
                                sc.SetState(SCE_APDL_DEFAULT);
 
83
                        } else if ((sc.ch == '\'' && stringStart == '\'') || (sc.ch == '\"' && stringStart == '\"')) {
 
84
                                sc.ForwardSetState(SCE_APDL_DEFAULT);
 
85
                        }
 
86
                } else if (sc.state == SCE_APDL_WORD) {
 
87
                        if (!IsAWordChar(sc.ch)) {
 
88
                                char s[100];
 
89
                                sc.GetCurrentLowered(s, sizeof(s));
 
90
                                if (processors.InList(s)) {
 
91
                                        sc.ChangeState(SCE_APDL_PROCESSOR);
 
92
                                } else if (slashcommands.InList(s)) {
 
93
                                        sc.ChangeState(SCE_APDL_SLASHCOMMAND);
 
94
                                } else if (starcommands.InList(s)) {
 
95
                                        sc.ChangeState(SCE_APDL_STARCOMMAND);
 
96
                                } else if (commands.InList(s)) {
 
97
                                        sc.ChangeState(SCE_APDL_COMMAND);
 
98
                                } else if (arguments.InList(s)) {
 
99
                                        sc.ChangeState(SCE_APDL_ARGUMENT);
 
100
                                } else if (functions.InList(s)) {
 
101
                                        sc.ChangeState(SCE_APDL_FUNCTION);
 
102
                                }
 
103
                                sc.SetState(SCE_APDL_DEFAULT);
 
104
                        }
 
105
                } else if (sc.state == SCE_APDL_OPERATOR) {
 
106
                        if (!IsAnOperator(static_cast<char>(sc.ch))) {
 
107
                            sc.SetState(SCE_APDL_DEFAULT);
 
108
                        }
 
109
                }
 
110
 
 
111
                // Determine if a new state should be entered.
 
112
                if (sc.state == SCE_APDL_DEFAULT) {
 
113
                        if (sc.ch == '!' && sc.chNext == '!') {
 
114
                                sc.SetState(SCE_APDL_COMMENTBLOCK);
 
115
                        } else if (sc.ch == '!') {
 
116
                                sc.SetState(SCE_APDL_COMMENT);
 
117
                        } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
 
118
                                sc.SetState(SCE_APDL_NUMBER);
 
119
                        } else if (sc.ch == '\'' || sc.ch == '\"') {
 
120
                                sc.SetState(SCE_APDL_STRING);
 
121
                                stringStart = sc.ch;
 
122
                        } else if (IsAWordChar(sc.ch) || ((sc.ch == '*' || sc.ch == '/') && !isgraph(sc.chPrev))) {
 
123
                                sc.SetState(SCE_APDL_WORD);
 
124
                        } else if (IsAnOperator(static_cast<char>(sc.ch))) {
 
125
                                sc.SetState(SCE_APDL_OPERATOR);
 
126
                        }
 
127
                }
 
128
        }
 
129
        sc.Complete();
 
130
}
 
131
 
 
132
//------------------------------------------------------------------------------
 
133
// 06-27-07 Sergio Lucato
 
134
// - Included code folding for Ansys APDL lexer
 
135
// - Copyied from LexBasic.cxx and modified for APDL
 
136
//------------------------------------------------------------------------------
 
137
 
 
138
/* Bits:
 
139
 * 1  - whitespace
 
140
 * 2  - operator
 
141
 * 4  - identifier
 
142
 * 8  - decimal digit
 
143
 * 16 - hex digit
 
144
 * 32 - bin digit
 
145
 */
 
146
static int character_classification[128] =
 
147
{
 
148
    0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,  0,
 
149
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 
150
    1,  2,  0,  2,  2,  2,  2,  2,  2,  2,  6,  2,  2,  2,  10, 6,
 
151
    60, 60, 28, 28, 28, 28, 28, 28, 28, 28, 2,  2,  2,  2,  2,  2,
 
152
    2,  20, 20, 20, 20, 20, 20, 4,  4,  4,  4,  4,  4,  4,  4,  4,
 
153
    4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  4,
 
154
    2,  20, 20, 20, 20, 20, 20, 4,  4,  4,  4,  4,  4,  4,  4,  4,
 
155
    4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  0
 
156
};
 
157
 
 
158
static bool IsSpace(int c) {
 
159
        return c < 128 && (character_classification[c] & 1);
 
160
}
 
161
 
 
162
static bool IsIdentifier(int c) {
 
163
        return c < 128 && (character_classification[c] & 4);
 
164
}
 
165
 
 
166
static int LowerCase(int c)
 
167
{
 
168
        if (c >= 'A' && c <= 'Z')
 
169
                return 'a' + c - 'A';
 
170
        return c;
 
171
}
 
172
 
 
173
static int CheckAPDLFoldPoint(char const *token, int &level) {
 
174
        if (!strcmp(token, "*if") ||
 
175
                !strcmp(token, "*do") ||
 
176
                !strcmp(token, "*dowhile") ) {
 
177
                level |= SC_FOLDLEVELHEADERFLAG;
 
178
                return 1;
 
179
        }
 
180
        if (!strcmp(token, "*endif") ||
 
181
                !strcmp(token, "*enddo") ) {
 
182
                return -1;
 
183
        }
 
184
        return 0;
 
185
}
 
186
 
 
187
static void FoldAPDLDoc(unsigned int startPos, int length, int,
 
188
        WordList *[], Accessor &styler) {
 
189
 
 
190
        int line = styler.GetLine(startPos);
 
191
        int level = styler.LevelAt(line);
 
192
        int go = 0, done = 0;
 
193
        int endPos = startPos + length;
 
194
        char word[256];
 
195
        int wordlen = 0;
 
196
        int i;
 
197
    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 
198
        // Scan for tokens at the start of the line (they may include
 
199
        // whitespace, for tokens like "End Function"
 
200
        for (i = startPos; i < endPos; i++) {
 
201
                int c = styler.SafeGetCharAt(i);
 
202
                if (!done && !go) {
 
203
                        if (wordlen) { // are we scanning a token already?
 
204
                                word[wordlen] = static_cast<char>(LowerCase(c));
 
205
                                if (!IsIdentifier(c)) { // done with token
 
206
                                        word[wordlen] = '\0';
 
207
                                        go = CheckAPDLFoldPoint(word, level);
 
208
                                        if (!go) {
 
209
                                                // Treat any whitespace as single blank, for
 
210
                                                // things like "End   Function".
 
211
                                                if (IsSpace(c) && IsIdentifier(word[wordlen - 1])) {
 
212
                                                        word[wordlen] = ' ';
 
213
                                                        if (wordlen < 255)
 
214
                                                                wordlen++;
 
215
                                                }
 
216
                                                else // done with this line
 
217
                                                        done = 1;
 
218
                                        }
 
219
                                } else if (wordlen < 255) {
 
220
                                        wordlen++;
 
221
                                }
 
222
                        } else { // start scanning at first non-whitespace character
 
223
                                if (!IsSpace(c)) {
 
224
                                        if (IsIdentifier(c)) {
 
225
                                                word[0] = static_cast<char>(LowerCase(c));
 
226
                                                wordlen = 1;
 
227
                                        } else // done with this line
 
228
                                                done = 1;
 
229
                                }
 
230
                        }
 
231
                }
 
232
                if (c == '\n') { // line end
 
233
                        if (!done && wordlen == 0 && foldCompact) // line was only space
 
234
                                level |= SC_FOLDLEVELWHITEFLAG;
 
235
                        if (level != styler.LevelAt(line))
 
236
                                styler.SetLevel(line, level);
 
237
                        level += go;
 
238
                        line++;
 
239
                        // reset state
 
240
                        wordlen = 0;
 
241
                        level &= ~SC_FOLDLEVELHEADERFLAG;
 
242
                        level &= ~SC_FOLDLEVELWHITEFLAG;
 
243
                        go = 0;
 
244
                        done = 0;
 
245
                }
 
246
        }
 
247
}
 
248
 
 
249
static const char * const apdlWordListDesc[] = {
 
250
    "processors",
 
251
    "commands",
 
252
    "slashommands",
 
253
    "starcommands",
 
254
    "arguments",
 
255
    "functions",
 
256
    0
 
257
};
 
258
 
 
259
LexerModule lmAPDL(SCLEX_APDL, ColouriseAPDLDoc, "apdl", FoldAPDLDoc, apdlWordListDesc);