[wxWidgets.git] / src / stc / scintilla / src / LexErlang.cxx

// Scintilla source code edit control
/** @file LexErlang.cxx
 ** Lexer for Erlang.
 ** Written by Peter-Henry Mander, based on Matlab lexer by Jose' Fonseca
 **/
// 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 <ctype.h>
#include <stdio.h>
#include <stdarg.h>

#include "Platform.h"

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

#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif

/*
   TODO:
   o  _Param should be a new lexical type
*/

static int is_radix(int radix, int ch) {
   int digit;
   if ( 16 < radix || 2 > radix ) {
      return 0;
   }
   if ( isdigit(ch) ) {
      digit = ch - '0';
   } else if ( isxdigit(ch) ) {
      digit = toupper(ch) - 'A' + 10;
   } else {
      return 0;
   }
   if ( digit < radix ) {
      return 1;
   } else {
      return 0;
   }
}

typedef enum {
   STATE_NULL,
   ATOM_UNQUOTED,
   ATOM_QUOTED,
   ATOM_FUN_NAME,
   NODE_NAME_UNQUOTED,
   NODE_NAME_QUOTED,
   MACRO_START,
   MACRO_UNQUOTED,
   MACRO_QUOTED,
   RECORD_START,
   RECORD_UNQUOTED,
   RECORD_QUOTED,
   NUMERAL_START,
   NUMERAL_SIGNED,
   NUMERAL_RADIX_LITERAL,
   NUMERAL_SPECULATIVE_MANTISSA,
   NUMERAL_FLOAT_MANTISSA,
   NUMERAL_FLOAT_EXPONENT,
   NUMERAL_FLOAT_SIGNED_EXPONENT,
   PARSE_ERROR
} atom_parse_state_t;

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

	WordList &keywords = *keywordlists[0];

	styler.StartAt(startPos);

	StyleContext sc(startPos, length, initStyle, styler);
   atom_parse_state_t parse_state = STATE_NULL;
   int radix_digits = 0;
   int exponent_digits = 0;
	for (; sc.More(); sc.Forward()) {
      if ( STATE_NULL != parse_state ) {
         switch (parse_state) {
         case STATE_NULL:
				sc.SetState(SCE_ERLANG_DEFAULT);
            break;
         case ATOM_UNQUOTED:
            if ( '@' == sc.ch ){
               parse_state = NODE_NAME_UNQUOTED;
            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
               char s[100];
               sc.GetCurrent(s, sizeof(s));
               if (keywords.InList(s)) {
                  sc.ChangeState(SCE_ERLANG_KEYWORD);
                  sc.SetState(SCE_ERLANG_DEFAULT);
                  parse_state = STATE_NULL;
               } else {
                  if ( '/' == sc.ch ) {
                     parse_state = ATOM_FUN_NAME;
                  } else {
                     sc.ChangeState(SCE_ERLANG_ATOM);
                     sc.SetState(SCE_ERLANG_DEFAULT);
                     parse_state = STATE_NULL;
                  }
               }
            }
            break;
         case ATOM_QUOTED:
            if ( '@' == sc.ch ){
               parse_state = NODE_NAME_QUOTED;
            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
               sc.ChangeState(SCE_ERLANG_ATOM);
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case ATOM_FUN_NAME:
            if ( !isdigit(sc.ch) ) {
               sc.ChangeState(SCE_ERLANG_FUNCTION_NAME);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NODE_NAME_QUOTED:
            if ( '@' == sc.ch ) {
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
               sc.ChangeState(SCE_ERLANG_NODE_NAME);
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NODE_NAME_UNQUOTED:
            if ( '@' == sc.ch ) {
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
               sc.ChangeState(SCE_ERLANG_NODE_NAME);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case RECORD_START:
            if ( '\'' == sc.ch ) {
               parse_state = RECORD_QUOTED;
            } else if (isalpha(sc.ch) && islower(sc.ch)) {
               parse_state = RECORD_UNQUOTED;
            } else { // error
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case RECORD_QUOTED:
            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
               sc.ChangeState(SCE_ERLANG_RECORD);
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case RECORD_UNQUOTED:
            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
               sc.ChangeState(SCE_ERLANG_RECORD);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case MACRO_START:
            if ( '\'' == sc.ch ) {
               parse_state = MACRO_QUOTED;
            } else if (isalpha(sc.ch)) {
               parse_state = MACRO_UNQUOTED;
            } else { // error
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case MACRO_UNQUOTED:
            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
               sc.ChangeState(SCE_ERLANG_MACRO);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case MACRO_QUOTED:
            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
               sc.ChangeState(SCE_ERLANG_MACRO);
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NUMERAL_START:
            if ( isdigit(sc.ch) ) {
               radix_digits *= 10;
               radix_digits += sc.ch - '0'; // Assuming ASCII here!
            } else if ( '#' == sc.ch ) {
               if ( 2 > radix_digits || 16 < radix_digits) {
                  sc.SetState(SCE_ERLANG_DEFAULT);
                  parse_state = STATE_NULL;
               } else {
                  parse_state = NUMERAL_RADIX_LITERAL;
               }
            } else if ( '.' == sc.ch && isdigit(sc.chNext)) {
               radix_digits = 0;
               parse_state = NUMERAL_FLOAT_MANTISSA;
            } else if ( 'e' == sc.ch || 'E' == sc.ch ) {
               exponent_digits = 0;
               parse_state = NUMERAL_FLOAT_EXPONENT;
            } else {
               radix_digits = 0;
               sc.ChangeState(SCE_ERLANG_NUMBER);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NUMERAL_RADIX_LITERAL:
            if ( !is_radix(radix_digits,sc.ch) ) {
               radix_digits = 0;
               if ( !isalnum(sc.ch) ) {
                  sc.ChangeState(SCE_ERLANG_NUMBER);
               }
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NUMERAL_FLOAT_MANTISSA:
            if ( 'e' == sc.ch || 'E' == sc.ch ) {
               exponent_digits = 0;
               parse_state = NUMERAL_FLOAT_EXPONENT;
            } else if ( !isdigit(sc.ch) ) {
               sc.ChangeState(SCE_ERLANG_NUMBER);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            }
            break;
         case NUMERAL_FLOAT_EXPONENT:
            if ( '-' == sc.ch || '+' == sc.ch ) {
               parse_state = NUMERAL_FLOAT_SIGNED_EXPONENT;
            } else if ( !isdigit(sc.ch) ) {
               if ( 0 < exponent_digits ) {
                  sc.ChangeState(SCE_ERLANG_NUMBER);
               }
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else {
               ++exponent_digits;
            }
            break;
         case NUMERAL_FLOAT_SIGNED_EXPONENT:
            if ( !isdigit(sc.ch) ) {
               if ( 0 < exponent_digits ) {
                  sc.ChangeState(SCE_ERLANG_NUMBER);
               }
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else {
               ++exponent_digits;
            }
            break;
         case NUMERAL_SIGNED:
            if ( !isdigit(sc.ch) ) {
               sc.ChangeState(SCE_ERLANG_NUMBER);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else if ( '.' == sc.ch ) {
               parse_state = NUMERAL_FLOAT_MANTISSA;
            }
            break;
         case NUMERAL_SPECULATIVE_MANTISSA:
            if ( !isdigit(sc.ch) ) {
               sc.ChangeState(SCE_ERLANG_OPERATOR);
               sc.SetState(SCE_ERLANG_DEFAULT);
               parse_state = STATE_NULL;
            } else {
               parse_state = NUMERAL_FLOAT_MANTISSA;
            }
            break;
         case PARSE_ERROR:
				sc.SetState(SCE_ERLANG_DEFAULT);
            parse_state = STATE_NULL;
            break;
         }
      } else if (sc.state == SCE_ERLANG_OPERATOR) {
			if (sc.chPrev == '.') {
				if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' || sc.ch == '^') {
					sc.ForwardSetState(SCE_ERLANG_DEFAULT);
				} else if (sc.ch == '\'') {
					sc.ForwardSetState(SCE_ERLANG_DEFAULT);
				} else {
					sc.SetState(SCE_ERLANG_DEFAULT);
				}
			} else {
				sc.SetState(SCE_ERLANG_DEFAULT);
			}
		} else if (sc.state == SCE_ERLANG_VARIABLE) {
			if (!isalnum(sc.ch) && sc.ch != '_') {
            sc.SetState(SCE_ERLANG_DEFAULT);
			}
		} else if (sc.state == SCE_ERLANG_STRING) {
			if (sc.ch == '\"' && sc.chPrev != '\\') {
				sc.ForwardSetState(SCE_ERLANG_DEFAULT);
			}
		} else if (sc.state == SCE_ERLANG_COMMENT ) {
			if (sc.atLineEnd) {
				sc.SetState(SCE_ERLANG_DEFAULT);
			}
      } else if (sc.state == SCE_ERLANG_CHARACTER ) {
         if ( sc.chPrev == '\\' ) {
            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
         } else if ( sc.ch != '\\' ) {
            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
         }
      }

		if (sc.state == SCE_ERLANG_DEFAULT) {
			if (sc.ch == '%') {
				sc.SetState(SCE_ERLANG_COMMENT);
			} else if (sc.ch == '\"') {
            sc.SetState(SCE_ERLANG_STRING);
         } else if (sc.ch == '#') {
            parse_state = RECORD_START;
				sc.SetState(SCE_ERLANG_UNKNOWN);
         } else if (sc.ch == '?') {
            parse_state = MACRO_START;
				sc.SetState(SCE_ERLANG_UNKNOWN);
         } else if (sc.ch == '$') {
				sc.SetState(SCE_ERLANG_CHARACTER);
         } else if (sc.ch == '\'') {
            parse_state = ATOM_QUOTED;
				sc.SetState(SCE_ERLANG_UNKNOWN);
			} else if ( isdigit(sc.ch) ) {
            parse_state = NUMERAL_START;
            radix_digits = sc.ch - '0';
				sc.SetState(SCE_ERLANG_UNKNOWN);
         } else if ( '.' == sc.ch ) {
            parse_state = NUMERAL_SPECULATIVE_MANTISSA;
				sc.SetState(SCE_ERLANG_UNKNOWN);
			} else if (isalpha(sc.ch) && isupper(sc.ch)) {
				sc.SetState(SCE_ERLANG_VARIABLE);
			} else if (isalpha(sc.ch)) {
            parse_state = ATOM_UNQUOTED;
				sc.SetState(SCE_ERLANG_UNKNOWN);
			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '\\') {
				sc.SetState(SCE_ERLANG_OPERATOR);
			}
		}
	}
	sc.Complete();
}

static int ClassifyFoldPointErlang(
   Accessor &styler,
   int styleNext,
   int keyword_start
) {
	int lev = 0;
   if ( styler.Match(keyword_start,"case")
      || (
            styler.Match(keyword_start,"fun")
         && SCE_ERLANG_FUNCTION_NAME != styleNext)
      || styler.Match(keyword_start,"if")
      || styler.Match(keyword_start,"query")
      || styler.Match(keyword_start,"receive")
   ) {
      ++lev;
   } else if ( styler.Match(keyword_start,"end") ) {
      --lev;
   }
	return lev;
}


static void FoldErlangDoc(
   unsigned int startPos, int length, int initStyle,
   WordList** /*keywordlists*/, Accessor &styler
) {
	unsigned int endPos = startPos + length;
	//~ int visibleChars = 0;
	int lineCurrent = styler.GetLine(startPos);
	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
	int levelCurrent = levelPrev;
	char chNext = styler.SafeGetCharAt(startPos);
	int styleNext = styler.StyleAt(startPos);
	int style = initStyle;
	int keyword_start = 0;

   bool fold_keywords = true;
   bool fold_comments = true;
   bool fold_braces = true;
   bool fold_function_clauses = false;
   bool fold_clauses = false;

   //int clause_level = 0;

	for (unsigned int i = startPos; i < endPos; i++) {
		char ch = chNext;
		chNext = styler.SafeGetCharAt(i + 1);
		int stylePrev = style;
		style = styleNext;
		styleNext = styler.StyleAt(i + 1);
		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');

      if ( (stylePrev != SCE_ERLANG_KEYWORD) && (style == SCE_ERLANG_KEYWORD) ) {
         keyword_start = i;
      }
      if ( fold_keywords ) {
         if ( (stylePrev == SCE_ERLANG_KEYWORD)
            && (style != SCE_ERLANG_KEYWORD)
            && (style != SCE_ERLANG_ATOM)
         ) {
            levelCurrent += ClassifyFoldPointErlang(styler,styleNext,keyword_start);
         }
      }

      if ( fold_comments ) {
         if (style == SCE_ERLANG_COMMENT) {
            if ((ch == '%') && (chNext == '{')) {
               levelCurrent++;
            } else if ((ch == '%') && (chNext == '}')) {
               levelCurrent--;
            }
         }
      }

      if ( fold_function_clauses ) {
         if ( (SC_FOLDLEVELBASE == levelCurrent) /*&& (style == SCE_ERLANG_OPERATOR)*/ ) {
            if ( (ch == '-') && (chNext == '>')) {
               //~ fprintf(stderr,"levelCurrent=%d\n", levelCurrent);
               //++clause_level;
               //~ if ( 0 < clause_level )
                  ++levelCurrent;
            }
         }
         //~ if (  (stylePrev != SCE_ERLANG_RECORD)
            //~ && (style != SCE_ERLANG_NUMBER)
            //~ && (style != SCE_ERLANG_STRING)
            //~ && (style != SCE_ERLANG_COMMENT)
         //~ ) {
            if ( (SC_FOLDLEVELBASE+1 == levelCurrent) && (ch == '.') ) {
               //--clause_level;
               //~ if ( 0 == clause_level )
                  --levelCurrent;
            }
         //~ }
      }

      if ( fold_clauses ) {
         if ( (0 < levelCurrent) && (style == SCE_ERLANG_OPERATOR) ) {
            if ((ch == '-') && (chNext == '>')) {
               levelCurrent++;
            }
            if ( (ch == ';') ) {
               levelCurrent--;
            }
         }
         if ( (stylePrev != SCE_ERLANG_RECORD)
            && (style != SCE_ERLANG_NUMBER)
            && (style != SCE_ERLANG_STRING)
            && (style != SCE_ERLANG_COMMENT)
         ) {
            if ( (ch == '.') ) {
               levelCurrent--;
            }
         }
         if (  (stylePrev == SCE_ERLANG_KEYWORD)
            && (style != SCE_ERLANG_KEYWORD)
            && (style != SCE_ERLANG_ATOM)
            && (
               styler.Match(keyword_start,"end") // 'end' counted twice if fold_keywords too
               || styler.Match(keyword_start,"after") )
         ) {
            levelCurrent--;
         }
      }

      if ( fold_braces ) {
         if (style == SCE_ERLANG_OPERATOR) {
            if ( (ch == '{') || (ch == '(') || (ch == '[') ) {
               levelCurrent++;
            } else if ( (ch == '}') || (ch == ')') || (ch == ']') ) {
               levelCurrent--;
            }
         }
      }

		if (atEOL) {
			int lev = levelPrev;
			//~ if (visibleChars == 0 && foldCompact)
				//~ lev |= SC_FOLDLEVELWHITEFLAG;
			//~ if ((levelCurrent > levelPrev) && (visibleChars > 0))
			if ((levelCurrent > levelPrev)) {
				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 erlangWordListDesc[] = {
	"Keywords",
	0
};

LexerModule lmErlang(
   SCLEX_ERLANG,
   ColouriseErlangDoc,
   "erlang",
   FoldErlangDoc,
   erlangWordListDesc);
Commit	Line	Data
8e54aaed RD	1	// Scintilla source code edit control
	2	/** @file LexErlang.cxx
	3	** Lexer for Erlang.
9d55bfef	4	** Written by Peter-Henry Mander, based on Matlab lexer by Jose' Fonseca
8e54aaed RD	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 <ctype.h>
	12	#include <stdio.h>
	13	#include <stdarg.h>
	14
	15	#include "Platform.h"
	16
	17	#include "PropSet.h"
	18	#include "Accessor.h"
	19	#include "StyleContext.h"
	20	#include "KeyWords.h"
	21	#include "Scintilla.h"
	22	#include "SciLexer.h"
	23
7e0c58e9 RD	24	#ifdef SCI_NAMESPACE
	25	using namespace Scintilla;
	26	#endif
	27
8e54aaed RD	28	/*
	29	TODO:
	30	o _Param should be a new lexical type
	31	*/
	32
	33	static int is_radix(int radix, int ch) {
	34	int digit;
	35	if ( 16 < radix \|\| 2 > radix ) {
	36	return 0;
	37	}
	38	if ( isdigit(ch) ) {
	39	digit = ch - '0';
	40	} else if ( isxdigit(ch) ) {
	41	digit = toupper(ch) - 'A' + 10;
	42	} else {
	43	return 0;
	44	}
	45	if ( digit < radix ) {
	46	return 1;
	47	} else {
	48	return 0;
	49	}
	50	}
	51
	52	typedef enum {
	53	STATE_NULL,
	54	ATOM_UNQUOTED,
	55	ATOM_QUOTED,
	56	ATOM_FUN_NAME,
	57	NODE_NAME_UNQUOTED,
	58	NODE_NAME_QUOTED,
	59	MACRO_START,
	60	MACRO_UNQUOTED,
	61	MACRO_QUOTED,
	62	RECORD_START,
	63	RECORD_UNQUOTED,
	64	RECORD_QUOTED,
	65	NUMERAL_START,
	66	NUMERAL_SIGNED,
	67	NUMERAL_RADIX_LITERAL,
	68	NUMERAL_SPECULATIVE_MANTISSA,
	69	NUMERAL_FLOAT_MANTISSA,
	70	NUMERAL_FLOAT_EXPONENT,
	71	NUMERAL_FLOAT_SIGNED_EXPONENT,
	72	PARSE_ERROR
	73	} atom_parse_state_t;
	74
	75	static void ColouriseErlangDoc(unsigned int startPos, int length, int initStyle,
	76	WordList *keywordlists[], Accessor &styler) {
	77
	78	WordList &keywords = *keywordlists[0];
	79
	80	styler.StartAt(startPos);
	81
	82	StyleContext sc(startPos, length, initStyle, styler);
	83	atom_parse_state_t parse_state = STATE_NULL;
	84	int radix_digits = 0;
	85	int exponent_digits = 0;
	86	for (; sc.More(); sc.Forward()) {
	87	if ( STATE_NULL != parse_state ) {
	88	switch (parse_state) {
	89	case STATE_NULL:
	90	sc.SetState(SCE_ERLANG_DEFAULT);
	91	break;
92	case ATOM_UNQUOTED:
93	if ( '@' == sc.ch ){
94	parse_state = NODE_NAME_UNQUOTED;
95	} else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
96	char s[100];
97	sc.GetCurrent(s, sizeof(s));
98	if (keywords.InList(s)) {
99	sc.ChangeState(SCE_ERLANG_KEYWORD);
100	sc.SetState(SCE_ERLANG_DEFAULT);
101	parse_state = STATE_NULL;
102	} else {
103	if ( '/' == sc.ch ) {
104	parse_state = ATOM_FUN_NAME;
105	} else {
106	sc.ChangeState(SCE_ERLANG_ATOM);
107	sc.SetState(SCE_ERLANG_DEFAULT);
108	parse_state = STATE_NULL;
109	}
110	}
111	}
112	break;
113	case ATOM_QUOTED:
114	if ( '@' == sc.ch ){
115	parse_state = NODE_NAME_QUOTED;
116	} else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
117	sc.ChangeState(SCE_ERLANG_ATOM);
118	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
119	parse_state = STATE_NULL;
120	}
121	break;
122	case ATOM_FUN_NAME:
123	if ( !isdigit(sc.ch) ) {
124	sc.ChangeState(SCE_ERLANG_FUNCTION_NAME);
125	sc.SetState(SCE_ERLANG_DEFAULT);
126	parse_state = STATE_NULL;
127	}
128	break;
129	case NODE_NAME_QUOTED:
130	if ( '@' == sc.ch ) {
131	sc.SetState(SCE_ERLANG_DEFAULT);
132	parse_state = STATE_NULL;
133	} else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
134	sc.ChangeState(SCE_ERLANG_NODE_NAME);
135	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
136	parse_state = STATE_NULL;
137	}
138	break;
139	case NODE_NAME_UNQUOTED:
140	if ( '@' == sc.ch ) {
141	sc.SetState(SCE_ERLANG_DEFAULT);
142	parse_state = STATE_NULL;
143	} else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
144	sc.ChangeState(SCE_ERLANG_NODE_NAME);
145	sc.SetState(SCE_ERLANG_DEFAULT);
146	parse_state = STATE_NULL;
147	}
148	break;
149	case RECORD_START:
150	if ( '\'' == sc.ch ) {
151	parse_state = RECORD_QUOTED;
152	} else if (isalpha(sc.ch) && islower(sc.ch)) {
153	parse_state = RECORD_UNQUOTED;
154	} else { // error
155	sc.SetState(SCE_ERLANG_DEFAULT);
156	parse_state = STATE_NULL;
157	}
158	break;
159	case RECORD_QUOTED:
160	if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
161	sc.ChangeState(SCE_ERLANG_RECORD);
162	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
163	parse_state = STATE_NULL;
164	}
165	break;
166	case RECORD_UNQUOTED:
167	if ( !isalpha(sc.ch) && '_' != sc.ch ) {
168	sc.ChangeState(SCE_ERLANG_RECORD);
169	sc.SetState(SCE_ERLANG_DEFAULT);
170	parse_state = STATE_NULL;
171	}
172	break;
173	case MACRO_START:
174	if ( '\'' == sc.ch ) {
175	parse_state = MACRO_QUOTED;
176	} else if (isalpha(sc.ch)) {
177	parse_state = MACRO_UNQUOTED;
178	} else { // error
179	sc.SetState(SCE_ERLANG_DEFAULT);
180	parse_state = STATE_NULL;
181	}
182	break;
183	case MACRO_UNQUOTED:
184	if ( !isalpha(sc.ch) && '_' != sc.ch ) {
185	sc.ChangeState(SCE_ERLANG_MACRO);
186	sc.SetState(SCE_ERLANG_DEFAULT);
187	parse_state = STATE_NULL;
188	}
189	break;
190	case MACRO_QUOTED:
191	if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
192	sc.ChangeState(SCE_ERLANG_MACRO);
193	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
194	parse_state = STATE_NULL;
195	}
196	break;
197	case NUMERAL_START:
198	if ( isdigit(sc.ch) ) {
199	radix_digits *= 10;
200	radix_digits += sc.ch - '0'; // Assuming ASCII here!
201	} else if ( '#' == sc.ch ) {
202	if ( 2 > radix_digits \|\| 16 < radix_digits) {
203	sc.SetState(SCE_ERLANG_DEFAULT);
204	parse_state = STATE_NULL;
205	} else {
206	parse_state = NUMERAL_RADIX_LITERAL;
207	}
208	} else if ( '.' == sc.ch && isdigit(sc.chNext)) {
209	radix_digits = 0;
210	parse_state = NUMERAL_FLOAT_MANTISSA;
211	} else if ( 'e' == sc.ch \|\| 'E' == sc.ch ) {
212	exponent_digits = 0;
213	parse_state = NUMERAL_FLOAT_EXPONENT;
214	} else {
215	radix_digits = 0;
216	sc.ChangeState(SCE_ERLANG_NUMBER);
217	sc.SetState(SCE_ERLANG_DEFAULT);
218	parse_state = STATE_NULL;
219	}
220	break;
221	case NUMERAL_RADIX_LITERAL:
222	if ( !is_radix(radix_digits,sc.ch) ) {
223	radix_digits = 0;
224	if ( !isalnum(sc.ch) ) {
225	sc.ChangeState(SCE_ERLANG_NUMBER);
226	}
227	sc.SetState(SCE_ERLANG_DEFAULT);
228	parse_state = STATE_NULL;
229	}
230	break;
231	case NUMERAL_FLOAT_MANTISSA:
232	if ( 'e' == sc.ch \|\| 'E' == sc.ch ) {
233	exponent_digits = 0;
234	parse_state = NUMERAL_FLOAT_EXPONENT;
235	} else if ( !isdigit(sc.ch) ) {
236	sc.ChangeState(SCE_ERLANG_NUMBER);
237	sc.SetState(SCE_ERLANG_DEFAULT);
238	parse_state = STATE_NULL;
239	}
240	break;
241	case NUMERAL_FLOAT_EXPONENT:
242	if ( '-' == sc.ch \|\| '+' == sc.ch ) {
243	parse_state = NUMERAL_FLOAT_SIGNED_EXPONENT;
244	} else if ( !isdigit(sc.ch) ) {
245	if ( 0 < exponent_digits ) {
246	sc.ChangeState(SCE_ERLANG_NUMBER);
247	}
248	sc.SetState(SCE_ERLANG_DEFAULT);
249	parse_state = STATE_NULL;
250	} else {
251	++exponent_digits;
252	}
253	break;
254	case NUMERAL_FLOAT_SIGNED_EXPONENT:
255	if ( !isdigit(sc.ch) ) {
256	if ( 0 < exponent_digits ) {
257	sc.ChangeState(SCE_ERLANG_NUMBER);
258	}
259	sc.SetState(SCE_ERLANG_DEFAULT);
260	parse_state = STATE_NULL;
261	} else {
262	++exponent_digits;
263	}
264	break;
265	case NUMERAL_SIGNED:
266	if ( !isdigit(sc.ch) ) {
267	sc.ChangeState(SCE_ERLANG_NUMBER);
268	sc.SetState(SCE_ERLANG_DEFAULT);
269	parse_state = STATE_NULL;
270	} else if ( '.' == sc.ch ) {
271	parse_state = NUMERAL_FLOAT_MANTISSA;
272	}
273	break;
274	case NUMERAL_SPECULATIVE_MANTISSA:
275	if ( !isdigit(sc.ch) ) {
276	sc.ChangeState(SCE_ERLANG_OPERATOR);
277	sc.SetState(SCE_ERLANG_DEFAULT);
278	parse_state = STATE_NULL;
279	} else {
280	parse_state = NUMERAL_FLOAT_MANTISSA;
281	}
282	break;
283	case PARSE_ERROR:
284	sc.SetState(SCE_ERLANG_DEFAULT);
285	parse_state = STATE_NULL;
286	break;
287	}
288	} else if (sc.state == SCE_ERLANG_OPERATOR) {
289	if (sc.chPrev == '.') {
290	if (sc.ch == '*' \|\| sc.ch == '/' \|\| sc.ch == '\\' \|\| sc.ch == '^') {
291	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
292	} else if (sc.ch == '\'') {
293	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
294	} else {
295	sc.SetState(SCE_ERLANG_DEFAULT);
296	}
297	} else {
298	sc.SetState(SCE_ERLANG_DEFAULT);
299	}
300	} else if (sc.state == SCE_ERLANG_VARIABLE) {
301	if (!isalnum(sc.ch) && sc.ch != '_') {
302	sc.SetState(SCE_ERLANG_DEFAULT);
303	}
304	} else if (sc.state == SCE_ERLANG_STRING) {
305	if (sc.ch == '\"' && sc.chPrev != '\\') {
306	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
307	}
308	} else if (sc.state == SCE_ERLANG_COMMENT ) {
309	if (sc.atLineEnd) {
310	sc.SetState(SCE_ERLANG_DEFAULT);
311	}
312	} else if (sc.state == SCE_ERLANG_CHARACTER ) {
313	if ( sc.chPrev == '\\' ) {
314	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
315	} else if ( sc.ch != '\\' ) {
316	sc.ForwardSetState(SCE_ERLANG_DEFAULT);
317	}
318	}
319
320	if (sc.state == SCE_ERLANG_DEFAULT) {
321	if (sc.ch == '%') {
322	sc.SetState(SCE_ERLANG_COMMENT);
323	} else if (sc.ch == '\"') {
324	sc.SetState(SCE_ERLANG_STRING);
325	} else if (sc.ch == '#') {
326	parse_state = RECORD_START;
327	sc.SetState(SCE_ERLANG_UNKNOWN);
328	} else if (sc.ch == '?') {
329	parse_state = MACRO_START;
330	sc.SetState(SCE_ERLANG_UNKNOWN);
331	} else if (sc.ch == '$') {
332	sc.SetState(SCE_ERLANG_CHARACTER);
333	} else if (sc.ch == '\'') {
334	parse_state = ATOM_QUOTED;
335	sc.SetState(SCE_ERLANG_UNKNOWN);
336	} else if ( isdigit(sc.ch) ) {
337	parse_state = NUMERAL_START;
338	radix_digits = sc.ch - '0';
339	sc.SetState(SCE_ERLANG_UNKNOWN);
340	} else if ( '.' == sc.ch ) {
341	parse_state = NUMERAL_SPECULATIVE_MANTISSA;
342	sc.SetState(SCE_ERLANG_UNKNOWN);
343	} else if (isalpha(sc.ch) && isupper(sc.ch)) {
344	sc.SetState(SCE_ERLANG_VARIABLE);
345	} else if (isalpha(sc.ch)) {
346	parse_state = ATOM_UNQUOTED;
347	sc.SetState(SCE_ERLANG_UNKNOWN);
348	} else if (isoperator(static_cast<char>(sc.ch)) \|\| sc.ch == '\\') {
349	sc.SetState(SCE_ERLANG_OPERATOR);
350	}
351	}
352	}
353	sc.Complete();
354	}
355
356	static int ClassifyFoldPointErlang(
357	Accessor &styler,
358	int styleNext,
359	int keyword_start
360	) {
361	int lev = 0;
362	if ( styler.Match(keyword_start,"case")
363	\|\| (
364	styler.Match(keyword_start,"fun")
365	&& SCE_ERLANG_FUNCTION_NAME != styleNext)
366	\|\| styler.Match(keyword_start,"if")
367	\|\| styler.Match(keyword_start,"query")
368	\|\| styler.Match(keyword_start,"receive")
369	) {
370	++lev;
371	} else if ( styler.Match(keyword_start,"end") ) {
372	--lev;
373	}
374	return lev;
375	}
376
377
378	static void FoldErlangDoc(
379	unsigned int startPos, int length, int initStyle,
380	WordList** /keywordlists/, Accessor &styler
381	) {
382	unsigned int endPos = startPos + length;
383	//~ int visibleChars = 0;
384	int lineCurrent = styler.GetLine(startPos);
385	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
386	int levelCurrent = levelPrev;
387	char chNext = styler.SafeGetCharAt(startPos);
388	int styleNext = styler.StyleAt(startPos);
389	int style = initStyle;
390	int keyword_start = 0;
391
392	bool fold_keywords = true;
393	bool fold_comments = true;
394	bool fold_braces = true;
395	bool fold_function_clauses = false;
396	bool fold_clauses = false;
397
398	//int clause_level = 0;
399
400	for (unsigned int i = startPos; i < endPos; i++) {
401	char ch = chNext;
402	chNext = styler.SafeGetCharAt(i + 1);
403	int stylePrev = style;
404	style = styleNext;
405	styleNext = styler.StyleAt(i + 1);
406	bool atEOL = (ch == '\r' && chNext != '\n') \|\| (ch == '\n');
407
408	if ( (stylePrev != SCE_ERLANG_KEYWORD) && (style == SCE_ERLANG_KEYWORD) ) {
409	keyword_start = i;
410	}
411	if ( fold_keywords ) {
412	if ( (stylePrev == SCE_ERLANG_KEYWORD)
413	&& (style != SCE_ERLANG_KEYWORD)
414	&& (style != SCE_ERLANG_ATOM)
415	) {
416	levelCurrent += ClassifyFoldPointErlang(styler,styleNext,keyword_start);
417	}
418	}
419
420	if ( fold_comments ) {
421	if (style == SCE_ERLANG_COMMENT) {
422	if ((ch == '%') && (chNext == '{')) {
423	levelCurrent++;
424	} else if ((ch == '%') && (chNext == '}')) {
425	levelCurrent--;
426	}
427	}
428	}
429
430	if ( fold_function_clauses ) {
431	if ( (SC_FOLDLEVELBASE == levelCurrent) /&& (style == SCE_ERLANG_OPERATOR)/ ) {
432	if ( (ch == '-') && (chNext == '>')) {
433	//~ fprintf(stderr,"levelCurrent=%d\n", levelCurrent);
434	//++clause_level;
435	//~ if ( 0 < clause_level )
436	++levelCurrent;
437	}
438	}
439	//~ if ( (stylePrev != SCE_ERLANG_RECORD)
440	//~ && (style != SCE_ERLANG_NUMBER)
441	//~ && (style != SCE_ERLANG_STRING)
442	//~ && (style != SCE_ERLANG_COMMENT)
443	//~ ) {
444	if ( (SC_FOLDLEVELBASE+1 == levelCurrent) && (ch == '.') ) {
445	//--clause_level;
446	//~ if ( 0 == clause_level )
447	--levelCurrent;
448	}
449	//~ }
450	}
451
452	if ( fold_clauses ) {
453	if ( (0 < levelCurrent) && (style == SCE_ERLANG_OPERATOR) ) {
454	if ((ch == '-') && (chNext == '>')) {
455	levelCurrent++;
456	}
457	if ( (ch == ';') ) {
458	levelCurrent--;
459	}
460	}
461	if ( (stylePrev != SCE_ERLANG_RECORD)
462	&& (style != SCE_ERLANG_NUMBER)
463	&& (style != SCE_ERLANG_STRING)
464	&& (style != SCE_ERLANG_COMMENT)
465	) {
466	if ( (ch == '.') ) {
467	levelCurrent--;
468	}
469	}
470	if ( (stylePrev == SCE_ERLANG_KEYWORD)
471	&& (style != SCE_ERLANG_KEYWORD)
472	&& (style != SCE_ERLANG_ATOM)
473	&& (
474	styler.Match(keyword_start,"end") // 'end' counted twice if fold_keywords too
475	\|\| styler.Match(keyword_start,"after") )
476	) {
477	levelCurrent--;
478	}
479	}
480
481	if ( fold_braces ) {
482	if (style == SCE_ERLANG_OPERATOR) {
483	if ( (ch == '{') \|\| (ch == '(') \|\| (ch == '[') ) {
484	levelCurrent++;
485	} else if ( (ch == '}') \|\| (ch == ')') \|\| (ch == ']') ) {
486	levelCurrent--;
487	}
488	}
489	}
490
491	if (atEOL) {
492	int lev = levelPrev;
493	//~ if (visibleChars == 0 && foldCompact)
494	//~ lev \|= SC_FOLDLEVELWHITEFLAG;
495	//~ if ((levelCurrent > levelPrev) && (visibleChars > 0))
496	if ((levelCurrent > levelPrev)) {
497	lev \|= SC_FOLDLEVELHEADERFLAG;
498	}
499	if (lev != styler.LevelAt(lineCurrent)) {
500	styler.SetLevel(lineCurrent, lev);
501	}
502	lineCurrent++;
503	levelPrev = levelCurrent;
504	//~ visibleChars = 0;
505	}
506	//~ if (!isspacechar(ch))
507	//~ visibleChars++;
508
509	}
510	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
511	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
512	styler.SetLevel(lineCurrent, levelPrev \| flagsNext);
513	}
514
515	static const char * const erlangWordListDesc[] = {
516	"Keywords",
517	0
518	};
519
520	LexerModule lmErlang(
521	SCLEX_ERLANG,
522	ColouriseErlangDoc,
523	"erlang",
524	FoldErlangDoc,
525	erlangWordListDesc);
526