[wxWidgets.git] / src / stc / scintilla / lexers / LexA68k.cxx

// Scintilla source code edit control
/** @file LexA68k.cxx
 ** Lexer for Assembler, just for the MASM syntax
 ** Written by Martial Demolins AKA Folco
 **/
// Copyright 2010 Martial Demolins <mdemolins(a)gmail.com>
// The License.txt file describes the conditions under which this software
// may be distributed.


#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>

#include "ILexer.h"
#include "Scintilla.h"
#include "SciLexer.h"

#include "WordList.h"
#include "LexAccessor.h"
#include "Accessor.h"
#include "StyleContext.h"
#include "CharacterSet.h"
#include "LexerModule.h"

#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif


// Return values for GetOperatorType
#define NO_OPERATOR     0
#define OPERATOR_1CHAR  1
#define OPERATOR_2CHAR  2


/**
 *  IsIdentifierStart
 *
 *  Return true if the given char is a valid identifier first char
 */

static inline bool IsIdentifierStart (const int ch)
{
    return (isalpha(ch) || (ch == '_') || (ch == '\\'));
}


/**
 *  IsIdentifierChar
 *
 *  Return true if the given char is a valid identifier char
 */

static inline bool IsIdentifierChar (const int ch)
{
    return (isalnum(ch) || (ch == '_') || (ch == '@') || (ch == ':') || (ch == '.'));
}


/**
 *  GetOperatorType
 *
 *  Return:
 *  NO_OPERATOR     if char is not an operator
 *  OPERATOR_1CHAR  if the operator is one char long
 *  OPERATOR_2CHAR  if the operator is two chars long
 */

static inline int GetOperatorType (const int ch1, const int ch2)
{
    int OpType = NO_OPERATOR;

    if ((ch1 == '+') || (ch1 == '-') || (ch1 == '*') || (ch1 == '/') || (ch1 == '#') ||
        (ch1 == '(') || (ch1 == ')') || (ch1 == '~') || (ch1 == '&') || (ch1 == '|') || (ch1 == ','))
        OpType = OPERATOR_1CHAR;

    else if ((ch1 == ch2) && (ch1 == '<' || ch1 == '>'))
        OpType = OPERATOR_2CHAR;

    return OpType;
}


/**
 *  IsBin
 *
 *  Return true if the given char is 0 or 1
 */

static inline bool IsBin (const int ch)
{
    return (ch == '0') || (ch == '1');
}


/**
 *  IsDoxygenChar
 *
 *  Return true if the char may be part of a Doxygen keyword
 */

static inline bool IsDoxygenChar (const int ch)
{
    return isalpha(ch) || (ch == '$') || (ch == '[') || (ch == ']') || (ch == '{') || (ch == '}');
}


/**
 *  ColouriseA68kDoc
 *
 *  Main function, which colourises a 68k source
 */

