chore: bump scintilla and lexilla version
This commit is contained in:
995
3rdparty/lexilla545/lexilla/lexers/LexBaan.cxx
vendored
Normal file
995
3rdparty/lexilla545/lexilla/lexers/LexBaan.cxx
vendored
Normal file
@ -0,0 +1,995 @@
|
||||
// Scintilla source code edit control
|
||||
/** @file LexBaan.cxx
|
||||
** Lexer for Baan.
|
||||
** Based heavily on LexCPP.cxx
|
||||
**/
|
||||
// Copyright 2001- by Vamsi Potluru <vamsi@who.net> & Praveen Ambekar <ambekarpraveen@yahoo.com>
|
||||
// Maintainer Email: oirfeodent@yahoo.co.in
|
||||
// The License.txt file describes the conditions under which this software may be distributed.
|
||||
|
||||
// C standard library
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// C++ wrappers of C standard library
|
||||
#include <cassert>
|
||||
|
||||
// C++ standard library
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <map>
|
||||
#include <functional>
|
||||
|
||||
// Scintilla headers
|
||||
|
||||
// Non-platform-specific headers
|
||||
|
||||
// include
|
||||
#include "ILexer.h"
|
||||
#include "Scintilla.h"
|
||||
#include "SciLexer.h"
|
||||
|
||||
// lexlib
|
||||
#include "WordList.h"
|
||||
#include "LexAccessor.h"
|
||||
#include "StyleContext.h"
|
||||
#include "CharacterSet.h"
|
||||
#include "LexerModule.h"
|
||||
#include "OptionSet.h"
|
||||
#include "DefaultLexer.h"
|
||||
|
||||
using namespace Scintilla;
|
||||
using namespace Lexilla;
|
||||
|
||||
namespace {
|
||||
// Use an unnamed namespace to protect the functions and classes from name conflicts
|
||||
|
||||
// Options used for LexerBaan
|
||||
struct OptionsBaan {
|
||||
bool fold;
|
||||
bool foldComment;
|
||||
bool foldPreprocessor;
|
||||
bool foldCompact;
|
||||
bool baanFoldSyntaxBased;
|
||||
bool baanFoldKeywordsBased;
|
||||
bool baanFoldSections;
|
||||
bool baanFoldInnerLevel;
|
||||
bool baanStylingWithinPreprocessor;
|
||||
OptionsBaan() {
|
||||
fold = false;
|
||||
foldComment = false;
|
||||
foldPreprocessor = false;
|
||||
foldCompact = false;
|
||||
baanFoldSyntaxBased = false;
|
||||
baanFoldKeywordsBased = false;
|
||||
baanFoldSections = false;
|
||||
baanFoldInnerLevel = false;
|
||||
baanStylingWithinPreprocessor = false;
|
||||
}
|
||||
};
|
||||
|
||||
const char *const baanWordLists[] = {
|
||||
"Baan & BaanSQL Reserved Keywords ",
|
||||
"Baan Standard functions",
|
||||
"Baan Functions Abridged",
|
||||
"Baan Main Sections ",
|
||||
"Baan Sub Sections",
|
||||
"PreDefined Variables",
|
||||
"PreDefined Attributes",
|
||||
"Enumerates",
|
||||
0,
|
||||
};
|
||||
|
||||
struct OptionSetBaan : public OptionSet<OptionsBaan> {
|
||||
OptionSetBaan() {
|
||||
DefineProperty("fold", &OptionsBaan::fold);
|
||||
|
||||
DefineProperty("fold.comment", &OptionsBaan::foldComment);
|
||||
|
||||
DefineProperty("fold.preprocessor", &OptionsBaan::foldPreprocessor);
|
||||
|
||||
DefineProperty("fold.compact", &OptionsBaan::foldCompact);
|
||||
|
||||
DefineProperty("fold.baan.syntax.based", &OptionsBaan::baanFoldSyntaxBased,
|
||||
"Set this property to 0 to disable syntax based folding, which is folding based on '{' & '('.");
|
||||
|
||||
DefineProperty("fold.baan.keywords.based", &OptionsBaan::baanFoldKeywordsBased,
|
||||
"Set this property to 0 to disable keywords based folding, which is folding based on "
|
||||
" for, if, on (case), repeat, select, while and fold ends based on endfor, endif, endcase, until, endselect, endwhile respectively."
|
||||
"Also folds declarations which are grouped together.");
|
||||
|
||||
DefineProperty("fold.baan.sections", &OptionsBaan::baanFoldSections,
|
||||
"Set this property to 0 to disable folding of Main Sections as well as Sub Sections.");
|
||||
|
||||
DefineProperty("fold.baan.inner.level", &OptionsBaan::baanFoldInnerLevel,
|
||||
"Set this property to 1 to enable folding of inner levels of select statements."
|
||||
"Disabled by default. case and if statements are also eligible" );
|
||||
|
||||
DefineProperty("lexer.baan.styling.within.preprocessor", &OptionsBaan::baanStylingWithinPreprocessor,
|
||||
"For Baan code, determines whether all preprocessor code is styled in the "
|
||||
"preprocessor style (0, the default) or only from the initial # to the end "
|
||||
"of the command word(1).");
|
||||
|
||||
DefineWordListSets(baanWordLists);
|
||||
}
|
||||
};
|
||||
|
||||
static inline bool IsAWordChar(const int ch) {
|
||||
return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '$');
|
||||
}
|
||||
|
||||
static inline bool IsAnOperator(int ch) {
|
||||
if (IsAlphaNumeric(ch))
|
||||
return false;
|
||||
if (ch == '#' || ch == '^' || ch == '&' || ch == '*' ||
|
||||
ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
|
||||
ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
|
||||
ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
|
||||
ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
|
||||
ch == '?' || ch == '!' || ch == '"' || ch == '~' ||
|
||||
ch == '\\')
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline int IsAnyOtherIdentifier(char *s, Sci_Position sLength) {
|
||||
|
||||
/* IsAnyOtherIdentifier uses standard templates used in baan.
|
||||
The matching template is shown as comments just above the return condition.
|
||||
^ - refers to any character [a-z].
|
||||
# - refers to any number [0-9].
|
||||
Other characters shown are compared as is.
|
||||
Tried implementing with Regex... it was too complicated for me.
|
||||
Any other implementation suggestion welcome.
|
||||
*/
|
||||
switch (sLength) {
|
||||
case 8:
|
||||
if (isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
//^^^^^###
|
||||
return(SCE_BAAN_TABLEDEF);
|
||||
}
|
||||
break;
|
||||
case 9:
|
||||
if (s[0] == 't' && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && isalpha(s[5]) && IsADigit(s[6]) && IsADigit(s[7]) && IsADigit(s[8])) {
|
||||
//t^^^^^###
|
||||
return(SCE_BAAN_TABLEDEF);
|
||||
}
|
||||
else if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
//^^^^^###.
|
||||
return(SCE_BAAN_TABLESQL);
|
||||
}
|
||||
break;
|
||||
case 13:
|
||||
if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
//^^^^^###.****
|
||||
return(SCE_BAAN_TABLESQL);
|
||||
}
|
||||
else if (s[0] == 'r' && s[1] == 'c' && s[2] == 'd' && s[3] == '.' && s[4] == 't' && isalpha(s[5]) && isalpha(s[6]) && isalpha(s[7]) && isalpha(s[8]) && isalpha(s[9]) && IsADigit(s[10]) && IsADigit(s[11]) && IsADigit(s[12])) {
|
||||
//rcd.t^^^^^###
|
||||
return(SCE_BAAN_TABLEDEF);
|
||||
}
|
||||
break;
|
||||
case 14:
|
||||
case 15:
|
||||
if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
if (s[13] != ':') {
|
||||
//^^^^^###.******
|
||||
return(SCE_BAAN_TABLESQL);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
case 17:
|
||||
if (s[8] == '.' && s[9] == '_' && s[10] == 'i' && s[11] == 'n' && s[12] == 'd' && s[13] == 'e' && s[14] == 'x' && IsADigit(s[15]) && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
//^^^^^###._index##
|
||||
return(SCE_BAAN_TABLEDEF);
|
||||
}
|
||||
else if (s[8] == '.' && s[9] == '_' && s[10] == 'c' && s[11] == 'o' && s[12] == 'm' && s[13] == 'p' && s[14] == 'n' && s[15] == 'r' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
|
||||
//^^^^^###._compnr
|
||||
return(SCE_BAAN_TABLEDEF);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (sLength > 14 && s[5] == '.' && s[6] == 'd' && s[7] == 'l' && s[8] == 'l' && s[13] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[9]) && IsADigit(s[10]) && IsADigit(s[11]) && IsADigit(s[12])) {
|
||||
//^^^^^.dll####.
|
||||
return(SCE_BAAN_FUNCTION);
|
||||
}
|
||||
else if (sLength > 15 && s[2] == 'i' && s[3] == 'n' && s[4] == 't' && s[5] == '.' && s[6] == 'd' && s[7] == 'l' && s[8] == 'l' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[9]) && isalpha(s[10]) && isalpha(s[11]) && isalpha(s[12]) && isalpha(s[13])) {
|
||||
//^^int.dll^^^^^.
|
||||
return(SCE_BAAN_FUNCTION);
|
||||
}
|
||||
else if (sLength > 11 && s[0] == 'i' && s[10] == '.' && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && isalpha(s[5]) && IsADigit(s[6]) && IsADigit(s[7]) && IsADigit(s[8]) && IsADigit(s[9])) {
|
||||
//i^^^^^####.
|
||||
return(SCE_BAAN_FUNCTION);
|
||||
}
|
||||
|
||||
return(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
|
||||
static bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (ch == '|' && style == SCE_BAAN_COMMENT)
|
||||
return true;
|
||||
else if (!IsASpaceOrTab(ch))
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool IsPreProcLine(Sci_Position line, LexAccessor &styler) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (ch == '#' && style == SCE_BAAN_PREPROCESSOR) {
|
||||
if (styler.Match(i, "#elif") || styler.Match(i, "#else") || styler.Match(i, "#endif")
|
||||
|| styler.Match(i, "#if") || styler.Match(i, "#ifdef") || styler.Match(i, "#ifndef"))
|
||||
// Above PreProcessors has a seperate fold mechanism.
|
||||
return false;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
else if (ch == '^')
|
||||
return true;
|
||||
else if (!IsASpaceOrTab(ch))
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static int mainOrSubSectionLine(Sci_Position line, LexAccessor &styler) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (style == SCE_BAAN_WORD5 || style == SCE_BAAN_WORD4)
|
||||
return style;
|
||||
else if (IsASpaceOrTab(ch))
|
||||
continue;
|
||||
else
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool priorSectionIsSubSection(Sci_Position line, LexAccessor &styler){
|
||||
while (line > 0) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (style == SCE_BAAN_WORD4)
|
||||
return true;
|
||||
else if (style == SCE_BAAN_WORD5)
|
||||
return false;
|
||||
else if (IsASpaceOrTab(ch))
|
||||
continue;
|
||||
else
|
||||
break;
|
||||
}
|
||||
line--;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool nextSectionIsSubSection(Sci_Position line, LexAccessor &styler) {
|
||||
while (line > 0) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (style == SCE_BAAN_WORD4)
|
||||
return true;
|
||||
else if (style == SCE_BAAN_WORD5)
|
||||
return false;
|
||||
else if (IsASpaceOrTab(ch))
|
||||
continue;
|
||||
else
|
||||
break;
|
||||
}
|
||||
line++;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool IsDeclarationLine(Sci_Position line, LexAccessor &styler) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (style == SCE_BAAN_WORD) {
|
||||
if (styler.Match(i, "table") || styler.Match(i, "extern") || styler.Match(i, "long")
|
||||
|| styler.Match(i, "double") || styler.Match(i, "boolean") || styler.Match(i, "string")
|
||||
|| styler.Match(i, "domain")) {
|
||||
for (Sci_Position j = eol_pos; j > pos; j--) {
|
||||
int styleFromEnd = styler.StyleAt(j);
|
||||
if (styleFromEnd == SCE_BAAN_COMMENT)
|
||||
continue;
|
||||
else if (IsASpace(styler[j]))
|
||||
continue;
|
||||
else if (styler[j] != ',')
|
||||
//Above conditions ensures, Declaration is not part of any function parameters.
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
else if (!IsASpaceOrTab(ch))
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool IsInnerLevelFold(Sci_Position line, LexAccessor &styler) {
|
||||
Sci_Position pos = styler.LineStart(line);
|
||||
Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
|
||||
for (Sci_Position i = pos; i < eol_pos; i++) {
|
||||
char ch = styler[i];
|
||||
int style = styler.StyleAt(i);
|
||||
if (style == SCE_BAAN_WORD && (styler.Match(i, "else" ) || styler.Match(i, "case")
|
||||
|| styler.Match(i, "default") || styler.Match(i, "selectdo") || styler.Match(i, "selecteos")
|
||||
|| styler.Match(i, "selectempty") || styler.Match(i, "selecterror")))
|
||||
return true;
|
||||
else if (IsASpaceOrTab(ch))
|
||||
continue;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool wordInArray(const std::string& value, std::string *array, int length)
|
||||
{
|
||||
for (int i = 0; i < length; i++)
|
||||
{
|
||||
if (value == array[i])
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
class WordListAbridged : public WordList {
|
||||
public:
|
||||
WordListAbridged() {
|
||||
kwAbridged = false;
|
||||
kwHasSection = false;
|
||||
};
|
||||
~WordListAbridged() {
|
||||
Clear();
|
||||
};
|
||||
bool kwAbridged;
|
||||
bool kwHasSection;
|
||||
bool Contains(const char *s) {
|
||||
return kwAbridged ? InListAbridged(s, '~') : InList(s);
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
class LexerBaan : public DefaultLexer {
|
||||
WordListAbridged keywords;
|
||||
WordListAbridged keywords2;
|
||||
WordListAbridged keywords3;
|
||||
WordListAbridged keywords4;
|
||||
WordListAbridged keywords5;
|
||||
WordListAbridged keywords6;
|
||||
WordListAbridged keywords7;
|
||||
WordListAbridged keywords8;
|
||||
WordListAbridged keywords9;
|
||||
OptionsBaan options;
|
||||
OptionSetBaan osBaan;
|
||||
public:
|
||||
LexerBaan() : DefaultLexer("baan", SCLEX_BAAN) {
|
||||
}
|
||||
|
||||
virtual ~LexerBaan() {
|
||||
}
|
||||
|
||||
int SCI_METHOD Version() const override {
|
||||
return lvRelease5;
|
||||
}
|
||||
|
||||
void SCI_METHOD Release() override {
|
||||
delete this;
|
||||
}
|
||||
|
||||
const char * SCI_METHOD PropertyNames() override {
|
||||
return osBaan.PropertyNames();
|
||||
}
|
||||
|
||||
int SCI_METHOD PropertyType(const char * name) override {
|
||||
return osBaan.PropertyType(name);
|
||||
}
|
||||
|
||||
const char * SCI_METHOD DescribeProperty(const char * name) override {
|
||||
return osBaan.DescribeProperty(name);
|
||||
}
|
||||
|
||||
Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
|
||||
|
||||
const char * SCI_METHOD PropertyGet(const char *key) override {
|
||||
return osBaan.PropertyGet(key);
|
||||
}
|
||||
|
||||
const char * SCI_METHOD DescribeWordListSets() override {
|
||||
return osBaan.DescribeWordListSets();
|
||||
}
|
||||
|
||||
Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
|
||||
|
||||
void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
|
||||
|
||||
void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
|
||||
|
||||
void * SCI_METHOD PrivateCall(int, void *) override {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static ILexer5 * LexerFactoryBaan() {
|
||||
return new LexerBaan();
|
||||
}
|
||||
};
|
||||
|
||||
Sci_Position SCI_METHOD LexerBaan::PropertySet(const char *key, const char *val) {
|
||||
if (osBaan.PropertySet(&options, key, val)) {
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
Sci_Position SCI_METHOD LexerBaan::WordListSet(int n, const char *wl) {
|
||||
WordListAbridged *WordListAbridgedN = 0;
|
||||
switch (n) {
|
||||
case 0:
|
||||
WordListAbridgedN = &keywords;
|
||||
break;
|
||||
case 1:
|
||||
WordListAbridgedN = &keywords2;
|
||||
break;
|
||||
case 2:
|
||||
WordListAbridgedN = &keywords3;
|
||||
break;
|
||||
case 3:
|
||||
WordListAbridgedN = &keywords4;
|
||||
break;
|
||||
case 4:
|
||||
WordListAbridgedN = &keywords5;
|
||||
break;
|
||||
case 5:
|
||||
WordListAbridgedN = &keywords6;
|
||||
break;
|
||||
case 6:
|
||||
WordListAbridgedN = &keywords7;
|
||||
break;
|
||||
case 7:
|
||||
WordListAbridgedN = &keywords8;
|
||||
break;
|
||||
case 8:
|
||||
WordListAbridgedN = &keywords9;
|
||||
break;
|
||||
}
|
||||
Sci_Position firstModification = -1;
|
||||
if (WordListAbridgedN) {
|
||||
WordListAbridged wlNew;
|
||||
wlNew.Set(wl);
|
||||
if (*WordListAbridgedN != wlNew) {
|
||||
WordListAbridgedN->Set(wl);
|
||||
WordListAbridgedN->kwAbridged = strchr(wl, '~') != NULL;
|
||||
WordListAbridgedN->kwHasSection = strchr(wl, ':') != NULL;
|
||||
|
||||
firstModification = 0;
|
||||
}
|
||||
}
|
||||
return firstModification;
|
||||
}
|
||||
|
||||
void SCI_METHOD LexerBaan::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
|
||||
|
||||
if (initStyle == SCE_BAAN_STRINGEOL) // Does not leak onto next line
|
||||
initStyle = SCE_BAAN_DEFAULT;
|
||||
|
||||
int visibleChars = 0;
|
||||
bool lineHasDomain = false;
|
||||
bool lineHasFunction = false;
|
||||
bool lineHasPreProc = false;
|
||||
bool lineIgnoreString = false;
|
||||
bool lineHasDefines = false;
|
||||
bool numberIsHex = false;
|
||||
char word[1000];
|
||||
int wordlen = 0;
|
||||
|
||||
std::string preProcessorTags[13] = { "#context_off", "#context_on",
|
||||
"#define", "#elif", "#else", "#endif",
|
||||
"#ident", "#if", "#ifdef", "#ifndef",
|
||||
"#include", "#pragma", "#undef" };
|
||||
LexAccessor styler(pAccess);
|
||||
StyleContext sc(startPos, length, initStyle, styler);
|
||||
|
||||
for (; sc.More(); sc.Forward()) {
|
||||
|
||||
// Determine if the current state should terminate.
|
||||
switch (sc.state) {
|
||||
case SCE_BAAN_OPERATOR:
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
break;
|
||||
case SCE_BAAN_NUMBER:
|
||||
if (IsASpaceOrTab(sc.ch) || sc.ch == '\r' || sc.ch == '\n' || IsAnOperator(sc.ch)) {
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
else if ((numberIsHex && !(MakeLowerCase(sc.ch) == 'x' || MakeLowerCase(sc.ch) == 'e' ||
|
||||
IsADigit(sc.ch, 16) || sc.ch == '.' || sc.ch == '-' || sc.ch == '+')) ||
|
||||
(!numberIsHex && !(MakeLowerCase(sc.ch) == 'e' || IsADigit(sc.ch)
|
||||
|| sc.ch == '.' || sc.ch == '-' || sc.ch == '+'))) {
|
||||
// check '-' for possible -10e-5. Add '+' as well.
|
||||
numberIsHex = false;
|
||||
sc.ChangeState(SCE_BAAN_IDENTIFIER);
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
break;
|
||||
case SCE_BAAN_IDENTIFIER:
|
||||
if (!IsAWordChar(sc.ch)) {
|
||||
char s[1000];
|
||||
char s1[1000];
|
||||
sc.GetCurrentLowered(s, sizeof(s));
|
||||
if (sc.ch == ':') {
|
||||
memcpy(s1, s, sizeof(s));
|
||||
s1[sc.LengthCurrent()] = sc.ch;
|
||||
s1[sc.LengthCurrent() + 1] = '\0';
|
||||
}
|
||||
if ((keywords.kwHasSection && (sc.ch == ':')) ? keywords.Contains(s1) : keywords.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD);
|
||||
if (0 == strcmp(s, "domain")) {
|
||||
lineHasDomain = true;
|
||||
}
|
||||
else if (0 == strcmp(s, "function")) {
|
||||
lineHasFunction = true;
|
||||
}
|
||||
}
|
||||
else if (lineHasDomain) {
|
||||
sc.ChangeState(SCE_BAAN_DOMDEF);
|
||||
lineHasDomain = false;
|
||||
}
|
||||
else if (lineHasFunction) {
|
||||
sc.ChangeState(SCE_BAAN_FUNCDEF);
|
||||
lineHasFunction = false;
|
||||
}
|
||||
else if ((keywords2.kwHasSection && (sc.ch == ':')) ? keywords2.Contains(s1) : keywords2.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD2);
|
||||
}
|
||||
else if ((keywords3.kwHasSection && (sc.ch == ':')) ? keywords3.Contains(s1) : keywords3.Contains(s)) {
|
||||
if (sc.ch == '(')
|
||||
sc.ChangeState(SCE_BAAN_WORD3);
|
||||
else
|
||||
sc.ChangeState(SCE_BAAN_IDENTIFIER);
|
||||
}
|
||||
else if ((keywords4.kwHasSection && (sc.ch == ':')) ? keywords4.Contains(s1) : keywords4.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD4);
|
||||
}
|
||||
else if ((keywords5.kwHasSection && (sc.ch == ':')) ? keywords5.Contains(s1) : keywords5.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD5);
|
||||
}
|
||||
else if ((keywords6.kwHasSection && (sc.ch == ':')) ? keywords6.Contains(s1) : keywords6.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD6);
|
||||
}
|
||||
else if ((keywords7.kwHasSection && (sc.ch == ':')) ? keywords7.Contains(s1) : keywords7.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD7);
|
||||
}
|
||||
else if ((keywords8.kwHasSection && (sc.ch == ':')) ? keywords8.Contains(s1) : keywords8.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD8);
|
||||
}
|
||||
else if ((keywords9.kwHasSection && (sc.ch == ':')) ? keywords9.Contains(s1) : keywords9.Contains(s)) {
|
||||
sc.ChangeState(SCE_BAAN_WORD9);
|
||||
}
|
||||
else if (lineHasPreProc) {
|
||||
sc.ChangeState(SCE_BAAN_OBJECTDEF);
|
||||
lineHasPreProc = false;
|
||||
}
|
||||
else if (lineHasDefines) {
|
||||
sc.ChangeState(SCE_BAAN_DEFINEDEF);
|
||||
lineHasDefines = false;
|
||||
}
|
||||
else {
|
||||
int state = IsAnyOtherIdentifier(s, sc.LengthCurrent());
|
||||
if (state > 0) {
|
||||
sc.ChangeState(state);
|
||||
}
|
||||
}
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
break;
|
||||
case SCE_BAAN_PREPROCESSOR:
|
||||
if (options.baanStylingWithinPreprocessor) {
|
||||
if (IsASpace(sc.ch) || IsAnOperator(sc.ch)) {
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (sc.atLineEnd && (sc.chNext != '^')) {
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SCE_BAAN_COMMENT:
|
||||
if (sc.ch == '\r' || sc.ch == '\n') {
|
||||
sc.SetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
break;
|
||||
case SCE_BAAN_COMMENTDOC:
|
||||
if (sc.MatchIgnoreCase("enddllusage")) {
|
||||
for (unsigned int i = 0; i < 10; i++) {
|
||||
sc.Forward();
|
||||
}
|
||||
sc.ForwardSetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
else if (sc.MatchIgnoreCase("endfunctionusage")) {
|
||||
for (unsigned int i = 0; i < 15; i++) {
|
||||
sc.Forward();
|
||||
}
|
||||
sc.ForwardSetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
break;
|
||||
case SCE_BAAN_STRING:
|
||||
if (sc.ch == '\"') {
|
||||
sc.ForwardSetState(SCE_BAAN_DEFAULT);
|
||||
}
|
||||
else if ((sc.atLineEnd) && (sc.chNext != '^')) {
|
||||
sc.ChangeState(SCE_BAAN_STRINGEOL);
|
||||
sc.ForwardSetState(SCE_BAAN_DEFAULT);
|
||||
visibleChars = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// Determine if a new state should be entered.
|
||||
if (sc.state == SCE_BAAN_DEFAULT) {
|
||||
if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))
|
||||
|| ((sc.ch == '-' || sc.ch == '+') && (IsADigit(sc.chNext) || sc.chNext == '.'))
|
||||
|| (MakeLowerCase(sc.ch) == 'e' && (IsADigit(sc.chNext) || sc.chNext == '+' || sc.chNext == '-'))) {
|
||||
if ((sc.ch == '0' && MakeLowerCase(sc.chNext) == 'x') ||
|
||||
((sc.ch == '-' || sc.ch == '+') && sc.chNext == '0' && MakeLowerCase(sc.GetRelativeCharacter(2)) == 'x')){
|
||||
numberIsHex = true;
|
||||
}
|
||||
sc.SetState(SCE_BAAN_NUMBER);
|
||||
}
|
||||
else if (sc.MatchIgnoreCase("dllusage") || sc.MatchIgnoreCase("functionusage")) {
|
||||
sc.SetState(SCE_BAAN_COMMENTDOC);
|
||||
do {
|
||||
sc.Forward();
|
||||
} while ((!sc.atLineEnd) && sc.More());
|
||||
}
|
||||
else if (iswordstart(sc.ch)) {
|
||||
sc.SetState(SCE_BAAN_IDENTIFIER);
|
||||
}
|
||||
else if (sc.Match('|')) {
|
||||
sc.SetState(SCE_BAAN_COMMENT);
|
||||
}
|
||||
else if (sc.ch == '\"' && !(lineIgnoreString)) {
|
||||
sc.SetState(SCE_BAAN_STRING);
|
||||
}
|
||||
else if (sc.ch == '#' && visibleChars == 0) {
|
||||
// Preprocessor commands are alone on their line
|
||||
sc.SetState(SCE_BAAN_PREPROCESSOR);
|
||||
word[0] = '\0';
|
||||
wordlen = 0;
|
||||
while (sc.More() && !(IsASpace(sc.chNext) || IsAnOperator(sc.chNext))) {
|
||||
sc.Forward();
|
||||
wordlen++;
|
||||
}
|
||||
sc.GetCurrentLowered(word, sizeof(word));
|
||||
if (!sc.atLineEnd) {
|
||||
word[wordlen++] = sc.ch;
|
||||
word[wordlen++] = '\0';
|
||||
}
|
||||
if (!wordInArray(word, preProcessorTags, 13))
|
||||
// Colorise only preprocessor built in Baan.
|
||||
sc.ChangeState(SCE_BAAN_IDENTIFIER);
|
||||
if (strcmp(word, "#pragma") == 0 || strcmp(word, "#include") == 0) {
|
||||
lineHasPreProc = true;
|
||||
lineIgnoreString = true;
|
||||
}
|
||||
else if (strcmp(word, "#define") == 0 || strcmp(word, "#undef") == 0 ||
|
||||
strcmp(word, "#ifdef") == 0 || strcmp(word, "#if") == 0 || strcmp(word, "#ifndef") == 0) {
|
||||
lineHasDefines = true;
|
||||
lineIgnoreString = false;
|
||||
}
|
||||
}
|
||||
else if (IsAnOperator(static_cast<char>(sc.ch))) {
|
||||
sc.SetState(SCE_BAAN_OPERATOR);
|
||||
}
|
||||
}
|
||||
|
||||
if (sc.atLineEnd) {
|
||||
// Reset states to begining of colourise so no surprises
|
||||
// if different sets of lines lexed.
|
||||
visibleChars = 0;
|
||||
lineHasDomain = false;
|
||||
lineHasFunction = false;
|
||||
lineHasPreProc = false;
|
||||
lineIgnoreString = false;
|
||||
lineHasDefines = false;
|
||||
numberIsHex = false;
|
||||
}
|
||||
if (!IsASpace(sc.ch)) {
|
||||
visibleChars++;
|
||||
}
|
||||
}
|
||||
sc.Complete();
|
||||
}
|
||||
|
||||
void SCI_METHOD LexerBaan::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
|
||||
if (!options.fold)
|
||||
return;
|
||||
|
||||
char word[100];
|
||||
int wordlen = 0;
|
||||
bool foldStart = true;
|
||||
bool foldNextSelect = true;
|
||||
bool afterFunctionSection = false;
|
||||
bool beforeDeclarationSection = false;
|
||||
int currLineStyle = 0;
|
||||
int nextLineStyle = 0;
|
||||
|
||||
std::string startTags[6] = { "for", "if", "on", "repeat", "select", "while" };
|
||||
std::string endTags[6] = { "endcase", "endfor", "endif", "endselect", "endwhile", "until" };
|
||||
std::string selectCloseTags[5] = { "selectdo", "selecteos", "selectempty", "selecterror", "endselect" };
|
||||
|
||||
LexAccessor styler(pAccess);
|
||||
Sci_PositionU endPos = startPos + length;
|
||||
int visibleChars = 0;
|
||||
Sci_Position lineCurrent = styler.GetLine(startPos);
|
||||
|
||||
// Backtrack to previous line in case need to fix its fold status
|
||||
if (startPos > 0) {
|
||||
if (lineCurrent > 0) {
|
||||
lineCurrent--;
|
||||
startPos = styler.LineStart(lineCurrent);
|
||||
}
|
||||
}
|
||||
|
||||
int levelPrev = SC_FOLDLEVELBASE;
|
||||
if (lineCurrent > 0)
|
||||
levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
|
||||
int levelCurrent = levelPrev;
|
||||
char chNext = styler[startPos];
|
||||
int style = initStyle;
|
||||
int styleNext = styler.StyleAt(startPos);
|
||||
|
||||
for (Sci_PositionU i = startPos; i < endPos; i++) {
|
||||
char ch = chNext;
|
||||
chNext = styler.SafeGetCharAt(i + 1);
|
||||
style = styleNext;
|
||||
styleNext = styler.StyleAt(i + 1);
|
||||
int stylePrev = (i) ? styler.StyleAt(i - 1) : SCE_BAAN_DEFAULT;
|
||||
bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
|
||||
|
||||
// Comment folding
|
||||
if (options.foldComment && style == SCE_BAAN_COMMENTDOC) {
|
||||
if (style != stylePrev) {
|
||||
levelCurrent++;
|
||||
}
|
||||
else if (style != styleNext) {
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
|
||||
if (!IsCommentLine(lineCurrent - 1, styler)
|
||||
&& IsCommentLine(lineCurrent + 1, styler))
|
||||
levelCurrent++;
|
||||
else if (IsCommentLine(lineCurrent - 1, styler)
|
||||
&& !IsCommentLine(lineCurrent + 1, styler))
|
||||
levelCurrent--;
|
||||
}
|
||||
// PreProcessor Folding
|
||||
if (options.foldPreprocessor) {
|
||||
if (atEOL && IsPreProcLine(lineCurrent, styler)) {
|
||||
if (!IsPreProcLine(lineCurrent - 1, styler)
|
||||
&& IsPreProcLine(lineCurrent + 1, styler))
|
||||
levelCurrent++;
|
||||
else if (IsPreProcLine(lineCurrent - 1, styler)
|
||||
&& !IsPreProcLine(lineCurrent + 1, styler))
|
||||
levelCurrent--;
|
||||
}
|
||||
else if (style == SCE_BAAN_PREPROCESSOR) {
|
||||
// folds #ifdef/#if/#ifndef - they are not part of the IsPreProcLine folding.
|
||||
if (ch == '#') {
|
||||
if (styler.Match(i, "#ifdef") || styler.Match(i, "#if") || styler.Match(i, "#ifndef")
|
||||
|| styler.Match(i, "#context_on"))
|
||||
levelCurrent++;
|
||||
else if (styler.Match(i, "#endif") || styler.Match(i, "#context_off"))
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
}
|
||||
//Syntax Folding
|
||||
if (options.baanFoldSyntaxBased && (style == SCE_BAAN_OPERATOR)) {
|
||||
if (ch == '{' || ch == '(') {
|
||||
levelCurrent++;
|
||||
}
|
||||
else if (ch == '}' || ch == ')') {
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
//Keywords Folding
|
||||
if (options.baanFoldKeywordsBased) {
|
||||
if (atEOL && IsDeclarationLine(lineCurrent, styler)) {
|
||||
if (!IsDeclarationLine(lineCurrent - 1, styler)
|
||||
&& IsDeclarationLine(lineCurrent + 1, styler))
|
||||
levelCurrent++;
|
||||
else if (IsDeclarationLine(lineCurrent - 1, styler)
|
||||
&& !IsDeclarationLine(lineCurrent + 1, styler))
|
||||
levelCurrent--;
|
||||
}
|
||||
else if (style == SCE_BAAN_WORD) {
|
||||
word[wordlen++] = static_cast<char>(MakeLowerCase(ch));
|
||||
if (wordlen == 100) { // prevent overflow
|
||||
word[0] = '\0';
|
||||
wordlen = 1;
|
||||
}
|
||||
if (styleNext != SCE_BAAN_WORD) {
|
||||
word[wordlen] = '\0';
|
||||
wordlen = 0;
|
||||
if (strcmp(word, "for") == 0) {
|
||||
Sci_PositionU j = i + 1;
|
||||
while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
|
||||
j++;
|
||||
}
|
||||
if (styler.Match(j, "update")) {
|
||||
// Means this is a "for update" used by Select which is already folded.
|
||||
foldStart = false;
|
||||
}
|
||||
}
|
||||
else if (strcmp(word, "on") == 0) {
|
||||
Sci_PositionU j = i + 1;
|
||||
while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
|
||||
j++;
|
||||
}
|
||||
if (!styler.Match(j, "case")) {
|
||||
// Means this is not a "on Case" statement... could be "on" used by index.
|
||||
foldStart = false;
|
||||
}
|
||||
}
|
||||
else if (strcmp(word, "select") == 0) {
|
||||
if (foldNextSelect) {
|
||||
// Next Selects are sub-clause till reach of selectCloseTags[] array.
|
||||
foldNextSelect = false;
|
||||
foldStart = true;
|
||||
}
|
||||
else {
|
||||
foldNextSelect = false;
|
||||
foldStart = false;
|
||||
}
|
||||
}
|
||||
else if (wordInArray(word, selectCloseTags, 5)) {
|
||||
// select clause ends, next select clause can be folded.
|
||||
foldNextSelect = true;
|
||||
foldStart = true;
|
||||
}
|
||||
else {
|
||||
foldStart = true;
|
||||
}
|
||||
if (foldStart) {
|
||||
if (wordInArray(word, startTags, 6)) {
|
||||
levelCurrent++;
|
||||
}
|
||||
else if (wordInArray(word, endTags, 6)) {
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Fold inner level of if/select/case statements
|
||||
if (options.baanFoldInnerLevel && atEOL) {
|
||||
bool currLineInnerLevel = IsInnerLevelFold(lineCurrent, styler);
|
||||
bool nextLineInnerLevel = IsInnerLevelFold(lineCurrent + 1, styler);
|
||||
if (currLineInnerLevel && currLineInnerLevel != nextLineInnerLevel) {
|
||||
levelCurrent++;
|
||||
}
|
||||
else if (nextLineInnerLevel && nextLineInnerLevel != currLineInnerLevel) {
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
// Section Foldings.
|
||||
// One way of implementing Section Foldings, as there is no END markings of sections.
|
||||
// first section ends on the previous line of next section.
|
||||
// Re-written whole folding to accomodate this.
|
||||
if (options.baanFoldSections && atEOL) {
|
||||
currLineStyle = mainOrSubSectionLine(lineCurrent, styler);
|
||||
nextLineStyle = mainOrSubSectionLine(lineCurrent + 1, styler);
|
||||
if (currLineStyle != 0 && currLineStyle != nextLineStyle) {
|
||||
if (levelCurrent < levelPrev)
|
||||
--levelPrev;
|
||||
for (Sci_Position j = styler.LineStart(lineCurrent); j < styler.LineStart(lineCurrent + 1) - 1; j++) {
|
||||
if (IsASpaceOrTab(styler[j]))
|
||||
continue;
|
||||
else if (styler.StyleAt(j) == SCE_BAAN_WORD5) {
|
||||
if (styler.Match(j, "functions:")) {
|
||||
// Means functions: is the end of MainSections.
|
||||
// Nothing to fold after this.
|
||||
afterFunctionSection = true;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
afterFunctionSection = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
afterFunctionSection = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!afterFunctionSection)
|
||||
levelCurrent++;
|
||||
}
|
||||
else if (nextLineStyle != 0 && currLineStyle != nextLineStyle
|
||||
&& (priorSectionIsSubSection(lineCurrent -1 ,styler)
|
||||
|| !nextSectionIsSubSection(lineCurrent + 1, styler))) {
|
||||
for (Sci_Position j = styler.LineStart(lineCurrent + 1); j < styler.LineStart(lineCurrent + 1 + 1) - 1; j++) {
|
||||
if (IsASpaceOrTab(styler[j]))
|
||||
continue;
|
||||
else if (styler.StyleAt(j) == SCE_BAAN_WORD5) {
|
||||
if (styler.Match(j, "declaration:")) {
|
||||
// Means declaration: is the start of MainSections.
|
||||
// Nothing to fold before this.
|
||||
beforeDeclarationSection = true;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
beforeDeclarationSection = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
beforeDeclarationSection = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!beforeDeclarationSection) {
|
||||
levelCurrent--;
|
||||
if (nextLineStyle == SCE_BAAN_WORD5 && priorSectionIsSubSection(lineCurrent-1, styler))
|
||||
// next levelCurrent--; is to unfold previous subsection fold.
|
||||
// On reaching the next main section, the previous main as well sub section ends.
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (atEOL) {
|
||||
int lev = levelPrev;
|
||||
lev |= levelCurrent << 16;
|
||||
if (visibleChars == 0 && options.foldCompact)
|
||||
lev |= SC_FOLDLEVELWHITEFLAG;
|
||||
if ((levelCurrent > levelPrev) && (visibleChars > 0))
|
||||
lev |= SC_FOLDLEVELHEADERFLAG;
|
||||
if (lev != styler.LevelAt(lineCurrent)) {
|
||||
styler.SetLevel(lineCurrent, lev);
|
||||
}
|
||||
lineCurrent++;
|
||||
levelPrev = levelCurrent;
|
||||
visibleChars = 0;
|
||||
}
|
||||
if (!isspacechar(ch))
|
||||
visibleChars++;
|
||||
}
|
||||
int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
|
||||
styler.SetLevel(lineCurrent, levelPrev | flagsNext);
|
||||
}
|
||||
|
||||
extern const LexerModule lmBaan(SCLEX_BAAN, LexerBaan::LexerFactoryBaan, "baan", baanWordLists);
|
||||
Reference in New Issue
Block a user