[wxWidgets.git] / contrib / src / stc / scintilla / src / LexMSSQL.cxx

// Scintilla source code edit control
/** @file LexMSSQL.cxx
 ** Lexer for MSSQL.
 **/
// Copyright 1998-2002 by Filip Yaghob <fy@eg.cz>


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

#include "Platform.h"

#include "PropSet.h"
#include "Accessor.h"
#include "KeyWords.h"
#include "Scintilla.h"
#include "SciLexer.h"

#define KW_MSSQL_STATEMENTS         0
#define KW_MSSQL_DATA_TYPES         1
#define KW_MSSQL_SYSTEM_TABLES      2
#define KW_MSSQL_GLOBAL_VARIABLES   3
#define KW_MSSQL_FUNCTIONS          4
#define KW_MSSQL_STORED_PROCEDURES  5
#define KW_MSSQL_OPERATORS          6

//~ val SCE_MSSQL_DEFAULT=0
//~ val SCE_MSSQL_COMMENT=1
//~ val SCE_MSSQL_LINE_COMMENT=2
//~ val SCE_MSSQL_NUMBER=3
//~ val SCE_MSSQL_STRING=4
//~ val SCE_MSSQL_OPERATOR=5
//~ val SCE_MSSQL_IDENTIFIER=6
//~ val SCE_MSSQL_VARIABLE=7
//~ val SCE_MSSQL_COLUMN_NAME=8
//~ val SCE_MSSQL_STATEMENT=9
//~ val SCE_MSSQL_DATATYPE=10
//~ val SCE_MSSQL_SYSTABLE=11
//~ val SCE_MSSQL_GLOBAL_VARIABLE=12
//~ val SCE_MSSQL_FUNCTION=13
//~ val SCE_MSSQL_STORED_PROCEDURE=14
//~ val SCE_MSSQL_DEFAULT_PREF_DATATYPE 15
//~ val SCE_MSSQL_COLUMN_NAME_2 16

static bool isMSSQLOperator(char ch) {
	if (isascii(ch) && isalnum(ch))
		return false;
	// '.' left out as it is used to make up numbers
	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
        ch == '-' || ch == '+' || ch == '=' || ch == '|' ||
        ch == '<' || ch == '>' || ch == '/' ||
        ch == '!' || ch == '~' || ch == '(' || ch == ')' ||
		ch == ',')
		return true;
	return false;
}

static char classifyWordSQL(unsigned int start,
                            unsigned int end,
                            WordList *keywordlists[],
                            Accessor &styler,
                            unsigned int actualState,
							unsigned int prevState) {
	char s[256];
	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');

	WordList &kwStatements          = *keywordlists[KW_MSSQL_STATEMENTS];
    WordList &kwDataTypes           = *keywordlists[KW_MSSQL_DATA_TYPES];
    WordList &kwSystemTables        = *keywordlists[KW_MSSQL_SYSTEM_TABLES];
    WordList &kwGlobalVariables     = *keywordlists[KW_MSSQL_GLOBAL_VARIABLES];
    WordList &kwFunctions           = *keywordlists[KW_MSSQL_FUNCTIONS];
    WordList &kwStoredProcedures    = *keywordlists[KW_MSSQL_STORED_PROCEDURES];
    WordList &kwOperators           = *keywordlists[KW_MSSQL_OPERATORS];

	for (unsigned int i = 0; i < end - start + 1 && i < 128; i++) {
		s[i] = static_cast<char>(tolower(styler[start + i]));
		s[i + 1] = '\0';
	}
	char chAttr = SCE_MSSQL_IDENTIFIER;

	if (actualState == SCE_MSSQL_GLOBAL_VARIABLE) {

        if (kwGlobalVariables.InList(&s[2]))
            chAttr = SCE_MSSQL_GLOBAL_VARIABLE;

	} else if (wordIsNumber) {
		chAttr = SCE_MSSQL_NUMBER;

	} else if (prevState == SCE_MSSQL_DEFAULT_PREF_DATATYPE) {
		// Look first in datatypes
        if (kwDataTypes.InList(s))
            chAttr = SCE_MSSQL_DATATYPE;
		else if (kwOperators.InList(s))
			chAttr = SCE_MSSQL_OPERATOR;
		else if (kwStatements.InList(s))
			chAttr = SCE_MSSQL_STATEMENT;
		else if (kwSystemTables.InList(s))
			chAttr = SCE_MSSQL_SYSTABLE;
		else if (kwFunctions.InList(s))
            chAttr = SCE_MSSQL_FUNCTION;
		else if (kwStoredProcedures.InList(s))
			chAttr = SCE_MSSQL_STORED_PROCEDURE;

	} else {
		if (kwOperators.InList(s))
			chAttr = SCE_MSSQL_OPERATOR;
		else if (kwStatements.InList(s))
			chAttr = SCE_MSSQL_STATEMENT;
		else if (kwSystemTables.InList(s))
			chAttr = SCE_MSSQL_SYSTABLE;
		else if (kwFunctions.InList(s))
			chAttr = SCE_MSSQL_FUNCTION;
		else if (kwStoredProcedures.InList(s))
			chAttr = SCE_MSSQL_STORED_PROCEDURE;
		else if (kwDataTypes.InList(s))
			chAttr = SCE_MSSQL_DATATYPE;
	}

	styler.ColourTo(end, chAttr);

	return chAttr;
}

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


	styler.StartAt(startPos);

	bool fold = styler.GetPropertyInt("fold") != 0;
	int lineCurrent = styler.GetLine(startPos);
	int spaceFlags = 0;
