src/stc/scintilla/lexers/LexLisp.cxx

// Scintilla source code edit control
/** @file LexLisp.cxx
 ** Lexer for Lisp.
 ** Written by Alexey Yutkin.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// 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

#define SCE_LISP_CHARACTER 29
#define SCE_LISP_MACRO 30
#define SCE_LISP_MACRO_DISPATCH 31

static inline bool isLispoperator(char ch) {
	if (isascii(ch) && isalnum(ch))
		return false;
	if (ch == '\'' || ch == '`' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '{' || ch == '}')
		return true;
	return false;
}

static inline bool isLispwordstart(char ch) {
	return isascii(ch) && ch != ';'  && !isspacechar(ch) && !isLispoperator(ch) &&
		ch != '\n' && ch != '\r' &&  ch != '\"';
}


static void classifyWordLisp(unsigned int start, unsigned int end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
	assert(end >= start);
	char s[100];
	unsigned int i;
	bool digit_flag = true;
	for (i = 0; (i < end - start + 1) && (i < 99); i++) {
		s[i] = styler[start + i];
		s[i + 1] = '\0';
		if (!isdigit(s[i]) && (s[i] != '.')) digit_flag = false;
	}
	char chAttr = SCE_LISP_IDENTIFIER;

	if(digit_flag) chAttr = SCE_LISP_NUMBER;
	else {
		if (keywords.InList(s)) {
			chAttr = SCE_LISP_KEYWORD;
		} else if (keywords_kw.InList(s)) {
			chAttr = SCE_LISP_KEYWORD_KW;
		} else if ((s[0] == '*' && s[i-1] == '*') ||
			   (s[0] == '+' && s[i-1] == '+')) {
			chAttr = SCE_LISP_SPECIAL;
		}
	}
	styler.ColourTo(end, chAttr);
	return;
}


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

	WordList &keywords = *keywordlists[0];
	WordList &keywords_kw = *keywordlists[1];

	styler.StartAt(startPos);

	int state = initStyle, radix = -1;
	char chNext = styler[startPos];
	unsigned int lengthDoc = startPos + length;
	styler.StartSegment(startPos);
	for (unsigned int i = startPos; i < lengthDoc; i++) {
		char ch = chNext;
		chNext = styler.SafeGetCharAt(i + 1);

		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');

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

		if (state == SCE_LISP_DEFAULT) {
			if (ch == '#') {
				styler.ColourTo(i - 1, state);
				radix = -1;
				state = SCE_LISP_MACRO_DISPATCH;
			} else if (ch == ':' && isLispwordstart(chNext)) {
				styler.ColourTo(i - 1, state);
				state = SCE_LISP_SYMBOL;
			} else if (isLispwordstart(ch)) {
				styler.ColourTo(i - 1, state);
				state = SCE_LISP_IDENTIFIER;
			}
			else if (ch == ';') {
				styler.ColourTo(i - 1, state);
				state = SCE_LISP_COMMENT;
			}
			else if (isLispoperator(ch) || ch=='\'') {
				styler.ColourTo(i - 1, state);
				styler.ColourTo(i, SCE_LISP_OPERATOR);
				if (ch=='\'' && isLispwordstart(chNext)) {
					state = SCE_LISP_SYMBOL;
				}
			}
			else if (ch == '\"') {
				styler.ColourTo(i - 1, state);
				state = SCE_LISP_STRING;
			}
		} else if (state == SCE_LISP_IDENTIFIER || state == SCE_LISP_SYMBOL) {
			if (!isLispwordstart(ch)) {
				if (state == SCE_LISP_IDENTIFIER) {
					classifyWordLisp(styler.GetStartSegment(), i - 1, keywords, keywords_kw, styler);
				} else {
					styler.ColourTo(i - 1, state);
				}
				state = SCE_LISP_DEFAULT;
			} /*else*/
			if (isLispoperator(ch) || ch=='\'') {
				styler.ColourTo(i - 1, state);
				styler.ColourTo(i, SCE_LISP_OPERATOR);
				if (ch=='\'' && isLispwordstart(chNext)) {
					state = SCE_LISP_SYMBOL;
				}
			}
		} else if (state == SCE_LISP_MACRO_DISPATCH) {
			if (!(isascii(ch) && isdigit(ch))) {
				if (ch != 'r' && ch != 'R' && (i - styler.GetStartSegment()) > 1) {
					state = SCE_LISP_DEFAULT;
				} else {
					switch (ch) {
						case '|': state = SCE_LISP_MULTI_COMMENT; break;
						case 'o':
						case 'O': radix = 8; state = SCE_LISP_MACRO; break;
						case 'x':
						case 'X': radix = 16; state = SCE_LISP_MACRO; break;
						case 'b':
						case 'B': radix = 2; state = SCE_LISP_MACRO; break;
						case '\\': state = SCE_LISP_CHARACTER; break;
						case ':':
						case '-':
						case '+': state = SCE_LISP_MACRO; break;
						case '\'': if (isLispwordstart(chNext)) {
								   state = SCE_LISP_SPECIAL;
							   } else {
								   styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
								   styler.ColourTo(i, SCE_LISP_OPERATOR);
								   state = SCE_LISP_DEFAULT;
							   }
							   break;
						default: if (isLispoperator(ch)) {
								 styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
								 styler.ColourTo(i, SCE_LISP_OPERATOR);
							 }
							 state = SCE_LISP_DEFAULT;
							 break;
					}
				}
			}
		} else if (state == SCE_LISP_MACRO) {
			if (isLispwordstart(ch) && (radix == -1 || IsADigit(ch, radix))) {
				state = SCE_LISP_SPECIAL;
			} else {
				state = SCE_LISP_DEFAULT;
			}
		} else if (state == SCE_LISP_CHARACTER) {
			if (isLispoperator(ch)) {
				styler.ColourTo(i, SCE_LISP_SPECIAL);
				state = SCE_LISP_DEFAULT;
			} else if (isLispwordstart(ch)) {
				styler.ColourTo(i, SCE_LISP_SPECIAL);
				state = SCE_LISP_SPECIAL;
			} else {
				state = SCE_LISP_DEFAULT;
			}
		} else if (state == SCE_LISP_SPECIAL) {
			if (!isLispwordstart(ch) || (radix != -1 && !IsADigit(ch, radix))) {
				styler.ColourTo(i - 1, state);
				state = SCE_LISP_DEFAULT;
			}
			if (isLispoperator(ch) || ch=='\'') {
				styler.ColourTo(i - 1, state);
				styler.ColourTo(i, SCE_LISP_OPERATOR);
				if (ch=='\'' && isLispwordstart(chNext)) {
					state = SCE_LISP_SYMBOL;
				}
			}
		} else {
			if (state == SCE_LISP_COMMENT) {
				if (atEOL) {
					styler.ColourTo(i - 1, state);
					state = SCE_LISP_DEFAULT;
				}
			} else if (state == SCE_LISP_MULTI_COMMENT) {
				if (ch == '|' && chNext == '#') {
					i++;
					chNext = styler.SafeGetCharAt(i + 1);
					styler.ColourTo(i, state);
					state = SCE_LISP_DEFAULT;
				}
			} else if (state == SCE_LISP_STRING) {
				if (ch == '\\') {
					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
						i++;
						chNext = styler.SafeGetCharAt(i + 1);
					}
				} else if (ch == '\"') {
					styler.ColourTo(i, state);
					state = SCE_LISP_DEFAULT;
				}
			}
		}

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

