← Back to branch summary

~efargaspro/+junk/codeblocks-16.01-release

« back to all changes in this revision

Viewing changes to src/plugins/contrib/wxSmithSTC/stc/scintilla/src/LexAsm.cxx

  • Committer: damienlmoore at gmail
  • Date: 2016-02-02 02:43:22 UTC
  • Revision ID: damienlmoore@gmail.com-20160202024322-yql5qmtbwdyamdwd
Code::Blocks 16.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/wxSmithSTC/stc/scintilla/src/LexAsm.cxx
 
1
// Scintilla source code edit control
 
2
/** @file LexAsm.cxx
 
3
 ** Lexer for Assembler, just for the MASM syntax
 
4
 ** Written by The Black Horus
 
5
 ** Enhancements and NASM stuff by Kein-Hong Man, 2003-10
 
6
 ** SCE_ASM_COMMENTBLOCK and SCE_ASM_CHARACTER are for future GNU as colouring
 
7
 **/
 
8
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 
9
// The License.txt file describes the conditions under which this software may be distributed.
 
10
 
 
11
#include <stdlib.h>
 
12
#include <string.h>
 
13
#include <ctype.h>
 
14
#include <stdio.h>
 
15
#include <stdarg.h>
 
16
 
 
17
#include "Platform.h"
 
18
 
 
19
#include "PropSet.h"
 
20
#include "Accessor.h"
 
21
#include "StyleContext.h"
 
22
#include "KeyWords.h"
 
23
#include "Scintilla.h"
 
24
#include "SciLexer.h"
 
25
 
 
26
 
 
27
static inline bool IsAWordChar(const int ch) {
 
28
        return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
 
29
                ch == '_' || ch == '?');
 
30
}
 
31
 
 
32
static inline bool IsAWordStart(const int ch) {
 
33
        return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' ||
 
34
                ch == '%' || ch == '@' || ch == '$' || ch == '?');
 
35
}
 
36
 
 
37
static inline bool IsAsmOperator(char ch) {
 
38
        if (isalnum(ch))
 
39
                return false;
 
40
        // '.' left out as it is used to make up numbers
 
41
        if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
 
42
                ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
 
43
                ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
 
44
                ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
 
45
                ch == '%' || ch == ':')
 
46
                return true;
 
47
        return false;
 
48
}
 
49
 
 
50
static void ColouriseAsmDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
 
