PageRenderTime 57ms CodeModel.GetById 14ms RepoModel.GetById 1ms app.codeStats 0ms

/scintilla/lexers/LexHTML.cxx

https://github.com/npp-community/notepad-plus-svn-mirror
C++ | 2165 lines | 1934 code | 119 blank | 112 comment | 1426 complexity | 2eeb6d160c613dbfe23c37fd8f6be0d9 MD5 | raw file
    

  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 "WordList.h"

    20. 

  20. #include "LexAccessor.h"

    21. 

  21. #include "Accessor.h"

    22. 

  22. #include "StyleContext.h"

    23. 

  23. #include "CharacterSet.h"

    24. 

  24. #include "LexerModule.h"

    25. 

  25. 

    26. 

  26. #ifdef SCI_NAMESPACE

    27. 

  27. using namespace Scintilla;

    28. 

  28. #endif

    29. 

  29. 

    30. 

  30. #define SCE_HA_JS (SCE_HJA_START - SCE_HJ_START)

    31. 

  31. #define SCE_HA_VBS (SCE_HBA_START - SCE_HB_START)

    32. 

  32. #define SCE_HA_PYTHON (SCE_HPA_START - SCE_HP_START)

    33. 

  33. 

    34. 

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

    35. 

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

    36. 

  36. 

    37. 

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

    38. 

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

    39. 

  39. }

    40. 

  40. 

    41. 

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

    42. 

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

    43. 

  43. }

    44. 

  44. 

    45. 

  45. inline bool IsOperator(int ch) {

    46. 

  46. 	if (isascii(ch) && isalnum(ch))

    47. 

  47. 		return false;

    48. 

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

    49. 

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

    50. 

  50. 	        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. 		return true;

    56. 

  56. 	return false;

    57. 

  57. }

    58. 

  58. 

    59. 

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

    60. 

  60. 	size_t i = 0;

    61. 

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

    62. 

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

    63. 

  63. 	}

    64. 

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

    65. 

  65. }

    66. 

  66. 

    67. 

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

    68. 

  68. 

    69. 

  69. 	size_t i = 0;

    70. 

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

    71. 

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

    72. 

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

    73. 

  73. 			break;

    74. 

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

    75. 

  75. 			break;

    76. 

  76. 		s[i] = ch;

    77. 

  77. 	}

    78. 

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

    79. 

  79. 

    80. 

  80. 	return s;

    81. 

  81. }

    82. 

  82. 

    83. 

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

    84. 

  84. 	char s[100];

    85. 

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

    86. 

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

    87. 

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

    88. 

  88. 		//return eScriptNone;

    89. 

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

    90. 

  90. 		return eScriptVBS;

    91. 

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

    92. 

  92. 		return eScriptPython;

    93. 

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

    94. 

  94. 		return eScriptJS;

    95. 

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

    96. 

  96. 		return eScriptJS;

    97. 

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

    98. 

  98. 		return eScriptPHP;

    99. 

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

    100. 

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

    101. 

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

    102. 

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

    103. 

  103. 				return prevValue;

    104. 

  104. 			}

    105. 

  105. 		}

    106. 

  106. 		return eScriptXML;

    107. 

  107. 	}

    108. 

  108. 

    109. 

  109. 	return prevValue;

    110. 

  110. }

    111. 

  111. 

    112. 

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

    113. 

  113. 	int iResult = 0;

    114. 

  114. 	char s[100];

    115. 

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

    116. 

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

    117. 

  117. 		iResult = 3;

    118. 

  118. 	}

    119. 

  119. 

    120. 

  120. 	return iResult;

    121. 

  121. }

    122. 

  122. 

    123. 

  123. static script_type ScriptOfState(int state) {

    124. 

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

    125. 

  125. 		return eScriptPython;

    126. 

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

    127. 

  127. 		return eScriptVBS;

    128. 

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

    129. 

  129. 		return eScriptJS;

    130. 

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

    131. 

  131. 		return eScriptPHP;

    132. 

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

    133. 

  133. 		return eScriptSGML;

    134. 

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

    135. 

  135. 		return eScriptSGMLblock;

    136. 

  136. 	} else {

    137. 

  137. 		return eScriptNone;

    138. 

  138. 	}

    139. 

  139. }

    140. 

  140. 

    141. 

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

    142. 

  142. 	int StateToPrint = state;

    143. 

  143. 

    144. 

  144. 	if (state >= SCE_HJ_START) {

    145. 

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

    146. 

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

    147. 

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

    148. 

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

    149. 

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

    150. 

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

    151. 

  151. 		}

    152. 

  152. 	}

    153. 

  153. 

    154. 

  154. 	return StateToPrint;

    155. 

  155. }

    156. 

  156. 

    157. 

  157. static int stateForPrintState(int StateToPrint) {

    158. 

  158. 	int state;

    159. 

  159. 

    160. 

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

    161. 

  161. 		state = StateToPrint - SCE_HA_PYTHON;

    162. 

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

    163. 

  163. 		state = StateToPrint - SCE_HA_VBS;

    164. 

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

    165. 

  165. 		state = StateToPrint - SCE_HA_JS;

    166. 

  166. 	} else {

    167. 

  167. 		state = StateToPrint;

    168. 

  168. 	}

    169. 

  169. 

    170. 

  170. 	return state;

    171. 

  171. }

    172. 

  172. 

    173. 

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

    174. 

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

    175. 

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

    176. 

  176. }

    177. 

  177. 

    178. 

  178. static inline bool isStringState(int state) {

    179. 

  179. 	bool bResult;

    180. 

  180. 

    181. 

  181. 	switch (state) {

    182. 

  182. 	case SCE_HJ_DOUBLESTRING:

    183. 

  183. 	case SCE_HJ_SINGLESTRING:

    184. 

  184. 	case SCE_HJA_DOUBLESTRING:

    185. 

  185. 	case SCE_HJA_SINGLESTRING:

    186. 

  186. 	case SCE_HB_STRING:

    187. 

  187. 	case SCE_HBA_STRING:

    188. 

  188. 	case SCE_HP_STRING:

    189. 

  189. 	case SCE_HP_CHARACTER:

    190. 

  190. 	case SCE_HP_TRIPLE:

    191. 

  191. 	case SCE_HP_TRIPLEDOUBLE:

    192. 

  192. 	case SCE_HPA_STRING:

    193. 

  193. 	case SCE_HPA_CHARACTER:

    194. 

  194. 	case SCE_HPA_TRIPLE:

    195. 

  195. 	case SCE_HPA_TRIPLEDOUBLE:

    196. 

  196. 	case SCE_HPHP_HSTRING:

    197. 

  197. 	case SCE_HPHP_SIMPLESTRING:

    198. 

  198. 	case SCE_HPHP_HSTRING_VARIABLE:

    199. 

  199. 	case SCE_HPHP_COMPLEX_VARIABLE:

    200. 

  200. 		bResult = true;

    201. 

  201. 		break;

    202. 

  202. 	default :

    203. 

  203. 		bResult = false;

    204. 

  204. 		break;

    205. 

  205. 	}

    206. 

  206. 	return bResult;

    207. 

  207. }

    208. 

  208. 

    209. 

  209. static inline bool stateAllowsTermination(int state) {

    210. 

  210. 	bool allowTermination = !isStringState(state);

    211. 

  211. 	if (allowTermination) {

    212. 

  212. 		switch (state) {

    213. 

  213. 		case SCE_HB_COMMENTLINE:

    214. 

  214. 		case SCE_HPHP_COMMENT:

    215. 

  215. 		case SCE_HP_COMMENTLINE:

    216. 

  216. 		case SCE_HPA_COMMENTLINE:

    217. 

  217. 			allowTermination = false;

    218. 

  218. 		}

    219. 

  219. 	}

    220. 

  220. 	return allowTermination;

    221. 

  221. }

    222. 

  222. 

    223. 

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

    224. 

  224. static inline bool isCommentASPState(int state) {

    225. 

  225. 	bool bResult;

    226. 

  226. 

    227. 

  227. 	switch (state) {

    228. 

  228. 	case SCE_HJ_COMMENT:

    229. 

  229. 	case SCE_HJ_COMMENTLINE:

    230. 

  230. 	case SCE_HJ_COMMENTDOC:

    231. 

  231. 	case SCE_HB_COMMENTLINE:

    232. 

  232. 	case SCE_HP_COMMENTLINE:

    233. 

  233. 	case SCE_HPHP_COMMENT:

    234. 

  234. 	case SCE_HPHP_COMMENTLINE:

    235. 

  235. 		bResult = true;

    236. 

  236. 		break;

    237. 

  237. 	default :

    238. 

  238. 		bResult = false;

    239. 

  239. 		break;

    240. 

  240. 	}

    241. 

  241. 	return bResult;

    242. 

  242. }

    243. 

  243. 

    244. 

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

    245. 

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

    246. 

  246. 	char chAttr = SCE_H_ATTRIBUTEUNKNOWN;

    247. 

  247. 	if (wordIsNumber) {

    248. 

  248. 		chAttr = SCE_H_NUMBER;

    249. 

  249. 	} else {

    250. 

  250. 		char s[100];

    251. 

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

    252. 

  252. 		if (keywords.InList(s))

    253. 

  253. 			chAttr = SCE_H_ATTRIBUTE;

    254. 

  254. 	}

    255. 

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

    256. 

  256. 		// No keywords -> all are known

    257. 

  257. 		chAttr = SCE_H_ATTRIBUTE;

    258. 

  258. 	styler.ColourTo(end, chAttr);

    259. 

  259. }

    260. 

  260. 

    261. 

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

    262. 

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

    263. 

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

    264. 

  264. 	char s[30 + 2];

    265. 

  265. 	// Copy after the '<'

    266. 

  266. 	unsigned int i = 0;

    267. 

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

    268. 

  268. 		char ch = styler[cPos];

    269. 

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

    270. 

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

    271. 

  271. 		}

    272. 

  272. 	}

    273. 

  273. 

    274. 

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

    275. 

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

    276. 

  276. 	s[i] = ' ';

    277. 

  277. 	s[i+1] = '\0';

    278. 

  278. 

    279. 

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

    280. 

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

    281. 

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

    282. 

  282. 	tagDontFold = (!isXml) && (NULL != strstr("meta link img area br hr input ", s));

    283. 

  283. 

    284. 

  284. 	//now we can remove the trailing space

    285. 

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

    286. 

  286. 

    287. 

  287. 	// No keywords -> all are known

    288. 

  288. 	char chAttr = SCE_H_TAGUNKNOWN;

    289. 

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

    290. 

  290. 		chAttr = SCE_H_SGML_DEFAULT;

    291. 

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

    292. 

  292. 		chAttr = SCE_H_TAG;

    293. 

  293. 	}

    294. 

  294. 	styler.ColourTo(end, chAttr);

    295. 

  295. 	if (chAttr == SCE_H_TAG) {

    296. 

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

    297. 

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

    298. 

  298. 			bool isSelfClose = false;

    299. 

  299. 			for (unsigned int cPos = end; cPos <= end + 100; cPos++) {

    300. 

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

    301. 

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

    302. 

  302. 					break;

    303. 

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

    304. 

  304. 					isSelfClose = true;

    305. 

  305. 					break;

    306. 

  306. 				}

    307. 

  307. 			}

    308. 

  308. 

    309. 

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

    310. 

  310. 			if (!isSelfClose)

    311. 

  311. 				chAttr = SCE_H_SCRIPT;

    312. 

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

    313. 

  313. 			chAttr = SCE_H_COMMENT;

    314. 

  314. 		}

    315. 

  315. 	}

    316. 

  316. 	return chAttr;

    317. 

  317. }

    318. 

  318. 

    319. 

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

    320. 

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

    321. 

  321. 	char s[30 + 1];

    322. 

  322. 	unsigned int i = 0;

    323. 

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

    324. 

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

    325. 

  325. 	}

    326. 

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

    327. 

  327. 

    328. 

  328. 	char chAttr = SCE_HJ_WORD;

    329. 

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

    330. 

  330. 	if (wordIsNumber) {

    331. 

  331. 		chAttr = SCE_HJ_NUMBER;

    332. 

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

    333. 

  333. 		chAttr = SCE_HJ_KEYWORD;

    334. 

  334. 	}

    335. 

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

    336. 

  336. }

    337. 

  337. 

    338. 

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

    339. 

  339. 	char chAttr = SCE_HB_IDENTIFIER;

    340. 

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

    341. 

  341. 	if (wordIsNumber)

    342. 

  342. 		chAttr = SCE_HB_NUMBER;

    343. 

  343. 	else {

    344. 

  344. 		char s[100];

    345. 

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

    346. 

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

    347. 

  347. 			chAttr = SCE_HB_WORD;

    348. 

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

    349. 

  349. 				chAttr = SCE_HB_COMMENTLINE;

    350. 

  350. 		}

    351. 

  351. 	}

    352. 

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

    353. 

  353. 	if (chAttr == SCE_HB_COMMENTLINE)

    354. 

  354. 		return SCE_HB_COMMENTLINE;

    355. 

  355. 	else

    356. 

  356. 		return SCE_HB_DEFAULT;

    357. 

  357. }

    358. 

  358. 

    359. 

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

    360. 

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

    361. 

  361. 	char s[30 + 1];

    362. 

  362. 	unsigned int i = 0;

    363. 

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

    364. 

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

    365. 

  365. 	}

    366. 

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

    367. 

  367. 	char chAttr = SCE_HP_IDENTIFIER;

    368. 

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

    369. 

  369. 		chAttr = SCE_HP_CLASSNAME;

    370. 

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

    371. 

  371. 		chAttr = SCE_HP_DEFNAME;

    372. 

  372. 	else if (wordIsNumber)

    373. 

  373. 		chAttr = SCE_HP_NUMBER;

    374. 

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

    375. 

  375. 		chAttr = SCE_HP_WORD;

    376. 

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

    377. 

  377. 	strcpy(prevWord, s);

    378. 

  378. }

    379. 

  379. 

    380. 

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

    381. 

  381. // Called when in a PHP word

    382. 

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

    383. 

  383. 	char chAttr = SCE_HPHP_DEFAULT;

    384. 

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

    385. 

  385. 	if (wordIsNumber)

    386. 

  386. 		chAttr = SCE_HPHP_NUMBER;

    387. 

  387. 	else {

    388. 

  388. 		char s[100];

    389. 

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

    390. 

  390. 		if (keywords.InList(s))

    391. 

  391. 			chAttr = SCE_HPHP_WORD;

    392. 

  392. 	}

    393. 

  393. 	styler.ColourTo(end, chAttr);

    394. 

  394. }

    395. 

  395. 

    396. 

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

    397. 

  397. 	char s[30 + 1];

    398. 

  398. 	unsigned int i = 0;

    399. 

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

    400. 

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

    401. 

  401. 	}

    402. 

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

    403. 

  403. 	return keywords.InList(s);

    404. 

  404. }

    405. 

  405. 

    406. 

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

    407. 

  407. 	char s[30 + 1];

    408. 

  408. 	unsigned int i = 0;

    409. 

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

    410. 

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

    411. 

  411. 	}

    412. 

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

    413. 

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

    414. 

  414. }

    415. 

  415. 

    416. 

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

    417. 

  417. static int StateForScript(script_type scriptLanguage) {

    418. 

  418. 	int Result;

    419. 

  419. 	switch (scriptLanguage) {

    420. 

  420. 	case eScriptJS:

    421. 

  421. 		Result = SCE_HJ_START;

    422. 

  422. 		break;

    423. 

  423. 	case eScriptPython:

    424. 

  424. 		Result = SCE_HP_START;

    425. 

  425. 		break;

    426. 

  426. 	case eScriptPHP:

    427. 

  427. 		Result = SCE_HPHP_DEFAULT;

    428. 

  428. 		break;

    429. 

  429. 	case eScriptXML:

    430. 

  430. 		Result = SCE_H_TAGUNKNOWN;

    431. 

  431. 		break;

    432. 

  432. 	case eScriptSGML:

    433. 

  433. 		Result = SCE_H_SGML_DEFAULT;

    434. 

  434. 		break;

    435. 

  435. 	case eScriptComment:

    436. 

  436. 		Result = SCE_H_COMMENT;

    437. 

  437. 		break;

    438. 

  438. 	default :

    439. 

  439. 		Result = SCE_HB_START;

    440. 

  440. 		break;

    441. 

  441. 	}

    442. 

  442. 	return Result;

    443. 

  443. }

    444. 

  444. 

    445. 

  445. static inline bool ishtmlwordchar(int ch) {

    446. 

  446. 	return !isascii(ch) ||

    447. 

  447. 		(isalnum(ch) || ch == '.' || ch == '-' || ch == '_' || ch == ':' || ch == '!' || ch == '#');

    448. 

  448. }

    449. 

  449. 

    450. 

  450. static inline bool issgmlwordchar(int ch) {

    451. 

  451. 	return !isascii(ch) ||

    452. 

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

    453. 

  453. }

    454. 

  454. 

    455. 

  455. static inline bool IsPhpWordStart(int ch) {

    456. 

  456. 	return (isascii(ch) && (isalpha(ch) || (ch == '_'))) || (ch >= 0x7f);

    457. 

  457. }

    458. 

  458. 

    459. 

  459. static inline bool IsPhpWordChar(int ch) {

    460. 

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

    461. 

  461. }

    462. 

  462. 

    463. 

  463. static bool InTagState(int state) {

    464. 

  464. 	return state == SCE_H_TAG || state == SCE_H_TAGUNKNOWN ||

    465. 

  465. 	       state == SCE_H_SCRIPT ||

    466. 

  466. 	       state == SCE_H_ATTRIBUTE || state == SCE_H_ATTRIBUTEUNKNOWN ||

    467. 

  467. 	       state == SCE_H_NUMBER || state == SCE_H_OTHER ||

    468. 

  468. 	       state == SCE_H_DOUBLESTRING || state == SCE_H_SINGLESTRING;

    469. 

  469. }

    470. 

  470. 

    471. 

  471. static bool IsCommentState(const int state) {

    472. 

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

    473. 

  473. }

    474. 

  474. 

    475. 

  475. static bool IsScriptCommentState(const int state) {

    476. 

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

    477. 

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

    478. 

  478. }

    479. 

  479. 

    480. 

  480. static bool isLineEnd(int ch) {

    481. 

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

    482. 

  482. }

    483. 

  483. 

    484. 

  484. static bool isOKBeforeRE(int ch) {

    485. 

  485. 	return (ch == '(') || (ch == '=') || (ch == ',');

    486. 

  486. }

    487. 

  487. 

    488. 

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

    489. 

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

    490. 

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

    491. 

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

    492. 

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

    493. 

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

    494. 

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

    495. 

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

    496. 

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

    497. 

  497. 		return isLineEnd(ch);

    498. 

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

    499. 

  499. 		return ch == '}';

    500. 

  500. 	} else {

    501. 

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

    502. 

  502. 	}

    503. 

  503. }

    504. 

  504. 

    505. 

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

    506. 

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

    507. 

  507. 		return 0;

    508. 

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

    509. 

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

    510. 

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

    511. 

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

    512. 

  512. 	} else {

    513. 

  513. 		return 0;

    514. 

  514. 	}

    515. 

  515. }

    516. 

  516. 

    517. 

  517. static bool isPHPStringState(int state) {

    518. 

  518. 	return

    519. 

  519. 	    (state == SCE_HPHP_HSTRING) ||

    520. 

  520. 	    (state == SCE_HPHP_SIMPLESTRING) ||

    521. 

  521. 	    (state == SCE_HPHP_HSTRING_VARIABLE) ||

    522. 

  522. 	    (state == SCE_HPHP_COMPLEX_VARIABLE);

    523. 

  523. }

    524. 

  524. 

    525. 

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

    526. 

  526. 	int j;

    527. 

  527. 	const int beginning = i - 1;

    528. 

  528. 	bool isValidSimpleString = false;

    529. 

  529. 

    530. 

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

    531. 

  531. 		i++;

    532. 

  532. 

    533. 

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

    534. 

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

    535. 

  535. 	if (!IsPhpWordStart(ch)) {

    536. 

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

    537. 

  537. 			i++;

    538. 

  538. 			ch = chNext;

    539. 

  539. 			isSimpleString = true;

    540. 

  540. 		} else {

    541. 

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

    542. 

  542. 			return beginning;

    543. 

  543. 		}

    544. 

  544. 	}

    545. 

  545. 	phpStringDelimiter[0] = ch;

    546. 

  546. 	i++;

    547. 

  547. 

    548. 

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

    549. 

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

    550. 

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

    551. 

  551. 				isValidSimpleString = true;

    552. 

  552. 				j++;

    553. 

  553. 				break;

    554. 

  554. 			} else {

    555. 

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

    556. 

  556. 				return beginning;

    557. 

  557. 			}

    558. 

  558. 		}

    559. 

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

    560. 

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

    561. 

  561. 		else

    562. 

  562. 			i++;

    563. 

  563. 	}

    564. 

  564. 	if (isSimpleString && !isValidSimpleString) {

    565. 

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

    566. 

  566. 		return beginning;

    567. 

  567. 	}

    568. 

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

    569. 

  569. 	return j - 1;

    570. 

  570. }

    571. 

  571. 

    572. 

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

    573. 

  573.                                   Accessor &styler, bool isXml) {

    574. 

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

    575. 

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

    576. 

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

    577. 

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

    578. 

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

    579. 

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

    580. 

  580. 

    581. 

  581. 	// Lexer for HTML requires more lexical states (8 bits worth) than most lexers

    582. 

  582. 	styler.StartAt(startPos, static_cast<char>(STYLE_MAX));

    583. 

  583. 	char prevWord[200];

    584. 

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

    585. 

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

    586. 

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

    587. 

  587. 	int StateToPrint = initStyle;

    588. 

  588. 	int state = stateForPrintState(StateToPrint);

    589. 

  589. 	char makoBlockType[200];

    590. 

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

    591. 

  591. 	char djangoBlockType[2];

    592. 

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

    593. 

  593. 

    594. 

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

    595. 

  595. 	if (InTagState(state)) {

    596. 

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

    597. 

  597. 			startPos--;

    598. 

  598. 			length++;

    599. 

  599. 		}

    600. 

  600. 		state = SCE_H_DEFAULT;

    601. 

  601. 	}

    602. 

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

    603. 

  603. 	if (isPHPStringState(state)) {

    604. 

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

    605. 

  605. 			startPos--;

    606. 

  606. 			length++;

    607. 

  607. 			state = styler.StyleAt(startPos);

    608. 

  608. 		}

    609. 

  609. 		if (startPos == 0)

    610. 

  610. 			state = SCE_H_DEFAULT;

    611. 

  611. 	}

    612. 

  612. 	styler.StartAt(startPos, static_cast<char>(STYLE_MAX));

    613. 

  613. 

    614. 

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

    615. 

  615. 	int lineState;

    616. 

  616. 	if (lineCurrent > 0) {

    617. 

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

    618. 

  618. 	} else {

    619. 

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

    620. 

  620. 		lineState = eScriptJS << 8;

    621. 

  621. 

    622. 

  622. 		// property asp.default.language

    623. 

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

    624. 

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

    625. 

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

    626. 

  626. 	}

    627. 

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

    628. 

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

    629. 

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

    630. 

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

    631. 

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

    632. 

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

    633. 

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

    634. 

  634. 

    635. 

  635. 	script_type scriptLanguage = ScriptOfState(state);

    636. 

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

    637. 

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

    638. 

  638. 		scriptLanguage = eScriptComment;

    639. 

  639. 	}

    640. 

  640. 	script_type beforeLanguage = ScriptOfState(beforePreProc);

    641. 

  641. 

    642. 

  642. 	// property fold.html

    643. 

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

    644. 

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

    645. 

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

    646. 

  646. 

    647. 

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

    648. 

  648. 

    649. 

  649. 	// property fold.html.preprocessor

    650. 

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

    651. 

  651. 	//	The default is on.

    652. 

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

    653. 

  653. 

    654. 

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

    655. 

  655. 

    656. 

  656. 	// property fold.hypertext.comment

    657. 

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

    658. 

  658. 	//	The default is off.

    659. 

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

    660. 

  660. 

    661. 

  661. 	// property fold.hypertext.heredoc

    662. 

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

    663. 

  663. 	//	The default is off.

    664. 

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

    665. 

  665. 

    666. 

  666. 	// property html.tags.case.sensitive

    667. 

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

    668. 

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

    669. 

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

    670. 

  670. 

    671. 

  671. 	// property lexer.xml.allow.scripts

    672. 

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

    673. 

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

    674. 

  674. 

    675. 

  675. 	// property lexer.html.mako

    676. 

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

    677. 

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

    678. 

  678. 

    679. 

  679. 	// property lexer.html.django

    680. 

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

    681. 

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

    682. 

  682. 

    683. 

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

    684. 

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

    685. 

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

    686. 

  686. 

    687. 

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

    688. 

  688. 	int levelCurrent = levelPrev;

    689. 

  689. 	int visibleChars = 0;

    690. 

  690. 	int lineStartVisibleChars = 0;

    691. 

  691. 

    692. 

  692. 	int chPrev = ' ';

    693. 

  693. 	int ch = ' ';

    694. 

  694. 	int chPrevNonWhite = ' ';

    695. 

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

    696. 

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

    697. 

  697. 		int back = startPos;

    698. 

  698. 		int style = 0;

    699. 

  699. 		while (--back) {

    700. 

  700. 			style = styler.StyleAt(back);

    701. 

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

    702. 

  702. 				// includes SCE_HJ_COMMENT & SCE_HJ_COMMENTLINE

    703. 

  703. 				break;

    704. 

  704. 		}

    705. 

  705. 		if (style == SCE_HJ_SYMBOLS) {

    706. 

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

    707. 

  707. 		}

    708. 

  708. 	}

    709. 

  709. 

    710. 

  710. 	styler.StartSegment(startPos);

    711. 

  711. 	const int lengthDoc = startPos + length;

    712. 

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

    713. 

  713. 		const int chPrev2 = chPrev;

    714. 

  714. 		chPrev = ch;

    715. 

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

    716. 

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

    717. 

  717. 			chPrevNonWhite = ch;

    718. 

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

    719. 

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

    720. 

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

    721. 

  721. 

    722. 

  722. 		// Handle DBCS codepages

    723. 

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

    724. 

  724. 			chPrev = ' ';

    725. 

  725. 			i += 1;

    726. 

  726. 			continue;

    727. 

  727. 		}

    728. 

  728. 

    729. 

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

    730. 

  730. 			visibleChars++;

    731. 

  731. 		if (!IsASpace(ch))

    732. 

  732. 			lineStartVisibleChars++;

    733. 

  733. 

    734. 

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

    735. 

  735. 		StateToPrint = statePrintForState(state, inScriptType);

    736. 

  736. 

    737. 

  737. 		// handle script folding

    738. 

  738. 		if (fold) {

    739. 

  739. 			switch (scriptLanguage) {

    740. 

  740. 			case eScriptJS:

    741. 

  741. 			case eScriptPHP:

    742. 

  742. 				//not currently supported				case eScriptVBS:

    743. 

  743. 

    744. 

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

    745. 

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

    746. 

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

    747. 

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

    748. 

  748. 						int j = i + 1;

    749. 

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

    750. 

  750. 							j++;

    751. 

  751. 						}

    752. 

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

    753. 

  753. 							levelCurrent++;

    754. 

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

    755. 

  755. 							levelCurrent--;

    756. 

  756. 						}

    757. 

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

    758. 

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

    759. 

  759. 					}

    760. 

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

    761. 

  761. 					levelCurrent--;

    762. 

  762. 				}

    763. 

  763. 				break;

    764. 

  764. 			case eScriptPython:

    765. 

  765. 				if (state != SCE_HP_COMMENTLINE) {

    766. 

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

    767. 

  767. 						levelCurrent++;

    768. 

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

    769. 

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

    770. 

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

    771. 

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

    772. 

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

    773. 

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

    774. 

  774. 								Findlevel -= 8;

    775. 

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

    776. 

  776. 								Findlevel--;

    777. 

  777. 							} else {

    778. 

  778. 								break;

    779. 

  779. 							}

    780. 

  780. 						}

    781. 

  781. 

    782. 

  782. 						if (Findlevel > 0) {

    783. 

  783. 							levelCurrent -= Findlevel / 8;

    784. 

  784. 							if (Findlevel % 8)

    785. 

  785. 								levelCurrent--;

    786. 

  786. 						}

    787. 

  787. 					}

    788. 

  788. 				}

    789. 

  789. 				break;

    790. 

  790. 			default:

    791. 

  791. 				break;

    792. 

  792. 			}

    793. 

  793. 		}

    794. 

  794. 

    795. 

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

    796. 

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

    797. 

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

    798. 

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

    799. 

  799. 			if (fold) {

    800. 

  800. 				int lev = levelPrev;

    801. 

  801. 				if (visibleChars == 0)

    802. 

  802. 					lev |= SC_FOLDLEVELWHITEFLAG;

    803. 

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

    804. 

  804. 					lev |= SC_FOLDLEVELHEADERFLAG;

    805. 

  805. 

    806. 

  806. 				styler.SetLevel(lineCurrent, lev);

    807. 

  807. 				visibleChars = 0;

    808. 

  808. 				levelPrev = levelCurrent;

    809. 

  809. 			}

    810. 

  810. 			styler.SetLineState(lineCurrent,

    811. 

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

    812. 

  812. 			                    ((tagOpened & 0x01) << 2) |

    813. 

  813. 			                    ((tagClosing & 0x01) << 3) |

    814. 

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

    815. 

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

    816. 

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

    817. 

  817. 			lineCurrent++;

    818. 

  818. 			lineStartVisibleChars = 0;

    819. 

  819. 		}

    820. 

  820. 

    821. 

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

    822. 

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

    823. 

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

    824. 

  824. 		}

    825. 

  825. 

    826. 

  826. 		// generic end of script processing

    827. 

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

    828. 

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

    829. 

  829. 			switch (state) {

    830. 

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

    831. 

  831. 			case SCE_H_DOUBLESTRING:

    832. 

  832. 			case SCE_H_SINGLESTRING:

    833. 

  833. 			case SCE_HJ_COMMENT:

    834. 

  834. 			case SCE_HJ_COMMENTDOC:

    835. 

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

    836. 

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

    837. 

  837. 			case SCE_HB_COMMENTLINE:

    838. 

  838. 			case SCE_HBA_COMMENTLINE:

    839. 

  839. 			case SCE_HJ_DOUBLESTRING:

    840. 

  840. 			case SCE_HJ_SINGLESTRING:

    841. 

  841. 			case SCE_HJ_REGEX:

    842. 

  842. 			case SCE_HB_STRING:

    843. 

  843. 			case SCE_HBA_STRING:

    844. 

  844. 			case SCE_HP_STRING:

    845. 

  845. 			case SCE_HP_TRIPLE:

    846. 

  846. 			case SCE_HP_TRIPLEDOUBLE:

    847. 

  847. 			case SCE_HPHP_HSTRING:

    848. 

  848. 			case SCE_HPHP_SIMPLESTRING:

    849. 

  849. 			case SCE_HPHP_COMMENT:

    850. 

  850. 			case SCE_HPHP_COMMENTLINE:

    851. 

  851. 				break;

    852. 

  852. 			default :

    853. 

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

    854. 

  854. 				if (const char *tag =

    855. 

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

    856. 

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

    857. 

  857. 					int j = i + 2;

    858. 

  858. 					int chr;

    859. 

  859. 					do {

    860. 

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

    861. 

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

    862. 

  862. 					if (chr != 0) break;

    863. 

  863. 				}

    864. 

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

    865. 

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

    866. 

  866. 				state = SCE_H_TAGUNKNOWN;

    867. 

  867. 				inScriptType = eHtml;

    868. 

  868. 				scriptLanguage = eScriptNone;

    869. 

  869. 				clientScript = eScriptJS;

    870. 

  870. 				i += 2;

    871. 

  871. 				visibleChars += 2;

    872. 

  872. 				tagClosing = true;

    873. 

  873. 				continue;

    874. 

  874. 			}

    875. 

  875. 		}

    876. 

  876. 

    877. 

  877. 		/////////////////////////////////////

    878. 

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

    879. 

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

    880. 

  880. 		         !isPHPStringState(state) &&

    881. 

  881. 		         (state != SCE_HPHP_COMMENT) &&

    882. 

  882. 		         (state != SCE_HPHP_COMMENTLINE) &&

    883. 

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

    884. 

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

    885. 

  885. 				 !IsScriptCommentState(state)) {

    886. 

  886.  			beforeLanguage = scriptLanguage;

    887. 

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

    888. 

  888. 			if (scriptLanguage != eScriptPHP && isStringState(state)) continue;

    889. 

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

    890. 

  890. 			beforePreProc = state;

    891. 

  891. 			i++;

    892. 

  892. 			visibleChars++;

    893. 

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

    894. 

  894. 			if (scriptLanguage == eScriptXML)

    895. 

  895. 				styler.ColourTo(i, SCE_H_XMLSTART);

    896. 

  896. 			else

    897. 

  897. 				styler.ColourTo(i, SCE_H_QUESTION);

    898. 

  898. 			state = StateForScript(scriptLanguage);

    899. 

  899. 			if (inScriptType == eNonHtmlScript)

    900. 

  900. 				inScriptType = eNonHtmlScriptPreProc;

    901. 

  901. 			else

    902. 

  902. 				inScriptType = eNonHtmlPreProc;

    903. 

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

    904. 

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

    905. 

  905. 				levelCurrent++;

    906. 

  906. 			}

    907. 

  907. 			// should be better

    908. 

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

    909. 

  909. 			continue;

    910. 

  910. 		}

    911. 

  911. 

    912. 

  912. 		// handle the start Mako template Python code

    913. 

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

    914. 

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

    915. 

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

    916. 

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

    917. 

  917. 			if (ch == '%')

    918. 

  918. 				strcpy(makoBlockType, "%");

    919. 

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

    920. 

  920. 				strcpy(makoBlockType, "{");

    921. 

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

    922. 

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

    923. 

  923. 			else

    924. 

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

    925. 

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

    926. 

  926. 			beforePreProc = state;

    927. 

  927. 			if (inScriptType == eNonHtmlScript)

    928. 

  928. 				inScriptType = eNonHtmlScriptPreProc;

    929. 

  929. 			else

    930. 

  930. 				inScriptType = eNonHtmlPreProc;

    931. 

  931. 

    932. 

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

    933. 

  933. 				i += 2;

    934. 

  934. 				visibleChars += 2;

    935. 

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

    936. 

  936. 				i++;

    937. 

  937. 				visibleChars++;

    938. 

  938. 			}

    939. 

  939. 			state = SCE_HP_START;

    940. 

  940. 			scriptLanguage = eScriptPython;

    941. 

  941. 			styler.ColourTo(i, SCE_H_ASP);

    942. 

  942. 			if (foldHTMLPreprocessor && ch == '<')

    943. 

  943. 				levelCurrent++;

    944. 

  944. 

    945. 

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

    946. 

  946. 				i += strlen(makoBlockType);

    947. 

  947. 				visibleChars += strlen(makoBlockType);

    948. 

  948. 				if (keywords4.InList(makoBlockType))

    949. 

  949. 					styler.ColourTo(i, SCE_HP_WORD);

    950. 

  950. 				else

    951. 

  951. 					styler.ColourTo(i, SCE_H_TAGUNKNOWN);

    952. 

  952. 			}

    953. 

  953. 

    954. 

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

    955. 

  955. 			continue;

    956. 

  956. 		}

    957. 

  957. 

    958. 

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

    959. 

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

    960. 

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

    961. 

  961. 			beforePreProc = state;

    962. 

  962. 			beforeLanguage = scriptLanguage;

    963. 

  963. 			if (inScriptType == eNonHtmlScript)

    964. 

  964. 				inScriptType = eNonHtmlScriptPreProc;

    965. 

  965. 			else

    966. 

  966. 				inScriptType = eNonHtmlPreProc;

    967. 

  967. 			i += 1;

    968. 

  968. 			visibleChars += 1;

    969. 

  969. 			scriptLanguage = eScriptComment;

    970. 

  970. 			state = SCE_H_COMMENT;

    971. 

  971. 			styler.ColourTo(i, SCE_H_ASP);

    972. 

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

    973. 

  973. 			continue;

    974. 

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

    975. 

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

    976. 

  976. 			i += 1;

    977. 

  977. 			visibleChars += 1;

    978. 

  978. 			styler.ColourTo(i, SCE_H_ASP);

    979. 

  979. 			state = beforePreProc;

    980. 

  980. 			if (inScriptType == eNonHtmlScriptPreProc)

    981. 

  981. 				inScriptType = eNonHtmlScript;

    982. 

  982. 			else

    983. 

  983. 				inScriptType = eHtml;

    984. 

  984. 			scriptLanguage = beforeLanguage;

    985. 

  985. 			continue;

    986. 

  986. 		}

    987. 

  987. 

    988. 

  988. 		// handle the start Django template code

    989. 

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

    990. 

  990. 			if (chNext == '%')

    991. 

  991. 				strcpy(djangoBlockType, "%");

    992. 

  992. 			else

    993. 

  993. 				strcpy(djangoBlockType, "{");

    994. 

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

    995. 

  995. 			beforePreProc = state;

    996. 

  996. 			if (inScriptType == eNonHtmlScript)

    997. 

  997. 				inScriptType = eNonHtmlScriptPreProc;

    998. 

  998. 			else

    999. 

  999. 				inScriptType = eNonHtmlPreProc;

    1000. 

  1000. 

    1001. 

  1001. 			i += 1;

    1002. 

  1002. 			visibleChars += 1;

    1003. 

  1003. 			state = SCE_HP_START;

    1004. 

  1004. 			beforeLanguage = scriptLanguage;

    1005. 

  1005. 			scriptLanguage = eScriptPython;

    1006. 

  1006. 			styler.ColourTo(i, SCE_H_ASP);

    1007. 

  1007. 

    1008. 

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

    1009. 

  1009. 			continue;

    1010. 

  1010. 		}

    1011. 

  1011. 

    1012. 

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

    1013. 

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

    1014. 

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

    1015. 

  1015. 			beforePreProc = state;

    1016. 

  1016. 			if (inScriptType == eNonHtmlScript)

    1017. 

  1017. 				inScriptType = eNonHtmlScriptPreProc;

    1018. 

  1018. 			else

    1019. 

  1019. 				inScriptType = eNonHtmlPreProc;

    1020. 

  1020. 

    1021. 

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

    1022. 

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

    1023. 

  1023. 				visibleChars += 2;

    1024. 

  1024. 				state = SCE_H_ASPAT;

    1025. 

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

    1026. 

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

    1027. 

  1027. 				state = SCE_H_XCCOMMENT;

    1028. 

  1028. 				scriptLanguage = eScriptVBS;

    1029. 

  1029. 				continue;

    1030. 

  1030. 			} else {

    1031. 

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

    1032. 

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

    1033. 

  1033. 					visibleChars += 2;

    1034. 

  1034. 				} else {

    1035. 

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

    1036. 

  1036. 					visibleChars++;

    1037. 

  1037. 				}

    1038. 

  1038. 

    1039. 

  1039. 				state = StateForScript(aspScript);

    1040. 

  1040. 			}

    1041. 

  1041. 			scriptLanguage = eScriptVBS;

    1042. 

  1042. 			styler.ColourTo(i, SCE_H_ASP);

    1043. 

  1043. 			// fold whole script

    1044. 

  1044. 			if (foldHTMLPreprocessor)

    1045. 

  1045. 				levelCurrent++;

    1046. 

  1046. 			// should be better

    1047. 

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

    1048. 

  1048. 			continue;

    1049. 

  1049. 		}

    1050. 

  1050. 

    1051. 

  1051. 		/////////////////////////////////////

    1052. 

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

    1053. 

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

    1054. 

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

    1055. 

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

    1056. 

  1056. 				 (StateToPrint != SCE_H_CDATA) &&

    1057. 

  1057. 				 (!IsCommentState(StateToPrint)) &&

    1058. 

  1058. 				 (!IsScriptCommentState(StateToPrint))) {

    1059. 

  1059. 			beforePreProc = state;

    1060. 

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

    1061. 

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

    1062. 

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

    1063. 

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

    1064. 

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

    1065. 

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

    1066. 

  1066. 				state = SCE_H_CDATA;

    1067. 

  1067. 			} else {

    1068. 

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

    1069. 

  1069. 				scriptLanguage = eScriptSGML;

    1070. 

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

    1071. 

  1071. 			}

    1072. 

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

    1073. 

  1073. 			if (foldHTMLPreprocessor || (state == SCE_H_COMMENT))

    1074. 

  1074. 				levelCurrent++;

    1075. 

  1075. 			continue;

    1076. 

  1076. 		}

    1077. 

  1077. 

    1078. 

  1078. 		// handle the end of Mako Python code

    1079. 

  1079. 		else if (isMako &&

    1080. 

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

    1081. 

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

    1082. 

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

    1083. 

  1083. 			if (state == SCE_H_ASPAT) {

    1084. 

  1084. 				aspScript = segIsScriptingIndicator(styler,

    1085. 

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

    1086. 

  1086. 			}

    1087. 

  1087. 			if (state == SCE_HP_WORD) {

    1088. 

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

    1089. 

  1089. 			} else {

    1090. 

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

    1091. 

  1091. 			}

    1092. 

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

    1093. 

  1093. 				i++;

    1094. 

  1094. 				visibleChars++;

    1095. 

  1095. 		    }

    1096. 

  1096. 			if (0 != strcmp(makoBlockType, "%")) {

    1097. 

  1097. 				styler.ColourTo(i, SCE_H_ASP);

    1098. 

  1098. 			}

    1099. 

  1099. 			state = beforePreProc;

    1100. 

  1100. 			if (inScriptType == eNonHtmlScriptPreProc)

    1101. 

  1101. 				inScriptType = eNonHtmlScript;

    1102. 

  1102. 			else

    1103. 

  1103. 				inScriptType = eHtml;

    1104. 

  1104. 			if (foldHTMLPreprocessor && ch != '\n' && ch != '\r') {

    1105. 

  1105. 				levelCurrent--;

    1106. 

  1106. 			}

    1107. 

  1107. 			scriptLanguage = eScriptNone;

    1108. 

  1108. 			continue;

    1109. 

  1109. 		}

    1110. 

  1110. 

    1111. 

  1111. 		// handle the end of Django template code

    1112. 

  1112. 		else if (isDjango &&

    1113. 

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

    1114. 

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

    1115. 

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

    1116. 

  1116. 			if (state == SCE_H_ASPAT) {

    1117. 

  1117. 				aspScript = segIsScriptingIndicator(styler,

    1118. 

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

    1119. 

  1119. 			}

    1120. 

  1120. 			if (state == SCE_HP_WORD) {

    1121. 

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

    1122. 

  1122. 			} else {

    1123. 

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

    1124. 

  1124. 			}

    1125. 

  1125. 			i += 1;

    1126. 

  1126. 			visibleChars += 1;

    1127. 

  1127. 			styler.ColourTo(i, SCE_H_ASP);

    1128. 

  1128. 			state = beforePreProc;

    1129. 

  1129. 			if (inScriptType == eNonHtmlScriptPreProc)

    1130. 

  1130. 				inScriptType = eNonHtmlScript;

    1131. 

  1131. 			else

    1132. 

  1132. 				inScriptType = eHtml;

    1133. 

  1133. 			scriptLanguage = beforeLanguage;

    1134. 

  1134. 			continue;

    1135. 

  1135. 		}

    1136. 

  1136. 

    1137. 

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

    1138. 

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

    1139. 

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

    1140. 

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

    1141. 

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

    1142. 

  1142. 			if (state == SCE_H_ASPAT) {

    1143. 

  1143. 				aspScript = segIsScriptingIndicator(styler,

    1144. 

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

    1145. 

  1145. 			}

    1146. 

  1146. 			// Bounce out of any ASP mode

    1147. 

  1147. 			switch (state) {

    1148. 

  1148. 			case SCE_HJ_WORD:

    1149. 

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

    1150. 

  1150. 				break;

    1151. 

  1151. 			case SCE_HB_WORD:

    1152. 

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

    1153. 

  1153. 				break;

    1154. 

  1154. 			case SCE_HP_WORD:

    1155. 

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

    1156. 

  1156. 				break;

    1157. 

  1157. 			case SCE_HPHP_WORD:

    1158. 

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

    1159. 

  1159. 				break;

    1160. 

  1160. 			case SCE_H_XCCOMMENT:

    1161. 

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

    1162. 

  1162. 				break;

    1163. 

  1163. 			default :

    1164. 

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

    1165. 

  1165. 				break;

    1166. 

  1166. 			}

    1167. 

  1167. 			if (scriptLanguage != eScriptSGML) {

    1168. 

  1168. 				i++;

    1169. 

  1169. 				visibleChars++;

    1170. 

  1170. 			}

    1171. 

  1171. 			if (ch == '%')

    1172. 

  1172. 				styler.ColourTo(i, SCE_H_ASP);

    1173. 

  1173. 			else if (scriptLanguage == eScriptXML)

    1174. 

  1174. 				styler.ColourTo(i, SCE_H_XMLEND);

    1175. 

  1175. 			else if (scriptLanguage == eScriptSGML)

    1176. 

  1176. 				styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1177. 

  1177. 			else

    1178. 

  1178. 				styler.ColourTo(i, SCE_H_QUESTION);

    1179. 

  1179. 			state = beforePreProc;

    1180. 

  1180. 			if (inScriptType == eNonHtmlScriptPreProc)

    1181. 

  1181. 				inScriptType = eNonHtmlScript;

    1182. 

  1182. 			else

    1183. 

  1183. 				inScriptType = eHtml;

    1184. 

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

    1185. 

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

    1186. 

  1186. 				levelCurrent--;

    1187. 

  1187. 			}

    1188. 

  1188. 			scriptLanguage = beforeLanguage;

    1189. 

  1189. 			continue;

    1190. 

  1190. 		}

    1191. 

  1191. 		/////////////////////////////////////

    1192. 

  1192. 

    1193. 

  1193. 		switch (state) {

    1194. 

  1194. 		case SCE_H_DEFAULT:

    1195. 

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

    1196. 

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

    1197. 

  1197. 				tagOpened = true;

    1198. 

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

    1199. 

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

    1200. 

  1200. 				if (chNext != '!')

    1201. 

  1201. 					state = SCE_H_TAGUNKNOWN;

    1202. 

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

    1203. 

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

    1204. 

  1204. 				state = SCE_H_ENTITY;

    1205. 

  1205. 			}

    1206. 

  1206. 			break;

    1207. 

  1207. 		case SCE_H_SGML_DEFAULT:

    1208. 

  1208. 		case SCE_H_SGML_BLOCK_DEFAULT:

    1209. 

  1209. //			if (scriptLanguage == eScriptSGMLblock)

    1210. 

  1210. //				StateToPrint = SCE_H_SGML_BLOCK_DEFAULT;

    1211. 

  1211. 

    1212. 

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

    1213. 

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

    1214. 

  1214. 				state = SCE_H_SGML_DOUBLESTRING;

    1215. 

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

    1216. 

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

    1217. 

  1217. 				state = SCE_H_SGML_SIMPLESTRING;

    1218. 

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

    1219. 

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

    1220. 

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

    1221. 

  1221. 				}

    1222. 

  1222. 				state = SCE_H_SGML_COMMENT;

    1223. 

  1223. 			} else if (isascii(ch) && isalpha(ch) && (chPrev == '%')) {

    1224. 

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

    1225. 

  1225. 				state = SCE_H_SGML_ENTITY;

    1226. 

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

    1227. 

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

    1228. 

  1228. 				state = SCE_H_SGML_SPECIAL;

    1229. 

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

    1230. 

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

    1231. 

  1231. 				scriptLanguage = eScriptSGMLblock;

    1232. 

  1232. 				state = SCE_H_SGML_BLOCK_DEFAULT;

    1233. 

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

    1234. 

  1234. 				if (scriptLanguage == eScriptSGMLblock) {

    1235. 

  1235. 					styler.ColourTo(i, StateToPrint);

    1236. 

  1236. 					scriptLanguage = eScriptSGML;

    1237. 

  1237. 				} else {

    1238. 

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

    1239. 

  1239. 					styler.ColourTo(i, SCE_H_SGML_ERROR);

    1240. 

  1240. 				}

    1241. 

  1241. 				state = SCE_H_SGML_DEFAULT;

    1242. 

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

    1243. 

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

    1244. 

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

    1245. 

  1245. 					styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1246. 

  1246. 					state = SCE_H_SGML_COMMAND;

    1247. 

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

    1248. 

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

    1249. 

  1249. 					styler.ColourTo(i, SCE_H_SGML_DEFAULT);

    1250. 

  1250. 				}

    1251. 

  1251. 			}

    1252. 

  1252. 			break;

    1253. 

  1253. 		case SCE_H_SGML_COMMAND:

    1254. 

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

    1255. 

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

    1256. 

  1256. 				state = SCE_H_SGML_COMMENT;

    1257. 

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

    1258. 

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

    1259. 

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

    1260. 

  1260. 					state = SCE_H_SGML_1ST_PARAM;

    1261. 

  1261. 				} else {

    1262. 

  1262. 					state = SCE_H_SGML_ERROR;

    1263. 

  1263. 				}

    1264. 

  1264. 			}

    1265. 

  1265. 			break;

    1266. 

  1266. 		case SCE_H_SGML_1ST_PARAM:

    1267. 

  1267. 			// wait for the beginning of the word

    1268. 

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

    1269. 

  1269. 				if (scriptLanguage == eScriptSGMLblock) {

    1270. 

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

    1271. 

  1271. 				} else {

    1272. 

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

    1273. 

  1273. 				}

    1274. 

  1274. 				state = SCE_H_SGML_1ST_PARAM_COMMENT;

    1275. 

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

    1276. 

  1276. 				if (scriptLanguage == eScriptSGMLblock) {

    1277. 

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

    1278. 

  1278. 				} else {

    1279. 

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

    1280. 

  1280. 				}

    1281. 

  1281. 				// find the length of the word

    1282. 

  1282. 				int size = 1;

    1283. 

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

    1284. 

  1284. 					size++;

    1285. 

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

    1286. 

  1286. 				i += size - 1;

    1287. 

  1287. 				visibleChars += size - 1;

    1288. 

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

    1289. 

  1289. 				if (scriptLanguage == eScriptSGMLblock) {

    1290. 

  1290. 					state = SCE_H_SGML_BLOCK_DEFAULT;

    1291. 

  1291. 				} else {

    1292. 

  1292. 					state = SCE_H_SGML_DEFAULT;

    1293. 

  1293. 				}

    1294. 

  1294. 				continue;

    1295. 

  1295. 			}

    1296. 

  1296. 			break;

    1297. 

  1297. 		case SCE_H_SGML_ERROR:

    1298. 

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

    1299. 

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

    1300. 

  1300. 				state = SCE_H_SGML_COMMENT;

    1301. 

  1301. 			}

    1302. 

  1302. 		case SCE_H_SGML_DOUBLESTRING:

    1303. 

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

    1304. 

  1304. 				styler.ColourTo(i, StateToPrint);

    1305. 

  1305. 				state = SCE_H_SGML_DEFAULT;

    1306. 

  1306. 			}

    1307. 

  1307. 			break;

    1308. 

  1308. 		case SCE_H_SGML_SIMPLESTRING:

    1309. 

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

    1310. 

  1310. 				styler.ColourTo(i, StateToPrint);

    1311. 

  1311. 				state = SCE_H_SGML_DEFAULT;

    1312. 

  1312. 			}

    1313. 

  1313. 			break;

    1314. 

  1314. 		case SCE_H_SGML_COMMENT:

    1315. 

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

    1316. 

  1316. 				styler.ColourTo(i, StateToPrint);

    1317. 

  1317. 				state = SCE_H_SGML_DEFAULT;

    1318. 

  1318. 			}

    1319. 

  1319. 			break;

    1320. 

  1320. 		case SCE_H_CDATA:

    1321. 

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

    1322. 

  1322. 				styler.ColourTo(i, StateToPrint);

    1323. 

  1323. 				state = SCE_H_DEFAULT;

    1324. 

  1324. 				levelCurrent--;

    1325. 

  1325. 			}

    1326. 

  1326. 			break;

    1327. 

  1327. 		case SCE_H_COMMENT:

    1328. 

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

    1329. 

  1329. 				styler.ColourTo(i, StateToPrint);

    1330. 

  1330. 				state = SCE_H_DEFAULT;

    1331. 

  1331. 				levelCurrent--;

    1332. 

  1332. 			}

    1333. 

  1333. 			break;

    1334. 

  1334. 		case SCE_H_SGML_1ST_PARAM_COMMENT:

    1335. 

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

    1336. 

  1336. 				styler.ColourTo(i, SCE_H_SGML_COMMENT);

    1337. 

  1337. 				state = SCE_H_SGML_1ST_PARAM;

    1338. 

  1338. 			}

    1339. 

  1339. 			break;

    1340. 

  1340. 		case SCE_H_SGML_SPECIAL:

    1341. 

  1341. 			if (!(isascii(ch) && isupper(ch))) {

    1342. 

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

    1343. 

  1343. 				if (isalnum(ch)) {

    1344. 

  1344. 					state = SCE_H_SGML_ERROR;

    1345. 

  1345. 				} else {

    1346. 

  1346. 					state = SCE_H_SGML_DEFAULT;

    1347. 

  1347. 				}

    1348. 

  1348. 			}

    1349. 

  1349. 			break;

    1350. 

  1350. 		case SCE_H_SGML_ENTITY:

    1351. 

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

    1352. 

  1352. 				styler.ColourTo(i, StateToPrint);

    1353. 

  1353. 				state = SCE_H_SGML_DEFAULT;

    1354. 

  1354. 			} else if (!(isascii(ch) && isalnum(ch)) && ch != '-' && ch != '.') {

    1355. 

  1355. 				styler.ColourTo(i, SCE_H_SGML_ERROR);

    1356. 

  1356. 				state = SCE_H_SGML_DEFAULT;

    1357. 

  1357. 			}

    1358. 

  1358. 			break;

    1359. 

  1359. 		case SCE_H_ENTITY:

    1360. 

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

    1361. 

  1361. 				styler.ColourTo(i, StateToPrint);

    1362. 

  1362. 				state = SCE_H_DEFAULT;

    1363. 

  1363. 			}

    1364. 

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

    1365. 

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

    1366. 

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

    1367. 

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

    1368. 

  1368. 				else

    1369. 

  1369. 					styler.ColourTo(i, SCE_H_TAGUNKNOWN);

    1370. 

  1370. 				state = SCE_H_DEFAULT;

    1371. 

  1371. 			}

    1372. 

  1372. 			break;

    1373. 

  1373. 		case SCE_H_TAGUNKNOWN:

    1374. 

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

    1375. 

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

    1376. 

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

    1377. 

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

    1378. 

  1378. 					if (!tagClosing) {

    1379. 

  1379. 						inScriptType = eNonHtmlScript;

    1380. 

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

    1381. 

  1381. 					} else {

    1382. 

  1382. 						scriptLanguage = eScriptNone;

    1383. 

  1383. 					}

    1384. 

  1384. 					eClass = SCE_H_TAG;

    1385. 

  1385. 				}

    1386. 

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

    1387. 

  1387. 					styler.ColourTo(i, eClass);

    1388. 

  1388. 					if (inScriptType == eNonHtmlScript) {

    1389. 

  1389. 						state = StateForScript(scriptLanguage);

    1390. 

  1390. 					} else {

    1391. 

  1391. 						state = SCE_H_DEFAULT;

    1392. 

  1392. 					}

    1393. 

  1393. 					tagOpened = false;

    1394. 

  1394. 					if (!tagDontFold) {

    1395. 

  1395. 						if (tagClosing) {

    1396. 

  1396. 							levelCurrent--;

    1397. 

  1397. 						} else {

    1398. 

  1398. 							levelCurrent++;

    1399. 

  1399. 						}

    1400. 

  1400. 					}

    1401. 

  1401. 					tagClosing = false;

    1402. 

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

    1403. 

  1403. 					if (eClass == SCE_H_TAGUNKNOWN) {

    1404. 

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

    1405. 

  1405. 					} else {

    1406. 

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

    1407. 

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

    1408. 

  1408. 					}

    1409. 

  1409. 					i++;

    1410. 

  1410. 					ch = chNext;

    1411. 

  1411. 					state = SCE_H_DEFAULT;

    1412. 

  1412. 					tagOpened = false;

    1413. 

  1413. 				} else {

    1414. 

  1414. 					if (eClass != SCE_H_TAGUNKNOWN) {

    1415. 

  1415. 						if (eClass == SCE_H_SGML_DEFAULT) {

    1416. 

  1416. 							state = SCE_H_SGML_DEFAULT;

    1417. 

  1417. 						} else {

    1418. 

  1418. 							state = SCE_H_OTHER;

    1419. 

  1419. 						}

    1420. 

  1420. 					}

    1421. 

  1421. 				}

    1422. 

  1422. 			}

    1423. 

  1423. 			break;

    1424. 

  1424. 		case SCE_H_ATTRIBUTE:

    1425. 

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

    1426. 

  1426. 				if (inScriptType == eNonHtmlScript) {

    1427. 

  1427. 					int scriptLanguagePrev = scriptLanguage;

    1428. 

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

    1429. 

  1429. 					scriptLanguage = clientScript;

    1430. 

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

    1431. 

  1431. 						inScriptType = eHtml;

    1432. 

  1432. 				}

    1433. 

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

    1434. 

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

    1435. 

  1435. 					styler.ColourTo(i, SCE_H_TAG);

    1436. 

  1436. 					if (inScriptType == eNonHtmlScript) {

    1437. 

  1437. 						state = StateForScript(scriptLanguage);

    1438. 

  1438. 					} else {

    1439. 

  1439. 						state = SCE_H_DEFAULT;

    1440. 

  1440. 					}

    1441. 

  1441. 					tagOpened = false;

    1442. 

  1442. 					if (!tagDontFold) {

    1443. 

  1443. 						if (tagClosing) {

    1444. 

  1444. 							levelCurrent--;

    1445. 

  1445. 						} else {

    1446. 

  1446. 							levelCurrent++;

    1447. 

  1447. 						}

    1448. 

  1448. 					}

    1449. 

  1449. 					tagClosing = false;

    1450. 

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

    1451. 

  1451. 					styler.ColourTo(i, SCE_H_OTHER);

    1452. 

  1452. 					state = SCE_H_VALUE;

    1453. 

  1453. 				} else {

    1454. 

  1454. 					state = SCE_H_OTHER;

    1455. 

  1455. 				}

    1456. 

  1456. 			}

    1457. 

  1457. 			break;

    1458. 

  1458. 		case SCE_H_OTHER:

    1459. 

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

    1460. 

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

    1461. 

  1461. 				styler.ColourTo(i, SCE_H_TAG);

    1462. 

  1462. 				if (inScriptType == eNonHtmlScript) {

    1463. 

  1463. 					state = StateForScript(scriptLanguage);

    1464. 

  1464. 				} else {

    1465. 

  1465. 					state = SCE_H_DEFAULT;

    1466. 

  1466. 				}

    1467. 

  1467. 				tagOpened = false;

    1468. 

  1468. 				if (!tagDontFold) {

    1469. 

  1469. 					if (tagClosing) {

    1470. 

  1470. 						levelCurrent--;

    1471. 

  1471. 					} else {

    1472. 

  1472. 						levelCurrent++;

    1473. 

  1473. 					}

    1474. 

  1474. 				}

    1475. 

  1475. 				tagClosing = false;

    1476. 

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

    1477. 

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

    1478. 

  1478. 				state = SCE_H_DOUBLESTRING;

    1479. 

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

    1480. 

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

    1481. 

  1481. 				state = SCE_H_SINGLESTRING;

    1482. 

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

    1483. 

  1483. 				styler.ColourTo(i, StateToPrint);

    1484. 

  1484. 				state = SCE_H_VALUE;

    1485. 

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

    1486. 

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

    1487. 

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

    1488. 

  1488. 				i++;

    1489. 

  1489. 				ch = chNext;

    1490. 

  1490. 				state = SCE_H_DEFAULT;

    1491. 

  1491. 				tagOpened = false;

    1492. 

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

    1493. 

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

    1494. 

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

    1495. 

  1495. 				i++;

    1496. 

  1496. 				ch = chNext;

    1497. 

  1497. 				state = SCE_H_DEFAULT;

    1498. 

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

    1499. 

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

    1500. 

  1500. 				state = SCE_H_ATTRIBUTE;

    1501. 

  1501. 			}

    1502. 

  1502. 			break;

    1503. 

  1503. 		case SCE_H_DOUBLESTRING:

    1504. 

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

    1505. 

  1505. 				if (inScriptType == eNonHtmlScript) {

    1506. 

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

    1507. 

  1507. 				}

    1508. 

  1508. 				styler.ColourTo(i, SCE_H_DOUBLESTRING);

    1509. 

  1509. 				state = SCE_H_OTHER;

    1510. 

  1510. 			}

    1511. 

  1511. 			break;

    1512. 

  1512. 		case SCE_H_SINGLESTRING:

    1513. 

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

    1514. 

  1514. 				if (inScriptType == eNonHtmlScript) {

    1515. 

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

    1516. 

  1516. 				}

    1517. 

  1517. 				styler.ColourTo(i, SCE_H_SINGLESTRING);

    1518. 

  1518. 				state = SCE_H_OTHER;

    1519. 

  1519. 			}

    1520. 

  1520. 			break;

    1521. 

  1521. 		case SCE_H_VALUE:

    1522. 

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

    1523. 

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

    1524. 

  1524. 					// Should really test for being first character

    1525. 

  1525. 					state = SCE_H_DOUBLESTRING;

    1526. 

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

    1527. 

  1527. 					state = SCE_H_SINGLESTRING;

    1528. 

  1528. 				} else {

    1529. 

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

    1530. 

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

    1531. 

  1531. 					} else {

    1532. 

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

    1533. 

  1533. 					}

    1534. 

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

    1535. 

  1535. 						styler.ColourTo(i, SCE_H_TAG);

    1536. 

  1536. 						if (inScriptType == eNonHtmlScript) {

    1537. 

  1537. 							state = StateForScript(scriptLanguage);

    1538. 

  1538. 						} else {

    1539. 

  1539. 							state = SCE_H_DEFAULT;

    1540. 

  1540. 						}

    1541. 

  1541. 						tagOpened = false;

    1542. 

  1542. 						if (!tagDontFold) {

    1543. 

  1543. 							if (tagClosing) {

    1544. 

  1544. 								levelCurrent--;

    1545. 

  1545. 							} else {

    1546. 

  1546. 								levelCurrent++;

    1547. 

  1547. 							}

    1548. 

  1548. 						}

    1549. 

  1549. 						tagClosing = false;

    1550. 

  1550. 					} else {

    1551. 

  1551. 						state = SCE_H_OTHER;

    1552. 

  1552. 					}

    1553. 

  1553. 				}

    1554. 

  1554. 			}

    1555. 

  1555. 			break;

    1556. 

  1556. 		case SCE_HJ_DEFAULT:

    1557. 

  1557. 		case SCE_HJ_START:

    1558. 

  1558. 		case SCE_HJ_SYMBOLS:

    1559. 

  1559. 			if (IsAWordStart(ch)) {

    1560. 

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

    1561. 

  1561. 				state = SCE_HJ_WORD;

    1562. 

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

    1563. 

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

    1564. 

  1564. 				if (chNext2 == '*')

    1565. 

  1565. 					state = SCE_HJ_COMMENTDOC;

    1566. 

  1566. 				else

    1567. 

  1567. 					state = SCE_HJ_COMMENT;

    1568. 

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

    1569. 

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

    1570. 

  1570. 				state = SCE_HJ_COMMENTLINE;

    1571. 

  1571. 			} else if (ch == '/' && isOKBeforeRE(chPrevNonWhite)) {

    1572. 

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

    1573. 

  1573. 				state = SCE_HJ_REGEX;

    1574. 

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

    1575. 

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

    1576. 

  1576. 				state = SCE_HJ_DOUBLESTRING;

    1577. 

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

    1578. 

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

    1579. 

  1579. 				state = SCE_HJ_SINGLESTRING;

    1580. 

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

    1581. 

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

    1582. 

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

    1583. 

  1583. 				state = SCE_HJ_COMMENTLINE;

    1584. 

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

    1585. 

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

    1586. 

  1586. 				state = SCE_HJ_COMMENTLINE;

    1587. 

  1587. 				i += 2;

    1588. 

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

    1589. 

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

    1590. 

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

    1591. 

  1591. 				state = SCE_HJ_DEFAULT;

    1592. 

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

    1593. 

  1593. 				if (state == SCE_HJ_START) {

    1594. 

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

    1595. 

  1595. 					state = SCE_HJ_DEFAULT;

    1596. 

  1596. 				}

    1597. 

  1597. 			}

    1598. 

  1598. 			break;

    1599. 

  1599. 		case SCE_HJ_WORD:

    1600. 

  1600. 			if (!IsAWordChar(ch)) {

    1601. 

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

    1602. 

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

    1603. 

  1603. 				state = SCE_HJ_DEFAULT;

    1604. 

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

    1605. 

  1605. 					if (chNext2 == '*')

    1606. 

  1606. 						state = SCE_HJ_COMMENTDOC;

    1607. 

  1607. 					else

    1608. 

  1608. 						state = SCE_HJ_COMMENT;

    1609. 

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

    1610. 

  1610. 					state = SCE_HJ_COMMENTLINE;

    1611. 

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

    1612. 

  1612. 					state = SCE_HJ_DOUBLESTRING;

    1613. 

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

    1614. 

  1614. 					state = SCE_HJ_SINGLESTRING;

    1615. 

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

    1616. 

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

    1617. 

  1617. 					state = SCE_HJ_COMMENTLINE;

    1618. 

  1618. 					i += 2;

    1619. 

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

    1620. 

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

    1621. 

  1621. 					state = SCE_HJ_DEFAULT;

    1622. 

  1622. 				}

    1623. 

  1623. 			}

    1624. 

  1624. 			break;

    1625. 

  1625. 		case SCE_HJ_COMMENT:

    1626. 

  1626. 		case SCE_HJ_COMMENTDOC:

    1627. 

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

    1628. 

  1628. 				styler.ColourTo(i, StateToPrint);

    1629. 

  1629. 				state = SCE_HJ_DEFAULT;

    1630. 

  1630. 				ch = ' ';

    1631. 

  1631. 			}

    1632. 

  1632. 			break;

    1633. 

  1633. 		case SCE_HJ_COMMENTLINE:

    1634. 

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

    1635. 

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

    1636. 

  1636. 				state = SCE_HJ_DEFAULT;

    1637. 

  1637. 				ch = ' ';

    1638. 

  1638. 			}

    1639. 

  1639. 			break;

    1640. 

  1640. 		case SCE_HJ_DOUBLESTRING:

    1641. 

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

    1642. 

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

    1643. 

  1643. 					i++;

    1644. 

  1644. 				}

    1645. 

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

    1646. 

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

    1647. 

  1647. 				state = SCE_HJ_DEFAULT;

    1648. 

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

    1649. 

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

    1650. 

  1650. 				state = SCE_HJ_COMMENTLINE;

    1651. 

  1651. 				i += 2;

    1652. 

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

    1653. 

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

    1654. 

  1654. 				state = SCE_HJ_STRINGEOL;

    1655. 

  1655. 			}

    1656. 

  1656. 			break;

    1657. 

  1657. 		case SCE_HJ_SINGLESTRING:

    1658. 

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

    1659. 

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

    1660. 

  1660. 					i++;

    1661. 

  1661. 				}

    1662. 

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

    1663. 

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

    1664. 

  1664. 				state = SCE_HJ_DEFAULT;

    1665. 

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

    1666. 

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

    1667. 

  1667. 				state = SCE_HJ_COMMENTLINE;

    1668. 

  1668. 				i += 2;

    1669. 

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

    1670. 

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

    1671. 

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

    1672. 

  1672. 					state = SCE_HJ_STRINGEOL;

    1673. 

  1673. 				}

    1674. 

  1674. 			}

    1675. 

  1675. 			break;

    1676. 

  1676. 		case SCE_HJ_STRINGEOL:

    1677. 

  1677. 			if (!isLineEnd(ch)) {

    1678. 

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

    1679. 

  1679. 				state = SCE_HJ_DEFAULT;

    1680. 

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

    1681. 

  1681. 				styler.ColourTo(i, StateToPrint);

    1682. 

  1682. 				state = SCE_HJ_DEFAULT;

    1683. 

  1683. 			}

    1684. 

  1684. 			break;

    1685. 

  1685. 		case SCE_HJ_REGEX:

    1686. 

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

    1687. 

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

    1688. 

  1688. 					while (isascii(chNext) && islower(chNext)) {   // gobble regex flags

    1689. 

  1689. 						i++;

    1690. 

  1690. 						ch = chNext;

    1691. 

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

    1692. 

  1692. 					}

    1693. 

  1693. 				}

    1694. 

  1694. 				styler.ColourTo(i, StateToPrint);

    1695. 

  1695. 				state = SCE_HJ_DEFAULT;

    1696. 

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

    1697. 

  1697. 				// Gobble up the quoted character

    1698. 

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

    1699. 

  1699. 					i++;

    1700. 

  1700. 					ch = chNext;

    1701. 

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

    1702. 

  1702. 				}

    1703. 

  1703. 			}

    1704. 

  1704. 			break;

    1705. 

  1705. 		case SCE_HB_DEFAULT:

    1706. 

  1706. 		case SCE_HB_START:

    1707. 

  1707. 			if (IsAWordStart(ch)) {

    1708. 

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

    1709. 

  1709. 				state = SCE_HB_WORD;

    1710. 

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

    1711. 

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

    1712. 

  1712. 				state = SCE_HB_COMMENTLINE;

    1713. 

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

    1714. 

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

    1715. 

  1715. 				state = SCE_HB_STRING;

    1716. 

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

    1717. 

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

    1718. 

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

    1719. 

  1719. 				state = SCE_HB_COMMENTLINE;

    1720. 

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

    1721. 

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

    1722. 

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

    1723. 

  1723. 				state = SCE_HB_DEFAULT;

    1724. 

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

    1725. 

  1725. 				if (state == SCE_HB_START) {

    1726. 

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

    1727. 

  1727. 					state = SCE_HB_DEFAULT;

    1728. 

  1728. 				}

    1729. 

  1729. 			}

    1730. 

  1730. 			break;

    1731. 

  1731. 		case SCE_HB_WORD:

    1732. 

  1732. 			if (!IsAWordChar(ch)) {

    1733. 

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

    1734. 

  1734. 				if (state == SCE_HB_DEFAULT) {

    1735. 

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

    1736. 

  1736. 						state = SCE_HB_STRING;

    1737. 

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

    1738. 

  1738. 						state = SCE_HB_COMMENTLINE;

    1739. 

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

    1740. 

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

    1741. 

  1741. 						state = SCE_HB_DEFAULT;

    1742. 

  1742. 					}

    1743. 

  1743. 				}

    1744. 

  1744. 			}

    1745. 

  1745. 			break;

    1746. 

  1746. 		case SCE_HB_STRING:

    1747. 

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

    1748. 

  1748. 				styler.ColourTo(i, StateToPrint);

    1749. 

  1749. 				state = SCE_HB_DEFAULT;

    1750. 

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

    1751. 

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

    1752. 

  1752. 				state = SCE_HB_STRINGEOL;

    1753. 

  1753. 			}

    1754. 

  1754. 			break;

    1755. 

  1755. 		case SCE_HB_COMMENTLINE:

    1756. 

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

    1757. 

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

    1758. 

  1758. 				state = SCE_HB_DEFAULT;

    1759. 

  1759. 			}

    1760. 

  1760. 			break;

    1761. 

  1761. 		case SCE_HB_STRINGEOL:

    1762. 

  1762. 			if (!isLineEnd(ch)) {

    1763. 

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

    1764. 

  1764. 				state = SCE_HB_DEFAULT;

    1765. 

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

    1766. 

  1766. 				styler.ColourTo(i, StateToPrint);

    1767. 

  1767. 				state = SCE_HB_DEFAULT;

    1768. 

  1768. 			}

    1769. 

  1769. 			break;

    1770. 

  1770. 		case SCE_HP_DEFAULT:

    1771. 

  1771. 		case SCE_HP_START:

    1772. 

  1772. 			if (IsAWordStart(ch)) {

    1773. 

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

    1774. 

  1774. 				state = SCE_HP_WORD;

    1775. 

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

    1776. 

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

    1777. 

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

    1778. 

  1778. 				state = SCE_HP_COMMENTLINE;

    1779. 

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

    1780. 

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

    1781. 

  1781. 				state = SCE_HP_COMMENTLINE;

    1782. 

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

    1783. 

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

    1784. 

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

    1785. 

  1785. 					i += 2;

    1786. 

  1786. 					state = SCE_HP_TRIPLEDOUBLE;

    1787. 

  1787. 					ch = ' ';

    1788. 

  1788. 					chPrev = ' ';

    1789. 

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

    1790. 

  1790. 				} else {

    1791. 

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

    1792. 

  1792. 					state = SCE_HP_STRING;

    1793. 

  1793. 				}

    1794. 

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

    1795. 

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

    1796. 

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

    1797. 

  1797. 					i += 2;

    1798. 

  1798. 					state = SCE_HP_TRIPLE;

    1799. 

  1799. 					ch = ' ';

    1800. 

  1800. 					chPrev = ' ';

    1801. 

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

    1802. 

  1802. 				} else {

    1803. 

  1803. 					state = SCE_HP_CHARACTER;

    1804. 

  1804. 				}

    1805. 

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

    1806. 

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

    1807. 

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

    1808. 

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

    1809. 

  1809. 				if (state == SCE_HP_START) {

    1810. 

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

    1811. 

  1811. 					state = SCE_HP_DEFAULT;

    1812. 

  1812. 				}

    1813. 

  1813. 			}

    1814. 

  1814. 			break;

    1815. 

  1815. 		case SCE_HP_WORD:

    1816. 

  1816. 			if (!IsAWordChar(ch)) {

    1817. 

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

    1818. 

  1818. 				state = SCE_HP_DEFAULT;

    1819. 

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

    1820. 

  1820. 					state = SCE_HP_COMMENTLINE;

    1821. 

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

    1822. 

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

    1823. 

  1823. 						i += 2;

    1824. 

  1824. 						state = SCE_HP_TRIPLEDOUBLE;

    1825. 

  1825. 						ch = ' ';

    1826. 

  1826. 						chPrev = ' ';

    1827. 

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

    1828. 

  1828. 					} else {

    1829. 

  1829. 						state = SCE_HP_STRING;

    1830. 

  1830. 					}

    1831. 

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

    1832. 

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

    1833. 

  1833. 						i += 2;

    1834. 

  1834. 						state = SCE_HP_TRIPLE;

    1835. 

  1835. 						ch = ' ';

    1836. 

  1836. 						chPrev = ' ';

    1837. 

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

    1838. 

  1838. 					} else {

    1839. 

  1839. 						state = SCE_HP_CHARACTER;

    1840. 

  1840. 					}

    1841. 

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

    1842. 

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

    1843. 

  1843. 				}

    1844. 

  1844. 			}

    1845. 

  1845. 			break;

    1846. 

  1846. 		case SCE_HP_COMMENTLINE:

    1847. 

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

    1848. 

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

    1849. 

  1849. 				state = SCE_HP_DEFAULT;

    1850. 

  1850. 			}

    1851. 

  1851. 			break;

    1852. 

  1852. 		case SCE_HP_STRING:

    1853. 

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

    1854. 

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

    1855. 

  1855. 					i++;

    1856. 

  1856. 					ch = chNext;

    1857. 

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

    1858. 

  1858. 				}

    1859. 

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

    1860. 

  1860. 				styler.ColourTo(i, StateToPrint);

    1861. 

  1861. 				state = SCE_HP_DEFAULT;

    1862. 

  1862. 			}

    1863. 

  1863. 			break;

    1864. 

  1864. 		case SCE_HP_CHARACTER:

    1865. 

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

    1866. 

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

    1867. 

  1867. 					i++;

    1868. 

  1868. 					ch = chNext;

    1869. 

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

    1870. 

  1870. 				}

    1871. 

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

    1872. 

  1872. 				styler.ColourTo(i, StateToPrint);

    1873. 

  1873. 				state = SCE_HP_DEFAULT;

    1874. 

  1874. 			}

    1875. 

  1875. 			break;

    1876. 

  1876. 		case SCE_HP_TRIPLE:

    1877. 

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

    1878. 

  1878. 				styler.ColourTo(i, StateToPrint);

    1879. 

  1879. 				state = SCE_HP_DEFAULT;

    1880. 

  1880. 			}

    1881. 

  1881. 			break;

    1882. 

  1882. 		case SCE_HP_TRIPLEDOUBLE:

    1883. 

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

    1884. 

  1884. 				styler.ColourTo(i, StateToPrint);

    1885. 

  1885. 				state = SCE_HP_DEFAULT;

    1886. 

  1886. 			}

    1887. 

  1887. 			break;

    1888. 

  1888. 			///////////// start - PHP state handling

    1889. 

  1889. 		case SCE_HPHP_WORD:

    1890. 

  1890. 			if (!IsAWordChar(ch)) {

    1891. 

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

    1892. 

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

    1893. 

  1893. 					i++;

    1894. 

  1894. 					state = SCE_HPHP_COMMENT;

    1895. 

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

    1896. 

  1896. 					i++;

    1897. 

  1897. 					state = SCE_HPHP_COMMENTLINE;

    1898. 

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

    1899. 

  1899. 					state = SCE_HPHP_COMMENTLINE;

    1900. 

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

    1901. 

  1901. 					state = SCE_HPHP_HSTRING;

    1902. 

  1902. 					strcpy(phpStringDelimiter, "\"");

    1903. 

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

    1904. 

  1904. 					bool isSimpleString = false;

    1905. 

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

    1906. 

  1906. 					if (strlen(phpStringDelimiter)) {

    1907. 

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

    1908. 

  1908. 						if (foldHeredoc) levelCurrent++;

    1909. 

  1909. 					}

    1910. 

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

    1911. 

  1911. 					state = SCE_HPHP_SIMPLESTRING;

    1912. 

  1912. 					strcpy(phpStringDelimiter, "\'");

    1913. 

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

    1914. 

  1914. 					state = SCE_HPHP_VARIABLE;

    1915. 

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

    1916. 

  1916. 					state = SCE_HPHP_OPERATOR;

    1917. 

  1917. 				} else {

    1918. 

  1918. 					state = SCE_HPHP_DEFAULT;

    1919. 

  1919. 				}

    1920. 

  1920. 			}

    1921. 

  1921. 			break;

    1922. 

  1922. 		case SCE_HPHP_NUMBER:

    1923. 

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

    1924. 

  1924. 			if (!IsADigit(ch)

    1925. 

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

    1926. 

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

    1927. 

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

    1928. 

  1928. 				if (IsOperator(ch))

    1929. 

  1929. 					state = SCE_HPHP_OPERATOR;

    1930. 

  1930. 				else

    1931. 

  1931. 					state = SCE_HPHP_DEFAULT;

    1932. 

  1932. 			}

    1933. 

  1933. 			break;

    1934. 

  1934. 		case SCE_HPHP_VARIABLE:

    1935. 

  1935. 			if (!IsPhpWordChar(chNext)) {

    1936. 

  1936. 				styler.ColourTo(i, SCE_HPHP_VARIABLE);

    1937. 

  1937. 				state = SCE_HPHP_DEFAULT;

    1938. 

  1938. 			}

    1939. 

  1939. 			break;

    1940. 

  1940. 		case SCE_HPHP_COMMENT:

    1941. 

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

    1942. 

  1942. 				styler.ColourTo(i, StateToPrint);

    1943. 

  1943. 				state = SCE_HPHP_DEFAULT;

    1944. 

  1944. 			}

    1945. 

  1945. 			break;

    1946. 

  1946. 		case SCE_HPHP_COMMENTLINE:

    1947. 

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

    1948. 

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

    1949. 

  1949. 				state = SCE_HPHP_DEFAULT;

    1950. 

  1950. 			}

    1951. 

  1951. 			break;

    1952. 

  1952. 		case SCE_HPHP_HSTRING:

    1953. 

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

    1954. 

  1954. 				// skip the next char

    1955. 

  1955. 				i++;

    1956. 

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

    1957. 

  1957. 				&& IsPhpWordStart(chNext2)) {

    1958. 

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

    1959. 

  1959. 				state = SCE_HPHP_COMPLEX_VARIABLE;

    1960. 

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

    1961. 

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

    1962. 

  1962. 				state = SCE_HPHP_HSTRING_VARIABLE;

    1963. 

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

    1964. 

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

    1965. 

  1965. 					styler.ColourTo(i, StateToPrint);

    1966. 

  1966. 					state = SCE_HPHP_DEFAULT;

    1967. 

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

    1968. 

  1968. 				const int psdLength = strlen(phpStringDelimiter);

    1969. 

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

    1970. 

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

    1971. 

  1971. 					if (isLineEnd(chAfterPsd) ||

    1972. 

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

    1973. 

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

    1974. 

  1974. 						styler.ColourTo(i, StateToPrint);

    1975. 

  1975. 						state = SCE_HPHP_DEFAULT;

    1976. 

  1976. 						if (foldHeredoc) levelCurrent--;

    1977. 

  1977. 					}

    1978. 

  1978. 				}

    1979. 

  1979. 			}

    1980. 

  1980. 			break;

    1981. 

  1981. 		case SCE_HPHP_SIMPLESTRING:

    1982. 

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

    1983. 

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

    1984. 

  1984. 					// skip the next char

    1985. 

  1985. 					i++;

    1986. 

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

    1987. 

  1987. 					styler.ColourTo(i, StateToPrint);

    1988. 

  1988. 					state = SCE_HPHP_DEFAULT;

    1989. 

  1989. 				}

    1990. 

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

    1991. 

  1991. 				const int psdLength = strlen(phpStringDelimiter);

    1992. 

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

    1993. 

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

    1994. 

  1994. 				if (isLineEnd(chAfterPsd) ||

    1995. 

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

    1996. 

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

    1997. 

  1997. 					styler.ColourTo(i, StateToPrint);

    1998. 

  1998. 					state = SCE_HPHP_DEFAULT;

    1999. 

  1999. 					if (foldHeredoc) levelCurrent--;

    2000. 

  2000. 				}

    2001. 

  2001. 			}

    2002. 

  2002. 			break;

    2003. 

  2003. 		case SCE_HPHP_HSTRING_VARIABLE:

    2004. 

  2004. 			if (!IsPhpWordChar(chNext)) {

    2005. 

  2005. 				styler.ColourTo(i, StateToPrint);

    2006. 

  2006. 				state = SCE_HPHP_HSTRING;

    2007. 

  2007. 			}

    2008. 

  2008. 			break;

    2009. 

  2009. 		case SCE_HPHP_COMPLEX_VARIABLE:

    2010. 

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

    2011. 

  2011. 				styler.ColourTo(i, StateToPrint);

    2012. 

  2012. 				state = SCE_HPHP_HSTRING;

    2013. 

  2013. 			}

    2014. 

  2014. 			break;

    2015. 

  2015. 		case SCE_HPHP_OPERATOR:

    2016. 

  2016. 		case SCE_HPHP_DEFAULT:

    2017. 

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

    2018. 

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

    2019. 

  2019. 				state = SCE_HPHP_NUMBER;

    2020. 

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

    2021. 

  2021. 				state = SCE_HPHP_WORD;

    2022. 

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

    2023. 

  2023. 				i++;

    2024. 

  2024. 				state = SCE_HPHP_COMMENT;

    2025. 

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

    2026. 

  2026. 				i++;

    2027. 

  2027. 				state = SCE_HPHP_COMMENTLINE;

    2028. 

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

    2029. 

  2029. 				state = SCE_HPHP_COMMENTLINE;

    2030. 

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

    2031. 

  2031. 				state = SCE_HPHP_HSTRING;

    2032. 

  2032. 				strcpy(phpStringDelimiter, "\"");

    2033. 

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

    2034. 

  2034. 				bool isSimpleString = false;

    2035. 

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

    2036. 

  2036. 				if (strlen(phpStringDelimiter)) {

    2037. 

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

    2038. 

  2038. 					if (foldHeredoc) levelCurrent++;

    2039. 

  2039. 				}

    2040. 

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

    2041. 

  2041. 				state = SCE_HPHP_SIMPLESTRING;

    2042. 

  2042. 				strcpy(phpStringDelimiter, "\'");

    2043. 

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

    2044. 

  2044. 				state = SCE_HPHP_VARIABLE;

    2045. 

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

    2046. 

  2046. 				state = SCE_HPHP_OPERATOR;

    2047. 

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

    2048. 

  2048. 				state = SCE_HPHP_DEFAULT;

    2049. 

  2049. 			}

    2050. 

  2050. 			break;

    2051. 

  2051. 			///////////// end - PHP state handling

    2052. 

  2052. 		}

    2053. 

  2053. 

    2054. 

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

    2055. 

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

    2056. 

  2056. 

    2057. 

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

    2058. 

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

    2059. 

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

    2060. 

  2060. 				state = SCE_HB_STRING;

    2061. 

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

    2062. 

  2062. 				state = SCE_HB_COMMENTLINE;

    2063. 

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

    2064. 

  2064. 				state = SCE_HB_WORD;

    2065. 

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

    2066. 

  2066. 				styler.ColourTo(i, SCE_HB_DEFAULT);

    2067. 

  2067. 			}

    2068. 

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

    2069. 

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

    2070. 

  2070. 				state = SCE_HBA_STRING;

    2071. 

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

    2072. 

  2072. 				state = SCE_HBA_COMMENTLINE;

    2073. 

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

    2074. 

  2074. 				state = SCE_HBA_WORD;

    2075. 

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

    2076. 

  2076. 				styler.ColourTo(i, SCE_HBA_DEFAULT);

    2077. 

  2077. 			}

    2078. 

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

    2079. 

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

    2080. 

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

    2081. 

  2081. 					state = SCE_HJ_COMMENTDOC;

    2082. 

  2082. 				else

    2083. 

  2083. 					state = SCE_HJ_COMMENT;

    2084. 

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

    2085. 

  2085. 				state = SCE_HJ_COMMENTLINE;

    2086. 

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

    2087. 

  2087. 				state = SCE_HJ_DOUBLESTRING;

    2088. 

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

    2089. 

  2089. 				state = SCE_HJ_SINGLESTRING;

    2090. 

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

    2091. 

  2091. 				state = SCE_HJ_WORD;

    2092. 

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

    2093. 

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

    2094. 

  2094. 			}

    2095. 

  2095. 		}

    2096. 

  2096. 	}

    2097. 

  2097. 

    2098. 

  2098. 	switch (state) {

    2099. 

  2099. 	case SCE_HJ_WORD:

    2100. 

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

    2101. 

  2101. 		break;

    2102. 

  2102. 	case SCE_HB_WORD:

    2103. 

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

    2104. 

  2104. 		break;

    2105. 

  2105. 	case SCE_HP_WORD:

    2106. 

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

    2107. 

  2107. 		break;

    2108. 

  2108. 	case SCE_HPHP_WORD:

    2109. 

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

    2110. 

  2110. 		break;

    2111. 

  2111. 	default:

    2112. 

  2112. 		StateToPrint = statePrintForState(state, inScriptType);

    2113. 

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

    2114. 

  2114. 		break;

    2115. 

  2115. 	}

    2116. 

  2116. 

    2117. 

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

    2118. 

  2118. 	if (fold) {

    2119. 

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

    2120. 

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

    2121. 

  2121. 	}

    2122. 

  2122. }

    2123. 

  2123. 

    2124. 

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

    2125. 

  2125.                                   Accessor &styler) {

    2126. 

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

    2127. 

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

    2128. 

  2128. }

    2129. 

  2129. 

    2130. 

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

    2131. 

  2131.                                   Accessor &styler) {

    2132. 

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

    2133. 

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

    2134. 

  2134. }

    2135. 

  2135. 

    2136. 

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

    2137. 

  2137.         Accessor &styler) {

    2138. 

  2138. 	if (startPos == 0)

    2139. 

  2139. 		initStyle = SCE_HPHP_DEFAULT;

    2140. 

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

    2141. 

  2141. }

    2142. 

  2142. 

    2143. 

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

    2144. 

  2144. 	"HTML elements and attributes",

    2145. 

  2145. 	"JavaScript keywords",

    2146. 

  2146. 	"VBScript keywords",

    2147. 

  2147. 	"Python keywords",

    2148. 

  2148. 	"PHP keywords",

    2149. 

  2149. 	"SGML and DTD keywords",

    2150. 

  2150. 	0,

    2151. 

  2151. };

    2152. 

  2152. 

    2153. 

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

    2154. 

  2154. 	"", //Unused

    2155. 

  2155. 	"", //Unused

    2156. 

  2156. 	"", //Unused

    2157. 

  2157. 	"", //Unused

    2158. 

  2158. 	"PHP keywords",

    2159. 

  2159. 	"", //Unused

    2160. 

  2160. 	0,

    2161. 

  2161. };

    2162. 

  2162. 

    2163. 

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

    2164. 

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

    2165. 

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

    2166. 

  2166.