/*
	WordList &kwStatements          = *keywordlists[KW_MSSQL_STATEMENTS];
    WordList &kwDataTypes           = *keywordlists[KW_MSSQL_DATA_TYPES];
    WordList &kwSystemTables        = *keywordlists[KW_MSSQL_SYSTEM_TABLES];
    WordList &kwGlobalVariables     = *keywordlists[KW_MSSQL_GLOBAL_VARIABLES];
    WordList &kwFunctions           = *keywordlists[KW_MSSQL_FUNCTIONS];

	char s[100];
	int iixx = 0;
	s[0] = 's';	s[1] = 'e'; s[2] = 'l'; s[3] = 'e'; s[4] = 'c'; s[5] = 't'; s[6] = 0;
	if (kwStatements.InList(s))
		iixx = 1;
	s[0] = 's';	s[1] = 'e'; s[2] = 'r'; s[3] = 'v'; s[4] = 'e'; s[5] = 'r'; s[6] = 'n'; s[7] = 'a'; s[8] = 'm'; s[9] = 'e'; s[10] = 0;
	if (kwGlobalVariables.InList(s))
		iixx += 2;
*/
	int state = initStyle;
	int prevState = initStyle;
	char chPrev = ' ';
	char chNext = styler[startPos];
	styler.StartSegment(startPos);
	unsigned int lengthDoc = startPos + length;
	for (unsigned int i = startPos; i < lengthDoc; i++) {
		char ch = chNext;
		chNext = styler.SafeGetCharAt(i + 1);

		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
			int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags);
			int lev = indentCurrent;
			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
				// Only non whitespace lines can be headers
				int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags);
				if (indentCurrent < (indentNext & ~SC_FOLDLEVELWHITEFLAG)) {
					lev |= SC_FOLDLEVELHEADERFLAG;
				}
			}
			if (fold) {
				styler.SetLevel(lineCurrent, lev);
			}
		}

		if (styler.IsLeadByte(ch)) {
			chNext = styler.SafeGetCharAt(i + 2);
			chPrev = ' ';
			i += 1;
			continue;
		}

		// When the last char isn't part of the state (have to deal with it too)...
		if ( (state == SCE_MSSQL_IDENTIFIER) ||
                    (state == SCE_MSSQL_STORED_PROCEDURE) ||
                    (state == SCE_MSSQL_DATATYPE) ||
                    //~ (state == SCE_MSSQL_COLUMN_NAME) ||
                    (state == SCE_MSSQL_FUNCTION) ||
                    //~ (state == SCE_MSSQL_GLOBAL_VARIABLE) ||
                    (state == SCE_MSSQL_VARIABLE)) {
			if (!iswordchar(ch)) {
				int stateTmp;

                if ((state == SCE_MSSQL_VARIABLE) || (state == SCE_MSSQL_COLUMN_NAME)) {
                    styler.ColourTo(i - 1, state);
					stateTmp = state;
                } else
                    stateTmp = classifyWordSQL(styler.GetStartSegment(), i - 1, keywordlists, styler, state, prevState);

				prevState = state;

				if (stateTmp == SCE_MSSQL_IDENTIFIER || stateTmp == SCE_MSSQL_VARIABLE)
					state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
				else
					state = SCE_MSSQL_DEFAULT;
			}
		} else if (state == SCE_MSSQL_LINE_COMMENT) {
			if (ch == '\r' || ch == '\n') {
				styler.ColourTo(i - 1, state);
				prevState = state;
				state = SCE_MSSQL_DEFAULT;
			}
		} else if (state == SCE_MSSQL_GLOBAL_VARIABLE) {
			if ((ch != '@') && !iswordchar(ch)) {
				classifyWordSQL(styler.GetStartSegment(), i - 1, keywordlists, styler, state, prevState);
				prevState = state;
				state = SCE_MSSQL_DEFAULT;
			}
		}

		// If is the default or one of the above succeeded
		if (state == SCE_MSSQL_DEFAULT || state == SCE_MSSQL_DEFAULT_PREF_DATATYPE) {
			if (iswordstart(ch)) {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_IDENTIFIER;
			} else if (ch == '/' && chNext == '*') {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_COMMENT;
			} else if (ch == '-' && chNext == '-') {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_LINE_COMMENT;
			} else if (ch == '\'') {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_STRING;
			} else if (ch == '"') {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_COLUMN_NAME;
			} else if (ch == '[') {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
				state = SCE_MSSQL_COLUMN_NAME_2;
			} else if (isMSSQLOperator(ch)) {
				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				styler.ColourTo(i, SCE_MSSQL_OPERATOR);
                //~ style = SCE_MSSQL_DEFAULT;
				prevState = state;
				state = SCE_MSSQL_DEFAULT;
			} else if (ch == '@') {
                styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
				prevState = state;
                if (chNext == '@') {
                    state = SCE_MSSQL_GLOBAL_VARIABLE;
//                    i += 2;
                } else
                    state = SCE_MSSQL_VARIABLE;
            }


		// When the last char is part of the state...
		} else if (state == SCE_MSSQL_COMMENT) {
				if (ch == '/' && chPrev == '*') {
					if (((i > (styler.GetStartSegment() + 2)) || ((initStyle == SCE_MSSQL_COMMENT) &&
					    (styler.GetStartSegment() == startPos)))) {
						styler.ColourTo(i, state);
						//~ state = SCE_MSSQL_COMMENT;
					prevState = state;
                        state = SCE_MSSQL_DEFAULT;
					}
				}
			} else if (state == SCE_MSSQL_STRING) {
				if (ch == '\'') {
					if ( chNext == '\'' ) {
						i++;
					ch = chNext;
					chNext = styler.SafeGetCharAt(i + 1);
					} else {
						styler.ColourTo(i, state);
					prevState = state;
						state = SCE_MSSQL_DEFAULT;
					//i++;
					}
				//ch = chNext;
				//chNext = styler.SafeGetCharAt(i + 1);
				}
			} else if (state == SCE_MSSQL_COLUMN_NAME) {
				if (ch == '"') {
					if (chNext == '"') {
						i++;
					ch = chNext;
					chNext = styler.SafeGetCharAt(i + 1);
				} else {
                    styler.ColourTo(i, state);
					prevState = state;
					state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
					//i++;
                }
                }
		} else if (state == SCE_MSSQL_COLUMN_NAME_2) {
			if (ch == ']') {
                styler.ColourTo(i, state);
				prevState = state;
                state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
                //i++;
			}
		}

		chPrev = ch;
	}
	styler.ColourTo(lengthDoc - 1, state);
}