51
                            Accessor &styler) {
 
52
 
 
53
        WordList &cpuInstruction = *keywordlists[0];
 
54
        WordList &mathInstruction = *keywordlists[1];
 
55
        WordList &registers = *keywordlists[2];
 
56
        WordList &directive = *keywordlists[3];
 
57
        WordList &directiveOperand = *keywordlists[4];
 
58
        WordList &extInstruction = *keywordlists[5];
 
59
 
 
60
        // Do not leak onto next line
 
61
        if (initStyle == SCE_ASM_STRINGEOL)
 
62
                initStyle = SCE_ASM_DEFAULT;
 
63
 
 
64
        StyleContext sc(startPos, length, initStyle, styler);
 
65
 
 
66
        for (; sc.More(); sc.Forward())
 
67
        {
 
68
 
 
69
                // Prevent SCE_ASM_STRINGEOL from leaking back to previous line
 
70
                if (sc.atLineStart && (sc.state == SCE_ASM_STRING)) {
 
71
                        sc.SetState(SCE_ASM_STRING);
 
72
                } else if (sc.atLineStart && (sc.state == SCE_ASM_CHARACTER)) {
 
73
                        sc.SetState(SCE_ASM_CHARACTER);
 
74
                }
 
75
 
 
76
                // Handle line continuation generically.
 
77
                if (sc.ch == '\\') {
 
78
                        if (sc.chNext == '\n' || sc.chNext == '\r') {
 
79
                                sc.Forward();
 
80
                                if (sc.ch == '\r' && sc.chNext == '\n') {
 
81
                                        sc.Forward();
 
82
                                }
 
83
                                continue;
 
84
                        }
 
85
                }
 
86
 
 
87
                // Determine if the current state should terminate.
 
88
                if (sc.state == SCE_ASM_OPERATOR) {
 
89
                        if (!IsAsmOperator(static_cast<char>(sc.ch))) {
 
90
                            sc.SetState(SCE_ASM_DEFAULT);
 
91
                        }
 
92
                }else if (sc.state == SCE_ASM_NUMBER) {
 
93
                        if (!IsAWordChar(sc.ch)) {
 
94
                                sc.SetState(SCE_ASM_DEFAULT);
 
95
                        }
 
96
                } else if (sc.state == SCE_ASM_IDENTIFIER) {
 
97
                        if (!IsAWordChar(sc.ch) ) {
 
98
                                char s[100];
 
99
                                sc.GetCurrentLowered(s, sizeof(s));
 
100
 
 
101
                                if (cpuInstruction.InList(s)) {
 
102
                                        sc.ChangeState(SCE_ASM_CPUINSTRUCTION);
 
103
                                } else if (mathInstruction.InList(s)) {
 
104
                                        sc.ChangeState(SCE_ASM_MATHINSTRUCTION);
 
105
                                } else if (registers.InList(s)) {
 
106
                                        sc.ChangeState(SCE_ASM_REGISTER);
 
107
                                }  else if (directive.InList(s)) {
 
108
                                        sc.ChangeState(SCE_ASM_DIRECTIVE);
 
109
                                } else if (directiveOperand.InList(s)) {
 
110
                                        sc.ChangeState(SCE_ASM_DIRECTIVEOPERAND);
 
111
                                } else if (extInstruction.InList(s)) {
 
112
                                        sc.ChangeState(SCE_ASM_EXTINSTRUCTION);
 
113
                                }
 
114
                                sc.SetState(SCE_ASM_DEFAULT);
 
115
                        }
 
116
                }
 
117
                else if (sc.state == SCE_ASM_COMMENT ) {
 
118
                        if (sc.atLineEnd) {
 
119
                                sc.SetState(SCE_ASM_DEFAULT);
 
120
                        }
 
121
                } else if (sc.state == SCE_ASM_STRING) {
 
122
                        if (sc.ch == '\\') {
 
123
                                if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 
124
                                        sc.Forward();
 
125
                                }
 
126
                        } else if (sc.ch == '\"') {
 
127
                                sc.ForwardSetState(SCE_ASM_DEFAULT);
 
128
                        } else if (sc.atLineEnd) {
 
129
                                sc.ChangeState(SCE_ASM_STRINGEOL);
 
130
                                sc.ForwardSetState(SCE_ASM_DEFAULT);
 
131
                        }
 
132
                } else if (sc.state == SCE_ASM_CHARACTER) {
 
133
                        if (sc.ch == '\\') {
 
134
                                if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 
135
                                        sc.Forward();
 
136
                                }
 
137
                        } else if (sc.ch == '\'') {
 
138
                                sc.ForwardSetState(SCE_ASM_DEFAULT);
 
139
                        } else if (sc.atLineEnd) {
 
140
                                sc.ChangeState(SCE_ASM_STRINGEOL);
 
141
                                sc.ForwardSetState(SCE_ASM_DEFAULT);
 
142
                        }
 
143
                }
 
144
 
 
145
                // Determine if a new state should be entered.
 
146
                if (sc.state == SCE_ASM_DEFAULT) {
 
147
                        if (sc.ch == ';'){
 
148
                                sc.SetState(SCE_ASM_COMMENT);
 
149
                        } else if (isdigit(sc.ch) || (sc.ch == '.' && isdigit(sc.chNext))) {
 
150
                                sc.SetState(SCE_ASM_NUMBER);
 
151
                        } else if (IsAWordStart(sc.ch)) {
 
152
                                sc.SetState(SCE_ASM_IDENTIFIER);
 
153
                        } else if (sc.ch == '\"') {
 
154
                                sc.SetState(SCE_ASM_STRING);
 
155
                        } else if (sc.ch == '\'') {
 
156
                                sc.SetState(SCE_ASM_CHARACTER);
 
157
                        } else if (IsAsmOperator(static_cast<char>(sc.ch))) {
 
158
                                sc.SetState(SCE_ASM_OPERATOR);
 
159
                        }
 
160
                }
 
161
 
 
162
        }
 
163
        sc.Complete();
 
164
}
 
165
 
 
166
static const char * const asmWordListDesc[] = {
 
167
        "CPU instructions",
 
168
        "FPU instructions",
 
169
        "Registers",
 
170
        "Directives",
 
171
        "Directive operands",
 
172
        "Extended instructions",
 
173
        0
 
174
};
 
175
 
 
176
LexerModule lmAsm(SCLEX_ASM, ColouriseAsmDoc, "asm", 0, asmWordListDesc);
 
177