static void FoldLispDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
                            Accessor &styler) {
	unsigned int lengthDoc = startPos + length;
	int visibleChars = 0;
	int lineCurrent = styler.GetLine(startPos);
	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
	int levelCurrent = levelPrev;
	char chNext = styler[startPos];
	int styleNext = styler.StyleAt(startPos);
	for (unsigned int i = startPos; i < lengthDoc; i++) {
		char ch = chNext;
		chNext = styler.SafeGetCharAt(i + 1);
		int style = styleNext;
		styleNext = styler.StyleAt(i + 1);
		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
		if (style == SCE_LISP_OPERATOR) {
			if (ch == '(' || ch == '[' || ch == '{') {
				levelCurrent++;
			} else if (ch == ')' || ch == ']' || ch == '}') {
				levelCurrent--;
			}
		}
		if (atEOL) {
			int lev = levelPrev;
			if (visibleChars == 0)
				lev |= SC_FOLDLEVELWHITEFLAG;
			if ((levelCurrent > levelPrev) && (visibleChars > 0))
				lev |= SC_FOLDLEVELHEADERFLAG;
			if (lev != styler.LevelAt(lineCurrent)) {
				styler.SetLevel(lineCurrent, lev);
			}
			lineCurrent++;
			levelPrev = levelCurrent;
			visibleChars = 0;
		}
		if (!isspacechar(ch))
			visibleChars++;
	}
	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
}