static void ColouriseA68kDoc (unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler)
{

    // Get references to keywords lists
    WordList &cpuInstruction = *keywordlists[0];
    WordList &registers = *keywordlists[1];
    WordList &directive = *keywordlists[2];
    WordList &extInstruction = *keywordlists[3];
    WordList &commentSpecial = *keywordlists[4];
    WordList &doxygenKeyword = *keywordlists[5];


    // Instanciate a context for our source
    StyleContext sc(startPos, length, initStyle, styler);


    /************************************************************
    *
    *   Parse the text
    *
    ************************************************************/

    for ( ; sc.More(); sc.Forward())
    {
        char Buffer[100];
        int OpType;

        // Reset style at beginning of line
        if (sc.atLineStart)
            sc.SetState(SCE_A68K_DEFAULT);


        /************************************************************
        *
        *   Handle current state if we are not in the "default style"
        *
        ************************************************************/

        if (sc.state != SCE_A68K_DEFAULT)
        {
            // Check if current style continue.
            // If this case, we loop because there is nothing else to do
            if (((sc.state == SCE_A68K_NUMBER_DEC) && isdigit(sc.ch))                                       // Decimal number
                || ((sc.state == SCE_A68K_NUMBER_BIN) && IsBin(sc.ch))                                      // Binary number
                || ((sc.state == SCE_A68K_NUMBER_HEX) && isxdigit(sc.ch))                                   // Hexa number
                || ((sc.state == SCE_A68K_MACRO_ARG)  && isdigit(sc.ch))                                    // Arg of macro
                || ((sc.state == SCE_A68K_STRING1)    && (sc.ch != '\''))                                   // String single-quoted
                || ((sc.state == SCE_A68K_STRING2)    && (sc.ch != '\"'))                                   // String double-quoted
                || ((sc.state == SCE_A68K_MACRO_ARG)  && isdigit(sc.ch))                                    // Macro argument
                // Label. ' ' and '\t' are needed to handle macro declarations
                || ((sc.state == SCE_A68K_LABEL)      && (sc.ch != ':') && (sc.ch != ' ') && (sc.ch != '\t'))
                || ((sc.state == SCE_A68K_IDENTIFIER) && (sc.ch < 0x80) && IsIdentifierChar(sc.ch))         // Identifier
                || ((sc.state == SCE_A68K_COMMENT_DOXYGEN) && (sc.ch < 0x80) && IsDoxygenChar(sc.ch))       // Doxygen keyword
                || ((sc.state == SCE_A68K_COMMENT_WORD) && (sc.ch < 0x80) && isalpha(sc.ch)))               // Comment current word
            {
                continue;
            }

            // Check if some states terminate at the current char:
            // we must include this char in the current style context
            else if (((sc.state == SCE_A68K_STRING1)    && (sc.ch < 0x80) && (sc.ch == '\''))       // String single-quoted
                     || ((sc.state == SCE_A68K_STRING2) && (sc.ch < 0x80) && (sc.ch == '\"'))       // String double-quoted
                     || ((sc.state == SCE_A68K_LABEL)   && (sc.ch < 0x80) && (sc.ch == ':')))       // Label
            {
                sc.ForwardSetState(SCE_A68K_DEFAULT);
            }

            // Check for special words or Doxygen keywords in comments
            else if (sc.state == SCE_A68K_COMMENT)
            {
                if (sc.ch == '\\') {
                    sc.SetState(SCE_A68K_COMMENT_DOXYGEN);
                }
                else if ((sc.ch < 0x80) && isalpha(sc.ch)) {
                    sc.SetState(SCE_A68K_COMMENT_WORD);
                }
                continue;
            }

            // Check for special words in comment
            else if ((sc.state == SCE_A68K_COMMENT_WORD) && (sc.ch < 0x80) && !isalpha(sc.ch))
            {
                sc.GetCurrent(Buffer, sizeof(Buffer));
                if (commentSpecial.InList(Buffer)) {
                    sc.ChangeState(SCE_A68K_COMMENT_SPECIAL);
                }
                else {
                    sc.ChangeState(SCE_A68K_COMMENT);
                }
                sc.SetState(SCE_A68K_COMMENT);
                continue;
            }

            // Check for Doxygen keywords
            else if ((sc.state == SCE_A68K_COMMENT_DOXYGEN) && (sc.ch < 0x80) && !IsDoxygenChar(sc.ch))
            {
                sc.GetCurrentLowered(Buffer, sizeof(Buffer));                           // Buffer the string of the current context
                if (!doxygenKeyword.InList(Buffer)) {
                    sc.ChangeState(SCE_A68K_COMMENT);
                }
                sc.SetState(SCE_A68K_COMMENT);
                continue;
            }

            // Check if we are in the case of a label which terminates without ':'
            // It should be a macro declaration, not a label
            else if ((sc.state == SCE_A68K_LABEL) && (sc.ch < 0x80) && ((sc.ch == ' ') || (sc.ch == '\t')))
            {
                sc.ChangeState(SCE_A68K_MACRO_DECLARATION);
            }

            // Check if we are at the end of an identifier
            // In this case, colourise it if was a keyword.
            else if ((sc.state == SCE_A68K_IDENTIFIER) && !IsIdentifierChar(sc.ch))
            {
                sc.GetCurrentLowered(Buffer, sizeof(Buffer));                           // Buffer the string of the current context
                if (cpuInstruction.InList(Buffer)) {                                    // And check if it belongs to a keyword list
                    sc.ChangeState(SCE_A68K_CPUINSTRUCTION);
                }
                else if (extInstruction.InList(Buffer)) {
                    sc.ChangeState(SCE_A68K_EXTINSTRUCTION);
                }
                else if (registers.InList(Buffer)) {
                    sc.ChangeState(SCE_A68K_REGISTER);
                }
                else if (directive.InList(Buffer)) {
                    sc.ChangeState(SCE_A68K_DIRECTIVE);
                }
            }

            // All special contexts are now handled.Come back to default style
            sc.SetState(SCE_A68K_DEFAULT);
        }


        /************************************************************
        *
        *   Check if we must enter a new state
        *
        ************************************************************/

        // Label and macro identifiers start at the beginning of a line
        // We set both as a label, but if it wasn't one (no ':' at the end),
        // it will be changed as a macro identifier.
        if (sc.atLineStart && (sc.ch < 0x80) && IsIdentifierStart(sc.ch)) {
            sc.SetState(SCE_A68K_LABEL);
        }
        else if ((sc.ch < 0x80) && (sc.ch == ';')) {                            // Comment
            sc.SetState(SCE_A68K_COMMENT);
        }
        else if ((sc.ch < 0x80) && isdigit(sc.ch)) {                            // Decimal numbers haven't prefix
            sc.SetState(SCE_A68K_NUMBER_DEC);
        }
        else if ((sc.ch < 0x80) && (sc.ch == '%')) {                            // Binary numbers are prefixed with '%'
            sc.SetState(SCE_A68K_NUMBER_BIN);
        }
        else if ((sc.ch < 0x80) && (sc.ch == '$')) {                            // Hexadecimal numbers are prefixed with '$'
            sc.SetState(SCE_A68K_NUMBER_HEX);
        }
        else if ((sc.ch < 0x80) && (sc.ch == '\'')) {                           // String (single-quoted)
            sc.SetState(SCE_A68K_STRING1);
        }
        else if ((sc.ch < 0x80) && (sc.ch == '\"')) {                           // String (double-quoted)
            sc.SetState(SCE_A68K_STRING2);
        }
        else if ((sc.ch < 0x80) && (sc.ch == '\\') && (isdigit(sc.chNext))) {   // Replacement symbols in macro
            sc.SetState(SCE_A68K_MACRO_ARG);
        }
        else if ((sc.ch < 0x80) && IsIdentifierStart(sc.ch)) {                  // An identifier: constant, label, etc...
            sc.SetState(SCE_A68K_IDENTIFIER);
        }
        else {
            if (sc.ch < 0x80) {
                OpType = GetOperatorType(sc.ch, sc.chNext);                     // Check if current char is an operator
                if (OpType != NO_OPERATOR) {
                    sc.SetState(SCE_A68K_OPERATOR);
                    if (OpType == OPERATOR_2CHAR) {                             // Check if the operator is 2 bytes long
                        sc.ForwardSetState(SCE_A68K_OPERATOR);                  // (>> or <<)
                    }
                }
            }
        }
    }                                                                           // End of for()
    sc.Complete();
}


