← Back to branch summary

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

« back to all changes in this revision

Viewing changes to scintilla/LexForth.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/LexForth.cxx
1
 
// Scintilla source code edit control
2
 
/** @file LexForth.cxx
3
 
 ** Lexer for FORTH
4
 
 **/
5
 
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
6
 
// The License.txt file describes the conditions under which this software may be distributed.
7
 
 
8
 
#include <stdlib.h>
9
 
#include <string.h>
10
 
#include <ctype.h>
11
 
#include <stdio.h>
12
 
#include <stdarg.h>
13
 
 
14
 
#include "Platform.h"
15
 
 
16
 
#include "PropSet.h"
17
 
#include "Accessor.h"
18
 
#include "StyleContext.h"
19
 
#include "KeyWords.h"
20
 
#include "Scintilla.h"
21
 
#include "SciLexer.h"
22
 
 
23
 
#ifdef SCI_NAMESPACE
24
 
using namespace Scintilla;
25
 
#endif
26
 
 
27
 
static inline bool IsAWordChar(int ch) {
28
 
        return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
29
 
                ch == '_' || ch == '?' || ch == '"' || ch == '@' ||
30
 
                ch == '!' || ch == '[' || ch == ']' || ch == '/' ||
31
 
                ch == '+' || ch == '-' || ch == '*' || ch == '<' ||
32
 
                ch == '>' || ch == '=' || ch == ';' || ch == '(' ||
33
 
                ch == ')' );
34
 
}
35
 
 
36
 
static inline bool IsAWordStart(int ch) {
37
 
        return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.');
38
 
}
39
 
 
40
 
static inline bool IsANumChar(int ch) {
41
 
        return (ch < 0x80) && (isxdigit(ch) || ch == '.' || ch == 'e' || ch == 'E' );
42
 
}
43
 
 
44
 
static inline bool IsASpaceChar(int ch) {
45
 
        return (ch < 0x80) && isspace(ch);
46
 
}
47
 
 
48
 
