PageRenderTime 65ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/scintilla/lexers/LexHTML.cxx

https://github.com/cezary12/notepad2-mod
C++ | 2184 lines | 1952 code | 119 blank | 113 comment | 1444 complexity | 88d00d6c6888a757dc4386a8b09e7a8a MD5 | raw file
Possible License(s): BSD-3-Clause 
    

  1. // Scintilla source code edit control

    2. 

  2. /** @file LexHTML.cxx

    3. 

  3.  ** Lexer for HTML.

    4. 

  4.  **/

    5. 

  5. // Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>

    6. 

  6. // The License.txt file describes the conditions under which this software may be distributed.

    7. 

  7. 

    8. 

  8. #include <stdlib.h>

    9. 

  9. #include <string.h>

    10. 

  10. #include <stdio.h>

    11. 

  11. #include <stdarg.h>

    12. 

  12. #include <assert.h>

    13. 

  13. #include <ctype.h>

    14. 

  14. 

    15. 

  15. #include "ILexer.h"

    16. 

  16. #include "Scintilla.h"

    17. 

  17. #include "SciLexer.h"

    18. 

  18. 

    19. 

  19. #include "StringCopy.h"

    20. 

  20. #include "WordList.h"

    21. 

  21. #include "LexAccessor.h"

    22. 

  22. #include "Accessor.h"

    23. 

  23. #include "StyleContext.h"

    24. 

  24. #include "CharacterSet.h"

    25. 

  25. #include "LexerModule.h"

    26. 

  26. 

    27. 

  27. #ifdef SCI_NAMESPACE

    28. 

  28. using namespace Scintilla;

    29. 

  29. #endif

    30. 

  30. 

    31. 

  31. #define SCE_HA_JS (SCE_HJA_START - SCE_HJ_START)

    32. 

  32. #define SCE_HA_VBS (SCE_HBA_START - SCE_HB_START)

    33. 

  33. #define SCE_HA_PYTHON (SCE_HPA_START - SCE_HP_START)

    34. 

  34. 

    35. 

  35. enum script_type { eScriptNone = 0, eScriptJS, eScriptVBS, eScriptPython, eScriptPHP, eScriptXML, eScriptSGML, eScriptSGMLblock, eScriptComment };

    36. 

  36. enum script_mode { eHtml = 0, eNonHtmlScript, eNonHtmlPreProc, eNonHtmlScriptPreProc };

    37. 

  37. 

    38. 

  38. static inline bool IsAWordChar(const int ch) {

    39. 

  39. 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_');

    40. 

  40. }

    41. 

  41. 

    42. 

  42. static inline bool IsAWordStart(const int ch) {

    43. 

  43. 	return (ch < 0x80) && (isalnum(ch) || ch == '_');

    44. 

  44. }

    45. 

  45. 

    46. 

  46. inline bool IsOperator(int ch) {

    47. 

  47. 	if (IsASCII(ch) && isalnum(ch))

    48. 

  48. 		return false;

    49. 

  49. 	// '.' left out as it is used to make up numbers

    50. 

  50. 	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||

    51. 

  51. 	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||

    52. 

  52. 	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||

    53. 

  53. 	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||

    54. 

  54. 	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||

    55. 

  55. 	        ch == '?' || ch == '!' || ch == '.' || ch == '~')

    56. 

  56. 		return true;

    57. 

  57. 	return false;

    58. 

  58. }

    59. 

  59. 

    60. 

  60. static void GetTextSegment(Accessor &styler, unsigned int start, unsigned int end, char *s, size_t len) {

    61. 

  61. 	unsigned int i = 0;

    62. 

  62. 	for (; (i < end - start + 1) && (i < len-1); i++) {

    63. 

  63. 		s[i] = static_cast<char>(MakeLowerCase(styler[start + i]));

    64. 

  64. 	}

    65. 

  65. 	s[i] = '\0';

    66. 

  66. }

    67. 

  67. 

    68. 

  68. static const char *GetNextWord(Accessor &styler, unsigned int start, char *s, size_t sLen) {

    69. 

  69. 

    70. 

  70. 	unsigned int i = 0;

    71. 

  71. 	for (; i < sLen-1; i++) {

    72. 

  72. 		char ch = static_cast<char>(styler.SafeGetCharAt(start + i));

    73. 

  73. 		if ((i == 0) && !IsAWordStart(ch))

    74. 

  74. 			break;

    75. 

  75. 		if ((i > 0) && !IsAWordChar(ch))

    76. 

  76. 			break;

    77. 

  77. 		s[i] = ch;

    78. 

  78. 	}

    79. 

  79. 	s[i] = '\0';

    80. 

  80. 

    81. 

  81. 	return s;

    82. 

  82. }

    83. 

  83. 

    84. 

  84. static script_type segIsScriptingIndicator(Accessor &styler, unsigned int start, unsigned int end, script_type prevValue) {

    85. 

  85. 	char s[100];

    86. 

  86. 	GetTextSegment(styler, start, end, s, sizeof(s));

    87. 

  87. 	//Platform::DebugPrintf("Scripting indicator [%s]\n", s);

    88. 

  88. 	if (strstr(s, "src"))	// External script

    89. 

  89. 		return eScriptNone;

    90. 

  90. 	if (strstr(s, "vbs"))

    91. 

  91. 		return eScriptVBS;

    92. 

  92. 	if (strstr(s, "pyth"))

    93. 

  93. 		return eScriptPython;

    94. 

  94. 	if (strstr(s, "javas"))

    95. 

  95. 		return eScriptJS;

    96. 

  96. 	if (strstr(s, "jscr"))

    97. 

  97. 		return eScriptJS;

    98. 

  98. 	if (strstr(s, "php"))

    99. 

  99. 		return eScriptPHP;

    100. 

  100. 	if (strstr(s, "xml")) {

    101. 

  101. 		const char *xml = strstr(s, "xml");

    102. 

  102. 		for (const char *t=s; t<xml; t++) {

    103. 

  103. 			if (!IsASpace(*t)) {

    104. 

  104. 				return prevValue;

    105. 

  105. 			}

    106. 

  106. 		}

    107. 

  107. 		return eScriptXML;

    108. 

  108. 	}

    109. 

  109. 

    110. 

  110. 	return prevValue;

    111. 

  111. }

    112. 

  112. 

    113. 

  113. static int PrintScriptingIndicatorOffset(Accessor &styler, unsigned int start, unsigned int end) {

    114. 

  114. 	int iResult = 0;

    115. 

  115. 	char s[100];

    116. 

  116. 	GetTextSegment(styler, start, end, s, sizeof(s));

    117. 

  117. 	if (0 == strncmp(s, "php", 3)) {

    118. 

  118. 		iResult = 3;

    119. 

  119. 	}

    120. 

  120. 

    121. 

  121. 	return iResult;

    122. 

  122. }

    123. 

  123. 

    124. 

  124. static script_type ScriptOfState(int state) {

    125. 

  125. 	if ((state >= SCE_HP_START) && (state <= SCE_HP_IDENTIFIER)) {

    126. 

  126. 		return eScriptPython;

    127. 

  127. 	} else if ((state >= SCE_HB_START) && (state <= SCE_HB_STRINGEOL)) {

    128. 

  128. 		return eScriptVBS;

    129. 

  129. 	} else if ((state >= SCE_HJ_START) && (state <= SCE_HJ_REGEX)) {

    130. 

  130. 		return eScriptJS;

    131. 

  131. 	} else if ((state >= SCE_HPHP_DEFAULT) && (state <= SCE_HPHP_COMMENTLINE)) {

    132. 

  132. 		return eScriptPHP;

    133. 

  133. 	} else if ((state >= SCE_H_SGML_DEFAULT) && (state < SCE_H_SGML_BLOCK_DEFAULT)) {

    134. 

  134. 		return eScriptSGML;

    135. 

  135. 	} else if (state == SCE_H_SGML_BLOCK_DEFAULT) {

    136. 

  136. 		return eScriptSGMLblock;

    137. 

  137. 	} else {

    138. 

  138. 		return eScriptNone;

    139. 

  139. 	}

    140. 

  140. }

    141. 

  141. 

    142. 

  142. static int statePrintForState(int state, script_mode inScriptType) {

    143. 

  143. 	int StateToPrint = state;

    144. 

  144. 

    145. 

  145. 	if (state >= SCE_HJ_START) {

    146. 

  146. 		if ((state >= SCE_HP_START) && (state <= SCE_HP_IDENTIFIER)) {

    147. 

  147. 			StateToPrint = state + ((inScriptType == eNonHtmlScript) ? 0 : SCE_HA_PYTHON);

    148. 

  148. 		} else if ((state >= SCE_HB_START) && (state <= SCE_HB_STRINGEOL)) {

    149. 

  149. 			StateToPrint = state + ((inScriptType == eNonHtmlScript) ? 0 : SCE_HA_VBS);

    150. 

  150. 		} else if ((state >= SCE_HJ_START) && (state <= SCE_HJ_REGEX)) {

    151. 

  151. 			StateToPrint = state + ((inScriptType == eNonHtmlScript) ? 0 : SCE_HA_JS);

    152. 

  152. 		}

    153. 

  153. 	}

    154. 

  154. 

    155. 

  155. 	return StateToPrint;

    156. 

  156. }

    157. 

  157. 

    158. 

  158. static int stateForPrintState(int StateToPrint) {

    159. 

  159. 	int state;

    160. 

  160. 

    161. 

  161. 	if ((StateToPrint >= SCE_HPA_START) && (StateToPrint <= SCE_HPA_IDENTIFIER)) {

    162. 

  162. 		state = StateToPrint - SCE_HA_PYTHON;

    163. 

  163. 	} else if ((StateToPrint >= SCE_HBA_START) && (StateToPrint <= SCE_HBA_STRINGEOL)) {

    164. 

  164. 		state = StateToPrint - SCE_HA_VBS;

    165. 

  165. 	} else if ((StateToPrint >= SCE_HJA_START) && (StateToPrint <= SCE_HJA_REGEX)) {

    166. 

  166. 		state = StateToPrint - SCE_HA_JS;

    167. 

  167. 	} else {

    168. 

  168. 		state = StateToPrint;

    169. 

  169. 	}

    170. 

  170. 

    171. 

  171. 	return state;

    172. 

  172. }

    173. 

  173. 

    174. 

  174. static inline bool IsNumber(unsigned int start, Accessor &styler) {

    175. 

  175. 	return IsADigit(styler[start]) || (styler[start] == '.') ||

    176. 

  176. 	       (styler[start] == '-') || (styler[start] == '#');

    177. 

  177. }

    178. 

  178. 

    179. 

  179. static inline bool isStringState(int state) {

    180. 

  180. 	bool bResult;

    181. 

  181. 

    182. 

  182. 	switch (state) {

    183. 

  183. 	case SCE_HJ_DOUBLESTRING:

    184. 

  184. 	case SCE_HJ_SINGLESTRING:

    185. 

  185. 	case SCE_HJA_DOUBLESTRING:

    186. 

  186. 	case SCE_HJA_SINGLESTRING:

    187. 

  187. 	case SCE_HB_STRING:

    188. 

  188. 	case SCE_HBA_STRING:

    189. 

  189. 	case SCE_HP_STRING:

    190. 

  190. 	case SCE_HP_CHARACTER:

    191. 

  191. 	case SCE_HP_TRIPLE:

    192. 

  192. 	case SCE_HP_TRIPLEDOUBLE:

    193. 

  193. 	case SCE_HPA_STRING:

    194. 

  194. 	case SCE_HPA_CHARACTER:

    195. 

  195. 	case SCE_HPA_TRIPLE:

    196. 

  196. 	case SCE_HPA_TRIPLEDOUBLE:

    197. 

  197. 	case SCE_HPHP_HSTRING:

    198. 

  198. 	case SCE_HPHP_SIMPLESTRING:

    199. 

  199. 	case SCE_HPHP_HSTRING_VARIABLE:

    200. 

  200. 	case SCE_HPHP_COMPLEX_VARIABLE:

    201. 

  201. 		bResult = true;

    202. 

  202. 		break;

    203. 

  203. 	default :

    204. 

  204. 		bResult = false;

    205. 

  205. 		break;

    206. 

  206. 	}

    207. 

  207. 	return bResult;

    208. 

  208. }

    209. 

  209. 

    210. 

  210. static inline bool stateAllowsTermination(int state) {

    211. 

  211. 	bool allowTermination = !isStringState(state);

    212. 

  212. 	if (allowTermination) {

    213. 

  213. 		switch (state) {

    214. 

  214. 		case SCE_HB_COMMENTLINE:

    215. 

  215. 		case SCE_HPHP_COMMENT:

    216. 

  216. 		case SCE_HP_COMMENTLINE:

    217. 

  217. 		case SCE_HPA_COMMENTLINE:

    218. 

  218. 			allowTermination = false;

    219. 

  219. 		}

    220. 

  220. 	}

    221. 

  221. 	return allowTermination;

    222. 

  222. }

    223. 

  223. 

    224. 

  224. // not really well done, since it's only comments that should lex the %> and <%

    225. 

  225. static inline bool isCommentASPState(int state) {

    226. 

  226. 	bool bResult;

    227. 

  227. 

    228. 

  228. 	switch (state) {

    229. 

  229. 	case SCE_HJ_COMMENT:

    230. 

  230. 	case SCE_HJ_COMMENTLINE:

    231. 

  231. 	case SCE_HJ_COMMENTDOC:

    232. 

  232. 	case SCE_HB_COMMENTLINE:

    233. 

  233. 	case SCE_HP_COMMENTLINE:

    234. 

  234. 	case SCE_HPHP_COMMENT:

    235. 

  235. 	case SCE_HPHP_COMMENTLINE:

    236. 

  236. 		bResult = true;

    237. 

  237. 		break;

    238. 

  238. 	default :

    239. 

  239. 		bResult = false;

    240. 

  240. 		break;

    241. 

  241. 	}

    242. 

  242. 	return bResult;

    243. 

  243. }

    244. 

  244. 

    245. 

  245. static void classifyAttribHTML(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {

    246. 

  246. 	bool wordIsNumber = IsNumber(start, styler);

    247. 

  247. 	char chAttr = SCE_H_ATTRIBUTEUNKNOWN;

    248. 

  248. 	if (wordIsNumber) {

    249. 

  249. 		chAttr = SCE_H_NUMBER;

    250. 

  250. 	} else {

    251. 

  251. 		char s[100];

    252. 

  252. 		GetTextSegment(styler, start, end, s, sizeof(s));

    253. 

  253. 		if (keywords.InList(s))

    254. 

  254. 			chAttr = SCE_H_ATTRIBUTE;

    255. 

  255. 	}

    256. 

  256. 	if ((chAttr == SCE_H_ATTRIBUTEUNKNOWN) && !keywords)

    257. 

  257. 		// No keywords -> all are known

    258. 

  258. 		chAttr = SCE_H_ATTRIBUTE;

    259. 

  259. 	styler.ColourTo(end, chAttr);

    260. 

  260. }

    261. 

  261. 

    262. 

  262. static int classifyTagHTML(unsigned int start, unsigned int end,

    263. 

  263.                            WordList &keywords, Accessor &styler, bool &tagDontFold,

    264. 

  264. 			   bool caseSensitive, bool isXml, bool allowScripts) {

    265. 

  265. 	char withSpace[30 + 2] = " ";

    266. 

  266. 	const char *s = withSpace + 1;

    267. 

  267. 	// Copy after the '<'

    268. 

  268. 	unsigned int i = 1;

    269. 

  269. 	for (unsigned int cPos = start; cPos <= end && i < 30; cPos++) {

    270. 

  270. 		char ch = styler[cPos];

    271. 

  271. 		if ((ch != '<') && (ch != '/')) {

    272. 

  272. 			withSpace[i++] = caseSensitive ? ch : static_cast<char>(MakeLowerCase(ch));

    273. 

  273. 		}

    274. 

  274. 	}

    275. 

  275. 

    276. 

  276. 	//The following is only a quick hack, to see if this whole thing would work

    277. 

  277. 	//we first need the tagname with a trailing space...

    278. 

  278. 	withSpace[i] = ' ';

    279. 

  279. 	withSpace[i+1] = '\0';

    280. 

  280. 

    281. 

  281. 	// if the current language is XML, I can fold any tag

    282. 

  282. 	// if the current language is HTML, I don't want to fold certain tags (input, meta, etc.)

    283. 

  283. 	//...to find it in the list of no-container-tags

    284. 

  284. 	tagDontFold = (!isXml) && (NULL != strstr(" area base basefont br col command embed frame hr img input isindex keygen link meta param source track wbr ", withSpace));

    285. 

  285. 

    286. 

  286. 	//now we can remove the trailing space

    287. 

  287. 	withSpace[i] = '\0';

    288. 

  288. 

    289. 

  289. 	// No keywords -> all are known

    290. 

  290. 	char chAttr = SCE_H_TAGUNKNOWN;

    291. 

  291. 	if (s[0] == '!') {

    292. 

  292. 		chAttr = SCE_H_SGML_DEFAULT;

    293. 

  293. 	} else if (!keywords || keywords.InList(s)) {

    294. 

  294. 		chAttr = SCE_H_TAG;

    295. 

  295. 	}

    296. 

  296. 	styler.ColourTo(end, chAttr);

    297. 

  297. 	if (chAttr == SCE_H_TAG) {

    298. 

  298. 		if (allowScripts && 0 == strcmp(s, "script")) {

    299. 

  299. 			// check to see if this is a self-closing tag by sniffing ahead

    300. 

  300. 			bool isSelfClose = false;

    301. 

  301. 			for (unsigned int cPos = end; cPos <= end + 200; cPos++) {

    302. 

  302. 				char ch = styler.SafeGetCharAt(cPos, '\0');

    303. 

  303. 				if (ch == '\0' || ch == '>')

    304. 

  304. 					break;

    305. 

  305. 				else if (ch == '/' && styler.SafeGetCharAt(cPos + 1, '\0') == '>') {

    306. 

  306. 					isSelfClose = true;

    307. 

  307. 					break;

    308. 

  308. 				}

    309. 

  309. 			}

    310. 

  310. 

    311. 

  311. 			// do not enter a script state if the tag self-closed

    312. 

  312. 			if (!isSelfClose)

    313. 

  313. 				chAttr = SCE_H_SCRIPT;

    314. 

  314. 		} else if (!isXml && 0 == strcmp(s, "comment")) {

    315. 

  315. 			chAttr = SCE_H_COMMENT;

    316. 

  316. 		}

    317. 

  317. 	}

    318. 

  318. 	return chAttr;

    319. 

  319. }

    320. 

  320. 

    321. 

  321. static void classifyWordHTJS(unsigned int start, unsigned int end,

    322. 

  322.                              WordList &keywords, Accessor &styler, script_mode inScriptType) {

    323. 

  323. 	char s[30 + 1];

    324. 

  324. 	unsigned int i = 0;

    325. 

  325. 	for (; i < end - start + 1 && i < 30; i++) {

    326. 

  326. 		s[i] = styler[start + i];

    327. 

  327. 	}

    328. 

  328. 	s[i] = '\0';

    329. 

  329. 

    330. 

  330. 	char chAttr = SCE_HJ_WORD;

    331. 

  331. 	bool wordIsNumber = IsADigit(s[0]) || ((s[0] == '.') && IsADigit(s[1]));

    332. 

  332. 	if (wordIsNumber) {

    333. 

  333. 		chAttr = SCE_HJ_NUMBER;

    334. 

  334. 	} else if (keywords.InList(s)) {

    335. 

  335. 		chAttr = SCE_HJ_KEYWORD;

    336. 

  336. 	}

    337. 

  337. 	styler.ColourTo(end, statePrintForState(chAttr, inScriptType));

    338. 

  338. }

    339. 

  339. 

    340. 

  340. static int classifyWordHTVB(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, script_mode inScriptType) {

    341. 

  341. 	char chAttr = SCE_HB_IDENTIFIER;

    342. 

  342. 	bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.');

    343. 

  343. 	if (wordIsNumber) {

    344. 

  344. 		chAttr = SCE_HB_NUMBER;

    345. 

  345. 	} else {

    346. 

  346. 		char s[100];

    347. 

  347. 		GetTextSegment(styler, start, end, s, sizeof(s));

    348. 

  348. 		if (keywords.InList(s)) {

    349. 

  349. 			chAttr = SCE_HB_WORD;

    350. 

  350. 			if (strcmp(s, "rem") == 0)

    351. 

  351. 				chAttr = SCE_HB_COMMENTLINE;

    352. 

  352. 		}

    353. 

  353. 	}

    354. 

  354. 	styler.ColourTo(end, statePrintForState(chAttr, inScriptType));

    355. 

  355. 	if (chAttr == SCE_HB_COMMENTLINE)

    356. 

  356. 		return SCE_HB_COMMENTLINE;

    357. 

  357. 	else

    358. 

  358. 		return SCE_HB_DEFAULT;

    359. 

  359. }

    360. 

  360. 

    361. 

  361. static void classifyWordHTPy(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, char *prevWord, script_mode inScriptType, bool isMako) {

    362. 

  362. 	bool wordIsNumber = IsADigit(styler[start]);

    363. 

  363. 	char s[30 + 1];

    364. 

  364. 	unsigned int i = 0;

    365. 

  365. 	for (; i < end - start + 1 && i < 30; i++) {

    366. 

  366. 		s[i] = styler[start + i];

    367. 

  367. 	}

    368. 

  368. 	s[i] = '\0';

    369. 

  369. 	char chAttr = SCE_HP_IDENTIFIER;

    370. 

  370. 	if (0 == strcmp(prevWord, "class"))

    371. 

  371. 		chAttr = SCE_HP_CLASSNAME;

    372. 

  372. 	else if (0 == strcmp(prevWord, "def"))

    373. 

  373. 		chAttr = SCE_HP_DEFNAME;

    374. 

  374. 	else if (wordIsNumber)

    375. 

  375. 		chAttr = SCE_HP_NUMBER;

    376. 

  376. 	else if (keywords.InList(s))

    377. 

  377. 		chAttr = SCE_HP_WORD;

    378. 

  378. 	else if (isMako && 0 == strcmp(s, "block"))

    379. 

  379. 		chAttr = SCE_HP_WORD;

    380. 

  380. 	styler.ColourTo(end, statePrintForState(chAttr, inScriptType));

    381. 

  381. 	strcpy(prevWord, s);

    382. 

  382. }

    383. 

  383. 

    384. 

  384. // Update the word colour to default or keyword

    385. 

  385. // Called when in a PHP word

    386. 

  386. static void classifyWordHTPHP(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {

    387. 

  387. 	char chAttr = SCE_HPHP_DEFAULT;

    388. 

  388. 	bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.' && start+1 <= end && IsADigit(styler[start+1]));

    389. 

  389. 	if (wordIsNumber) {

    390. 

  390. 		chAttr = SCE_HPHP_NUMBER;

    391. 

  391. 	} else {

    392. 

  392. 		char s[100];

    393. 

  393. 		GetTextSegment(styler, start, end, s, sizeof(s));

    394. 

  394. 		if (keywords.InList(s))

    395. 

  395. 			chAttr = SCE_HPHP_WORD;

    396. 

  396. 	}

    397. 

  397. 	styler.ColourTo(end, chAttr);

    398. 

  398. }

    399. 

  399. 

    400. 

  400. static bool isWordHSGML(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {

    401. 

  401. 	char s[30 + 1];

    402. 

  402. 	unsigned int i = 0;

    403. 

  403. 	for (; i < end - start + 1 && i < 30; i++) {

    404. 

  404. 		s[i] = styler[start + i];

    405. 

  405. 	}

    406. 

  406. 	s[i] = '\0';

    407. 

  407. 	return keywords.InList(s);

    408. 

  408. }

    409. 

  409. 

    410. 

  410. static bool isWordCdata(unsigned int start, unsigned int end, Accessor &styler) {

    411. 

  411. 	char s[30 + 1];

    412. 

  412. 	unsigned int i = 0;

    413. 

  413. 	for (; i < end - start + 1 && i < 30; i++) {

    414. 

  414. 		s[i] = styler[start + i];

    415. 

  415. 	}

    416. 

  416. 	s[i] = '\0';

    417. 

  417. 	return (0 == strcmp(s, "[CDATA["));

    418. 

  418. }

    419. 

  419. 

    420. 

  420. // Return the first state to reach when entering a scripting language

    421. 

  421. static int StateForScript(script_type scriptLanguage) {

    422. 

  422. 	int Result;

    423. 

  423. 	switch (scriptLanguage) {

    424. 

  424. 	case eScriptVBS:

    425. 

  425. 		Result = SCE_HB_START;

    426. 

  426. 		break;

    427. 

  427. 	case eScriptPython:

    428. 

  428. 		Result = SCE_HP_START;

    429. 

  429. 		break;

    430. 

  430. 	case eScriptPHP:

    431. 

  431. 		Result = SCE_HPHP_DEFAULT;

    432. 

  432. 		break;

    433. 

  433. 	case eScriptXML:

    434. 

  434. 		Result = SCE_H_TAGUNKNOWN;

    435. 

  435. 		break;

    436. 

  436. 	case eScriptSGML:

    437. 

  437. 		Result = SCE_H_SGML_DEFAULT;

    438. 

  438. 		break;

    439. 

  439. 	case eScriptComment:

    440. 

  440. 		Result = SCE_H_COMMENT;

    441. 

  441. 		break;

    442. 

  442. 	default :

    443. 

  443. 		Result = SCE_HJ_START;

    444. 

  444. 		break;

    445. 

  445. 	}

    446. 

  446. 	return Result;

    447. 

  447. }

    448. 

  448. 

    449. 

  449. static inline bool issgmlwordchar(int ch) {

    450. 

  450. 	return !IsASCII(ch) ||

    451. 

  451. 		(isalnum(ch) || ch == '.' || ch == '_' || ch == ':' || ch == '!' || ch == '#' || ch == '[');

    452. 

  452. }

    453. 

  453. 

    454. 

  454. static inline bool IsPhpWordStart(int ch) {

    455. 

  455. 	return (IsASCII(ch) && (isalpha(ch) || (ch == '_'))) || (ch >= 0x7f);

    456. 

  456. }

    457. 

  457. 

    458. 

  458. static inline bool IsPhpWordChar(int ch) {

    459. 

  459. 	return IsADigit(ch) || IsPhpWordStart(ch);

    460. 

  460. }

    461. 

  461. 

    462. 

  462. static bool InTagState(int state) {

    463. 

  463. 	return state == SCE_H_TAG || state == SCE_H_TAGUNKNOWN ||

    464. 

  464. 	       state == SCE_H_SCRIPT ||

    465. 

  465. 	       state == SCE_H_ATTRIBUTE || state == SCE_H_ATTRIBUTEUNKNOWN ||

    466. 

  466. 	       state == SCE_H_NUMBER || state == SCE_H_OTHER ||

    467. 

  467. 	       state == SCE_H_DOUBLESTRING || state == SCE_H_SINGLESTRING;

    468. 

  468. }

    469. 

  469. 

    470. 

  470. static bool IsCommentState(const int state) {

    471. 

  471. 	return state == SCE_H_COMMENT || state == SCE_H_SGML_COMMENT;

    472. 

  472. }

    473. 

  473. 

    474. 

  474. static bool IsScriptCommentState(const int state) {

    475. 

  475. 	return state == SCE_HJ_COMMENT || state == SCE_HJ_COMMENTLINE || state == SCE_HJA_COMMENT ||

    476. 

  476. 		   state == SCE_HJA_COMMENTLINE || state == SCE_HB_COMMENTLINE || state == SCE_HBA_COMMENTLINE;

    477. 

  477. }

    478. 

  478. 

    479. 

  479. static bool isLineEnd(int ch) {

    480. 

  480. 	return ch == '\r' || ch == '\n';

    481. 

  481. }

    482. 

  482. 

    483. 

  483. static bool isMakoBlockEnd(const int ch, const int chNext, const char *blockType) {

    484. 

  484. 	if (strlen(blockType) == 0) {

    485. 

  485. 		return ((ch == '%') && (chNext == '>'));

    486. 

  486. 	} else if ((0 == strcmp(blockType, "inherit")) ||

    487. 

  487. 			   (0 == strcmp(blockType, "namespace")) ||

    488. 

  488. 			   (0 == strcmp(blockType, "include")) ||

    489. 

  489. 			   (0 == strcmp(blockType, "page"))) {

    490. 

  490. 		return ((ch == '/') && (chNext == '>'));

    491. 

  491. 	} else if (0 == strcmp(blockType, "%")) {

    492. 

  492. 		if (ch == '/' && isLineEnd(chNext))

    493. 

  493. 			return 1;

    494. 

  494. 		else

    495. 

  495. 		    return isLineEnd(ch);

    496. 

  496. 	} else if (0 == strcmp(blockType, "{")) {

    497. 

  497. 		return ch == '}';

    498. 

  498. 	} else {

    499. 

  499. 		return (ch == '>');

    500. 

  500. 	}

    501. 

  501. }

    502. 

  502. 

    503. 

  503. static bool isDjangoBlockEnd(const int ch, const int chNext, const char *blockType) {

    504. 

  504. 	if (strlen(blockType) == 0) {

    505. 

  505. 		return 0;

    506. 

  506. 	} else if (0 == strcmp(blockType, "%")) {

    507. 

  507. 		return ((ch == '%') && (chNext == '}'));

    508. 

  508. 	} else if (0 == strcmp(blockType, "{")) {

    509. 

  509. 		return ((ch == '}') && (chNext == '}'));

    510. 

  510. 	} else {

    511. 

  511. 		return 0;

    512. 

  512. 	}

    513. 

  513. }

    514. 

  514. 

    515. 

  515. static bool isPHPStringState(int state) {

    516. 

  516. 	return

    517. 

  517. 	    (state == SCE_HPHP_HSTRING) ||

    518. 

  518. 	    (state == SCE_HPHP_SIMPLESTRING) ||

    519. 

  519. 	    (state == SCE_HPHP_HSTRING_VARIABLE) ||

    520. 

  520. 	    (state == SCE_HPHP_COMPLEX_VARIABLE);

    521. 

  521. }

    522. 

  522. 

    523. 

  523. static int FindPhpStringDelimiter(char *phpStringDelimiter, const int phpStringDelimiterSize, int i, const int lengthDoc, Accessor &styler, bool &isSimpleString) {

    524. 

  524. 	int j;

    525. 

  525. 	const int beginning = i - 1;

    526. 

  526. 	bool isValidSimpleString = false;

    527. 

  527. 

    528. 

  528. 	while (i < lengthDoc && (styler[i] == ' ' || styler[i] == '\t'))

    529. 

  529. 		i++;

    530. 

  530. 

    531. 

  531. 	char ch = styler.SafeGetCharAt(i);

    532. 

  532. 	const char chNext = styler.SafeGetCharAt(i + 1);

    533. 

  533. 	if (!IsPhpWordStart(ch)) {

    534. 

  534. 		if (ch == '\'' && IsPhpWordStart(chNext)) {

    535. 

  535. 			i++;

    536. 

  536. 			ch = chNext;

    537. 

  537. 			isSimpleString = true;

    538. 

  538. 		} else {

    539. 

  539. 			phpStringDelimiter[0] = '\0';

    540. 

  540. 			return beginning;

    541. 

  541. 		}

    542. 

  542. 	}

    543. 

  543. 	phpStringDelimiter[0] = ch;

    544. 

  544. 	i++;

    545. 

  545. 

    546. 

  546. 	for (j = i; j < lengthDoc && !isLineEnd(styler[j]); j++) {

    547. 

  547. 		if (!IsPhpWordChar(styler[j])) {

    548. 

  548. 			if (isSimpleString && (styler[j] == '\'') && isLineEnd(styler.SafeGetCharAt(j + 1))) {

    549. 

  549. 				isValidSimpleString = true;

    550. 

  550. 				j++;

    551. 

  551. 				break;

    552. 

  552. 			} else {

    553. 

  553. 				phpStringDelimiter[0] = '\0';

    554. 

  554. 				return beginning;

    555. 

  555. 			}

    556. 

  556. 		}

    557. 

  557. 		if (j - i < phpStringDelimiterSize - 2)

    558. 

  558. 			phpStringDelimiter[j-i+1] = styler[j];

    559. 

  559. 		else

    560. 

  560. 			i++;

    561. 

  561. 	}

    562. 

  562. 	if (isSimpleString && !isValidSimpleString) {

    563. 

  563. 		phpStringDelimiter[0] = '\0';

    564. 

  564. 		return beginning;

    565. 

  565. 	}

    566. 

  566. 	phpStringDelimiter[j-i+1 - (isSimpleString ? 1 : 0)] = '\0';

    567. 

  567. 	return j - 1;

    568. 

  568. }

    569. 

  569. 

    570. 

  570. static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],

    571. 

  571.                                   Accessor &styler, bool isXml) {

    572. 

  572. 	WordList &keywords = *keywordlists[0];

    573. 

  573. 	WordList &keywords2 = *keywordlists[1];

    574. 

  574. 	WordList &keywords3 = *keywordlists[2];

    575. 

  575. 	WordList &keywords4 = *keywordlists[3];

    576. 

  576. 	WordList &keywords5 = *keywordlists[4];

    577. 

  577. 	WordList &keywords6 = *keywordlists[5]; // SGML (DTD) keywords

    578. 

  578. 

    579. 

  579. 	styler.StartAt(startPos);

    580. 

  580. 	char prevWord[200];

    581. 

  581. 	prevWord[0] = '\0';

    582. 

  582. 	char phpStringDelimiter[200]; // PHP is not limited in length, we are

    583. 

  583. 	phpStringDelimiter[0] = '\0';

    584. 

  584. 	int StateToPrint = initStyle;

    585. 

  585. 	int state = stateForPrintState(StateToPrint);

    586. 

  586. 	char makoBlockType[200];

    587. 

  587. 	makoBlockType[0] = '\0';

    588. 

  588. 	int makoComment = 0;

    589. 

  589. 	char djangoBlockType[2];

    590. 

  590. 	djangoBlockType[0] = '\0';

    591. 

  591. 

    592. 

  592. 	// If inside a tag, it may be a script tag, so reread from the start of line starting tag to ensure any language tags are seen

    593. 

  593. 	if (InTagState(state)) {

    594. 

  594. 		while ((startPos > 0) && (InTagState(styler.StyleAt(startPos - 1)))) {

    595. 

  595. 			int backLineStart = styler.LineStart(styler.GetLine(startPos-1));

    596. 

  596. 			length += startPos - backLineStart;

    597. 

  597. 			startPos = backLineStart;

    598. 

  598. 		}

    599. 

  599. 		state = SCE_H_DEFAULT;

    600. 

  600. 	}

    601. 

  601. 	// String can be heredoc, must find a delimiter first. Reread from beginning of line containing the string, to get the correct lineState

    602. 

  602. 	if (isPHPStringState(state)) {

    603. 

  603. 		while (startPos > 0 && (isPHPStringState(state) || !isLineEnd(styler[startPos - 1]))) {

    604. 

  604. 			startPos--;

    605. 

  605. 			length++;

    606. 

  606. 			state = styler.StyleAt(startPos);

    607. 

  607. 		}

    608. 

  608. 		if (startPos == 0)

    609. 

  609. 			state = SCE_H_DEFAULT;

    610. 

  610. 	}

    611. 

  611. 	styler.StartAt(startPos);

    612. 

  612. 

    613. 

  613. 	int lineCurrent = styler.GetLine(startPos);

    614. 

  614. 	int lineState;

    615. 

  615. 	if (lineCurrent > 0) {

    616. 

  616. 		lineState = styler.GetLineState(lineCurrent-1);

    617. 

  617. 	} else {

    618. 

  618. 		// Default client and ASP scripting language is JavaScript

    619. 

  619. 		lineState = eScriptJS << 8;

    620. 

  620. 

    621. 

  621. 		// property asp.default.language

    622. 

  622. 		//	Script in ASP code is initially assumed to be in JavaScript.

    623. 

  623. 		//	To change this to VBScript set asp.default.language to 2. Python is 3.

    624. 

  624. 		lineState |= styler.GetPropertyInt("asp.default.language", eScriptJS) << 4;

    625. 

  625. 	}

    626. 

  626. 	script_mode inScriptType = script_mode((lineState >> 0) & 0x03); // 2 bits of scripting mode

    627. 

  627. 	bool tagOpened = (lineState >> 2) & 0x01; // 1 bit to know if we are in an opened tag

    628. 

  628. 	bool tagClosing = (lineState >> 3) & 0x01; // 1 bit to know if we are in a closing tag

    629. 

  629. 	bool tagDontFold = false; //some HTML tags should not be folded

    630. 

  630. 	script_type aspScript = script_type((lineState >> 4) & 0x0F); // 4 bits of script name

    631. 

  631. 	script_type clientScript = script_type((lineState >> 8) & 0x0F); // 4 bits of script name

    632. 

  632. 	int beforePreProc = (lineState >> 12) & 0xFF; // 8 bits of state

    633. 

  633. 

    634. 

  634. 	script_type scriptLanguage = ScriptOfState(state);

    635. 

  635. 	// If eNonHtmlScript coincides with SCE_H_COMMENT, assume eScriptComment

    636. 

  636. 	if (inScriptType == eNonHtmlScript && state == SCE_H_COMMENT) {

    637. 

  637. 		scriptLanguage = eScriptComment;

    638. 

  638. 	}

    639. 

  639. 	script_type beforeLanguage = ScriptOfState(beforePreProc);

    640. 

  640. 

    641. 

  641. 	// property fold.html

    642. 

  642. 	//	Folding is turned on or off for HTML and XML files with this option.

    643. 

  643. 	//	The fold option must also be on for folding to occur.

    644. 

  644. 	const bool foldHTML = styler.GetPropertyInt("fold.html", 0) != 0;

    645. 

  645. 

    646. 

  646. 	const bool fold = foldHTML && styler.GetPropertyInt("fold", 0);

    647. 

  647. 

    648. 

  648. 	// property fold.html.preprocessor

    649. 

  649. 	//	Folding is turned on or off for scripts embedded in HTML files with this option.

    650. 

  650. 	//	The default is on.

    651. 

  651. 	const bool foldHTMLPreprocessor = foldHTML && styler.GetPropertyInt("fold.html.preprocessor", 1);

    652. 

  652. 

    653. 

  653. 	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;

    654. 

  654. 

    655. 

  655. 	// property fold.hypertext.comment

    656. 

  656. 	//	Allow folding for comments in scripts embedded in HTML.

    657. 

  657. 	//	The default is off.

    658. 

  658. 	const bool foldComment = fold && styler.GetPropertyInt("fold.hypertext.comment", 0) != 0;

    659. 

  659. 

    660. 

  660. 	// property fold.hypertext.heredoc

    661. 

  661. 	//	Allow folding for heredocs in scripts embedded in HTML.

    662. 

  662. 	//	The default is off.

    663. 

  663. 	const bool foldHeredoc = fold && styler.GetPropertyInt("fold.hypertext.heredoc", 0) != 0;

    664. 

  664. 

    665. 

  665. 	// property html.tags.case.sensitive

    666. 

  666. 	//	For XML and HTML, setting this property to 1 will make tags match in a case

    667. 

  667. 	//	sensitive way which is the expected behaviour for XML and XHTML.

    668. 

  668. 	const bool caseSensitive = styler.GetPropertyInt("html.tags.case.sensitive", 0) != 0;

    669. 

  669. 

    670. 

  670. 	// property lexer.xml.allow.scripts

    671. 

  671. 	//	Set to 0 to disable scripts in XML.

    672. 

  672. 	const bool allowScripts = styler.GetPropertyInt("lexer.xml.allow.scripts", 1) != 0;

    673. 

  673. 

    674. 

  674. 	// property lexer.html.mako

    675. 

  675. 	//	Set to 1 to enable the mako template language.

    676. 

  676. 	const bool isMako = styler.GetPropertyInt("lexer.html.mako", 0) != 0;

    677. 

  677. 

    678. 

  678. 	// property lexer.html.django

    679. 

  679. 	//	Set to 1 to enable the django template language.

    680. 

  680. 	const bool isDjango = styler.GetPropertyInt("lexer.html.django", 0) != 0;

    681. 

  681. 

    682. 

  682. 	const CharacterSet setHTMLWord(CharacterSet::setAlphaNum, ".-_:!#", 0x80, true);

    683. 

  683. 	const CharacterSet setTagContinue(CharacterSet::setAlphaNum, ".-_:!#[", 0x80, true);

    684. 

  684. 	const CharacterSet setAttributeContinue(CharacterSet::setAlphaNum, ".-_:!#/", 0x80, true);

    685. 

  685. 	// TODO: also handle + and - (except if they're part of ++ or --) and return keywords

    686. 

  686. 	const CharacterSet setOKBeforeJSRE(CharacterSet::setNone, "([{=,:;!%^&*|?~");

    687. 

  687. 

    688. 

  688. 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;

    689. 

  689. 	int levelCurrent = levelPrev;

    690. 

  690. 	int visibleChars = 0;

    691. 

  691. 	int lineStartVisibleChars = 0;

    692. 

  692. 

    693. 

  693. 	int chPrev = ' ';

    694. 

  694. 	int ch = ' ';

    695. 

  695. 	int chPrevNonWhite = ' ';

    696. 

  696. 	// look back to set chPrevNonWhite properly for better regex colouring

    697. 

  697. 	if (scriptLanguage == eScriptJS && startPos > 0) {

    698. 

  698. 		int back = startPos;

    699. 

  699. 		int style = 0;

    700. 

  700. 		while (--back) {

    701. 

  701. 			style = styler.StyleAt(back);

    702. 

  702. 			if (style < SCE_HJ_DEFAULT || style > SCE_HJ_COMMENTDOC)

    703. 

  703. 				// includes SCE_HJ_COMMENT & SCE_HJ_COMMENTLINE

    704. 

  704. 				break;

    705. 

  705. 		}

    706. 

  706. 		if (style == SCE_HJ_SYMBOLS) {

    707. 

  707. 			chPrevNonWhite = static_cast<unsigned char>(styler.SafeGetCharAt(back));

    708. 

  708. 		}

    709. 

  709. 	}

    710. 

  710. 

    711. 

  711. 	styler.StartSegment(startPos);

    712. 

  712. 	const int lengthDoc = startPos + length;

    713. 

  713. 	for (int i = startPos; i < lengthDoc; i++) {

    714. 

  714. 		const int chPrev2 = chPrev;

    715. 

  715. 		chPrev = ch;

    716. 

  716. 		if (!IsASpace(ch) && state != SCE_HJ_COMMENT &&

    717. 

  717. 			state != SCE_HJ_COMMENTLINE && state != SCE_HJ_COMMENTDOC)

    718. 

  718. 			chPrevNonWhite = ch;

    719. 

  719. 		ch = static_cast<unsigned char>(styler[i]);

    720. 

  720. 		int chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    721. 

  721. 		const int chNext2 = static_cast<unsigned char>(styler.SafeGetCharAt(i + 2));

    722. 

  722. 

    723. 

  723. 		// Handle DBCS codepages

    724. 

  724. 		if (styler.IsLeadByte(static_cast<char>(ch))) {

    725. 

  725. 			chPrev = ' ';

    726. 

  726. 			i += 1;

    727. 

  727. 			continue;

    728. 

  728. 		}

    729. 

  729. 

    730. 

  730. 		if ((!IsASpace(ch) || !foldCompact) && fold)

    731. 

  731. 			visibleChars++;

    732. 

  732. 		if (!IsASpace(ch))

    733. 

  733. 			lineStartVisibleChars++;

    734. 

  734. 

    735. 

  735. 		// decide what is the current state to print (depending of the script tag)

    736. 

  736. 		StateToPrint = statePrintForState(state, inScriptType);

    737. 

  737. 

    738. 

  738. 		// handle script folding

    739. 

  739. 		if (fold) {

    740. 

  740. 			switch (scriptLanguage) {

    741. 

  741. 			case eScriptJS:

    742. 

  742. 			case eScriptPHP:

    743. 

  743. 				//not currently supported				case eScriptVBS:

    744. 

  744. 

    745. 

  745. 				if ((state != SCE_HPHP_COMMENT) && (state != SCE_HPHP_COMMENTLINE) && (state != SCE_HJ_COMMENT) && (state != SCE_HJ_COMMENTLINE) && (state != SCE_HJ_COMMENTDOC) && (!isStringState(state))) {

    746. 

  746. 				//Platform::DebugPrintf("state=%d, StateToPrint=%d, initStyle=%d\n", state, StateToPrint, initStyle);

    747. 

  747. 				//if ((state == SCE_HPHP_OPERATOR) || (state == SCE_HPHP_DEFAULT) || (state == SCE_HJ_SYMBOLS) || (state == SCE_HJ_START) || (state == SCE_HJ_DEFAULT)) {

    748. 

  748. 					if (ch == '#') {

    749. 

  749. 						int j = i + 1;

    750. 

  750. 						while ((j < lengthDoc) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {

    751. 

  751. 							j++;

    752. 

  752. 						}

    753. 

  753. 						if (styler.Match(j, "region") || styler.Match(j, "if")) {

    754. 

  754. 							levelCurrent++;

    755. 

  755. 						} else if (styler.Match(j, "end")) {

    756. 

  756. 							levelCurrent--;

    757. 

  757. 						}

    758. 

  758. 					} else if ((ch == '{') || (ch == '}') || (foldComment && (ch == '/') && (chNext == '*'))) {

    759. 

  759. 						levelCurrent += (((ch == '{') || (ch == '/')) ? 1 : -1);

    760. 

  760. 					}

    761. 

  761. 				} else if (((state == SCE_HPHP_COMMENT) || (state == SCE_HJ_COMMENT)) && foldComment && (ch == '*') && (chNext == '/')) {

    762. 

  762. 					levelCurrent--;

    763. 

  763. 				}

    764. 

  764. 				break;

    765. 

  765. 			case eScriptPython:

    766. 

  766. 				if (state != SCE_HP_COMMENTLINE && !isMako) {

    767. 

  767. 					if ((ch == ':') && ((chNext == '\n') || (chNext == '\r' && chNext2 == '\n'))) {

    768. 

  768. 						levelCurrent++;

    769. 

  769. 					} else if ((ch == '\n') && !((chNext == '\r') && (chNext2 == '\n')) && (chNext != '\n')) {

    770. 

  770. 						// check if the number of tabs is lower than the level

    771. 

  771. 						int Findlevel = (levelCurrent & ~SC_FOLDLEVELBASE) * 8;

    772. 

  772. 						for (int j = 0; Findlevel > 0; j++) {

    773. 

  773. 							char chTmp = styler.SafeGetCharAt(i + j + 1);

    774. 

  774. 							if (chTmp == '\t') {

    775. 

  775. 								Findlevel -= 8;

    776. 

  776. 							} else if (chTmp == ' ') {

    777. 

  777. 								Findlevel--;

    778. 

  778. 							} else {

    779. 

  779. 								break;

    780. 

  780. 							}

    781. 

  781. 						}

    782. 

  782. 

    783. 

  783. 						if (Findlevel > 0) {

    784. 

  784. 							levelCurrent -= Findlevel / 8;

    785. 

  785. 							if (Findlevel % 8)

    786. 

  786. 								levelCurrent--;

    787. 

  787. 						}

    788. 

  788. 					}

    789. 

  789. 				}

    790. 

  790. 				break;

    791. 

  791. 			default:

    792. 

  792. 				break;

    793. 

  793. 			}

    794. 

  794. 		}

    795. 

  795. 

    796. 

  796. 		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {

    797. 

  797. 			// Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix)

    798. 

  798. 			// Avoid triggering two times on Dos/Win

    799. 

  799. 			// New line -> record any line state onto /next/ line

    800. 

  800. 			if (fold) {

    801. 

  801. 				int lev = levelPrev;

    802. 

  802. 				if (visibleChars == 0)

    803. 

  803. 					lev |= SC_FOLDLEVELWHITEFLAG;

    804. 

  804. 				if ((levelCurrent > levelPrev) && (visibleChars > 0))

    805. 

  805. 					lev |= SC_FOLDLEVELHEADERFLAG;

    806. 

  806. 

    807. 

  807. 				styler.SetLevel(lineCurrent, lev);

    808. 

  808. 				visibleChars = 0;

    809. 

  809. 				levelPrev = levelCurrent;

    810. 

  810. 			}

    811. 

  811. 			styler.SetLineState(lineCurrent,

    812. 

  812. 			                    ((inScriptType & 0x03) << 0) |

    813. 

  813. 			                    ((tagOpened ? 1 : 0) << 2) |

    814. 

  814. 			                    ((tagClosing ? 1 : 0) << 3) |

    815. 

  815. 			                    ((aspScript & 0x0F) << 4) |

    816. 

  816. 			                    ((clientScript & 0x0F) << 8) |

    817. 

  817. 			                    ((beforePreProc & 0xFF) << 12));

    818. 

  818. 			lineCurrent++;

    819. 

  819. 			lineStartVisibleChars = 0;

    820. 

  820. 		}

    821. 

  821. 

    822. 

  822. 		// handle start of Mako comment line

    823. 

  823. 		if (isMako && ch == '#' && chNext == '#') {

    824. 

  824. 			makoComment = 1;

    825. 

  825. 		}

    826. 

  826. 

    827. 

  827. 		// handle end of Mako comment line

    828. 

  828. 		else if (isMako && makoComment && (ch == '\r' || ch == '\n')) {

    829. 

  829. 			makoComment = 0;

    830. 

  830. 			styler.ColourTo(i, SCE_HP_COMMENTLINE);

    831. 

  831. 			state = SCE_HP_DEFAULT;

    832. 

  832. 		}

    833. 

  833. 

    834. 

  834. 		// Allow falling through to mako handling code if newline is going to end a block

    835. 

  835. 		if (((ch == '\r' && chNext != '\n') || (ch == '\n')) &&

    836. 

  836. 			(!isMako || (0 != strcmp(makoBlockType, "%")))) {

    837. 

  837. 		}

    838. 

  838. 

    839. 

  839. 		// generic end of script processing

    840. 

  840. 		else if ((inScriptType == eNonHtmlScript) && (ch == '<') && (chNext == '/')) {

    841. 

  841. 			// Check if it's the end of the script tag (or any other HTML tag)

    842. 

  842. 			switch (state) {

    843. 

  843. 				// in these cases, you can embed HTML tags (to confirm !!!!!!!!!!!!!!!!!!!!!!)

    844. 

  844. 			case SCE_H_DOUBLESTRING:

    845. 

  845. 			case SCE_H_SINGLESTRING:

    846. 

  846. 			case SCE_HJ_COMMENT:

    847. 

  847. 			case SCE_HJ_COMMENTDOC:

    848. 

  848. 			//case SCE_HJ_COMMENTLINE: // removed as this is a common thing done to hide

    849. 

  849. 			// the end of script marker from some JS interpreters.

    850. 

  850. 			case SCE_HB_COMMENTLINE:

    851. 

  851. 			case SCE_HBA_COMMENTLINE:

    852. 

  852. 			case SCE_HJ_DOUBLESTRING:

    853. 

  853. 			case SCE_HJ_SINGLESTRING:

    854. 

  854. 			case SCE_HJ_REGEX:

    855. 

  855. 			case SCE_HB_STRING:

    856. 

  856. 			case SCE_HBA_STRING:

    857. 

  857. 			case SCE_HP_STRING:

    858. 

  858. 			case SCE_HP_TRIPLE:

    859. 

  859. 			case SCE_HP_TRIPLEDOUBLE:

    860. 

  860. 			case SCE_HPHP_HSTRING:

    861. 

  861. 			case SCE_HPHP_SIMPLESTRING:

    862. 

  862. 			case SCE_HPHP_COMMENT:

    863. 

  863. 			case SCE_HPHP_COMMENTLINE:

    864. 

  864. 				break;

    865. 

  865. 			default :

    866. 

  866. 				// check if the closing tag is a script tag

    867. 

  867. 				if (const char *tag =

    868. 

  868. 						state == SCE_HJ_COMMENTLINE || isXml ? "script" :

    869. 

  869. 						state == SCE_H_COMMENT ? "comment" : 0) {

    870. 

  870. 					int j = i + 2;

    871. 

  871. 					int chr;

    872. 

  872. 					do {

    873. 

  873. 						chr = static_cast<int>(*tag++);

    874. 

  874. 					} while (chr != 0 && chr == MakeLowerCase(styler.SafeGetCharAt(j++)));

    875. 

  875. 					if (chr != 0) break;

    876. 

  876. 				}

    877. 

  877. 				// closing tag of the script (it's a closing HTML tag anyway)

    878. 

  878. 				styler.ColourTo(i - 1, StateToPrint);

    879. 

  879. 				state = SCE_H_TAGUNKNOWN;

    880. 

  880. 				inScriptType = eHtml;

    881. 

  881. 				scriptLanguage = eScriptNone;

    882. 

  882. 				clientScript = eScriptJS;

    883. 

  883. 				i += 2;

    884. 

  884. 				visibleChars += 2;

    885. 

  885. 				tagClosing = true;

    886. 

  886. 				continue;

    887. 

  887. 			}

    888. 

  888. 		}

    889. 

  889. 

    890. 

  890. 		/////////////////////////////////////

    891. 

  891. 		// handle the start of PHP pre-processor = Non-HTML

    892. 

  892. 		else if ((state != SCE_H_ASPAT) &&

    893. 

  893. 		         !isPHPStringState(state) &&

    894. 

  894. 		         (state != SCE_HPHP_COMMENT) &&

    895. 

  895. 		         (state != SCE_HPHP_COMMENTLINE) &&

    896. 

  896. 		         (ch == '<') &&

    897. 

  897. 		         (chNext == '?') &&

    898. 

  898. 				 !IsScriptCommentState(state)) {

    899. 

  899.  			beforeLanguage = scriptLanguage;

    900. 

  900. 			scriptLanguage = segIsScriptingIndicator(styler, i + 2, i + 6, isXml ? eScriptXML : eScriptPHP);

    901. 

  901. 			if ((scriptLanguage != eScriptPHP) && (isStringState(state) || (state==SCE_H_COMMENT))) continue;

    902. 

  902. 			styler.ColourTo(i - 1, StateToPrint);

    903. 

  903. 			beforePreProc = state;

    904. 

  904. 			i++;

    905. 

  905. 			visibleChars++;

    906. 

  906. 			i += PrintScriptingIndicatorOffset(styler, styler.GetStartSegment() + 2, i + 6);

    907. 

  907. 			if (scriptLanguage == eScriptXML)

    908. 

  908. 				styler.ColourTo(i, SCE_H_XMLSTART);

    909. 

  909. 			else

    910. 

  910. 				styler.ColourTo(i, SCE_H_QUESTION);

    911. 

  911. 			state = StateForScript(scriptLanguage);

    912. 

  912. 			if (inScriptType == eNonHtmlScript)

    913. 

  913. 				inScriptType = eNonHtmlScriptPreProc;

    914. 

  914. 			else

    915. 

  915. 				inScriptType = eNonHtmlPreProc;

    916. 

  916. 			// Fold whole script, but not if the XML first tag (all XML-like tags in this case)

    917. 

  917. 			if (foldHTMLPreprocessor && (scriptLanguage != eScriptXML)) {

    918. 

  918. 				levelCurrent++;

    919. 

  919. 			}

    920. 

  920. 			// should be better

    921. 

  921. 			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    922. 

  922. 			continue;

    923. 

  923. 		}

    924. 

  924. 

    925. 

  925. 		// handle the start Mako template Python code

    926. 

  926. 		else if (isMako && scriptLanguage == eScriptNone && ((ch == '<' && chNext == '%') ||

    927. 

  927. 															 (lineStartVisibleChars == 1 && ch == '%') ||

    928. 

  928. 															 (lineStartVisibleChars == 1 && ch == '/' && chNext == '%') ||

    929. 

  929. 															 (ch == '$' && chNext == '{') ||

    930. 

  930. 															 (ch == '<' && chNext == '/' && chNext2 == '%'))) {

    931. 

  931. 			if (ch == '%' || ch == '/')

    932. 

  932. 				StringCopy(makoBlockType, "%");

    933. 

  933. 			else if (ch == '$')

    934. 

  934. 				StringCopy(makoBlockType, "{");

    935. 

  935. 			else if (chNext == '/')

    936. 

  936. 				GetNextWord(styler, i+3, makoBlockType, sizeof(makoBlockType));

    937. 

  937. 			else

    938. 

  938. 				GetNextWord(styler, i+2, makoBlockType, sizeof(makoBlockType));

    939. 

  939. 			styler.ColourTo(i - 1, StateToPrint);

    940. 

  940. 			beforePreProc = state;

    941. 

  941. 			if (inScriptType == eNonHtmlScript)

    942. 

  942. 				inScriptType = eNonHtmlScriptPreProc;

    943. 

  943. 			else

    944. 

  944. 				inScriptType = eNonHtmlPreProc;

    945. 

  945. 

    946. 

  946. 			if (chNext == '/') {

    947. 

  947. 				i += 2;

    948. 

  948. 				visibleChars += 2;

    949. 

  949. 			} else if (ch != '%') {

    950. 

  950. 				i++;

    951. 

  951. 				visibleChars++;

    952. 

  952. 			}

    953. 

  953. 			state = SCE_HP_START;

    954. 

  954. 			scriptLanguage = eScriptPython;

    955. 

  955. 			styler.ColourTo(i, SCE_H_ASP);

    956. 

  956. 

    957. 

  957. 			if (ch != '%' && ch != '$' && ch != '/') {

    958. 

  958. 				i += static_cast<int>(strlen(makoBlockType));

    959. 

  959. 				visibleChars += static_cast<int>(strlen(makoBlockType));

    960. 

  960. 				if (keywords4.InList(makoBlockType))

    961. 

  961. 					styler.ColourTo(i, SCE_HP_WORD);

    962. 

  962. 				else

    963. 

  963. 					styler.ColourTo(i, SCE_H_TAGUNKNOWN);

    964. 

  964. 			}

    965. 

  965. 

    966. 

  966. 			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    967. 

  967. 			continue;

    968. 

  968. 		}

    969. 

  969. 

    970. 

  970. 		// handle the start/end of Django comment

    971. 

  971. 		else if (isDjango && state != SCE_H_COMMENT && (ch == '{' && chNext == '#')) {

    972. 

  972. 			styler.ColourTo(i - 1, StateToPrint);

    973. 

  973. 			beforePreProc = state;

    974. 

  974. 			beforeLanguage = scriptLanguage;

    975. 

  975. 			if (inScriptType == eNonHtmlScript)

    976. 

  976. 				inScriptType = eNonHtmlScriptPreProc;

    977. 

  977. 			else

    978. 

  978. 				inScriptType = eNonHtmlPreProc;

    979. 

  979. 			i += 1;

    980. 

  980. 			visibleChars += 1;

    981. 

  981. 			scriptLanguage = eScriptComment;

    982. 

  982. 			state = SCE_H_COMMENT;

    983. 

  983. 			styler.ColourTo(i, SCE_H_ASP);

    984. 

  984. 			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    985. 

  985. 			continue;

    986. 

  986. 		} else if (isDjango && state == SCE_H_COMMENT && (ch == '#' && chNext == '}')) {

    987. 

  987. 			styler.ColourTo(i - 1, StateToPrint);

    988. 

  988. 			i += 1;

    989. 

  989. 			visibleChars += 1;

    990. 

  990. 			styler.ColourTo(i, SCE_H_ASP);

    991. 

  991. 			state = beforePreProc;

    992. 

  992. 			if (inScriptType == eNonHtmlScriptPreProc)

    993. 

  993. 				inScriptType = eNonHtmlScript;

    994. 

  994. 			else

    995. 

  995. 				inScriptType = eHtml;

    996. 

  996. 			scriptLanguage = beforeLanguage;

    997. 

  997. 			continue;

    998. 

  998. 		}

    999. 

  999. 

    1000. 

  1000. 		// handle the start Django template code

    1001. 

  1001. 		else if (isDjango && scriptLanguage != eScriptPython && (ch == '{' && (chNext == '%' ||  chNext == '{'))) {

    1002. 

  1002. 			if (chNext == '%')

    1003. 

  1003. 				StringCopy(djangoBlockType, "%");

    1004. 

  1004. 			else

    1005. 

  1005. 				StringCopy(djangoBlockType, "{");

    1006. 

  1006. 			styler.ColourTo(i - 1, StateToPrint);

    1007. 

  1007. 			beforePreProc = state;

    1008. 

  1008. 			if (inScriptType == eNonHtmlScript)

    1009. 

  1009. 				inScriptType = eNonHtmlScriptPreProc;

    1010. 

  1010. 			else

    1011. 

  1011. 				inScriptType = eNonHtmlPreProc;

    1012. 

  1012. 

    1013. 

  1013. 			i += 1;

    1014. 

  1014. 			visibleChars += 1;

    1015. 

  1015. 			state = SCE_HP_START;

    1016. 

  1016. 			beforeLanguage = scriptLanguage;

    1017. 

  1017. 			scriptLanguage = eScriptPython;

    1018. 

  1018. 			styler.ColourTo(i, SCE_H_ASP);

    1019. 

  1019. 

    1020. 

  1020. 			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    1021. 

  1021. 			continue;

    1022. 

  1022. 		}

    1023. 

  1023. 

    1024. 

  1024. 		// handle the start of ASP pre-processor = Non-HTML

    1025. 

  1025. 		else if (!isMako && !isDjango && !isCommentASPState(state) && (ch == '<') && (chNext == '%') && !isPHPStringState(state)) {

    1026. 

  1026. 			styler.ColourTo(i - 1, StateToPrint);

    1027. 

  1027. 			beforePreProc = state;

    1028. 

  1028. 			if (inScriptType == eNonHtmlScript)

    1029. 

  1029. 				inScriptType = eNonHtmlScriptPreProc;

    1030. 

  1030. 			else

    1031. 

  1031. 				inScriptType = eNonHtmlPreProc;

    1032. 

  1032. 

    1033. 

  1033. 			if (chNext2 == '@') {

    1034. 

  1034. 				i += 2; // place as if it was the second next char treated

    1035. 

  1035. 				visibleChars += 2;

    1036. 

  1036. 				state = SCE_H_ASPAT;

    1037. 

  1037. 			} else if ((chNext2 == '-') && (styler.SafeGetCharAt(i + 3) == '-')) {

    1038. 

  1038. 				styler.ColourTo(i + 3, SCE_H_ASP);

    1039. 

  1039. 				state = SCE_H_XCCOMMENT;

    1040. 

  1040. 				scriptLanguage = eScriptVBS;

    1041. 

  1041. 				continue;

    1042. 

  1042. 			} else {

    1043. 

  1043. 				if (chNext2 == '=') {

    1044. 

  1044. 					i += 2; // place as if it was the second next char treated

    1045. 

  1045. 					visibleChars += 2;

    1046. 

  1046. 				} else {

    1047. 

  1047. 					i++; // place as if it was the next char treated

    1048. 

  1048. 					visibleChars++;

    1049. 

  1049. 				}

    1050. 

  1050. 

    1051. 

  1051. 				state = StateForScript(aspScript);

    1052. 

  1052. 			}

    1053. 

  1053. 			scriptLanguage = eScriptVBS;

    1054. 

  1054. 			styler.ColourTo(i, SCE_H_ASP);

    1055. 

  1055. 			// fold whole script

    1056. 

  1056. 			if (foldHTMLPreprocessor)

    1057. 

  1057. 				levelCurrent++;

    1058. 

  1058. 			// should be better

    1059. 

  1059. 			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    1060. 

  1060. 			continue;

    1061. 

  1061. 		}

    1062. 

  1062. 

    1063. 

  1063. 		/////////////////////////////////////

    1064. 

  1064. 		// handle the start of SGML language (DTD)

    1065. 

  1065. 		else if (((scriptLanguage == eScriptNone) || (scriptLanguage == eScriptXML)) &&

    1066. 

  1066. 				 (chPrev == '<') &&

    1067. 

  1067. 				 (ch == '!') &&

    1068. 

  1068. 				 (StateToPrint != SCE_H_CDATA) &&

    1069. 

  1069. 				 (!IsCommentState(StateToPrint)) &&

    1070. 

  1070. 				 (!IsScriptCommentState(StateToPrint))) {

    1071. 

  1071. 			beforePreProc = state;

    1072. 

  1072. 			styler.ColourTo(i - 2, StateToPrint);

    1073. 

  1073. 			if ((chNext == '-') && (chNext2 == '-')) {

    1074. 

  1074. 				state = SCE_H_COMMENT; // wait for a pending command

    1075. 

  1075. 				styler.ColourTo(i + 2, SCE_H_COMMENT);

    1076. 

  1076. 				i += 2; // follow styling after the --

    1077. 

  1077. 			} else if (isWordCdata(i + 1, i + 7, styler)) {

    1078. 

  1078. 				state = SCE_H_CDATA;

    1079. 

  1079. 			} else {

    1080. 

  1080. 				styler.ColourTo(i, SCE_H_SGML_DEFAULT); // <! is default

    1081. 

  1081. 				scriptLanguage = eScriptSGML;

    1082. 

  1082. 				state = SCE_H_SGML_COMMAND; // wait for a pending command

    1083. 

  1083. 			}

    1084. 

  1084. 			// fold whole tag (-- when closing the tag)

    1085. 

  1085. 			if (foldHTMLPreprocessor || state == SCE_H_COMMENT || state == SCE_H_CDATA)

    1086. 

  1086. 				levelCurrent++;

    1087. 

  1087. 			continue;

    1088. 

  1088. 		}

    1089. 

  1089. 

    1090. 

  1090. 		// handle the end of Mako Python code

    1091. 

  1091. 		else if (isMako &&

    1092. 

  1092. 			     ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&

    1093. 

  1093. 				 (scriptLanguage != eScriptNone) && stateAllowsTermination(state) &&

    1094. 

  1094. 				 isMakoBlockEnd(ch, chNext, makoBlockType)) {

    1095. 

  1095. 			if (state == SCE_H_ASPAT) {

    1096. 

  1096. 				aspScript = segIsScriptingIndicator(styler,

    1097. 

  1097. 				                                    styler.GetStartSegment(), i - 1, aspScript);

    1098. 

  1098. 			}

    1099. 

  1099. 			if (state == SCE_HP_WORD) {

    1100. 

  1100. 				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);

    1101. 

  1101. 			} else {

    1102. 

  1102. 				styler.ColourTo(i - 1, StateToPrint);

    1103. 

  1103. 			}

    1104. 

  1104. 			if (0 != strcmp(makoBlockType, "%") && (0 != strcmp(makoBlockType, "{")) && ch != '>') {

    1105. 

  1105. 				i++;

    1106. 

  1106. 				visibleChars++;

    1107. 

  1107. 		    }

    1108. 

  1108. 			else if (0 == strcmp(makoBlockType, "%") && ch == '/') {

    1109. 

  1109. 				i++;

    1110. 

  1110. 				visibleChars++;

    1111. 

  1111. 			}

    1112. 

  1112. 			if (0 != strcmp(makoBlockType, "%") || ch == '/') {

    1113. 

  1113. 				styler.ColourTo(i, SCE_H_ASP);

    1114. 

  1114. 			}

    1115. 

  1115. 			state = beforePreProc;

    1116. 

  1116. 			if (inScriptType == eNonHtmlScriptPreProc)

    1117. 

  1117. 				inScriptType = eNonHtmlScript;

    1118. 

  1118. 			else

    1119. 

  1119. 				inScriptType = eHtml;

    1120. 

  1120. 			scriptLanguage = eScriptNone;

    1121. 

  1121. 			continue;

    1122. 

  1122. 		}

    1123. 

  1123. 

    1124. 

  1124. 		// handle the end of Django template code

    1125. 

  1125. 		else if (isDjango &&

    1126. 

  1126. 			     ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&

    1127. 

  1127. 				 (scriptLanguage != eScriptNone) && stateAllowsTermination(state) &&

    1128. 

  1128. 				 isDjangoBlockEnd(ch, chNext, djangoBlockType)) {

    1129. 

  1129. 			if (state == SCE_H_ASPAT) {

    1130. 

  1130. 				aspScript = segIsScriptingIndicator(styler,

    1131. 

  1131. 				                                    styler.GetStartSegment(), i - 1, aspScript);

    1132. 

  1132. 			}

    1133. 

  1133. 			if (state == SCE_HP_WORD) {

    1134. 

  1134. 				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);

    1135. 

  1135. 			} else {

    1136. 

  1136. 				styler.ColourTo(i - 1, StateToPrint);

    1137. 

  1137. 			}

    1138. 

  1138. 			i += 1;

    1139. 

  1139. 			visibleChars += 1;

    1140. 

  1140. 			styler.ColourTo(i, SCE_H_ASP);

    1141. 

  1141. 			state = beforePreProc;

    1142. 

  1142. 			if (inScriptType == eNonHtmlScriptPreProc)

    1143. 

  1143. 				inScriptType = eNonHtmlScript;

    1144. 

  1144. 			else

    1145. 

  1145. 				inScriptType = eHtml;

    1146. 

  1146. 			scriptLanguage = beforeLanguage;

    1147. 

  1147. 			continue;

    1148. 

  1148. 		}

    1149. 

  1149. 

    1150. 

  1150. 		// handle the end of a pre-processor = Non-HTML

    1151. 

  1151. 		else if ((!isMako && !isDjango && ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&

    1152. 

  1152. 				  (((scriptLanguage != eScriptNone) && stateAllowsTermination(state))) &&

    1153. 

  1153. 				  (((ch == '%') || (ch == '?')) && (chNext == '>'))) ||

    1154. 

  1154. 		         ((scriptLanguage == eScriptSGML) && (ch == '>') && (state != SCE_H_SGML_COMMENT))) {

    1155. 

  1155. 			if (state == SCE_H_ASPAT) {

    1156. 

  1156. 				aspScript = segIsScriptingIndicator(styler,

    1157. 

  1157. 				                                    styler.GetStartSegment(), i - 1, aspScript);

    1158. 

  1158. 			}

    1159. 

  1159. 			// Bounce out of any ASP mode

    1160. 

  1160. 			switch (state) {

    1161. 

  1161. 			case SCE_HJ_WORD:

    1162. 

  1162. 				classifyWordHTJS(styler.GetStartSegment(), i - 1, keywords2, styler, inScriptType);

    1163. 

  1163. 				break;

    1164. 

  1164. 			case SCE_HB_WORD:

    1165. 

  1165. 				classifyWordHTVB(styler.GetStartSegment(), i - 1, keywords3, styler, inScriptType);

    1166. 

  1166. 				break;

    1167. 

  1167. 			case SCE_HP_WORD:

    1168. 

  1168. 				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);

    1169. 

  1169. 				break;

    1170. 

  1170. 			case SCE_HPHP_WORD:

    1171. 

  1171. 				classifyWordHTPHP(styler.GetStartSegment(), i - 1, keywords5, styler);

    1172. 

  1172. 				break;

    1173. 

  1173. 			case SCE_H_XCCOMMENT:

    1174. 

  1174. 				styler.ColourTo(i - 1, state);

    1175. 

  1175. 				break;

    1176. 

  1176. 			default :

    1177. 

  1177. 				styler.ColourTo(i - 1, StateToPrint);

    1178. 

  1178. 				break;

    1179. 

  1179. 			}

    1180. 

  1180. 			if (scriptLanguage != eScriptSGML) {

    1181. 

  1181. 				i++;

    1182. 

  1182. 				visibleChars++;

    1183. 

  1183. 			}

    1184. 

  1184. 			if (ch == '%')

    1185. 

  1185. 				styler.ColourTo(i, SCE_H_ASP);

    1186. 

  1186. 			else if (scriptLanguage == eScriptXML)

    1187. 

  1187. 				styler.ColourTo(i, SCE_H_XMLEND);

    1188. 

  1188. 			else if (scriptLanguage == eScriptSGML)

    1189. 

  1189. 				styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1190. 

  1190. 			else

    1191. 

  1191. 				styler.ColourTo(i, SCE_H_QUESTION);

    1192. 

  1192. 			state = beforePreProc;

    1193. 

  1193. 			if (inScriptType == eNonHtmlScriptPreProc)

    1194. 

  1194. 				inScriptType = eNonHtmlScript;

    1195. 

  1195. 			else

    1196. 

  1196. 				inScriptType = eHtml;

    1197. 

  1197. 			// Unfold all scripting languages, except for XML tag

    1198. 

  1198. 			if (foldHTMLPreprocessor && (scriptLanguage != eScriptXML)) {

    1199. 

  1199. 				levelCurrent--;

    1200. 

  1200. 			}

    1201. 

  1201. 			scriptLanguage = beforeLanguage;

    1202. 

  1202. 			continue;

    1203. 

  1203. 		}

    1204. 

  1204. 		/////////////////////////////////////

    1205. 

  1205. 

    1206. 

  1206. 		switch (state) {

    1207. 

  1207. 		case SCE_H_DEFAULT:

    1208. 

  1208. 			if (ch == '<') {

    1209. 

  1209. 				// in HTML, fold on tag open and unfold on tag close

    1210. 

  1210. 				tagOpened = true;

    1211. 

  1211. 				tagClosing = (chNext == '/');

    1212. 

  1212. 				styler.ColourTo(i - 1, StateToPrint);

    1213. 

  1213. 				if (chNext != '!')

    1214. 

  1214. 					state = SCE_H_TAGUNKNOWN;

    1215. 

  1215. 			} else if (ch == '&') {

    1216. 

  1216. 				styler.ColourTo(i - 1, SCE_H_DEFAULT);

    1217. 

  1217. 				state = SCE_H_ENTITY;

    1218. 

  1218. 			}

    1219. 

  1219. 			break;

    1220. 

  1220. 		case SCE_H_SGML_DEFAULT:

    1221. 

  1221. 		case SCE_H_SGML_BLOCK_DEFAULT:

    1222. 

  1222. //			if (scriptLanguage == eScriptSGMLblock)

    1223. 

  1223. //				StateToPrint = SCE_H_SGML_BLOCK_DEFAULT;

    1224. 

  1224. 

    1225. 

  1225. 			if (ch == '\"') {

    1226. 

  1226. 				styler.ColourTo(i - 1, StateToPrint);

    1227. 

  1227. 				state = SCE_H_SGML_DOUBLESTRING;

    1228. 

  1228. 			} else if (ch == '\'') {

    1229. 

  1229. 				styler.ColourTo(i - 1, StateToPrint);

    1230. 

  1230. 				state = SCE_H_SGML_SIMPLESTRING;

    1231. 

  1231. 			} else if ((ch == '-') && (chPrev == '-')) {

    1232. 

  1232. 				if (static_cast<int>(styler.GetStartSegment()) <= (i - 2)) {

    1233. 

  1233. 					styler.ColourTo(i - 2, StateToPrint);

    1234. 

  1234. 				}

    1235. 

  1235. 				state = SCE_H_SGML_COMMENT;

    1236. 

  1236. 			} else if (IsASCII(ch) && isalpha(ch) && (chPrev == '%')) {

    1237. 

  1237. 				styler.ColourTo(i - 2, StateToPrint);

    1238. 

  1238. 				state = SCE_H_SGML_ENTITY;

    1239. 

  1239. 			} else if (ch == '#') {

    1240. 

  1240. 				styler.ColourTo(i - 1, StateToPrint);

    1241. 

  1241. 				state = SCE_H_SGML_SPECIAL;

    1242. 

  1242. 			} else if (ch == '[') {

    1243. 

  1243. 				styler.ColourTo(i - 1, StateToPrint);

    1244. 

  1244. 				scriptLanguage = eScriptSGMLblock;

    1245. 

  1245. 				state = SCE_H_SGML_BLOCK_DEFAULT;

    1246. 

  1246. 			} else if (ch == ']') {

    1247. 

  1247. 				if (scriptLanguage == eScriptSGMLblock) {

    1248. 

  1248. 					styler.ColourTo(i, StateToPrint);

    1249. 

  1249. 					scriptLanguage = eScriptSGML;

    1250. 

  1250. 				} else {

    1251. 

  1251. 					styler.ColourTo(i - 1, StateToPrint);

    1252. 

  1252. 					styler.ColourTo(i, SCE_H_SGML_ERROR);

    1253. 

  1253. 				}

    1254. 

  1254. 				state = SCE_H_SGML_DEFAULT;

    1255. 

  1255. 			} else if (scriptLanguage == eScriptSGMLblock) {

    1256. 

  1256. 				if ((ch == '!') && (chPrev == '<')) {

    1257. 

  1257. 					styler.ColourTo(i - 2, StateToPrint);

    1258. 

  1258. 					styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1259. 

  1259. 					state = SCE_H_SGML_COMMAND;

    1260. 

  1260. 				} else if (ch == '>') {

    1261. 

  1261. 					styler.ColourTo(i - 1, StateToPrint);

    1262. 

  1262. 					styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1263. 

  1263. 				}

    1264. 

  1264. 			}

    1265. 

  1265. 			break;

    1266. 

  1266. 		case SCE_H_SGML_COMMAND:

    1267. 

  1267. 			if ((ch == '-') && (chPrev == '-')) {

    1268. 

  1268. 				styler.ColourTo(i - 2, StateToPrint);

    1269. 

  1269. 				state = SCE_H_SGML_COMMENT;

    1270. 

  1270. 			} else if (!issgmlwordchar(ch)) {

    1271. 

  1271. 				if (isWordHSGML(styler.GetStartSegment(), i - 1, keywords6, styler)) {

    1272. 

  1272. 					styler.ColourTo(i - 1, StateToPrint);

    1273. 

  1273. 					state = SCE_H_SGML_1ST_PARAM;

    1274. 

  1274. 				} else {

    1275. 

  1275. 					state = SCE_H_SGML_ERROR;

    1276. 

  1276. 				}

    1277. 

  1277. 			}

    1278. 

  1278. 			break;

    1279. 

  1279. 		case SCE_H_SGML_1ST_PARAM:

    1280. 

  1280. 			// wait for the beginning of the word

    1281. 

  1281. 			if ((ch == '-') && (chPrev == '-')) {

    1282. 

  1282. 				if (scriptLanguage == eScriptSGMLblock) {

    1283. 

  1283. 					styler.ColourTo(i - 2, SCE_H_SGML_BLOCK_DEFAULT);

    1284. 

  1284. 				} else {

    1285. 

  1285. 					styler.ColourTo(i - 2, SCE_H_SGML_DEFAULT);

    1286. 

  1286. 				}

    1287. 

  1287. 				state = SCE_H_SGML_1ST_PARAM_COMMENT;

    1288. 

  1288. 			} else if (issgmlwordchar(ch)) {

    1289. 

  1289. 				if (scriptLanguage == eScriptSGMLblock) {

    1290. 

  1290. 					styler.ColourTo(i - 1, SCE_H_SGML_BLOCK_DEFAULT);

    1291. 

  1291. 				} else {

    1292. 

  1292. 					styler.ColourTo(i - 1, SCE_H_SGML_DEFAULT);

    1293. 

  1293. 				}

    1294. 

  1294. 				// find the length of the word

    1295. 

  1295. 				int size = 1;

    1296. 

  1296. 				while (setHTMLWord.Contains(static_cast<unsigned char>(styler.SafeGetCharAt(i + size))))

    1297. 

  1297. 					size++;

    1298. 

  1298. 				styler.ColourTo(i + size - 1, StateToPrint);

    1299. 

  1299. 				i += size - 1;

    1300. 

  1300. 				visibleChars += size - 1;

    1301. 

  1301. 				ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

    1302. 

  1302. 				if (scriptLanguage == eScriptSGMLblock) {

    1303. 

  1303. 					state = SCE_H_SGML_BLOCK_DEFAULT;

    1304. 

  1304. 				} else {

    1305. 

  1305. 					state = SCE_H_SGML_DEFAULT;

    1306. 

  1306. 				}

    1307. 

  1307. 				continue;

    1308. 

  1308. 			}

    1309. 

  1309. 			break;

    1310. 

  1310. 		case SCE_H_SGML_ERROR:

    1311. 

  1311. 			if ((ch == '-') && (chPrev == '-')) {

    1312. 

  1312. 				styler.ColourTo(i - 2, StateToPrint);

    1313. 

  1313. 				state = SCE_H_SGML_COMMENT;

    1314. 

  1314. 			}

    1315. 

  1315. 			break;

    1316. 

  1316. 		case SCE_H_SGML_DOUBLESTRING:

    1317. 

  1317. 			if (ch == '\"') {

    1318. 

  1318. 				styler.ColourTo(i, StateToPrint);

    1319. 

  1319. 				state = SCE_H_SGML_DEFAULT;

    1320. 

  1320. 			}

    1321. 

  1321. 			break;

    1322. 

  1322. 		case SCE_H_SGML_SIMPLESTRING:

    1323. 

  1323. 			if (ch == '\'') {

    1324. 

  1324. 				styler.ColourTo(i, StateToPrint);

    1325. 

  1325. 				state = SCE_H_SGML_DEFAULT;

    1326. 

  1326. 			}

    1327. 

  1327. 			break;

    1328. 

  1328. 		case SCE_H_SGML_COMMENT:

    1329. 

  1329. 			if ((ch == '-') && (chPrev == '-')) {

    1330. 

  1330. 				styler.ColourTo(i, StateToPrint);

    1331. 

  1331. 				state = SCE_H_SGML_DEFAULT;

    1332. 

  1332. 			}

    1333. 

  1333. 			break;

    1334. 

  1334. 		case SCE_H_CDATA:

    1335. 

  1335. 			if ((chPrev2 == ']') && (chPrev == ']') && (ch == '>')) {

    1336. 

  1336. 				styler.ColourTo(i, StateToPrint);

    1337. 

  1337. 				state = SCE_H_DEFAULT;

    1338. 

  1338. 				levelCurrent--;

    1339. 

  1339. 			}

    1340. 

  1340. 			break;

    1341. 

  1341. 		case SCE_H_COMMENT:

    1342. 

  1342. 			if ((scriptLanguage != eScriptComment) && (chPrev2 == '-') && (chPrev == '-') && (ch == '>')) {

    1343. 

  1343. 				styler.ColourTo(i, StateToPrint);

    1344. 

  1344. 				state = SCE_H_DEFAULT;

    1345. 

  1345. 				levelCurrent--;

    1346. 

  1346. 			}

    1347. 

  1347. 			break;

    1348. 

  1348. 		case SCE_H_SGML_1ST_PARAM_COMMENT:

    1349. 

  1349. 			if ((ch == '-') && (chPrev == '-')) {

    1350. 

  1350. 				styler.ColourTo(i, SCE_H_SGML_COMMENT);

    1351. 

  1351. 				state = SCE_H_SGML_1ST_PARAM;

    1352. 

  1352. 			}

    1353. 

  1353. 			break;

    1354. 

  1354. 		case SCE_H_SGML_SPECIAL:

    1355. 

  1355. 			if (!(IsASCII(ch) && isupper(ch))) {

    1356. 

  1356. 				styler.ColourTo(i - 1, StateToPrint);

    1357. 

  1357. 				if (isalnum(ch)) {

    1358. 

  1358. 					state = SCE_H_SGML_ERROR;

    1359. 

  1359. 				} else {

    1360. 

  1360. 					state = SCE_H_SGML_DEFAULT;

    1361. 

  1361. 				}

    1362. 

  1362. 			}

    1363. 

  1363. 			break;

    1364. 

  1364. 		case SCE_H_SGML_ENTITY:

    1365. 

  1365. 			if (ch == ';') {

    1366. 

  1366. 				styler.ColourTo(i, StateToPrint);

    1367. 

  1367. 				state = SCE_H_SGML_DEFAULT;

    1368. 

  1368. 			} else if (!(IsASCII(ch) && isalnum(ch)) && ch != '-' && ch != '.') {

    1369. 

  1369. 				styler.ColourTo(i, SCE_H_SGML_ERROR);

    1370. 

  1370. 				state = SCE_H_SGML_DEFAULT;

    1371. 

  1371. 			}

    1372. 

  1372. 			break;

    1373. 

  1373. 		case SCE_H_ENTITY:

    1374. 

  1374. 			if (ch == ';') {

    1375. 

  1375. 				styler.ColourTo(i, StateToPrint);

    1376. 

  1376. 				state = SCE_H_DEFAULT;

    1377. 

  1377. 			}

    1378. 

  1378. 			if (ch != '#' && !(IsASCII(ch) && isalnum(ch))	// Should check that '#' follows '&', but it is unlikely anyway...

    1379. 

  1379. 				&& ch != '.' && ch != '-' && ch != '_' && ch != ':') { // valid in XML

    1380. 

  1380. 				if (!IsASCII(ch))	// Possibly start of a multibyte character so don't allow this byte to be in entity style

    1381. 

  1381. 					styler.ColourTo(i-1, SCE_H_TAGUNKNOWN);

    1382. 

  1382. 				else

    1383. 

  1383. 					styler.ColourTo(i, SCE_H_TAGUNKNOWN);

    1384. 

  1384. 				state = SCE_H_DEFAULT;

    1385. 

  1385. 			}

    1386. 

  1386. 			break;

    1387. 

  1387. 		case SCE_H_TAGUNKNOWN:

    1388. 

  1388. 			if (!setTagContinue.Contains(ch) && !((ch == '/') && (chPrev == '<'))) {

    1389. 

  1389. 				int eClass = classifyTagHTML(styler.GetStartSegment(),

    1390. 

  1390. 					i - 1, keywords, styler, tagDontFold, caseSensitive, isXml, allowScripts);

    1391. 

  1391. 				if (eClass == SCE_H_SCRIPT || eClass == SCE_H_COMMENT) {

    1392. 

  1392. 					if (!tagClosing) {

    1393. 

  1393. 						inScriptType = eNonHtmlScript;

    1394. 

  1394. 						scriptLanguage = eClass == SCE_H_SCRIPT ? clientScript : eScriptComment;

    1395. 

  1395. 					} else {

    1396. 

  1396. 						scriptLanguage = eScriptNone;

    1397. 

  1397. 					}

    1398. 

  1398. 					eClass = SCE_H_TAG;

    1399. 

  1399. 				}

    1400. 

  1400. 				if (ch == '>') {

    1401. 

  1401. 					styler.ColourTo(i, eClass);

    1402. 

  1402. 					if (inScriptType == eNonHtmlScript) {

    1403. 

  1403. 						state = StateForScript(scriptLanguage);

    1404. 

  1404. 					} else {

    1405. 

  1405. 						state = SCE_H_DEFAULT;

    1406. 

  1406. 					}

    1407. 

  1407. 					tagOpened = false;

    1408. 

  1408. 					if (!tagDontFold) {

    1409. 

  1409. 						if (tagClosing) {

    1410. 

  1410. 							levelCurrent--;

    1411. 

  1411. 						} else {

    1412. 

  1412. 							levelCurrent++;

    1413. 

  1413. 						}

    1414. 

  1414. 					}

    1415. 

  1415. 					tagClosing = false;

    1416. 

  1416. 				} else if (ch == '/' && chNext == '>') {

    1417. 

  1417. 					if (eClass == SCE_H_TAGUNKNOWN) {

    1418. 

  1418. 						styler.ColourTo(i + 1, SCE_H_TAGUNKNOWN);

    1419. 

  1419. 					} else {

    1420. 

  1420. 						styler.ColourTo(i - 1, StateToPrint);

    1421. 

  1421. 						styler.ColourTo(i + 1, SCE_H_TAGEND);

    1422. 

  1422. 					}

    1423. 

  1423. 					i++;

    1424. 

  1424. 					ch = chNext;

    1425. 

  1425. 					state = SCE_H_DEFAULT;

    1426. 

  1426. 					tagOpened = false;

    1427. 

  1427. 				} else {

    1428. 

  1428. 					if (eClass != SCE_H_TAGUNKNOWN) {

    1429. 

  1429. 						if (eClass == SCE_H_SGML_DEFAULT) {

    1430. 

  1430. 							state = SCE_H_SGML_DEFAULT;

    1431. 

  1431. 						} else {

    1432. 

  1432. 							state = SCE_H_OTHER;

    1433. 

  1433. 						}

    1434. 

  1434. 					}

    1435. 

  1435. 				}

    1436. 

  1436. 			}

    1437. 

  1437. 			break;

    1438. 

  1438. 		case SCE_H_ATTRIBUTE:

    1439. 

  1439. 			if (!setAttributeContinue.Contains(ch)) {

    1440. 

  1440. 				if (inScriptType == eNonHtmlScript) {

    1441. 

  1441. 					int scriptLanguagePrev = scriptLanguage;

    1442. 

  1442. 					clientScript = segIsScriptingIndicator(styler, styler.GetStartSegment(), i - 1, scriptLanguage);

    1443. 

  1443. 					scriptLanguage = clientScript;

    1444. 

  1444. 					if ((scriptLanguagePrev != scriptLanguage) && (scriptLanguage == eScriptNone))

    1445. 

  1445. 						inScriptType = eHtml;

    1446. 

  1446. 				}

    1447. 

  1447. 				classifyAttribHTML(styler.GetStartSegment(), i - 1, keywords, styler);

    1448. 

  1448. 				if (ch == '>') {

    1449. 

  1449. 					styler.ColourTo(i, SCE_H_TAG);

    1450. 

  1450. 					if (inScriptType == eNonHtmlScript) {

    1451. 

  1451. 						state = StateForScript(scriptLanguage);

    1452. 

  1452. 					} else {

    1453. 

  1453. 						state = SCE_H_DEFAULT;

    1454. 

  1454. 					}

    1455. 

  1455. 					tagOpened = false;

    1456. 

  1456. 					if (!tagDontFold) {

    1457. 

  1457. 						if (tagClosing) {

    1458. 

  1458. 							levelCurrent--;

    1459. 

  1459. 						} else {

    1460. 

  1460. 							levelCurrent++;

    1461. 

  1461. 						}

    1462. 

  1462. 					}

    1463. 

  1463. 					tagClosing = false;

    1464. 

  1464. 				} else if (ch == '=') {

    1465. 

  1465. 					styler.ColourTo(i, SCE_H_OTHER);

    1466. 

  1466. 					state = SCE_H_VALUE;

    1467. 

  1467. 				} else {

    1468. 

  1468. 					state = SCE_H_OTHER;

    1469. 

  1469. 				}

    1470. 

  1470. 			}

    1471. 

  1471. 			break;

    1472. 

  1472. 		case SCE_H_OTHER:

    1473. 

  1473. 			if (ch == '>') {

    1474. 

  1474. 				styler.ColourTo(i - 1, StateToPrint);

    1475. 

  1475. 				styler.ColourTo(i, SCE_H_TAG);

    1476. 

  1476. 				if (inScriptType == eNonHtmlScript) {

    1477. 

  1477. 					state = StateForScript(scriptLanguage);

    1478. 

  1478. 				} else {

    1479. 

  1479. 					state = SCE_H_DEFAULT;

    1480. 

  1480. 				}

    1481. 

  1481. 				tagOpened = false;

    1482. 

  1482. 				if (!tagDontFold) {

    1483. 

  1483. 					if (tagClosing) {

    1484. 

  1484. 						levelCurrent--;

    1485. 

  1485. 					} else {

    1486. 

  1486. 						levelCurrent++;

    1487. 

  1487. 					}

    1488. 

  1488. 				}

    1489. 

  1489. 				tagClosing = false;

    1490. 

  1490. 			} else if (ch == '\"') {

    1491. 

  1491. 				styler.ColourTo(i - 1, StateToPrint);

    1492. 

  1492. 				state = SCE_H_DOUBLESTRING;

    1493. 

  1493. 			} else if (ch == '\'') {

    1494. 

  1494. 				styler.ColourTo(i - 1, StateToPrint);

    1495. 

  1495. 				state = SCE_H_SINGLESTRING;

    1496. 

  1496. 			} else if (ch == '=') {

    1497. 

  1497. 				styler.ColourTo(i, StateToPrint);

    1498. 

  1498. 				state = SCE_H_VALUE;

    1499. 

  1499. 			} else if (ch == '/' && chNext == '>') {

    1500. 

  1500. 				styler.ColourTo(i - 1, StateToPrint);

    1501. 

  1501. 				styler.ColourTo(i + 1, SCE_H_TAGEND);

    1502. 

  1502. 				i++;

    1503. 

  1503. 				ch = chNext;

    1504. 

  1504. 				state = SCE_H_DEFAULT;

    1505. 

  1505. 				tagOpened = false;

    1506. 

  1506. 			} else if (ch == '?' && chNext == '>') {

    1507. 

  1507. 				styler.ColourTo(i - 1, StateToPrint);

    1508. 

  1508. 				styler.ColourTo(i + 1, SCE_H_XMLEND);

    1509. 

  1509. 				i++;

    1510. 

  1510. 				ch = chNext;

    1511. 

  1511. 				state = SCE_H_DEFAULT;

    1512. 

  1512. 			} else if (setHTMLWord.Contains(ch)) {

    1513. 

  1513. 				styler.ColourTo(i - 1, StateToPrint);

    1514. 

  1514. 				state = SCE_H_ATTRIBUTE;

    1515. 

  1515. 			}

    1516. 

  1516. 			break;

    1517. 

  1517. 		case SCE_H_DOUBLESTRING:

    1518. 

  1518. 			if (ch == '\"') {

    1519. 

  1519. 				if (inScriptType == eNonHtmlScript) {

    1520. 

  1520. 					scriptLanguage = segIsScriptingIndicator(styler, styler.GetStartSegment(), i, scriptLanguage);

    1521. 

  1521. 				}

    1522. 

  1522. 				styler.ColourTo(i, SCE_H_DOUBLESTRING);

    1523. 

  1523. 				state = SCE_H_OTHER;

    1524. 

  1524. 			}

    1525. 

  1525. 			break;

    1526. 

  1526. 		case SCE_H_SINGLESTRING:

    1527. 

  1527. 			if (ch == '\'') {

    1528. 

  1528. 				if (inScriptType == eNonHtmlScript) {

    1529. 

  1529. 					scriptLanguage = segIsScriptingIndicator(styler, styler.GetStartSegment(), i, scriptLanguage);

    1530. 

  1530. 				}

    1531. 

  1531. 				styler.ColourTo(i, SCE_H_SINGLESTRING);

    1532. 

  1532. 				state = SCE_H_OTHER;

    1533. 

  1533. 			}

    1534. 

  1534. 			break;

    1535. 

  1535. 		case SCE_H_VALUE:

    1536. 

  1536. 			if (!setHTMLWord.Contains(ch)) {

    1537. 

  1537. 				if (ch == '\"' && chPrev == '=') {

    1538. 

  1538. 					// Should really test for being first character

    1539. 

  1539. 					state = SCE_H_DOUBLESTRING;

    1540. 

  1540. 				} else if (ch == '\'' && chPrev == '=') {

    1541. 

  1541. 					state = SCE_H_SINGLESTRING;

    1542. 

  1542. 				} else {

    1543. 

  1543. 					if (IsNumber(styler.GetStartSegment(), styler)) {

    1544. 

  1544. 						styler.ColourTo(i - 1, SCE_H_NUMBER);

    1545. 

  1545. 					} else {

    1546. 

  1546. 						styler.ColourTo(i - 1, StateToPrint);

    1547. 

  1547. 					}

    1548. 

  1548. 					if (ch == '>') {

    1549. 

  1549. 						styler.ColourTo(i, SCE_H_TAG);

    1550. 

  1550. 						if (inScriptType == eNonHtmlScript) {

    1551. 

  1551. 							state = StateForScript(scriptLanguage);

    1552. 

  1552. 						} else {

    1553. 

  1553. 							state = SCE_H_DEFAULT;

    1554. 

  1554. 						}

    1555. 

  1555. 						tagOpened = false;

    1556. 

  1556. 						if (!tagDontFold) {

    1557. 

  1557. 							if (tagClosing) {

    1558. 

  1558. 								levelCurrent--;

    1559. 

  1559. 							} else {

    1560. 

  1560. 								levelCurrent++;

    1561. 

  1561. 							}

    1562. 

  1562. 						}

    1563. 

  1563. 						tagClosing = false;

    1564. 

  1564. 					} else {

    1565. 

  1565. 						state = SCE_H_OTHER;

    1566. 

  1566. 					}

    1567. 

  1567. 				}

    1568. 

  1568. 			}

    1569. 

  1569. 			break;

    1570. 

  1570. 		case SCE_HJ_DEFAULT:

    1571. 

  1571. 		case SCE_HJ_START:

    1572. 

  1572. 		case SCE_HJ_SYMBOLS:

    1573. 

  1573. 			if (IsAWordStart(ch)) {

    1574. 

  1574. 				styler.ColourTo(i - 1, StateToPrint);

    1575. 

  1575. 				state = SCE_HJ_WORD;

    1576. 

  1576. 			} else if (ch == '/' && chNext == '*') {

    1577. 

  1577. 				styler.ColourTo(i - 1, StateToPrint);

    1578. 

  1578. 				if (chNext2 == '*')

    1579. 

  1579. 					state = SCE_HJ_COMMENTDOC;

    1580. 

  1580. 				else

    1581. 

  1581. 					state = SCE_HJ_COMMENT;

    1582. 

  1582. 				if (chNext2 == '/') {

    1583. 

  1583. 					// Eat the * so it isn't used for the end of the comment

    1584. 

  1584. 					i++;

    1585. 

  1585. 				}

    1586. 

  1586. 			} else if (ch == '/' && chNext == '/') {

    1587. 

  1587. 				styler.ColourTo(i - 1, StateToPrint);

    1588. 

  1588. 				state = SCE_HJ_COMMENTLINE;

    1589. 

  1589. 			} else if (ch == '/' && setOKBeforeJSRE.Contains(chPrevNonWhite)) {

    1590. 

  1590. 				styler.ColourTo(i - 1, StateToPrint);

    1591. 

  1591. 				state = SCE_HJ_REGEX;

    1592. 

  1592. 			} else if (ch == '\"') {

    1593. 

  1593. 				styler.ColourTo(i - 1, StateToPrint);

    1594. 

  1594. 				state = SCE_HJ_DOUBLESTRING;

    1595. 

  1595. 			} else if (ch == '\'') {

    1596. 

  1596. 				styler.ColourTo(i - 1, StateToPrint);

    1597. 

  1597. 				state = SCE_HJ_SINGLESTRING;

    1598. 

  1598. 			} else if ((ch == '<') && (chNext == '!') && (chNext2 == '-') &&

    1599. 

  1599. 			           styler.SafeGetCharAt(i + 3) == '-') {

    1600. 

  1600. 				styler.ColourTo(i - 1, StateToPrint);

    1601. 

  1601. 				state = SCE_HJ_COMMENTLINE;

    1602. 

  1602. 			} else if ((ch == '-') && (chNext == '-') && (chNext2 == '>')) {

    1603. 

  1603. 				styler.ColourTo(i - 1, StateToPrint);

    1604. 

  1604. 				state = SCE_HJ_COMMENTLINE;

    1605. 

  1605. 				i += 2;

    1606. 

  1606. 			} else if (IsOperator(ch)) {

    1607. 

  1607. 				styler.ColourTo(i - 1, StateToPrint);

    1608. 

  1608. 				styler.ColourTo(i, statePrintForState(SCE_HJ_SYMBOLS, inScriptType));

    1609. 

  1609. 				state = SCE_HJ_DEFAULT;

    1610. 

  1610. 			} else if ((ch == ' ') || (ch == '\t')) {

    1611. 

  1611. 				if (state == SCE_HJ_START) {

    1612. 

  1612. 					styler.ColourTo(i - 1, StateToPrint);

    1613. 

  1613. 					state = SCE_HJ_DEFAULT;

    1614. 

  1614. 				}

    1615. 

  1615. 			}

    1616. 

  1616. 			break;

    1617. 

  1617. 		case SCE_HJ_WORD:

    1618. 

  1618. 			if (!IsAWordChar(ch)) {

    1619. 

  1619. 				classifyWordHTJS(styler.GetStartSegment(), i - 1, keywords2, styler, inScriptType);

    1620. 

  1620. 				//styler.ColourTo(i - 1, eHTJSKeyword);

    1621. 

  1621. 				state = SCE_HJ_DEFAULT;

    1622. 

  1622. 				if (ch == '/' && chNext == '*') {

    1623. 

  1623. 					if (chNext2 == '*')

    1624. 

  1624. 						state = SCE_HJ_COMMENTDOC;

    1625. 

  1625. 					else

    1626. 

  1626. 						state = SCE_HJ_COMMENT;

    1627. 

  1627. 				} else if (ch == '/' && chNext == '/') {

    1628. 

  1628. 					state = SCE_HJ_COMMENTLINE;

    1629. 

  1629. 				} else if (ch == '\"') {

    1630. 

  1630. 					state = SCE_HJ_DOUBLESTRING;

    1631. 

  1631. 				} else if (ch == '\'') {

    1632. 

  1632. 					state = SCE_HJ_SINGLESTRING;

    1633. 

  1633. 				} else if ((ch == '-') && (chNext == '-') && (chNext2 == '>')) {

    1634. 

  1634. 					styler.ColourTo(i - 1, StateToPrint);

    1635. 

  1635. 					state = SCE_HJ_COMMENTLINE;

    1636. 

  1636. 					i += 2;

    1637. 

  1637. 				} else if (IsOperator(ch)) {

    1638. 

  1638. 					styler.ColourTo(i, statePrintForState(SCE_HJ_SYMBOLS, inScriptType));

    1639. 

  1639. 					state = SCE_HJ_DEFAULT;

    1640. 

  1640. 				}

    1641. 

  1641. 			}

    1642. 

  1642. 			break;

    1643. 

  1643. 		case SCE_HJ_COMMENT:

    1644. 

  1644. 		case SCE_HJ_COMMENTDOC:

    1645. 

  1645. 			if (ch == '/' && chPrev == '*') {

    1646. 

  1646. 				styler.ColourTo(i, StateToPrint);

    1647. 

  1647. 				state = SCE_HJ_DEFAULT;

    1648. 

  1648. 				ch = ' ';

    1649. 

  1649. 			}

    1650. 

  1650. 			break;

    1651. 

  1651. 		case SCE_HJ_COMMENTLINE:

    1652. 

  1652. 			if (ch == '\r' || ch == '\n') {

    1653. 

  1653. 				styler.ColourTo(i - 1, statePrintForState(SCE_HJ_COMMENTLINE, inScriptType));

    1654. 

  1654. 				state = SCE_HJ_DEFAULT;

    1655. 

  1655. 				ch = ' ';

    1656. 

  1656. 			}

    1657. 

  1657. 			break;

    1658. 

  1658. 		case SCE_HJ_DOUBLESTRING:

    1659. 

  1659. 			if (ch == '\\') {

    1660. 

  1660. 				if (chNext == '\"' || chNext == '\'' || chNext == '\\') {

    1661. 

  1661. 					i++;

    1662. 

  1662. 				}

    1663. 

  1663. 			} else if (ch == '\"') {

    1664. 

  1664. 				styler.ColourTo(i, statePrintForState(SCE_HJ_DOUBLESTRING, inScriptType));

    1665. 

  1665. 				state = SCE_HJ_DEFAULT;

    1666. 

  1666. 			} else if ((inScriptType == eNonHtmlScript) && (ch == '-') && (chNext == '-') && (chNext2 == '>')) {

    1667. 

  1667. 				styler.ColourTo(i - 1, StateToPrint);

    1668. 

  1668. 				state = SCE_HJ_COMMENTLINE;

    1669. 

  1669. 				i += 2;

    1670. 

  1670. 			} else if (isLineEnd(ch)) {

    1671. 

  1671. 				styler.ColourTo(i - 1, StateToPrint);

    1672. 

  1672. 				state = SCE_HJ_STRINGEOL;

    1673. 

  1673. 			}

    1674. 

  1674. 			break;

    1675. 

  1675. 		case SCE_HJ_SINGLESTRING:

    1676. 

  1676. 			if (ch == '\\') {

    1677. 

  1677. 				if (chNext == '\"' || chNext == '\'' || chNext == '\\') {

    1678. 

  1678. 					i++;

    1679. 

  1679. 				}

    1680. 

  1680. 			} else if (ch == '\'') {

    1681. 

  1681. 				styler.ColourTo(i, statePrintForState(SCE_HJ_SINGLESTRING, inScriptType));

    1682. 

  1682. 				state = SCE_HJ_DEFAULT;

    1683. 

  1683. 			} else if ((inScriptType == eNonHtmlScript) && (ch == '-') && (chNext == '-') && (chNext2 == '>')) {

    1684. 

  1684. 				styler.ColourTo(i - 1, StateToPrint);

    1685. 

  1685. 				state = SCE_HJ_COMMENTLINE;

    1686. 

  1686. 				i += 2;

    1687. 

  1687. 			} else if (isLineEnd(ch)) {

    1688. 

  1688. 				styler.ColourTo(i - 1, StateToPrint);

    1689. 

  1689. 				if (chPrev != '\\' && (chPrev2 != '\\' || chPrev != '\r' || ch != '\n')) {

    1690. 

  1690. 					state = SCE_HJ_STRINGEOL;

    1691. 

  1691. 				}

    1692. 

  1692. 			}

    1693. 

  1693. 			break;

    1694. 

  1694. 		case SCE_HJ_STRINGEOL:

    1695. 

  1695. 			if (!isLineEnd(ch)) {

    1696. 

  1696. 				styler.ColourTo(i - 1, StateToPrint);

    1697. 

  1697. 				state = SCE_HJ_DEFAULT;

    1698. 

  1698. 			} else if (!isLineEnd(chNext)) {

    1699. 

  1699. 				styler.ColourTo(i, StateToPrint);

    1700. 

  1700. 				state = SCE_HJ_DEFAULT;

    1701. 

  1701. 			}

    1702. 

  1702. 			break;

    1703. 

  1703. 		case SCE_HJ_REGEX:

    1704. 

  1704. 			if (ch == '\r' || ch == '\n' || ch == '/') {

    1705. 

  1705. 				if (ch == '/') {

    1706. 

  1706. 					while (IsASCII(chNext) && islower(chNext)) {   // gobble regex flags

    1707. 

  1707. 						i++;

    1708. 

  1708. 						ch = chNext;

    1709. 

  1709. 						chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1710. 

  1710. 					}

    1711. 

  1711. 				}

    1712. 

  1712. 				styler.ColourTo(i, StateToPrint);

    1713. 

  1713. 				state = SCE_HJ_DEFAULT;

    1714. 

  1714. 			} else if (ch == '\\') {

    1715. 

  1715. 				// Gobble up the quoted character

    1716. 

  1716. 				if (chNext == '\\' || chNext == '/') {

    1717. 

  1717. 					i++;

    1718. 

  1718. 					ch = chNext;

    1719. 

  1719. 					chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1720. 

  1720. 				}

    1721. 

  1721. 			}

    1722. 

  1722. 			break;

    1723. 

  1723. 		case SCE_HB_DEFAULT:

    1724. 

  1724. 		case SCE_HB_START:

    1725. 

  1725. 			if (IsAWordStart(ch)) {

    1726. 

  1726. 				styler.ColourTo(i - 1, StateToPrint);

    1727. 

  1727. 				state = SCE_HB_WORD;

    1728. 

  1728. 			} else if (ch == '\'') {

    1729. 

  1729. 				styler.ColourTo(i - 1, StateToPrint);

    1730. 

  1730. 				state = SCE_HB_COMMENTLINE;

    1731. 

  1731. 			} else if (ch == '\"') {

    1732. 

  1732. 				styler.ColourTo(i - 1, StateToPrint);

    1733. 

  1733. 				state = SCE_HB_STRING;

    1734. 

  1734. 			} else if ((ch == '<') && (chNext == '!') && (chNext2 == '-') &&

    1735. 

  1735. 			           styler.SafeGetCharAt(i + 3) == '-') {

    1736. 

  1736. 				styler.ColourTo(i - 1, StateToPrint);

    1737. 

  1737. 				state = SCE_HB_COMMENTLINE;

    1738. 

  1738. 			} else if (IsOperator(ch)) {

    1739. 

  1739. 				styler.ColourTo(i - 1, StateToPrint);

    1740. 

  1740. 				styler.ColourTo(i, statePrintForState(SCE_HB_DEFAULT, inScriptType));

    1741. 

  1741. 				state = SCE_HB_DEFAULT;

    1742. 

  1742. 			} else if ((ch == ' ') || (ch == '\t')) {

    1743. 

  1743. 				if (state == SCE_HB_START) {

    1744. 

  1744. 					styler.ColourTo(i - 1, StateToPrint);

    1745. 

  1745. 					state = SCE_HB_DEFAULT;

    1746. 

  1746. 				}

    1747. 

  1747. 			}

    1748. 

  1748. 			break;

    1749. 

  1749. 		case SCE_HB_WORD:

    1750. 

  1750. 			if (!IsAWordChar(ch)) {

    1751. 

  1751. 				state = classifyWordHTVB(styler.GetStartSegment(), i - 1, keywords3, styler, inScriptType);

    1752. 

  1752. 				if (state == SCE_HB_DEFAULT) {

    1753. 

  1753. 					if (ch == '\"') {

    1754. 

  1754. 						state = SCE_HB_STRING;

    1755. 

  1755. 					} else if (ch == '\'') {

    1756. 

  1756. 						state = SCE_HB_COMMENTLINE;

    1757. 

  1757. 					} else if (IsOperator(ch)) {

    1758. 

  1758. 						styler.ColourTo(i, statePrintForState(SCE_HB_DEFAULT, inScriptType));

    1759. 

  1759. 						state = SCE_HB_DEFAULT;

    1760. 

  1760. 					}

    1761. 

  1761. 				}

    1762. 

  1762. 			}

    1763. 

  1763. 			break;

    1764. 

  1764. 		case SCE_HB_STRING:

    1765. 

  1765. 			if (ch == '\"') {

    1766. 

  1766. 				styler.ColourTo(i, StateToPrint);

    1767. 

  1767. 				state = SCE_HB_DEFAULT;

    1768. 

  1768. 			} else if (ch == '\r' || ch == '\n') {

    1769. 

  1769. 				styler.ColourTo(i - 1, StateToPrint);

    1770. 

  1770. 				state = SCE_HB_STRINGEOL;

    1771. 

  1771. 			}

    1772. 

  1772. 			break;

    1773. 

  1773. 		case SCE_HB_COMMENTLINE:

    1774. 

  1774. 			if (ch == '\r' || ch == '\n') {

    1775. 

  1775. 				styler.ColourTo(i - 1, StateToPrint);

    1776. 

  1776. 				state = SCE_HB_DEFAULT;

    1777. 

  1777. 			}

    1778. 

  1778. 			break;

    1779. 

  1779. 		case SCE_HB_STRINGEOL:

    1780. 

  1780. 			if (!isLineEnd(ch)) {

    1781. 

  1781. 				styler.ColourTo(i - 1, StateToPrint);

    1782. 

  1782. 				state = SCE_HB_DEFAULT;

    1783. 

  1783. 			} else if (!isLineEnd(chNext)) {

    1784. 

  1784. 				styler.ColourTo(i, StateToPrint);

    1785. 

  1785. 				state = SCE_HB_DEFAULT;

    1786. 

  1786. 			}

    1787. 

  1787. 			break;

    1788. 

  1788. 		case SCE_HP_DEFAULT:

    1789. 

  1789. 		case SCE_HP_START:

    1790. 

  1790. 			if (IsAWordStart(ch)) {

    1791. 

  1791. 				styler.ColourTo(i - 1, StateToPrint);

    1792. 

  1792. 				state = SCE_HP_WORD;

    1793. 

  1793. 			} else if ((ch == '<') && (chNext == '!') && (chNext2 == '-') &&

    1794. 

  1794. 			           styler.SafeGetCharAt(i + 3) == '-') {

    1795. 

  1795. 				styler.ColourTo(i - 1, StateToPrint);

    1796. 

  1796. 				state = SCE_HP_COMMENTLINE;

    1797. 

  1797. 			} else if (ch == '#') {

    1798. 

  1798. 				styler.ColourTo(i - 1, StateToPrint);

    1799. 

  1799. 				state = SCE_HP_COMMENTLINE;

    1800. 

  1800. 			} else if (ch == '\"') {

    1801. 

  1801. 				styler.ColourTo(i - 1, StateToPrint);

    1802. 

  1802. 				if (chNext == '\"' && chNext2 == '\"') {

    1803. 

  1803. 					i += 2;

    1804. 

  1804. 					state = SCE_HP_TRIPLEDOUBLE;

    1805. 

  1805. 					ch = ' ';

    1806. 

  1806. 					chPrev = ' ';

    1807. 

  1807. 					chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1808. 

  1808. 				} else {

    1809. 

  1809. 					//					state = statePrintForState(SCE_HP_STRING,inScriptType);

    1810. 

  1810. 					state = SCE_HP_STRING;

    1811. 

  1811. 				}

    1812. 

  1812. 			} else if (ch == '\'') {

    1813. 

  1813. 				styler.ColourTo(i - 1, StateToPrint);

    1814. 

  1814. 				if (chNext == '\'' && chNext2 == '\'') {

    1815. 

  1815. 					i += 2;

    1816. 

  1816. 					state = SCE_HP_TRIPLE;

    1817. 

  1817. 					ch = ' ';

    1818. 

  1818. 					chPrev = ' ';

    1819. 

  1819. 					chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1820. 

  1820. 				} else {

    1821. 

  1821. 					state = SCE_HP_CHARACTER;

    1822. 

  1822. 				}

    1823. 

  1823. 			} else if (IsOperator(ch)) {

    1824. 

  1824. 				styler.ColourTo(i - 1, StateToPrint);

    1825. 

  1825. 				styler.ColourTo(i, statePrintForState(SCE_HP_OPERATOR, inScriptType));

    1826. 

  1826. 			} else if ((ch == ' ') || (ch == '\t')) {

    1827. 

  1827. 				if (state == SCE_HP_START) {

    1828. 

  1828. 					styler.ColourTo(i - 1, StateToPrint);

    1829. 

  1829. 					state = SCE_HP_DEFAULT;

    1830. 

  1830. 				}

    1831. 

  1831. 			}

    1832. 

  1832. 			break;

    1833. 

  1833. 		case SCE_HP_WORD:

    1834. 

  1834. 			if (!IsAWordChar(ch)) {

    1835. 

  1835. 				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);

    1836. 

  1836. 				state = SCE_HP_DEFAULT;

    1837. 

  1837. 				if (ch == '#') {

    1838. 

  1838. 					state = SCE_HP_COMMENTLINE;

    1839. 

  1839. 				} else if (ch == '\"') {

    1840. 

  1840. 					if (chNext == '\"' && chNext2 == '\"') {

    1841. 

  1841. 						i += 2;

    1842. 

  1842. 						state = SCE_HP_TRIPLEDOUBLE;

    1843. 

  1843. 						ch = ' ';

    1844. 

  1844. 						chPrev = ' ';

    1845. 

  1845. 						chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1846. 

  1846. 					} else {

    1847. 

  1847. 						state = SCE_HP_STRING;

    1848. 

  1848. 					}

    1849. 

  1849. 				} else if (ch == '\'') {

    1850. 

  1850. 					if (chNext == '\'' && chNext2 == '\'') {

    1851. 

  1851. 						i += 2;

    1852. 

  1852. 						state = SCE_HP_TRIPLE;

    1853. 

  1853. 						ch = ' ';

    1854. 

  1854. 						chPrev = ' ';

    1855. 

  1855. 						chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1856. 

  1856. 					} else {

    1857. 

  1857. 						state = SCE_HP_CHARACTER;

    1858. 

  1858. 					}

    1859. 

  1859. 				} else if (IsOperator(ch)) {

    1860. 

  1860. 					styler.ColourTo(i, statePrintForState(SCE_HP_OPERATOR, inScriptType));

    1861. 

  1861. 				}

    1862. 

  1862. 			}

    1863. 

  1863. 			break;

    1864. 

  1864. 		case SCE_HP_COMMENTLINE:

    1865. 

  1865. 			if (ch == '\r' || ch == '\n') {

    1866. 

  1866. 				styler.ColourTo(i - 1, StateToPrint);

    1867. 

  1867. 				state = SCE_HP_DEFAULT;

    1868. 

  1868. 			}

    1869. 

  1869. 			break;

    1870. 

  1870. 		case SCE_HP_STRING:

    1871. 

  1871. 			if (ch == '\\') {

    1872. 

  1872. 				if (chNext == '\"' || chNext == '\'' || chNext == '\\') {

    1873. 

  1873. 					i++;

    1874. 

  1874. 					ch = chNext;

    1875. 

  1875. 					chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1876. 

  1876. 				}

    1877. 

  1877. 			} else if (ch == '\"') {

    1878. 

  1878. 				styler.ColourTo(i, StateToPrint);

    1879. 

  1879. 				state = SCE_HP_DEFAULT;

    1880. 

  1880. 			}

    1881. 

  1881. 			break;

    1882. 

  1882. 		case SCE_HP_CHARACTER:

    1883. 

  1883. 			if (ch == '\\') {

    1884. 

  1884. 				if (chNext == '\"' || chNext == '\'' || chNext == '\\') {

    1885. 

  1885. 					i++;

    1886. 

  1886. 					ch = chNext;

    1887. 

  1887. 					chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));

    1888. 

  1888. 				}

    1889. 

  1889. 			} else if (ch == '\'') {

    1890. 

  1890. 				styler.ColourTo(i, StateToPrint);

    1891. 

  1891. 				state = SCE_HP_DEFAULT;

    1892. 

  1892. 			}

    1893. 

  1893. 			break;

    1894. 

  1894. 		case SCE_HP_TRIPLE:

    1895. 

  1895. 			if (ch == '\'' && chPrev == '\'' && chPrev2 == '\'') {

    1896. 

  1896. 				styler.ColourTo(i, StateToPrint);

    1897. 

  1897. 				state = SCE_HP_DEFAULT;

    1898. 

  1898. 			}

    1899. 

  1899. 			break;

    1900. 

  1900. 		case SCE_HP_TRIPLEDOUBLE:

    1901. 

  1901. 			if (ch == '\"' && chPrev == '\"' && chPrev2 == '\"') {

    1902. 

  1902. 				styler.ColourTo(i, StateToPrint);

    1903. 

  1903. 				state = SCE_HP_DEFAULT;

    1904. 

  1904. 			}

    1905. 

  1905. 			break;

    1906. 

  1906. 			///////////// start - PHP state handling

    1907. 

  1907. 		case SCE_HPHP_WORD:

    1908. 

  1908. 			if (!IsAWordChar(ch)) {

    1909. 

  1909. 				classifyWordHTPHP(styler.GetStartSegment(), i - 1, keywords5, styler);

    1910. 

  1910. 				if (ch == '/' && chNext == '*') {

    1911. 

  1911. 					i++;

    1912. 

  1912. 					state = SCE_HPHP_COMMENT;

    1913. 

  1913. 				} else if (ch == '/' && chNext == '/') {

    1914. 

  1914. 					i++;

    1915. 

  1915. 					state = SCE_HPHP_COMMENTLINE;

    1916. 

  1916. 				} else if (ch == '#') {

    1917. 

  1917. 					state = SCE_HPHP_COMMENTLINE;

    1918. 

  1918. 				} else if (ch == '\"') {

    1919. 

  1919. 					state = SCE_HPHP_HSTRING;

    1920. 

  1920. 					StringCopy(phpStringDelimiter, "\"");

    1921. 

  1921. 				} else if (styler.Match(i, "<<<")) {

    1922. 

  1922. 					bool isSimpleString = false;

    1923. 

  1923. 					i = FindPhpStringDelimiter(phpStringDelimiter, sizeof(phpStringDelimiter), i + 3, lengthDoc, styler, isSimpleString);

    1924. 

  1924. 					if (strlen(phpStringDelimiter)) {

    1925. 

  1925. 						state = (isSimpleString ? SCE_HPHP_SIMPLESTRING : SCE_HPHP_HSTRING);

    1926. 

  1926. 						if (foldHeredoc) levelCurrent++;

    1927. 

  1927. 					}

    1928. 

  1928. 				} else if (ch == '\'') {

    1929. 

  1929. 					state = SCE_HPHP_SIMPLESTRING;

    1930. 

  1930. 					StringCopy(phpStringDelimiter, "\'");

    1931. 

  1931. 				} else if (ch == '$' && IsPhpWordStart(chNext)) {

    1932. 

  1932. 					state = SCE_HPHP_VARIABLE;

    1933. 

  1933. 				} else if (IsOperator(ch)) {

    1934. 

  1934. 					state = SCE_HPHP_OPERATOR;

    1935. 

  1935. 				} else {

    1936. 

  1936. 					state = SCE_HPHP_DEFAULT;

    1937. 

  1937. 				}

    1938. 

  1938. 			}

    1939. 

  1939. 			break;

    1940. 

  1940. 		case SCE_HPHP_NUMBER:

    1941. 

  1941. 			// recognize bases 8,10 or 16 integers OR floating-point numbers

    1942. 

  1942. 			if (!IsADigit(ch)

    1943. 

  1943. 				&& strchr(".xXabcdefABCDEF", ch) == NULL

    1944. 

  1944. 				&& ((ch != '-' && ch != '+') || (chPrev != 'e' && chPrev != 'E'))) {

    1945. 

  1945. 				styler.ColourTo(i - 1, SCE_HPHP_NUMBER);

    1946. 

  1946. 				if (IsOperator(ch))

    1947. 

  1947. 					state = SCE_HPHP_OPERATOR;

    1948. 

  1948. 				else

    1949. 

  1949. 					state = SCE_HPHP_DEFAULT;

    1950. 

  1950. 			}

    1951. 

  1951. 			break;

    1952. 

  1952. 		case SCE_HPHP_VARIABLE:

    1953. 

  1953. 			if (!IsPhpWordChar(chNext)) {

    1954. 

  1954. 				styler.ColourTo(i, SCE_HPHP_VARIABLE);

    1955. 

  1955. 				state = SCE_HPHP_DEFAULT;

    1956. 

  1956. 			}

    1957. 

  1957. 			break;

    1958. 

  1958. 		case SCE_HPHP_COMMENT:

    1959. 

  1959. 			if (ch == '/' && chPrev == '*') {

    1960. 

  1960. 				styler.ColourTo(i, StateToPrint);

    1961. 

  1961. 				state = SCE_HPHP_DEFAULT;

    1962. 

  1962. 			}

    1963. 

  1963. 			break;

    1964. 

  1964. 		case SCE_HPHP_COMMENTLINE:

    1965. 

  1965. 			if (ch == '\r' || ch == '\n') {

    1966. 

  1966. 				styler.ColourTo(i - 1, StateToPrint);

    1967. 

  1967. 				state = SCE_HPHP_DEFAULT;

    1968. 

  1968. 			}

    1969. 

  1969. 			break;

    1970. 

  1970. 		case SCE_HPHP_HSTRING:

    1971. 

  1971. 			if (ch == '\\' && (phpStringDelimiter[0] == '\"' || chNext == '$' || chNext == '{')) {

    1972. 

  1972. 				// skip the next char

    1973. 

  1973. 				i++;

    1974. 

  1974. 			} else if (((ch == '{' && chNext == '$') || (ch == '$' && chNext == '{'))

    1975. 

  1975. 				&& IsPhpWordStart(chNext2)) {

    1976. 

  1976. 				styler.ColourTo(i - 1, StateToPrint);

    1977. 

  1977. 				state = SCE_HPHP_COMPLEX_VARIABLE;

    1978. 

  1978. 			} else if (ch == '$' && IsPhpWordStart(chNext)) {

    1979. 

  1979. 				styler.ColourTo(i - 1, StateToPrint);

    1980. 

  1980. 				state = SCE_HPHP_HSTRING_VARIABLE;

    1981. 

  1981. 			} else if (styler.Match(i, phpStringDelimiter)) {

    1982. 

  1982. 				if (phpStringDelimiter[0] == '\"') {

    1983. 

  1983. 					styler.ColourTo(i, StateToPrint);

    1984. 

  1984. 					state = SCE_HPHP_DEFAULT;

    1985. 

  1985. 				} else if (isLineEnd(chPrev)) {

    1986. 

  1986. 					const int psdLength = static_cast<int>(strlen(phpStringDelimiter));

    1987. 

  1987. 					const char chAfterPsd = styler.SafeGetCharAt(i + psdLength);

    1988. 

  1988. 					const char chAfterPsd2 = styler.SafeGetCharAt(i + psdLength + 1);

    1989. 

  1989. 					if (isLineEnd(chAfterPsd) ||

    1990. 

  1990. 						(chAfterPsd == ';' && isLineEnd(chAfterPsd2))) {

    1991. 

  1991. 							i += (((i + psdLength) < lengthDoc) ? psdLength : lengthDoc) - 1;

    1992. 

  1992. 						styler.ColourTo(i, StateToPrint);

    1993. 

  1993. 						state = SCE_HPHP_DEFAULT;

    1994. 

  1994. 						if (foldHeredoc) levelCurrent--;

    1995. 

  1995. 					}

    1996. 

  1996. 				}

    1997. 

  1997. 			}

    1998. 

  1998. 			break;

    1999. 

  1999. 		case SCE_HPHP_SIMPLESTRING:

    2000. 

  2000. 			if (phpStringDelimiter[0] == '\'') {

    2001. 

  2001. 				if (ch == '\\') {

    2002. 

  2002. 					// skip the next char

    2003. 

  2003. 					i++;

    2004. 

  2004. 				} else if (ch == '\'') {

    2005. 

  2005. 					styler.ColourTo(i, StateToPrint);

    2006. 

  2006. 					state = SCE_HPHP_DEFAULT;

    2007. 

  2007. 				}

    2008. 

  2008. 			} else if (isLineEnd(chPrev) && styler.Match(i, phpStringDelimiter)) {

    2009. 

  2009. 				const int psdLength = static_cast<int>(strlen(phpStringDelimiter));

    2010. 

  2010. 				const char chAfterPsd = styler.SafeGetCharAt(i + psdLength);

    2011. 

  2011. 				const char chAfterPsd2 = styler.SafeGetCharAt(i + psdLength + 1);

    2012. 

  2012. 				if (isLineEnd(chAfterPsd) ||

    2013. 

  2013. 				(chAfterPsd == ';' && isLineEnd(chAfterPsd2))) {

    2014. 

  2014. 					i += (((i + psdLength) < lengthDoc) ? psdLength : lengthDoc) - 1;

    2015. 

  2015. 					styler.ColourTo(i, StateToPrint);

    2016. 

  2016. 					state = SCE_HPHP_DEFAULT;

    2017. 

  2017. 					if (foldHeredoc) levelCurrent--;

    2018. 

  2018. 				}

    2019. 

  2019. 			}

    2020. 

  2020. 			break;

    2021. 

  2021. 		case SCE_HPHP_HSTRING_VARIABLE:

    2022. 

  2022. 			if (!IsPhpWordChar(chNext)) {

    2023. 

  2023. 				styler.ColourTo(i, StateToPrint);

    2024. 

  2024. 				state = SCE_HPHP_HSTRING;

    2025. 

  2025. 			}

    2026. 

  2026. 			break;

    2027. 

  2027. 		case SCE_HPHP_COMPLEX_VARIABLE:

    2028. 

  2028. 			if (ch == '}') {

    2029. 

  2029. 				styler.ColourTo(i, StateToPrint);

    2030. 

  2030. 				state = SCE_HPHP_HSTRING;

    2031. 

  2031. 			}

    2032. 

  2032. 			break;

    2033. 

  2033. 		case SCE_HPHP_OPERATOR:

    2034. 

  2034. 		case SCE_HPHP_DEFAULT:

    2035. 

  2035. 			styler.ColourTo(i - 1, StateToPrint);

    2036. 

  2036. 			if (IsADigit(ch) || (ch == '.' && IsADigit(chNext))) {

    2037. 

  2037. 				state = SCE_HPHP_NUMBER;

    2038. 

  2038. 			} else if (IsAWordStart(ch)) {

    2039. 

  2039. 				state = SCE_HPHP_WORD;

    2040. 

  2040. 			} else if (ch == '/' && chNext == '*') {

    2041. 

  2041. 				i++;

    2042. 

  2042. 				state = SCE_HPHP_COMMENT;

    2043. 

  2043. 			} else if (ch == '/' && chNext == '/') {

    2044. 

  2044. 				i++;

    2045. 

  2045. 				state = SCE_HPHP_COMMENTLINE;

    2046. 

  2046. 			} else if (ch == '#') {

    2047. 

  2047. 				state = SCE_HPHP_COMMENTLINE;

    2048. 

  2048. 			} else if (ch == '\"') {

    2049. 

  2049. 				state = SCE_HPHP_HSTRING;

    2050. 

  2050. 				StringCopy(phpStringDelimiter, "\"");

    2051. 

  2051. 			} else if (styler.Match(i, "<<<")) {

    2052. 

  2052. 				bool isSimpleString = false;

    2053. 

  2053. 				i = FindPhpStringDelimiter(phpStringDelimiter, sizeof(phpStringDelimiter), i + 3, lengthDoc, styler, isSimpleString);

    2054. 

  2054. 				if (strlen(phpStringDelimiter)) {

    2055. 

  2055. 					state = (isSimpleString ? SCE_HPHP_SIMPLESTRING : SCE_HPHP_HSTRING);

    2056. 

  2056. 					if (foldHeredoc) levelCurrent++;

    2057. 

  2057. 				}

    2058. 

  2058. 			} else if (ch == '\'') {

    2059. 

  2059. 				state = SCE_HPHP_SIMPLESTRING;

    2060. 

  2060. 				StringCopy(phpStringDelimiter, "\'");

    2061. 

  2061. 			} else if (ch == '$' && IsPhpWordStart(chNext)) {

    2062. 

  2062. 				state = SCE_HPHP_VARIABLE;

    2063. 

  2063. 			} else if (IsOperator(ch)) {

    2064. 

  2064. 				state = SCE_HPHP_OPERATOR;

    2065. 

  2065. 			} else if ((state == SCE_HPHP_OPERATOR) && (IsASpace(ch))) {

    2066. 

  2066. 				state = SCE_HPHP_DEFAULT;

    2067. 

  2067. 			}

    2068. 

  2068. 			break;

    2069. 

  2069. 			///////////// end - PHP state handling

    2070. 

  2070. 		}

    2071. 

  2071. 

    2072. 

  2072. 		// Some of the above terminated their lexeme but since the same character starts

    2073. 

  2073. 		// the same class again, only reenter if non empty segment.

    2074. 

  2074. 

    2075. 

  2075. 		bool nonEmptySegment = i >= static_cast<int>(styler.GetStartSegment());

    2076. 

  2076. 		if (state == SCE_HB_DEFAULT) {    // One of the above succeeded

    2077. 

  2077. 			if ((ch == '\"') && (nonEmptySegment)) {

    2078. 

  2078. 				state = SCE_HB_STRING;

    2079. 

  2079. 			} else if (ch == '\'') {

    2080. 

  2080. 				state = SCE_HB_COMMENTLINE;

    2081. 

  2081. 			} else if (IsAWordStart(ch)) {

    2082. 

  2082. 				state = SCE_HB_WORD;

    2083. 

  2083. 			} else if (IsOperator(ch)) {

    2084. 

  2084. 				styler.ColourTo(i, SCE_HB_DEFAULT);

    2085. 

  2085. 			}

    2086. 

  2086. 		} else if (state == SCE_HBA_DEFAULT) {    // One of the above succeeded

    2087. 

  2087. 			if ((ch == '\"') && (nonEmptySegment)) {

    2088. 

  2088. 				state = SCE_HBA_STRING;

    2089. 

  2089. 			} else if (ch == '\'') {

    2090. 

  2090. 				state = SCE_HBA_COMMENTLINE;

    2091. 

  2091. 			} else if (IsAWordStart(ch)) {

    2092. 

  2092. 				state = SCE_HBA_WORD;

    2093. 

  2093. 			} else if (IsOperator(ch)) {

    2094. 

  2094. 				styler.ColourTo(i, SCE_HBA_DEFAULT);

    2095. 

  2095. 			}

    2096. 

  2096. 		} else if (state == SCE_HJ_DEFAULT) {    // One of the above succeeded

    2097. 

  2097. 			if (ch == '/' && chNext == '*') {

    2098. 

  2098. 				if (styler.SafeGetCharAt(i + 2) == '*')

    2099. 

  2099. 					state = SCE_HJ_COMMENTDOC;

    2100. 

  2100. 				else

    2101. 

  2101. 					state = SCE_HJ_COMMENT;

    2102. 

  2102. 			} else if (ch == '/' && chNext == '/') {

    2103. 

  2103. 				state = SCE_HJ_COMMENTLINE;

    2104. 

  2104. 			} else if ((ch == '\"') && (nonEmptySegment)) {

    2105. 

  2105. 				state = SCE_HJ_DOUBLESTRING;

    2106. 

  2106. 			} else if ((ch == '\'') && (nonEmptySegment)) {

    2107. 

  2107. 				state = SCE_HJ_SINGLESTRING;

    2108. 

  2108. 			} else if (IsAWordStart(ch)) {

    2109. 

  2109. 				state = SCE_HJ_WORD;

    2110. 

  2110. 			} else if (IsOperator(ch)) {

    2111. 

  2111. 				styler.ColourTo(i, statePrintForState(SCE_HJ_SYMBOLS, inScriptType));

    2112. 

  2112. 			}

    2113. 

  2113. 		}

    2114. 

  2114. 	}

    2115. 

  2115. 

    2116. 

  2116. 	switch (state) {

    2117. 

  2117. 	case SCE_HJ_WORD:

    2118. 

  2118. 		classifyWordHTJS(styler.GetStartSegment(), lengthDoc - 1, keywords2, styler, inScriptType);

    2119. 

  2119. 		break;

    2120. 

  2120. 	case SCE_HB_WORD:

    2121. 

  2121. 		classifyWordHTVB(styler.GetStartSegment(), lengthDoc - 1, keywords3, styler, inScriptType);

    2122. 

  2122. 		break;

    2123. 

  2123. 	case SCE_HP_WORD:

    2124. 

  2124. 		classifyWordHTPy(styler.GetStartSegment(), lengthDoc - 1, keywords4, styler, prevWord, inScriptType, isMako);

    2125. 

  2125. 		break;

    2126. 

  2126. 	case SCE_HPHP_WORD:

    2127. 

  2127. 		classifyWordHTPHP(styler.GetStartSegment(), lengthDoc - 1, keywords5, styler);

    2128. 

  2128. 		break;

    2129. 

  2129. 	default:

    2130. 

  2130. 		StateToPrint = statePrintForState(state, inScriptType);

    2131. 

  2131. 		if (static_cast<int>(styler.GetStartSegment()) < lengthDoc)

    2132. 

  2132. 			styler.ColourTo(lengthDoc - 1, StateToPrint);

    2133. 

  2133. 		break;

    2134. 

  2134. 	}

    2135. 

  2135. 

    2136. 

  2136. 	// Fill in the real level of the next line, keeping the current flags as they will be filled in later

    2137. 

  2137. 	if (fold) {

    2138. 

  2138. 		int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;

    2139. 

  2139. 		styler.SetLevel(lineCurrent, levelPrev | flagsNext);

    2140. 

  2140. 	}

    2141. 

  2141. }

    2142. 

  2142. 

    2143. 

  2143. static void ColouriseXMLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],

    2144. 

  2144.                                   Accessor &styler) {

    2145. 

  2145. 	// Passing in true because we're lexing XML

    2146. 

  2146. 	ColouriseHyperTextDoc(startPos, length, initStyle, keywordlists, styler, true);

    2147. 

  2147. }

    2148. 

  2148. 

    2149. 

  2149. static void ColouriseHTMLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],

    2150. 

  2150.                                   Accessor &styler) {

    2151. 

  2151. 	// Passing in false because we're notlexing XML

    2152. 

  2152. 	ColouriseHyperTextDoc(startPos, length, initStyle, keywordlists, styler, false);

    2153. 

  2153. }

    2154. 

  2154. 

    2155. 

  2155. static void ColourisePHPScriptDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],

    2156. 

  2156.         Accessor &styler) {

    2157. 

  2157. 	if (startPos == 0)

    2158. 

  2158. 		initStyle = SCE_HPHP_DEFAULT;

    2159. 

  2159. 	ColouriseHTMLDoc(startPos, length, initStyle, keywordlists, styler);

    2160. 

  2160. }

    2161. 

  2161. 

    2162. 

  2162. static const char * const htmlWordListDesc[] = {

    2163. 

  2163. 	"HTML elements and attributes",

    2164. 

  2164. 	"JavaScript keywords",

    2165. 

  2165. 	"VBScript keywords",

    2166. 

  2166. 	"Python keywords",

    2167. 

  2167. 	"PHP keywords",

    2168. 

  2168. 	"SGML and DTD keywords",

    2169. 

  2169. 	0,

    2170. 

  2170. };

    2171. 

  2171. 

    2172. 

  2172. static const char * const phpscriptWordListDesc[] = {

    2173. 

  2173. 	"", //Unused

    2174. 

  2174. 	"", //Unused

    2175. 

  2175. 	"", //Unused

    2176. 

  2176. 	"", //Unused

    2177. 

  2177. 	"PHP keywords",

    2178. 

  2178. 	"", //Unused

    2179. 

  2179. 	0,

    2180. 

  2180. };

    2181. 

  2181. 

    2182. 

  2182. LexerModule lmHTML(SCLEX_HTML, ColouriseHTMLDoc, "hypertext", 0, htmlWordListDesc);

    2183. 

  2183. LexerModule lmXML(SCLEX_XML, ColouriseXMLDoc, "xml", 0, htmlWordListDesc);

    2184. 

  2184. LexerModule lmPHPSCRIPT(SCLEX_PHPSCRIPT, ColourisePHPScriptDoc, "phpscript", 0, phpscriptWordListDesc);

    2185. 

  2185.