text: // Scintilla source code edit control
  /** @file LexClw.cxx
   ** Lexer for Clarion.
   ** 2004/12/17 Updated Lexer
   **/
  // Copyright 2003-2004 by Ron Schofield <ron@schofieldcomputer.com>
  // The License.txt file describes the conditions under which this software may be distributed.
  
  #include <stdlib.h>
  #include <string.h>
  #include <stdio.h>
  #include <stdarg.h>
  #include <assert.h>
  #include <ctype.h>
  
  #include "ILexer.h"
  #include "Scintilla.h"
  #include "SciLexer.h"
  
  #include "WordList.h"
  #include "LexAccessor.h"
  #include "Accessor.h"
  #include "StyleContext.h"
  #include "CharacterSet.h"
  #include "LexerModule.h"
  
  using namespace Scintilla;
  
  // Is an end of line character
  inline bool IsEOL(const int ch) {
  
  	return(ch == '\n');
  }
  
  // Convert character to uppercase
  static char CharacterUpper(char chChar) {
  
  	if (chChar < 'a' || chChar > 'z') {
  		return(chChar);
  	}
  	else {
  		return(static_cast<char>(chChar - 'a' + 'A'));
  	}
  }
  
  // Convert string to uppercase
  static void StringUpper(char *szString) {
  
  	while (*szString) {
  		*szString = CharacterUpper(*szString);
  		szString++;
  	}
  }
  
  // Is a label start character
  inline bool IsALabelStart(const int iChar) {
  
  	return(isalpha(iChar) || iChar == '_');
  }
  
  // Is a label character
  inline bool IsALabelCharacter(const int iChar) {
  
  	return(isalnum(iChar) || iChar == '_' || iChar == ':');
  }
  
  // Is the character is a ! and the the next character is not a !
  inline bool IsACommentStart(const int iChar) {
  
  	return(iChar == '!');
  }
  
  // Is the character a Clarion hex character (ABCDEF)
  inline bool IsAHexCharacter(const int iChar, bool bCaseSensitive) {
  
  	// Case insensitive.
  	if (!bCaseSensitive) {
  		if (strchr("ABCDEFabcdef", iChar) != NULL) {
  			return(true);
  		}
  	}
  	// Case sensitive
  	else {
  		if (strchr("ABCDEF", iChar) != NULL) {
  			return(true);
  		}
  	}
  	return(false);
  }
  
  // Is the character a Clarion base character (B=Binary, O=Octal, H=Hex)
  inline bool IsANumericBaseCharacter(const int iChar, bool bCaseSensitive) {
  
  	// Case insensitive.
  	if (!bCaseSensitive) {
  		// If character is a numeric base character
  		if (strchr("BOHboh", iChar) != NULL) {
  			return(true);
  		}
  	}
  	// Case sensitive
  	else {
  		// If character is a numeric base character
  		if (strchr("BOH", iChar) != NULL) {
  			return(true);
  		}
  	}
  	return(false);
  }
  
  // Set the correct numeric constant state
  inline bool SetNumericConstantState(StyleContext &scDoc) {
  
  	int iPoints = 0;			// Point counter
  	char cNumericString[512];	// Numeric string buffer
  
  	// Buffer the current numberic string
  	scDoc.GetCurrent(cNumericString, sizeof(cNumericString));
  	// Loop through the string until end of string (NULL termination)
  	for (int iIndex = 0; cNumericString[iIndex] != '\0'; iIndex++) {
  		// Depending on the character
  		switch (cNumericString[iIndex]) {
  			// Is a . (point)
  			case '.' :
  				// Increment point counter
  				iPoints++;
  				break;
  			default :
  				break;
  		}
  	}
  	// If points found (can be more than one for improper formatted number
  	if (iPoints > 0) {
  		return(true);
  	}
  	// Else no points found
  	else {
  		return(false);
  	}
  }
  
  // Get the next word in uppercase from the current position (keyword lookahead)
  inline bool GetNextWordUpper(Accessor &styler, Sci_PositionU uiStartPos, Sci_Position iLength, char *cWord) {
  
  	Sci_PositionU iIndex = 0;		// Buffer Index
  
  	// Loop through the remaining string from the current position
  	for (Sci_Position iOffset = uiStartPos; iOffset < iLength; iOffset++) {
  		// Get the character from the buffer using the offset
  		char cCharacter = styler[iOffset];
  		if (IsEOL(cCharacter)) {
  			break;
  		}
  		// If the character is alphabet character
  		if (isalpha(cCharacter)) {
  			// Add UPPERCASE character to the word buffer
  			cWord[iIndex++] = CharacterUpper(cCharacter);
  		}
  	}
  	// Add null termination
  	cWord[iIndex] = '\0';
  	// If no word was found
  	if (iIndex == 0) {
  		// Return failure
  		return(false);
  	}
  	// Else word was found
  	else {
  		// Return success
  		return(true);
  	}
  }
  
  // Clarion Language Colouring Procedure
  static void ColouriseClarionDoc(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler, bool bCaseSensitive) {
  
  	int iParenthesesLevel = 0;		// Parenthese Level
  	int iColumn1Label = false;		// Label starts in Column 1
  
  	WordList &wlClarionKeywords = *wlKeywords[0];			// Clarion Keywords
  	WordList &wlCompilerDirectives = *wlKeywords[1];		// Compiler Directives
  	WordList &wlRuntimeExpressions = *wlKeywords[2];		// Runtime Expressions
  	WordList &wlBuiltInProcsFuncs = *wlKeywords[3];			// Builtin Procedures and Functions
  	WordList &wlStructsDataTypes = *wlKeywords[4];			// Structures and Data Types
  	WordList &wlAttributes = *wlKeywords[5];				// Procedure Attributes
  	WordList &wlStandardEquates = *wlKeywords[6];			// Standard Equates
  	WordList &wlLabelReservedWords = *wlKeywords[7];		// Clarion Reserved Keywords (Labels)
  	WordList &wlProcLabelReservedWords = *wlKeywords[8];	// Clarion Reserved Keywords (Procedure Labels)
  
  	const char wlProcReservedKeywordList[] =
  	"PROCEDURE FUNCTION";
  	WordList wlProcReservedKeywords;
  	wlProcReservedKeywords.Set(wlProcReservedKeywordList);
  
  	const char wlCompilerKeywordList[] =
  	"COMPILE OMIT";
  	WordList wlCompilerKeywords;
  	wlCompilerKeywords.Set(wlCompilerKeywordList);
  
  	const char wlLegacyStatementsList[] =
  	"BOF EOF FUNCTION POINTER SHARE";
  	WordList wlLegacyStatements;
  	wlLegacyStatements.Set(wlLegacyStatementsList);
  
  	StyleContext scDoc(uiStartPos, iLength, iInitStyle, accStyler);
  
  	// lex source code
      for (; scDoc.More(); scDoc.Forward())
  	{
  		//
  		// Determine if the current state should terminate.
  		//
  
  		// Label State Handling
  		if (scDoc.state == SCE_CLW_LABEL) {
  			// If the character is not a valid label
  			if (!IsALabelCharacter(scDoc.ch)) {
  				// If the character is a . (dot syntax)
  				if (scDoc.ch == '.') {
  					// Turn off column 1 label flag as label now cannot be reserved work
  					iColumn1Label = false;
  					// Uncolour the . (dot) to default state, move forward one character,
  					// and change back to the label state.
  					scDoc.SetState(SCE_CLW_DEFAULT);
  					scDoc.Forward();
  					scDoc.SetState(SCE_CLW_LABEL);
  				}
  				// Else check label
  				else {
  					char cLabel[512];		// Label buffer
  					// Buffer the current label string
  					scDoc.GetCurrent(cLabel,sizeof(cLabel));
  					// If case insensitive, convert string to UPPERCASE to match passed keywords.
  					if (!bCaseSensitive) {
  						StringUpper(cLabel);
  					}
  					// Else if UPPERCASE label string is in the Clarion compiler keyword list
  					if (wlCompilerKeywords.InList(cLabel) && iColumn1Label){
  						// change the label to error state
  						scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE);
  					}
  					// Else if UPPERCASE label string is in the Clarion reserved keyword list
  					else if (wlLabelReservedWords.InList(cLabel) && iColumn1Label){
  						// change the label to error state
  						scDoc.ChangeState(SCE_CLW_ERROR);
  					}
  					// Else if UPPERCASE label string is
  					else if (wlProcLabelReservedWords.InList(cLabel) && iColumn1Label) {
  						char cWord[512];	// Word buffer
  						// Get the next word from the current position
  						if (GetNextWordUpper(accStyler,scDoc.currentPos,uiStartPos+iLength,cWord)) {
  							// If the next word is a procedure reserved word
  							if (wlProcReservedKeywords.InList(cWord)) {
  								// Change the label to error state
  								scDoc.ChangeState(SCE_CLW_ERROR);
  							}
  						}
  					}
  					// Else if label string is in the compiler directive keyword list
  					else if (wlCompilerDirectives.InList(cLabel)) {
  						// change the state to compiler directive state
  						scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE);
  					}
  					// Terminate the label state and set to default state
  					scDoc.SetState(SCE_CLW_DEFAULT);
  				}
  			}
  		}
  		// Keyword State Handling
  		else if (scDoc.state == SCE_CLW_KEYWORD) {
  			// If character is : (colon)
  			if (scDoc.ch == ':') {
  				char cEquate[512];		// Equate buffer
  				// Move forward to include : (colon) in buffer
  				scDoc.Forward();
  				// Buffer the equate string
  				scDoc.GetCurrent(cEquate,sizeof(cEquate));
  				// If case insensitive, convert string to UPPERCASE to match passed keywords.
  				if (!bCaseSensitive) {
  					StringUpper(cEquate);
  				}
  				// If statement string is in the equate list
  				if (wlStandardEquates.InList(cEquate)) {
  					// Change to equate state
  					scDoc.ChangeState(SCE_CLW_STANDARD_EQUATE);
  				}
  			}
  			// If the character is not a valid label character
  			else if (!IsALabelCharacter(scDoc.ch)) {
  				char cStatement[512];		// Statement buffer
  				// Buffer the statement string
  				scDoc.GetCurrent(cStatement,sizeof(cStatement));
  				// If case insensitive, convert string to UPPERCASE to match passed keywords.
  				if (!bCaseSensitive) {
  					StringUpper(cStatement);
  				}
  				// If statement string is in the Clarion keyword list
  				if (wlClarionKeywords.InList(cStatement)) {
  					// Change the statement string to the Clarion keyword state
  					scDoc.ChangeState(SCE_CLW_KEYWORD);
  				}
  				// Else if statement string is in the compiler directive keyword list
  				else if (wlCompilerDirectives.InList(cStatement)) {
  					// Change the statement string to the compiler directive state
  					scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE);
  				}
  				// Else if statement string is in the runtime expressions keyword list
  				else if (wlRuntimeExpressions.InList(cStatement)) {
  					// Change the statement string to the runtime expressions state
  					scDoc.ChangeState(SCE_CLW_RUNTIME_EXPRESSIONS);
  				}
  				// Else if statement string is in the builtin procedures and functions keyword list
  				else if (wlBuiltInProcsFuncs.InList(cStatement)) {
  					// Change the statement string to the builtin procedures and functions state
  					scDoc.ChangeState(SCE_CLW_BUILTIN_PROCEDURES_FUNCTION);
  				}
  				// Else if statement string is in the tructures and data types keyword list
  				else if (wlStructsDataTypes.InList(cStatement)) {
  					// Change the statement string to the structures and data types state
  					scDoc.ChangeState(SCE_CLW_STRUCTURE_DATA_TYPE);
  				}
  				// Else if statement string is in the procedure attribute keyword list
  				else if (wlAttributes.InList(cStatement)) {
  					// Change the statement string to the procedure attribute state
  					scDoc.ChangeState(SCE_CLW_ATTRIBUTE);
  				}
  				// Else if statement string is in the standard equate keyword list
  				else if (wlStandardEquates.InList(cStatement)) {
  					// Change the statement string to the standard equate state
  					scDoc.ChangeState(SCE_CLW_STANDARD_EQUATE);
  				}
  				// Else if statement string is in the deprecated or legacy keyword list
  				else if (wlLegacyStatements.InList(cStatement)) {
  					// Change the statement string to the standard equate state
  					scDoc.ChangeState(SCE_CLW_DEPRECATED);
  				}
  				// Else the statement string doesn't match any work list
  				else {
  					// Change the statement string to the default state
  					scDoc.ChangeState(SCE_CLW_DEFAULT);
  				}
  				// Terminate the keyword state and set to default state
  				scDoc.SetState(SCE_CLW_DEFAULT);
  			}
  		}
  		// String State Handling
  		else if (scDoc.state == SCE_CLW_STRING) {
  			// If the character is an ' (single quote)
  			if (scDoc.ch == '\'') {
  				// Set the state to default and move forward colouring
  				// the ' (single quote) as default state
  				// terminating the string state
  				scDoc.SetState(SCE_CLW_DEFAULT);
  				scDoc.Forward();
  			}
  			// If the next character is an ' (single quote)
  			if (scDoc.chNext == '\'') {
  				// Move forward one character and set to default state
  				// colouring the next ' (single quote) as default state
  				// terminating the string state
  				scDoc.ForwardSetState(SCE_CLW_DEFAULT);
  				scDoc.Forward();
  			}
  		}
  		// Picture String State Handling
  		else if (scDoc.state == SCE_CLW_PICTURE_STRING) {
  			// If the character is an ( (open parenthese)
  			if (scDoc.ch == '(') {
  				// Increment the parenthese level
  				iParenthesesLevel++;
  			}
  			// Else if the character is a ) (close parenthese)
  			else if (scDoc.ch == ')') {
  				// If the parenthese level is set to zero
  				// parentheses matched
  				if (!iParenthesesLevel) {
  					scDoc.SetState(SCE_CLW_DEFAULT);
  				}
  				// Else parenthese level is greater than zero
  				// still looking for matching parentheses
  				else {
  					// Decrement the parenthese level
  					iParenthesesLevel--;
  				}
  			}
  		}
  		// Standard Equate State Handling
  		else if (scDoc.state == SCE_CLW_STANDARD_EQUATE) {
  			if (!isalnum(scDoc.ch)) {
  				scDoc.SetState(SCE_CLW_DEFAULT);
  			}
  		}
  		// Integer Constant State Handling
  		else if (scDoc.state == SCE_CLW_INTEGER_CONSTANT) {
  			// If the character is not a digit (0-9)
  			// or character is not a hexidecimal character (A-F)
  			// or character is not a . (point)
  			// or character is not a numberic base character (B,O,H)
  			if (!(isdigit(scDoc.ch)
  			|| IsAHexCharacter(scDoc.ch, bCaseSensitive)
  			|| scDoc.ch == '.'
  			|| IsANumericBaseCharacter(scDoc.ch, bCaseSensitive))) {
  				// If the number was a real
  				if (SetNumericConstantState(scDoc)) {
  					// Colour the matched string to the real constant state
  					scDoc.ChangeState(SCE_CLW_REAL_CONSTANT);
  				}
  				// Else the number was an integer
  				else {
  					// Colour the matched string to an integer constant state
  					scDoc.ChangeState(SCE_CLW_INTEGER_CONSTANT);
  				}
  				// Terminate the integer constant state and set to default state
  				scDoc.SetState(SCE_CLW_DEFAULT);
  			}
  		}
  
  		//
  		// Determine if a new state should be entered.
  		//
  
  		// Beginning of Line Handling
  		if (scDoc.atLineStart) {
  			// Reset the column 1 label flag
  			iColumn1Label = false;
  			// If column 1 character is a label start character
  			if (IsALabelStart(scDoc.ch)) {
  				// Label character is found in column 1
  				// so set column 1 label flag and clear last column 1 label
  				iColumn1Label = true;
  				// Set the state to label
  				scDoc.SetState(SCE_CLW_LABEL);
  			}
  			// else if character is a space or tab
  			else if (IsASpace(scDoc.ch)){
  				// Set to default state
  				scDoc.SetState(SCE_CLW_DEFAULT);
  			}
  			// else if comment start (!) or is an * (asterisk)
  			else if (IsACommentStart(scDoc.ch) || scDoc.ch == '*' ) {
  				// then set the state to comment.
  				scDoc.SetState(SCE_CLW_COMMENT);
  			}
  			// else the character is a ? (question mark)
  			else if (scDoc.ch == '?') {
  				// Change to the compiler directive state, move forward,
  				// colouring the ? (question mark), change back to default state.
  				scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE);
  				scDoc.Forward();
  				scDoc.SetState(SCE_CLW_DEFAULT);
  			}
  			// else an invalid character in column 1
  			else {
  				// Set to error state
  				scDoc.SetState(SCE_CLW_ERROR);
  			}
  		}
  		// End of Line Handling
  		else if (scDoc.atLineEnd) {
  			// Reset to the default state at the end of each line.
  			scDoc.SetState(SCE_CLW_DEFAULT);
  		}
  		// Default Handling
  		else {
  			// If in default state
  			if (scDoc.state == SCE_CLW_DEFAULT) {
  				// If is a letter could be a possible statement
  				if (isalpha(scDoc.ch)) {
  					// Set the state to Clarion Keyword and verify later
  					scDoc.SetState(SCE_CLW_KEYWORD);
  				}
  				// else is a number
  				else if (isdigit(scDoc.ch)) {
  					// Set the state to Integer Constant and verify later
  					scDoc.SetState(SCE_CLW_INTEGER_CONSTANT);
  				}
  				// else if the start of a comment or a | (line continuation)
  				else if (IsACommentStart(scDoc.ch) || scDoc.ch == '|') {
  					// then set the state to comment.
  					scDoc.SetState(SCE_CLW_COMMENT);
  				}
  				// else if the character is a ' (single quote)
  				else if (scDoc.ch == '\'') {
  					// If the character is also a ' (single quote)
  					// Embedded Apostrophe
  					if (scDoc.chNext == '\'') {
  						// Move forward colouring it as default state
  						scDoc.ForwardSetState(SCE_CLW_DEFAULT);
  					}
  					else {
  						// move to the next character and then set the state to comment.
  						scDoc.ForwardSetState(SCE_CLW_STRING);
  					}
  				}
  				// else the character is an @ (ampersand)
  				else if (scDoc.ch == '@') {
  					// Case insensitive.
  					if (!bCaseSensitive) {
  						// If character is a valid picture token character
  						if (strchr("DEKNPSTdeknpst", scDoc.chNext) != NULL) {
  							// Set to the picture string state
  							scDoc.SetState(SCE_CLW_PICTURE_STRING);
  						}
  					}
  					// Case sensitive
  					else {
  						// If character is a valid picture token character
  						if (strchr("DEKNPST", scDoc.chNext) != NULL) {
  							// Set the picture string state
  							scDoc.SetState(SCE_CLW_PICTURE_STRING);
  						}
  					}
  				}
  			}
  		}
  	}
  	// lexing complete
  	scDoc.Complete();
  }
  
  // Clarion Language Case Sensitive Colouring Procedure
  static void ColouriseClarionDocSensitive(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
  
  	ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, true);
  }
  
  // Clarion Language Case Insensitive Colouring Procedure
  static void ColouriseClarionDocInsensitive(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
  
  	ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, false);
  }
  
  // Fill Buffer
  
  static void FillBuffer(Sci_PositionU uiStart, Sci_PositionU uiEnd, Accessor &accStyler, char *szBuffer, Sci_PositionU uiLength) {
  
  	Sci_PositionU uiPos = 0;
  
  	while ((uiPos < uiEnd - uiStart + 1) && (uiPos < uiLength-1)) {
  		szBuffer[uiPos] = static_cast<char>(toupper(accStyler[uiStart + uiPos]));
  		uiPos++;
  	}
  	szBuffer[uiPos] = '\0';
  }
  
  // Classify Clarion Fold Point
  
  static int ClassifyClarionFoldPoint(int iLevel, const char* szString) {
  
  	if (!(isdigit(szString[0]) || (szString[0] == '.'))) {
  		if (strcmp(szString, "PROCEDURE") == 0) {
  	//		iLevel = SC_FOLDLEVELBASE + 1;
  		}
  		else if (strcmp(szString, "MAP") == 0 ||
  			strcmp(szString,"ACCEPT") == 0 ||
  			strcmp(szString,"BEGIN") == 0 ||
  			strcmp(szString,"CASE") == 0 ||
  			strcmp(szString,"EXECUTE") == 0 ||
  			strcmp(szString,"IF") == 0 ||
  			strcmp(szString,"ITEMIZE") == 0 ||
  			strcmp(szString,"INTERFACE") == 0 ||
  			strcmp(szString,"JOIN") == 0 ||
  			strcmp(szString,"LOOP") == 0 ||
  			strcmp(szString,"MODULE") == 0 ||
  			strcmp(szString,"RECORD") == 0) {
  			iLevel++;
  		}
  		else if (strcmp(szString, "APPLICATION") == 0 ||
  			strcmp(szString, "CLASS") == 0 ||
  			strcmp(szString, "DETAIL") == 0 ||
  			strcmp(szString, "FILE") == 0 ||
  			strcmp(szString, "FOOTER") == 0 ||
  			strcmp(szString, "FORM") == 0 ||
  			strcmp(szString, "GROUP") == 0 ||
  			strcmp(szString, "HEADER") == 0 ||
  			strcmp(szString, "INTERFACE") == 0 ||
  			strcmp(szString, "MENU") == 0 ||
  			strcmp(szString, "MENUBAR") == 0 ||
  			strcmp(szString, "OLE") == 0 ||
  			strcmp(szString, "OPTION") == 0 ||
  			strcmp(szString, "QUEUE") == 0 ||
  			strcmp(szString, "REPORT") == 0 ||
  			strcmp(szString, "SHEET") == 0 ||
  			strcmp(szString, "TAB") == 0 ||
  			strcmp(szString, "TOOLBAR") == 0 ||
  			strcmp(szString, "VIEW") == 0 ||
  			strcmp(szString, "WINDOW") == 0) {
  			iLevel++;
  		}
  		else if (strcmp(szString, "END") == 0 ||
  			strcmp(szString, "UNTIL") == 0 ||
  			strcmp(szString, "WHILE") == 0) {
  			iLevel--;
  		}
  	}
  	return(iLevel);
  }
  
  // Clarion Language Folding Procedure
  static void FoldClarionDoc(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *[], Accessor &accStyler) {
  
  	Sci_PositionU uiEndPos = uiStartPos + iLength;
  	Sci_Position iLineCurrent = accStyler.GetLine(uiStartPos);
  	int iLevelPrev = accStyler.LevelAt(iLineCurrent) & SC_FOLDLEVELNUMBERMASK;
  	int iLevelCurrent = iLevelPrev;
  	char chNext = accStyler[uiStartPos];
  	int iStyle = iInitStyle;
  	int iStyleNext = accStyler.StyleAt(uiStartPos);
  	int iVisibleChars = 0;
  	Sci_Position iLastStart = 0;
  
  	for (Sci_PositionU uiPos = uiStartPos; uiPos < uiEndPos; uiPos++) {
  
  		char chChar = chNext;
  		chNext = accStyler.SafeGetCharAt(uiPos + 1);
  		int iStylePrev = iStyle;
  		iStyle = iStyleNext;
  		iStyleNext = accStyler.StyleAt(uiPos + 1);
  		bool bEOL = (chChar == '\r' && chNext != '\n') || (chChar == '\n');
  
  		if (iStylePrev == SCE_CLW_DEFAULT) {
  			if (iStyle == SCE_CLW_KEYWORD || iStyle == SCE_CLW_STRUCTURE_DATA_TYPE) {
  				// Store last word start point.
  				iLastStart = uiPos;
  			}
  		}
  
  		if (iStylePrev == SCE_CLW_KEYWORD || iStylePrev == SCE_CLW_STRUCTURE_DATA_TYPE) {
  			if(iswordchar(chChar) && !iswordchar(chNext)) {
  				char chBuffer[100];
  				FillBuffer(iLastStart, uiPos, accStyler, chBuffer, sizeof(chBuffer));
  				iLevelCurrent = ClassifyClarionFoldPoint(iLevelCurrent,chBuffer);
  			//	if ((iLevelCurrent == SC_FOLDLEVELBASE + 1) && iLineCurrent > 1) {
  			//		accStyler.SetLevel(iLineCurrent-1,SC_FOLDLEVELBASE);
  			//		iLevelPrev = SC_FOLDLEVELBASE;
  			//	}
  			}
  		}
  
  		if (bEOL) {
  			int iLevel = iLevelPrev;
  			if ((iLevelCurrent > iLevelPrev) && (iVisibleChars > 0))
  				iLevel |= SC_FOLDLEVELHEADERFLAG;
  			if (iLevel != accStyler.LevelAt(iLineCurrent)) {
  				accStyler.SetLevel(iLineCurrent,iLevel);
  			}
  			iLineCurrent++;
  			iLevelPrev = iLevelCurrent;
  			iVisibleChars = 0;
  		}
  
  		if (!isspacechar(chChar))
  			iVisibleChars++;
  	}
  
  	// Fill in the real level of the next line, keeping the current flags
  	// as they will be filled in later.
  	int iFlagsNext = accStyler.LevelAt(iLineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
  	accStyler.SetLevel(iLineCurrent, iLevelPrev | iFlagsNext);
  }
  
  // Word List Descriptions
  static const char * const rgWordListDescriptions[] = {
  	"Clarion Keywords",
  	"Compiler Directives",
  	"Built-in Procedures and Functions",
  	"Runtime Expressions",
  	"Structure and Data Types",
  	"Attributes",
  	"Standard Equates",
  	"Reserved Words (Labels)",
  	"Reserved Words (Procedure Labels)",
  	0,
  };
  
  // Case Sensitive Clarion Language Lexer
  LexerModule lmClw(SCLEX_CLW, ColouriseClarionDocSensitive, "clarion", FoldClarionDoc, rgWordListDescriptions);
  
  // Case Insensitive Clarion Language Lexer
  LexerModule lmClwNoCase(SCLEX_CLWNOCASE, ColouriseClarionDocInsensitive, "clarionnocase", FoldClarionDoc, rgWordListDescriptions);
  