// Names of the keyword lists

static const char * const a68kWordListDesc[] =
{
    "CPU instructions",
    "Registers",
    "Directives",
    "Extended instructions",
    "Comment special words",
    "Doxygen keywords",
    0
};

LexerModule lmA68k(SCLEX_A68K, ColouriseA68kDoc, "a68k", 0, a68kWordListDesc);
Commit	Line	Data
1dcf666d RD	1	// Scintilla source code edit control
	2	/** @file LexA68k.cxx
	3	** Lexer for Assembler, just for the MASM syntax
	4	** Written by Martial Demolins AKA Folco
	5	**/
	6	// Copyright 2010 Martial Demolins <mdemolins(a)gmail.com>
	7	// The License.txt file describes the conditions under which this software
	8	// may be distributed.
	9
	10
	11	#include <stdlib.h>
	12	#include <string.h>
	13	#include <stdio.h>
	14	#include <stdarg.h>
	15	#include <assert.h>
	16	#include <ctype.h>
	17
	18	#include "ILexer.h"
	19	#include "Scintilla.h"
	20	#include "SciLexer.h"
	21
	22	#include "WordList.h"
	23	#include "LexAccessor.h"
	24	#include "Accessor.h"
	25	#include "StyleContext.h"
	26	#include "CharacterSet.h"
	27	#include "LexerModule.h"
	28
	29	#ifdef SCI_NAMESPACE
	30	using namespace Scintilla;
	31	#endif
	32
	33
	34	// Return values for GetOperatorType
	35	#define NO_OPERATOR 0
	36	#define OPERATOR_1CHAR 1
	37	#define OPERATOR_2CHAR 2
	38
	39
	40	/**
	41	* IsIdentifierStart
	42	*
	43	* Return true if the given char is a valid identifier first char
	44	*/
	45
	46	static inline bool IsIdentifierStart (const int ch)
	47	{
	48	return (isalpha(ch) \|\| (ch == '_') \|\| (ch == '\\'));
	49	}
	50
	51
	52	/**
	53	* IsIdentifierChar
	54	*
	55	* Return true if the given char is a valid identifier char
	56	*/
	57
	58	static inline bool IsIdentifierChar (const int ch)
	59	{
	60	return (isalnum(ch) \|\| (ch == '_') \|\| (ch == '@') \|\| (ch == ':') \|\| (ch == '.'));
	61	}
	62
	63
	64	/**
65	* GetOperatorType
66	*
67	* Return:
68	* NO_OPERATOR if char is not an operator
69	* OPERATOR_1CHAR if the operator is one char long
70	* OPERATOR_2CHAR if the operator is two chars long
71	*/
72
73	static inline int GetOperatorType (const int ch1, const int ch2)
74	{
75	int OpType = NO_OPERATOR;
76
77	if ((ch1 == '+') \|\| (ch1 == '-') \|\| (ch1 == '*') \|\| (ch1 == '/') \|\| (ch1 == '#') \|\|
78	(ch1 == '(') \|\| (ch1 == ')') \|\| (ch1 == '~') \|\| (ch1 == '&') \|\| (ch1 == '\|') \|\| (ch1 == ','))
79	OpType = OPERATOR_1CHAR;
80
81	else if ((ch1 == ch2) && (ch1 == '<' \|\| ch1 == '>'))
82	OpType = OPERATOR_2CHAR;
83
84	return OpType;
85	}
86
87
88	/**
89	* IsBin
90	*
91	* Return true if the given char is 0 or 1
92	*/
93
94	static inline bool IsBin (const int ch)
95	{
96	return (ch == '0') \|\| (ch == '1');
97	}
98
99
100	/**
101	* IsDoxygenChar
102	*
103	* Return true if the char may be part of a Doxygen keyword
104	*/
105
106	static inline bool IsDoxygenChar (const int ch)
107	{
108	return isalpha(ch) \|\| (ch == '$') \|\| (ch == '[') \|\| (ch == ']') \|\| (ch == '{') \|\| (ch == '}');
109	}
110
111
112	/**
113	* ColouriseA68kDoc
114	*
115	* Main function, which colourises a 68k source
116	*/
117
118	static void ColouriseA68kDoc (unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler)
119	{
120
121	// Get references to keywords lists
122	WordList &cpuInstruction = *keywordlists[0];
123	WordList &registers = *keywordlists[1];
124	WordList &directive = *keywordlists[2];
125	WordList &extInstruction = *keywordlists[3];
126	WordList &commentSpecial = *keywordlists[4];
127	WordList &doxygenKeyword = *keywordlists[5];
128
129
130	// Instanciate a context for our source
131	StyleContext sc(startPos, length, initStyle, styler);
132
133
134	/************************************************************
135	*
136	* Parse the text
137	*
138	************************************************************/
139
140	for ( ; sc.More(); sc.Forward())
141	{
142	char Buffer[100];
143	int OpType;
144
145	// Reset style at beginning of line
146	if (sc.atLineStart)
147	sc.SetState(SCE_A68K_DEFAULT);
148
149
150	/************************************************************
151	*
152	* Handle current state if we are not in the "default style"
153	*
154	************************************************************/
155
156	if (sc.state != SCE_A68K_DEFAULT)
157	{
158	// Check if current style continue.
159	// If this case, we loop because there is nothing else to do
160	if (((sc.state == SCE_A68K_NUMBER_DEC) && isdigit(sc.ch)) // Decimal number
161	\|\| ((sc.state == SCE_A68K_NUMBER_BIN) && IsBin(sc.ch)) // Binary number
162	\|\| ((sc.state == SCE_A68K_NUMBER_HEX) && isxdigit(sc.ch)) // Hexa number
163	\|\| ((sc.state == SCE_A68K_MACRO_ARG) && isdigit(sc.ch)) // Arg of macro
164	\|\| ((sc.state == SCE_A68K_STRING1) && (sc.ch != '\'')) // String single-quoted
165	\|\| ((sc.state == SCE_A68K_STRING2) && (sc.ch != '\"')) // String double-quoted
166	\|\| ((sc.state == SCE_A68K_MACRO_ARG) && isdigit(sc.ch)) // Macro argument
167	// Label. ' ' and '\t' are needed to handle macro declarations
168	\|\| ((sc.state == SCE_A68K_LABEL) && (sc.ch != ':') && (sc.ch != ' ') && (sc.ch != '\t'))
169	\|\| ((sc.state == SCE_A68K_IDENTIFIER) && (sc.ch < 0x80) && IsIdentifierChar(sc.ch)) // Identifier
170	\|\| ((sc.state == SCE_A68K_COMMENT_DOXYGEN) && (sc.ch < 0x80) && IsDoxygenChar(sc.ch)) // Doxygen keyword
171	\|\| ((sc.state == SCE_A68K_COMMENT_WORD) && (sc.ch < 0x80) && isalpha(sc.ch))) // Comment current word
172	{
173	continue;
174	}
175
176	// Check if some states terminate at the current char:
177	// we must include this char in the current style context
178	else if (((sc.state == SCE_A68K_STRING1) && (sc.ch < 0x80) && (sc.ch == '\'')) // String single-quoted
179	\|\| ((sc.state == SCE_A68K_STRING2) && (sc.ch < 0x80) && (sc.ch == '\"')) // String double-quoted
180	\|\| ((sc.state == SCE_A68K_LABEL) && (sc.ch < 0x80) && (sc.ch == ':'))) // Label
181	{
182	sc.ForwardSetState(SCE_A68K_DEFAULT);
183	}
184
185	// Check for special words or Doxygen keywords in comments
186	else if (sc.state == SCE_A68K_COMMENT)
187	{
188	if (sc.ch == '\\') {
189	sc.SetState(SCE_A68K_COMMENT_DOXYGEN);
190	}
191	else if ((sc.ch < 0x80) && isalpha(sc.ch)) {
192	sc.SetState(SCE_A68K_COMMENT_WORD);
193	}
194	continue;
195	}
196
197	// Check for special words in comment
198	else if ((sc.state == SCE_A68K_COMMENT_WORD) && (sc.ch < 0x80) && !isalpha(sc.ch))
199	{
200	sc.GetCurrent(Buffer, sizeof(Buffer));
201	if (commentSpecial.InList(Buffer)) {
202	sc.ChangeState(SCE_A68K_COMMENT_SPECIAL);
203	}
204	else {
205	sc.ChangeState(SCE_A68K_COMMENT);
206	}
207	sc.SetState(SCE_A68K_COMMENT);
208	continue;
209	}
210
211	// Check for Doxygen keywords
212	else if ((sc.state == SCE_A68K_COMMENT_DOXYGEN) && (sc.ch < 0x80) && !IsDoxygenChar(sc.ch))
213	{
214	sc.GetCurrentLowered(Buffer, sizeof(Buffer)); // Buffer the string of the current context
215	if (!doxygenKeyword.InList(Buffer)) {
216	sc.ChangeState(SCE_A68K_COMMENT);
217	}
218	sc.SetState(SCE_A68K_COMMENT);
219	continue;
220	}
221
222	// Check if we are in the case of a label which terminates without ':'
223	// It should be a macro declaration, not a label
224	else if ((sc.state == SCE_A68K_LABEL) && (sc.ch < 0x80) && ((sc.ch == ' ') \|\| (sc.ch == '\t')))
225	{
226	sc.ChangeState(SCE_A68K_MACRO_DECLARATION);
227	}
228
229	// Check if we are at the end of an identifier
230	// In this case, colourise it if was a keyword.
231	else if ((sc.state == SCE_A68K_IDENTIFIER) && !IsIdentifierChar(sc.ch))
232	{
233	sc.GetCurrentLowered(Buffer, sizeof(Buffer)); // Buffer the string of the current context
234	if (cpuInstruction.InList(Buffer)) { // And check if it belongs to a keyword list
235	sc.ChangeState(SCE_A68K_CPUINSTRUCTION);
236	}
237	else if (extInstruction.InList(Buffer)) {
238	sc.ChangeState(SCE_A68K_EXTINSTRUCTION);
239	}
240	else if (registers.InList(Buffer)) {
241	sc.ChangeState(SCE_A68K_REGISTER);
242	}
243	else if (directive.InList(Buffer)) {
244	sc.ChangeState(SCE_A68K_DIRECTIVE);
245	}
246	}
247
248	// All special contexts are now handled.Come back to default style
249	sc.SetState(SCE_A68K_DEFAULT);
250	}
251
252
253	/************************************************************
254	*
255	* Check if we must enter a new state
256	*
257	************************************************************/
258
259	// Label and macro identifiers start at the beginning of a line
260	// We set both as a label, but if it wasn't one (no ':' at the end),
261	// it will be changed as a macro identifier.
262	if (sc.atLineStart && (sc.ch < 0x80) && IsIdentifierStart(sc.ch)) {
263	sc.SetState(SCE_A68K_LABEL);
264	}
265	else if ((sc.ch < 0x80) && (sc.ch == ';')) { // Comment
266	sc.SetState(SCE_A68K_COMMENT);
267	}
268	else if ((sc.ch < 0x80) && isdigit(sc.ch)) { // Decimal numbers haven't prefix
269	sc.SetState(SCE_A68K_NUMBER_DEC);
270	}
271	else if ((sc.ch < 0x80) && (sc.ch == '%')) { // Binary numbers are prefixed with '%'
272	sc.SetState(SCE_A68K_NUMBER_BIN);
273	}
274	else if ((sc.ch < 0x80) && (sc.ch == '$')) { // Hexadecimal numbers are prefixed with '$'
275	sc.SetState(SCE_A68K_NUMBER_HEX);
276	}
277	else if ((sc.ch < 0x80) && (sc.ch == '\'')) { // String (single-quoted)
278	sc.SetState(SCE_A68K_STRING1);
279	}
280	else if ((sc.ch < 0x80) && (sc.ch == '\"')) { // String (double-quoted)
281	sc.SetState(SCE_A68K_STRING2);
282	}
283	else if ((sc.ch < 0x80) && (sc.ch == '\\') && (isdigit(sc.chNext))) { // Replacement symbols in macro
284	sc.SetState(SCE_A68K_MACRO_ARG);
285	}
286	else if ((sc.ch < 0x80) && IsIdentifierStart(sc.ch)) { // An identifier: constant, label, etc...
287	sc.SetState(SCE_A68K_IDENTIFIER);
288	}
289	else {
290	if (sc.ch < 0x80) {
291	OpType = GetOperatorType(sc.ch, sc.chNext); // Check if current char is an operator
292	if (OpType != NO_OPERATOR) {
293	sc.SetState(SCE_A68K_OPERATOR);
294	if (OpType == OPERATOR_2CHAR) { // Check if the operator is 2 bytes long
295	sc.ForwardSetState(SCE_A68K_OPERATOR); // (>> or <<)
296	}
297	}
298	}
299	}
300	} // End of for()
301	sc.Complete();
302	}
303
304
305	// Names of the keyword lists
306
307	static const char * const a68kWordListDesc[] =
308	{
309	"CPU instructions",
310	"Registers",
311	"Directives",
312	"Extended instructions",
313	"Comment special words",
314	"Doxygen keywords",
315	0
316	};
317
318	LexerModule lmA68k(SCLEX_A68K, ColouriseA68kDoc, "a68k", 0, a68kWordListDesc);