static void ColouriseForthDoc(unsigned int startPos, int length, int initStyle, WordList *keywordLists[],
49
 
                            Accessor &styler) {
50
 
 
51
 
    WordList &control = *keywordLists[0];
52
 
    WordList &keyword = *keywordLists[1];
53
 
    WordList &defword = *keywordLists[2];
54
 
    WordList &preword1 = *keywordLists[3];
55
 
    WordList &preword2 = *keywordLists[4];
56
 
    WordList &strings = *keywordLists[5];
57
 
 
58
 
        StyleContext sc(startPos, length, initStyle, styler);
59
 
 
60
 
        for (; sc.More(); sc.Forward())
61
 
        {
62
 
                // Determine if the current state should terminate.
63
 
                if (sc.state == SCE_FORTH_COMMENT) {
64
 
                        if (sc.atLineEnd) {
65
 
                                sc.SetState(SCE_FORTH_DEFAULT);
66
 
                        }
67
 
                }else if (sc.state == SCE_FORTH_COMMENT_ML) {
68
 
                        if (sc.ch == ')') {
69
 
                                sc.ForwardSetState(SCE_FORTH_DEFAULT);
70
 
                        }
71
 
                }else if (sc.state == SCE_FORTH_IDENTIFIER || sc.state == SCE_FORTH_NUMBER) {
72
 
                        // handle numbers here too, because what we thought was a number might
73
 
                        // turn out to be a keyword e.g. 2DUP
74
 
                        if (IsASpaceChar(sc.ch) ) {
75
 
                                char s[100];
76
 
                                sc.GetCurrentLowered(s, sizeof(s));
77
 
                                int newState = sc.state == SCE_FORTH_NUMBER ? SCE_FORTH_NUMBER : SCE_FORTH_DEFAULT;
78
 
                                if (control.InList(s)) {
79
 
                                        sc.ChangeState(SCE_FORTH_CONTROL);
80
 
                                } else if (keyword.InList(s)) {
81
 
                                        sc.ChangeState(SCE_FORTH_KEYWORD);
82
 
                                } else if (defword.InList(s)) {
83
 
                                        sc.ChangeState(SCE_FORTH_DEFWORD);
84
 
                                }  else if (preword1.InList(s)) {
85
 
                                        sc.ChangeState(SCE_FORTH_PREWORD1);
86
 
                                } else if (preword2.InList(s)) {
87
 
                                        sc.ChangeState(SCE_FORTH_PREWORD2);
88
 
                                } else if (strings.InList(s)) {
89
 
                                        sc.ChangeState(SCE_FORTH_STRING);
90
 
                                        newState = SCE_FORTH_STRING;
91
 
                                }
92
 
                                sc.SetState(newState);
93
 
                        }
94
 
                        if (sc.state == SCE_FORTH_NUMBER) {
95
 
                                if (IsASpaceChar(sc.ch)) {
96
 
                                        sc.SetState(SCE_FORTH_DEFAULT);
97
 
                                } else if (!IsANumChar(sc.ch)) {
98
 
                                        sc.ChangeState(SCE_FORTH_IDENTIFIER);
99
 
                                }
100
 
                        }
101
 
                }else if (sc.state == SCE_FORTH_STRING) {
102
 
                        if (sc.ch == '\"') {
103
 
                                sc.ForwardSetState(SCE_FORTH_DEFAULT);
104
 
                        }
105
 
                }else if (sc.state == SCE_FORTH_LOCALE) {
106
 
                        if (sc.ch == '}') {
107
 
                                sc.ForwardSetState(SCE_FORTH_DEFAULT);
108
 
                        }
109
 
                }else if (sc.state == SCE_FORTH_DEFWORD) {
110
 
                        if (IsASpaceChar(sc.ch)) {
111
 
                                sc.SetState(SCE_FORTH_DEFAULT);
112
 
                        }
113
 
                }
114
 
 
115
 
                // Determine if a new state should be entered.
116
 
                if (sc.state == SCE_FORTH_DEFAULT) {
117
 
                        if (sc.ch == '\\'){
118
 
                                sc.SetState(SCE_FORTH_COMMENT);
119
 
                        } else if (sc.ch == '(' &&
120
 
                                        (sc.atLineStart || IsASpaceChar(sc.chPrev)) &&
121
 
                                        (sc.atLineEnd   || IsASpaceChar(sc.chNext))) {
122
 
                                sc.SetState(SCE_FORTH_COMMENT_ML);
123
 
                        } else if (     (sc.ch == '$' && (isascii(sc.chNext) && isxdigit(sc.chNext))) ) {
124
 
                                // number starting with $ is a hex number
125
 
                                sc.SetState(SCE_FORTH_NUMBER);
126
 
                                while(sc.More() && isascii(sc.chNext) && isxdigit(sc.chNext))
127
 
                                        sc.Forward();
128
 
                        } else if ( (sc.ch == '%' && (isascii(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1'))) ) {
129
 
                                // number starting with % is binary
130
 
                                sc.SetState(SCE_FORTH_NUMBER);
131
 
                                while(sc.More() && isascii(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1'))
132
 
                                        sc.Forward();
133
 
                        } else if (     isascii(sc.ch) && 
134
 
                                                (isxdigit(sc.ch) || ((sc.ch == '.' || sc.ch == '-') && isascii(sc.chNext) && isxdigit(sc.chNext)) )
135
 
                                        ){
136
 
                                sc.SetState(SCE_FORTH_NUMBER);
137
 
                        } else if (IsAWordStart(sc.ch)) {
138
 
                                sc.SetState(SCE_FORTH_IDENTIFIER);
139
 
                        } else if (sc.ch == '{') {
140
 
                                sc.SetState(SCE_FORTH_LOCALE);
141
 
                        } else if (sc.ch == ':' && isascii(sc.chNext) && isspace(sc.chNext)) {
142
 
                                // highlight word definitions e.g.  : GCD ( n n -- n ) ..... ;
143
 
                                //                                  ^ ^^^
144
 
                                sc.SetState(SCE_FORTH_DEFWORD);
145
 
                                while(sc.More() && isascii(sc.chNext) && isspace(sc.chNext))
146
 
                                        sc.Forward();
147
 
                        } else if (sc.ch == ';' &&
148
 
                                        (sc.atLineStart || IsASpaceChar(sc.chPrev)) &&
149
 
                                        (sc.atLineEnd   || IsASpaceChar(sc.chNext))     ) {
150
 
                                // mark the ';' that ends a word
151
 
                                sc.SetState(SCE_FORTH_DEFWORD);
152
 
                                sc.ForwardSetState(SCE_FORTH_DEFAULT);
153
 
                        }
154
 
                }
155
 
 
156
 
        }
157
 
        sc.Complete();
158
 
}
159
 
 
160
 
static void FoldForthDoc(unsigned int, int, int, WordList *[],
161
 
                                                Accessor &) {
162
 
}
163
 
 
164
 
static const char * const forthWordLists[] = {
165
 
                        "control keywords",
166
 
                        "keywords",
167
 
                        "definition words",
168
 
                        "prewords with one argument",
169
 
                        "prewords with two arguments",
170
 
                        "string definition keywords",
171
 
                        0,
172
 
                };
173
 
 
174
 
LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth", FoldForthDoc, forthWordLists);
175
 
 
176