static const char * const sqlWordListDesc[] = {
	"Statements",
    "Data Types",
    "System tables",
    "Global variables",
    "Functions",
    "System Stored Procedures",
    "Operators",
	0,
};

LexerModule lmMSSQL(SCLEX_MSSQL, ColouriseMSSQLDoc, "mssql", 0, sqlWordListDesc);
Commit	Line	Data
591d01be RD	1	// Scintilla source code edit control
	2	/** @file LexMSSQL.cxx
	3	** Lexer for MSSQL.
	4	**/
	5	// Copyright 1998-2002 by Filip Yaghob <fy@eg.cz>
	6
	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 "KeyWords.h"
	19	#include "Scintilla.h"
	20	#include "SciLexer.h"
	21
	22	#define KW_MSSQL_STATEMENTS 0
	23	#define KW_MSSQL_DATA_TYPES 1
	24	#define KW_MSSQL_SYSTEM_TABLES 2
	25	#define KW_MSSQL_GLOBAL_VARIABLES 3
	26	#define KW_MSSQL_FUNCTIONS 4
	27	#define KW_MSSQL_STORED_PROCEDURES 5
	28	#define KW_MSSQL_OPERATORS 6
	29
	30	//~ val SCE_MSSQL_DEFAULT=0
	31	//~ val SCE_MSSQL_COMMENT=1
	32	//~ val SCE_MSSQL_LINE_COMMENT=2
	33	//~ val SCE_MSSQL_NUMBER=3
	34	//~ val SCE_MSSQL_STRING=4
	35	//~ val SCE_MSSQL_OPERATOR=5
	36	//~ val SCE_MSSQL_IDENTIFIER=6
	37	//~ val SCE_MSSQL_VARIABLE=7
	38	//~ val SCE_MSSQL_COLUMN_NAME=8
	39	//~ val SCE_MSSQL_STATEMENT=9
	40	//~ val SCE_MSSQL_DATATYPE=10
	41	//~ val SCE_MSSQL_SYSTABLE=11
	42	//~ val SCE_MSSQL_GLOBAL_VARIABLE=12
	43	//~ val SCE_MSSQL_FUNCTION=13
	44	//~ val SCE_MSSQL_STORED_PROCEDURE=14
	45	//~ val SCE_MSSQL_DEFAULT_PREF_DATATYPE 15
	46	//~ val SCE_MSSQL_COLUMN_NAME_2 16
	47
	48	static bool isMSSQLOperator(char ch) {
	49	if (isascii(ch) && isalnum(ch))
	50	return false;
	51	// '.' left out as it is used to make up numbers
	52	if (ch == '%' \|\| ch == '^' \|\| ch == '&' \|\| ch == '*' \|\|
	53	ch == '-' \|\| ch == '+' \|\| ch == '=' \|\| ch == '\|' \|\|
	54	ch == '<' \|\| ch == '>' \|\| ch == '/' \|\|
	55	ch == '!' \|\| ch == '~' \|\| ch == '(' \|\| ch == ')' \|\|
	56	ch == ',')
	57	return true;
	58	return false;
	59	}
	60
	61	static char classifyWordSQL(unsigned int start,
	62	unsigned int end,
	63	WordList *keywordlists[],
	64	Accessor &styler,
65	unsigned int actualState,
66	unsigned int prevState) {
67	char s[256];
68	bool wordIsNumber = isdigit(styler[start]) \|\| (styler[start] == '.');
69
70	WordList &kwStatements = *keywordlists[KW_MSSQL_STATEMENTS];
71	WordList &kwDataTypes = *keywordlists[KW_MSSQL_DATA_TYPES];
72	WordList &kwSystemTables = *keywordlists[KW_MSSQL_SYSTEM_TABLES];
73	WordList &kwGlobalVariables = *keywordlists[KW_MSSQL_GLOBAL_VARIABLES];
74	WordList &kwFunctions = *keywordlists[KW_MSSQL_FUNCTIONS];
75	WordList &kwStoredProcedures = *keywordlists[KW_MSSQL_STORED_PROCEDURES];
76	WordList &kwOperators = *keywordlists[KW_MSSQL_OPERATORS];
77
78	for (unsigned int i = 0; i < end - start + 1 && i < 128; i++) {
79	s[i] = static_cast<char>(tolower(styler[start + i]));
80	s[i + 1] = '\0';
81	}
82	char chAttr = SCE_MSSQL_IDENTIFIER;
83
84	if (actualState == SCE_MSSQL_GLOBAL_VARIABLE) {
85
86	if (kwGlobalVariables.InList(&s[2]))
87	chAttr = SCE_MSSQL_GLOBAL_VARIABLE;
88
89	} else if (wordIsNumber) {
90	chAttr = SCE_MSSQL_NUMBER;
91
92	} else if (prevState == SCE_MSSQL_DEFAULT_PREF_DATATYPE) {
93	// Look first in datatypes
94	if (kwDataTypes.InList(s))
95	chAttr = SCE_MSSQL_DATATYPE;
96	else if (kwOperators.InList(s))
97	chAttr = SCE_MSSQL_OPERATOR;
98	else if (kwStatements.InList(s))
99	chAttr = SCE_MSSQL_STATEMENT;
100	else if (kwSystemTables.InList(s))
101	chAttr = SCE_MSSQL_SYSTABLE;
102	else if (kwFunctions.InList(s))
103	chAttr = SCE_MSSQL_FUNCTION;
104	else if (kwStoredProcedures.InList(s))
105	chAttr = SCE_MSSQL_STORED_PROCEDURE;
106
107	} else {
108	if (kwOperators.InList(s))
109	chAttr = SCE_MSSQL_OPERATOR;
110	else if (kwStatements.InList(s))
111	chAttr = SCE_MSSQL_STATEMENT;
112	else if (kwSystemTables.InList(s))
113	chAttr = SCE_MSSQL_SYSTABLE;
114	else if (kwFunctions.InList(s))
115	chAttr = SCE_MSSQL_FUNCTION;
116	else if (kwStoredProcedures.InList(s))
117	chAttr = SCE_MSSQL_STORED_PROCEDURE;
118	else if (kwDataTypes.InList(s))
119	chAttr = SCE_MSSQL_DATATYPE;
120	}
121
122	styler.ColourTo(end, chAttr);
123
124	return chAttr;
125	}
126
127	static void ColouriseMSSQLDoc(unsigned int startPos, int length,
128	int initStyle, WordList *keywordlists[], Accessor &styler) {
129
130
131	styler.StartAt(startPos);
132
133	bool fold = styler.GetPropertyInt("fold") != 0;
134	int lineCurrent = styler.GetLine(startPos);
135	int spaceFlags = 0;
136	/*
137	WordList &kwStatements = *keywordlists[KW_MSSQL_STATEMENTS];
138	WordList &kwDataTypes = *keywordlists[KW_MSSQL_DATA_TYPES];
139	WordList &kwSystemTables = *keywordlists[KW_MSSQL_SYSTEM_TABLES];
140	WordList &kwGlobalVariables = *keywordlists[KW_MSSQL_GLOBAL_VARIABLES];
141	WordList &kwFunctions = *keywordlists[KW_MSSQL_FUNCTIONS];
142
143	char s[100];
144	int iixx = 0;
145	s[0] = 's'; s[1] = 'e'; s[2] = 'l'; s[3] = 'e'; s[4] = 'c'; s[5] = 't'; s[6] = 0;
146	if (kwStatements.InList(s))
147	iixx = 1;
148	s[0] = 's'; s[1] = 'e'; s[2] = 'r'; s[3] = 'v'; s[4] = 'e'; s[5] = 'r'; s[6] = 'n'; s[7] = 'a'; s[8] = 'm'; s[9] = 'e'; s[10] = 0;
149	if (kwGlobalVariables.InList(s))
150	iixx += 2;
151	*/
152	int state = initStyle;
153	int prevState = initStyle;
154	char chPrev = ' ';
155	char chNext = styler[startPos];
156	styler.StartSegment(startPos);
157	unsigned int lengthDoc = startPos + length;
158	for (unsigned int i = startPos; i < lengthDoc; i++) {
159	char ch = chNext;
160	chNext = styler.SafeGetCharAt(i + 1);
161
162	if ((ch == '\r' && chNext != '\n') \|\| (ch == '\n')) {
163	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags);
164	int lev = indentCurrent;
165	if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
166	// Only non whitespace lines can be headers
167	int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags);
168	if (indentCurrent < (indentNext & ~SC_FOLDLEVELWHITEFLAG)) {
169	lev \|= SC_FOLDLEVELHEADERFLAG;
170	}
171	}
172	if (fold) {
173	styler.SetLevel(lineCurrent, lev);
174	}
175	}
176
177	if (styler.IsLeadByte(ch)) {
178	chNext = styler.SafeGetCharAt(i + 2);
179	chPrev = ' ';
180	i += 1;
181	continue;
182	}
183
184	// When the last char isn't part of the state (have to deal with it too)...
185	if ( (state == SCE_MSSQL_IDENTIFIER) \|\|
186	(state == SCE_MSSQL_STORED_PROCEDURE) \|\|
187	(state == SCE_MSSQL_DATATYPE) \|\|
188	//~ (state == SCE_MSSQL_COLUMN_NAME) \|\|
189	(state == SCE_MSSQL_FUNCTION) \|\|
190	//~ (state == SCE_MSSQL_GLOBAL_VARIABLE) \|\|
191	(state == SCE_MSSQL_VARIABLE)) {
192	if (!iswordchar(ch)) {
193	int stateTmp;
194
195	if ((state == SCE_MSSQL_VARIABLE) \|\| (state == SCE_MSSQL_COLUMN_NAME)) {
196	styler.ColourTo(i - 1, state);
197	stateTmp = state;
198	} else
199	stateTmp = classifyWordSQL(styler.GetStartSegment(), i - 1, keywordlists, styler, state, prevState);
200
201	prevState = state;
202
203	if (stateTmp == SCE_MSSQL_IDENTIFIER \|\| stateTmp == SCE_MSSQL_VARIABLE)
204	state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
205	else
206	state = SCE_MSSQL_DEFAULT;
207	}
208	} else if (state == SCE_MSSQL_LINE_COMMENT) {
209	if (ch == '\r' \|\| ch == '\n') {
210	styler.ColourTo(i - 1, state);
211	prevState = state;
212	state = SCE_MSSQL_DEFAULT;
213	}
214	} else if (state == SCE_MSSQL_GLOBAL_VARIABLE) {
215	if ((ch != '@') && !iswordchar(ch)) {
216	classifyWordSQL(styler.GetStartSegment(), i - 1, keywordlists, styler, state, prevState);
217	prevState = state;
218	state = SCE_MSSQL_DEFAULT;
219	}
220	}
221
222	// If is the default or one of the above succeeded
223	if (state == SCE_MSSQL_DEFAULT \|\| state == SCE_MSSQL_DEFAULT_PREF_DATATYPE) {
224	if (iswordstart(ch)) {
225	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
226	prevState = state;
227	state = SCE_MSSQL_IDENTIFIER;
228	} else if (ch == '/' && chNext == '*') {
229	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
230	prevState = state;
231	state = SCE_MSSQL_COMMENT;
232	} else if (ch == '-' && chNext == '-') {
233	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
234	prevState = state;
235	state = SCE_MSSQL_LINE_COMMENT;
236	} else if (ch == '\'') {
237	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
238	prevState = state;
239	state = SCE_MSSQL_STRING;
240	} else if (ch == '"') {
241	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
242	prevState = state;
243	state = SCE_MSSQL_COLUMN_NAME;
244	} else if (ch == '[') {
245	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
246	prevState = state;
247	state = SCE_MSSQL_COLUMN_NAME_2;
248	} else if (isMSSQLOperator(ch)) {
249	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
250	styler.ColourTo(i, SCE_MSSQL_OPERATOR);
251	//~ style = SCE_MSSQL_DEFAULT;
252	prevState = state;
253	state = SCE_MSSQL_DEFAULT;
254	} else if (ch == '@') {
255	styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
256	prevState = state;
257	if (chNext == '@') {
258	state = SCE_MSSQL_GLOBAL_VARIABLE;
259	// i += 2;
260	} else
261	state = SCE_MSSQL_VARIABLE;
262	}
263
264
265	// When the last char is part of the state...
266	} else if (state == SCE_MSSQL_COMMENT) {
267	if (ch == '/' && chPrev == '*') {
268	if (((i > (styler.GetStartSegment() + 2)) \|\| ((initStyle == SCE_MSSQL_COMMENT) &&
269	(styler.GetStartSegment() == startPos)))) {
270	styler.ColourTo(i, state);
271	//~ state = SCE_MSSQL_COMMENT;
272	prevState = state;
273	state = SCE_MSSQL_DEFAULT;
274	}
275	}
276	} else if (state == SCE_MSSQL_STRING) {
277	if (ch == '\'') {
278	if ( chNext == '\'' ) {
279	i++;
280	ch = chNext;
281	chNext = styler.SafeGetCharAt(i + 1);
282	} else {
283	styler.ColourTo(i, state);
284	prevState = state;
285	state = SCE_MSSQL_DEFAULT;
286	//i++;
287	}
288	//ch = chNext;
289	//chNext = styler.SafeGetCharAt(i + 1);
290	}
291	} else if (state == SCE_MSSQL_COLUMN_NAME) {
292	if (ch == '"') {
293	if (chNext == '"') {
294	i++;
295	ch = chNext;
296	chNext = styler.SafeGetCharAt(i + 1);
297	} else {
298	styler.ColourTo(i, state);
299	prevState = state;
300	state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
301	//i++;
302	}
303	}
304	} else if (state == SCE_MSSQL_COLUMN_NAME_2) {
305	if (ch == ']') {
306	styler.ColourTo(i, state);
307	prevState = state;
308	state = SCE_MSSQL_DEFAULT_PREF_DATATYPE;
309	//i++;
310	}
311	}
312
313	chPrev = ch;
314	}
315	styler.ColourTo(lengthDoc - 1, state);
316	}
317
318	static const char * const sqlWordListDesc[] = {
319	"Statements",
320	"Data Types",
321	"System tables",
322	"Global variables",
323	"Functions",
324	"System Stored Procedures",
325	"Operators",
326	0,
327	};
328
329	LexerModule lmMSSQL(SCLEX_MSSQL, ColouriseMSSQLDoc, "mssql", 0, sqlWordListDesc);