static const char * const lispWordListDesc[] = {
	"Functions and special operators",
	"Keywords",
	0
};

LexerModule lmLISP(SCLEX_LISP, ColouriseLispDoc, "lisp", FoldLispDoc, lispWordListDesc);
Commit	Line	Data
	1	// Scintilla source code edit control
	2	/** @file LexLisp.cxx
	3	** Lexer for Lisp.
	4	** Written by Alexey Yutkin.
	5	**/
	6	// Copyright 1998-2001 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	#define SCE_LISP_CHARACTER 29
	32	#define SCE_LISP_MACRO 30
	33	#define SCE_LISP_MACRO_DISPATCH 31
	34
	35	static inline bool isLispoperator(char ch) {
	36	if (isascii(ch) && isalnum(ch))
	37	return false;
	38	if (ch == '\'' \|\| ch == '`' \|\| ch == '(' \|\| ch == ')' \|\| ch == '[' \|\| ch == ']' \|\| ch == '{' \|\| ch == '}')
	39	return true;
	40	return false;
	41	}
	42
	43	static inline bool isLispwordstart(char ch) {
	44	return isascii(ch) && ch != ';' && !isspacechar(ch) && !isLispoperator(ch) &&
	45	ch != '\n' && ch != '\r' && ch != '\"';
	46	}
	47
	48
	49	static void classifyWordLisp(unsigned int start, unsigned int end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
	50	assert(end >= start);
	51	char s[100];
	52	unsigned int i;
	53	bool digit_flag = true;
	54	for (i = 0; (i < end - start + 1) && (i < 99); i++) {
	55	s[i] = styler[start + i];
	56	s[i + 1] = '\0';
	57	if (!isdigit(s[i]) && (s[i] != '.')) digit_flag = false;
	58	}
	59	char chAttr = SCE_LISP_IDENTIFIER;
	60
	61	if(digit_flag) chAttr = SCE_LISP_NUMBER;
	62	else {
	63	if (keywords.InList(s)) {
	64	chAttr = SCE_LISP_KEYWORD;
	65	} else if (keywords_kw.InList(s)) {
	66	chAttr = SCE_LISP_KEYWORD_KW;
	67	} else if ((s[0] == '' && s[i-1] == '') \|\|
	68	(s[0] == '+' && s[i-1] == '+')) {
	69	chAttr = SCE_LISP_SPECIAL;
	70	}
	71	}
	72	styler.ColourTo(end, chAttr);
	73	return;
	74	}
	75
	76
	77	static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
	78	Accessor &styler) {
	79
	80	WordList &keywords = *keywordlists[0];
	81	WordList &keywords_kw = *keywordlists[1];
	82
	83	styler.StartAt(startPos);
	84
	85	int state = initStyle, radix = -1;
	86	char chNext = styler[startPos];
	87	unsigned int lengthDoc = startPos + length;
	88	styler.StartSegment(startPos);
	89	for (unsigned int i = startPos; i < lengthDoc; i++) {
	90	char ch = chNext;
	91	chNext = styler.SafeGetCharAt(i + 1);
	92
	93	bool atEOL = (ch == '\r' && chNext != '\n') \|\| (ch == '\n');
	94
	95	if (styler.IsLeadByte(ch)) {
	96	chNext = styler.SafeGetCharAt(i + 2);
	97	i += 1;
	98	continue;
	99	}
	100
	101	if (state == SCE_LISP_DEFAULT) {
	102	if (ch == '#') {
	103	styler.ColourTo(i - 1, state);
	104	radix = -1;
	105	state = SCE_LISP_MACRO_DISPATCH;
	106	} else if (ch == ':' && isLispwordstart(chNext)) {
	107	styler.ColourTo(i - 1, state);
	108	state = SCE_LISP_SYMBOL;
	109	} else if (isLispwordstart(ch)) {
	110	styler.ColourTo(i - 1, state);
	111	state = SCE_LISP_IDENTIFIER;
	112	}
	113	else if (ch == ';') {
	114	styler.ColourTo(i - 1, state);
	115	state = SCE_LISP_COMMENT;
	116	}
	117	else if (isLispoperator(ch) \|\| ch=='\'') {
	118	styler.ColourTo(i - 1, state);
	119	styler.ColourTo(i, SCE_LISP_OPERATOR);
	120	if (ch=='\'' && isLispwordstart(chNext)) {
	121	state = SCE_LISP_SYMBOL;
	122	}
	123	}
	124	else if (ch == '\"') {
	125	styler.ColourTo(i - 1, state);
	126	state = SCE_LISP_STRING;
	127	}
	128	} else if (state == SCE_LISP_IDENTIFIER \|\| state == SCE_LISP_SYMBOL) {
	129	if (!isLispwordstart(ch)) {
	130	if (state == SCE_LISP_IDENTIFIER) {
	131	classifyWordLisp(styler.GetStartSegment(), i - 1, keywords, keywords_kw, styler);
	132	} else {
	133	styler.ColourTo(i - 1, state);
	134	}
	135	state = SCE_LISP_DEFAULT;
	136	} /else/
	137	if (isLispoperator(ch) \|\| ch=='\'') {
	138	styler.ColourTo(i - 1, state);
	139	styler.ColourTo(i, SCE_LISP_OPERATOR);
	140	if (ch=='\'' && isLispwordstart(chNext)) {
	141	state = SCE_LISP_SYMBOL;
	142	}
	143	}
	144	} else if (state == SCE_LISP_MACRO_DISPATCH) {
	145	if (!(isascii(ch) && isdigit(ch))) {
	146	if (ch != 'r' && ch != 'R' && (i - styler.GetStartSegment()) > 1) {
	147	state = SCE_LISP_DEFAULT;
	148	} else {
	149	switch (ch) {
	150	case '\|': state = SCE_LISP_MULTI_COMMENT; break;
	151	case 'o':
	152	case 'O': radix = 8; state = SCE_LISP_MACRO; break;
	153	case 'x':
	154	case 'X': radix = 16; state = SCE_LISP_MACRO; break;
	155	case 'b':
	156	case 'B': radix = 2; state = SCE_LISP_MACRO; break;
	157	case '\\': state = SCE_LISP_CHARACTER; break;
	158	case ':':
	159	case '-':
	160	case '+': state = SCE_LISP_MACRO; break;
	161	case '\'': if (isLispwordstart(chNext)) {
	162	state = SCE_LISP_SPECIAL;
	163	} else {
	164	styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
	165	styler.ColourTo(i, SCE_LISP_OPERATOR);
	166	state = SCE_LISP_DEFAULT;
	167	}
	168	break;
	169	default: if (isLispoperator(ch)) {
	170	styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
	171	styler.ColourTo(i, SCE_LISP_OPERATOR);
	172	}
	173	state = SCE_LISP_DEFAULT;
	174	break;
	175	}
	176	}
	177	}
	178	} else if (state == SCE_LISP_MACRO) {
	179	if (isLispwordstart(ch) && (radix == -1 \|\| IsADigit(ch, radix))) {
	180	state = SCE_LISP_SPECIAL;
	181	} else {
	182	state = SCE_LISP_DEFAULT;
	183	}
	184	} else if (state == SCE_LISP_CHARACTER) {
	185	if (isLispoperator(ch)) {
	186	styler.ColourTo(i, SCE_LISP_SPECIAL);
	187	state = SCE_LISP_DEFAULT;
	188	} else if (isLispwordstart(ch)) {
	189	styler.ColourTo(i, SCE_LISP_SPECIAL);
	190	state = SCE_LISP_SPECIAL;
	191	} else {
	192	state = SCE_LISP_DEFAULT;
	193	}
	194	} else if (state == SCE_LISP_SPECIAL) {
	195	if (!isLispwordstart(ch) \|\| (radix != -1 && !IsADigit(ch, radix))) {
	196	styler.ColourTo(i - 1, state);
	197	state = SCE_LISP_DEFAULT;
	198	}
	199	if (isLispoperator(ch) \|\| ch=='\'') {
	200	styler.ColourTo(i - 1, state);
	201	styler.ColourTo(i, SCE_LISP_OPERATOR);
	202	if (ch=='\'' && isLispwordstart(chNext)) {
	203	state = SCE_LISP_SYMBOL;
	204	}
	205	}
	206	} else {
	207	if (state == SCE_LISP_COMMENT) {
	208	if (atEOL) {
	209	styler.ColourTo(i - 1, state);
	210	state = SCE_LISP_DEFAULT;
	211	}
	212	} else if (state == SCE_LISP_MULTI_COMMENT) {
	213	if (ch == '\|' && chNext == '#') {
	214	i++;
	215	chNext = styler.SafeGetCharAt(i + 1);
	216	styler.ColourTo(i, state);
	217	state = SCE_LISP_DEFAULT;
	218	}
	219	} else if (state == SCE_LISP_STRING) {
	220	if (ch == '\\') {
	221	if (chNext == '\"' \|\| chNext == '\'' \|\| chNext == '\\') {
	222	i++;
	223	chNext = styler.SafeGetCharAt(i + 1);
	224	}
	225	} else if (ch == '\"') {
	226	styler.ColourTo(i, state);
	227	state = SCE_LISP_DEFAULT;
	228	}
	229	}
	230	}
	231
	232	}
	233	styler.ColourTo(lengthDoc - 1, state);
	234	}
	235
	236	static void FoldLispDoc(unsigned int startPos, int length, int /* initStyle /, WordList [],
	237	Accessor &styler) {
	238	unsigned int lengthDoc = startPos + length;
	239	int visibleChars = 0;
	240	int lineCurrent = styler.GetLine(startPos);
	241	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
	242	int levelCurrent = levelPrev;
	243	char chNext = styler[startPos];
	244	int styleNext = styler.StyleAt(startPos);
	245	for (unsigned int i = startPos; i < lengthDoc; i++) {
	246	char ch = chNext;
	247	chNext = styler.SafeGetCharAt(i + 1);
	248	int style = styleNext;
	249	styleNext = styler.StyleAt(i + 1);
	250	bool atEOL = (ch == '\r' && chNext != '\n') \|\| (ch == '\n');
	251	if (style == SCE_LISP_OPERATOR) {
	252	if (ch == '(' \|\| ch == '[' \|\| ch == '{') {
	253	levelCurrent++;
	254	} else if (ch == ')' \|\| ch == ']' \|\| ch == '}') {
	255	levelCurrent--;
	256	}
	257	}
	258	if (atEOL) {
	259	int lev = levelPrev;
	260	if (visibleChars == 0)
	261	lev \|= SC_FOLDLEVELWHITEFLAG;
	262	if ((levelCurrent > levelPrev) && (visibleChars > 0))
	263	lev \|= SC_FOLDLEVELHEADERFLAG;
	264	if (lev != styler.LevelAt(lineCurrent)) {
	265	styler.SetLevel(lineCurrent, lev);
	266	}
	267	lineCurrent++;
	268	levelPrev = levelCurrent;
	269	visibleChars = 0;
	270	}
	271	if (!isspacechar(ch))
	272	visibleChars++;
	273	}
	274	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
	275	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
	276	styler.SetLevel(lineCurrent, levelPrev \| flagsNext);
	277	}
	278
	279	static const char * const lispWordListDesc[] = {
	280	"Functions and special operators",
	281	"Keywords",
	282	0
	283	};
	284
	285	LexerModule lmLISP(SCLEX_LISP, ColouriseLispDoc, "lisp", FoldLispDoc, lispWordListDesc);