github
/
notepad-plus-plus
mirror of https://github.com/notepad-plus-plus/notepad-plus-plus
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
notepad-plus-plus/scintilla/lexers/LexRaku.cxx

1606 lines
49 KiB
C++
Raw Blame History

/** @file LexRaku.cxx
** Lexer for Raku
**
** Copyright (c) 2019 Mark Reay <mark@reay.net.au>
**/
// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.
/*
* Raku (Perl6) Lexer for Scintilla
* ---------------------------------
* ---------------------------------
* 06-Dec-2019: More Unicode support:
* - Added a full scope of allowed numbers and letters
* 29-Nov-2019: More highlighting / implemented basic folding:
* - Operators (blanket cover, no sequence checking)
* - Class / Grammar name highlighting
* - Folding:
* - Comments: line / multi-line
* - POD sections
* - Code blocks {}
* 26-Nov-2019: Basic syntax highlighting covering the following:
* - Comments, both line and embedded (multi-line)
* - POD, no inline highlighting as yet...
* - Heredoc block string, with variable highlighting (with qq)
* - Strings, with variable highlighting (with ")
* - Q Language, including adverbs (also basic q and qq)
* - Regex, including adverbs
* - Numbers
* - Bareword / identifiers
* - Types
* - Variables: mu, positional, associative, callable
* TODO:
* - POD inline
* - Better operator sequence coverage
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>
#include <string>
#include <vector>
#include <map>
#include "ILexer.h"
#include "Scintilla.h"
#include "SciLexer.h"
#include "WordList.h"
#include "LexAccessor.h"
#include "StyleContext.h"
#include "CharacterSet.h"
#include "CharacterCategory.h"
#include "LexerModule.h"
#include "OptionSet.h"
#include "DefaultLexer.h"
using namespace Scintilla;
namespace { // anonymous namespace to isolate any name clashes
/*----------------------------------------------------------------------------*
* --- DEFINITIONS: OPTIONS / CONSTANTS ---
*----------------------------------------------------------------------------*/
// Number types
#define RAKUNUM_BINARY 1 // order is significant: 1-3 cannot have a dot
#define RAKUNUM_OCTAL 2
#define RAKUNUM_FLOAT_EXP 3 // exponent part only
#define RAKUNUM_HEX 4 // may be a hex float
#define RAKUNUM_DECIMAL 5 // 1-5 are numbers; 6-7 are strings
#define RAKUNUM_VECTOR 6
#define RAKUNUM_V_VECTOR 7
#define RAKUNUM_VERSION 8 // can contain multiple '.'s
#define RAKUNUM_BAD 9
// Regex / Q string types
#define RAKUTYPE_REGEX_NORM 0 // 0 char ident
#define RAKUTYPE_REGEX_S 1 // order is significant:
#define RAKUTYPE_REGEX_M 2 // 1 char ident
#define RAKUTYPE_REGEX_Y 3 // 1 char ident
#define RAKUTYPE_REGEX 4 // > RAKUTYPE_REGEX == 2 char identifiers
#define RAKUTYPE_REGEX_RX 5 // 2 char ident
#define RAKUTYPE_REGEX_TR 6 // 2 char ident
#define RAKUTYPE_QLANG 7 // < RAKUTYPE_QLANG == RAKUTYPE_REGEX_?
#define RAKUTYPE_STR_WQ 8 // 0 char ident < word quote >
#define RAKUTYPE_STR_Q 9 // 1 char ident
#define RAKUTYPE_STR_QX 10 // 2 char ident
#define RAKUTYPE_STR_QW 11 // 2 char ident
#define RAKUTYPE_STR_QQ 12 // 2 char ident
#define RAKUTYPE_STR_QQX 13 // 3 char ident
#define RAKUTYPE_STR_QQW 14 // 3 char ident
#define RAKUTYPE_STR_QQWW 15 // 4 char ident
// Delimiter types
#define RAKUDELIM_BRACKET 0 // bracket: regex, Q language
#define RAKUDELIM_QUOTE 1 // quote: normal string
// rakuWordLists: keywords as defined in config
const char *const rakuWordLists[] = {
"Keywords and identifiers",
"Functions",
"Types basic",
"Types composite",
"Types domain-specific",
"Types exception",
"Adverbs",
nullptr,
};
// Options and defaults
struct OptionsRaku {
bool fold;
bool foldCompact;
bool foldComment;
bool foldCommentMultiline;
bool foldCommentPOD;
OptionsRaku() {
fold = true;
foldCompact = false;
foldComment = true;
foldCommentMultiline = true;
foldCommentPOD = true;
}
};
// init options and words
struct OptionSetRaku : public OptionSet<OptionsRaku> {
OptionSetRaku() {
DefineProperty("fold", &OptionsRaku::fold);
DefineProperty("fold.comment", &OptionsRaku::foldComment);
DefineProperty("fold.compact", &OptionsRaku::foldCompact);
DefineProperty("fold.raku.comment.multiline", &OptionsRaku::foldCommentMultiline,
"Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
DefineProperty("fold.raku.comment.pod", &OptionsRaku::foldCommentPOD,
"Set this property to 0 to disable folding POD comments when fold.comment=1.");
// init word lists
DefineWordListSets(rakuWordLists);
}
};
// Delimiter pair
struct DelimPair {
int opener; // opener char
int closer[2]; // closer chars
bool interpol; // can variables be interpolated?
short count; // delimiter char count
DelimPair() {
opener = 0;
closer[0] = 0;
closer[1] = 0;
interpol = false;
count = 0;
}
bool isCloser(int ch) const {
return ch == closer[0] || ch == closer[1];
}
};
/*----------------------------------------------------------------------------*
* --- FUNCTIONS ---
*----------------------------------------------------------------------------*/
/*
* IsANewLine
* - returns true if this is a new line char
*/
constexpr bool IsANewLine(int ch) noexcept {
return ch == '\r' || ch == '\n';
}
/*
* IsAWhitespace
* - returns true if this is a whitespace (or newline) char
*/
bool IsAWhitespace(int ch) noexcept {
return IsASpaceOrTab(ch) || IsANewLine(ch);
}
/*
* IsAlphabet
* - returns true if this is an alphabetical char
*/
constexpr bool IsAlphabet(int ch) noexcept {
return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
}
/*
* IsCommentLine
* - returns true if this is a comment line
* - tests: SCE_RAKU_COMMENTLINE or SCE_RAKU_COMMENTEMBED
* modified from: LexPerl.cxx
*/
bool IsCommentLine(Sci_Position line, LexAccessor &styler, int type = SCE_RAKU_COMMENTLINE) {
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 (type == SCE_RAKU_COMMENTEMBED) {
if (i == (eol_pos - 1) && style == type)
return true;
} else { // make sure the line is NOT a SCE_RAKU_COMMENTEMBED
if (ch == '#' && style == type && styler[i+1] != '`' )
return true;
else if (!IsASpaceOrTab(ch))
return false;
}
}
return false;
}
/*
* GetBracketCloseChar
* - returns the end bracket char: opposite of start
* - see: http://www.unicode.org/Public/5.1.0/ucd/BidiMirroring.txt (first section)
* - Categories are general matches for valid BiDi types
* - Most closer chars are opener + 1
*/
int GetBracketCloseChar(const int ch) noexcept {
const CharacterCategory cc = CategoriseCharacter(ch);
switch (cc) {
case ccSm:
switch (ch) {
case 0x3C: return 0x3E; // LESS-THAN SIGN
case 0x2208: return 0x220B; // ELEMENT OF
case 0x2209: return 0x220C; // NOT AN ELEMENT OF
case 0x220A: return 0x220D; // SMALL ELEMENT OF
case 0x2215: return 0x29F5; // DIVISION SLASH
case 0x2243: return 0x22CD; // ASYMPTOTICALLY EQUAL TO
case 0x2298: return 0x29B8; // CIRCLED DIVISION SLASH
case 0x22A6: return 0x2ADE; // ASSERTION
case 0x22A8: return 0x2AE4; // TRUE
case 0x22A9: return 0x2AE3; // FORCES
case 0x22AB: return 0x2AE5; // DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
case 0x22F2: return 0x22FA; // ELEMENT OF WITH LONG HORIZONTAL STROKE
case 0x22F3: return 0x22FB; // ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
case 0x22F4: return 0x22FC; // SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
case 0x22F6: return 0x22FD; // ELEMENT OF WITH OVERBAR
case 0x22F7: return 0x22FE; // SMALL ELEMENT OF WITH OVERBAR
case 0xFF1C: return 0xFF1E; // FULLWIDTH LESS-THAN SIGN
}
break;
case ccPs:
switch (ch) {
case 0x5B: return 0x5D; // LEFT SQUARE BRACKET
case 0x7B: return 0x7D; // LEFT CURLY BRACKET
case 0x298D: return 0x2990; // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
case 0x298F: return 0x298E; // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
case 0xFF3B: return 0xFF3D; // FULLWIDTH LEFT SQUARE BRACKET
case 0xFF5B: return 0xFF5D; // FULLWIDTH LEFT CURLY BRACKET
}
break;
case ccPi:
break;
default: return 0;
}
return ch + 1;
}
/*
* IsValidQuoteOpener
* -
*/
bool IsValidQuoteOpener(const int ch, DelimPair &dp, int type = RAKUDELIM_BRACKET) noexcept {
dp.closer[0] = 0;
dp.closer[1] = 0;
dp.interpol = true;
if (type == RAKUDELIM_QUOTE) {
switch (ch) {
// Opener Closer Description
case '\'': dp.closer[0] = '\''; // APOSTROPHE
dp.interpol = false;
break;
case '"': dp.closer[0] = '"'; // QUOTATION MARK
break;
case 0x2018: dp.closer[0] = 0x2019; // LEFT SINGLE QUOTATION MARK
dp.interpol = false;
break;
case 0x201C: dp.closer[0] = 0x201D; // LEFT DOUBLE QUOTATION MARK
break;
case 0x201D: dp.closer[0] = 0x201C; // RIGHT DOUBLE QUOTATION MARK
break;
case 0x201E: dp.closer[0] = 0x201C; // DOUBLE LOW-9 QUOTATION MARK
dp.closer[1] = 0x201D;
break;
case 0xFF62: dp.closer[0] = 0xFF63; // HALFWIDTH LEFT CORNER BRACKET
dp.interpol = false;
break;
default: return false;
}
} else if (type == RAKUDELIM_BRACKET) {
dp.closer[0] = GetBracketCloseChar(ch);
}
dp.opener = ch;
dp.count = 1;
return dp.closer[0] > 0;
}
/*
* IsBracketOpenChar
* - true if this is a valid start bracket character
*/
bool IsBracketOpenChar(int ch) noexcept {
return GetBracketCloseChar(ch) > 0;
}
/*
* IsValidRegOrQAdjacent
* - returns true if ch is a valid character to put directly after Q / q
* * ref: Q Language: https://docs.raku.org/language/quoting
*/
bool IsValidRegOrQAdjacent(int ch) noexcept {
return !(IsAlphaNumeric(ch) || ch == '_' || ch == '(' || ch == ')' || ch == '\'' );
}
/*
* IsValidRegOrQPrecede
* - returns true if ch is a valid preceeding character to put directly before Q / q
* * ref: Q Language: https://docs.raku.org/language/quoting
*/
bool IsValidRegOrQPrecede(int ch) noexcept {
return !(IsAlphaNumeric(ch) || ch == '_');
}
/*
* MatchCharInRange
* - returns true if the mach character is found in range (of length)
* - ignoreDelim (default false)
*/
bool MatchCharInRange(StyleContext &sc, const Sci_Position length,
const int match, bool ignoreDelim = false) {
Sci_Position len = 0;
int chPrev = sc.chPrev;
while (++len < length) {
const int ch = sc.GetRelativeCharacter(len);
if (ch == match && (ignoreDelim || chPrev != '\\'))
return true;
}
return false;
}
/*
* PrevNonWhitespaceChar
* - returns the last non-whitespace char
*/
int PrevNonWhitespaceChar(StyleContext &sc) {
Sci_Position rel = 0;
Sci_Position max_back = 0 - sc.currentPos;
while (--rel > max_back) {
const int ch = sc.GetRelativeCharacter(rel);
if (!IsAWhitespace(ch))
return ch;
}
return 0; // no matching char
}
/*
* IsQLangStartAtScPos
* - returns true if this is a valid Q Language sc position
* - ref: https://docs.raku.org/language/quoting
* - Q :adverb :adverb //;
* - q,qx,qw,qq,qqx,qqw,qqww :adverb /:adverb /;
*/
bool IsQLangStartAtScPos(StyleContext &sc, int &type, const Sci_Position length) {
const bool valid_adj = IsValidRegOrQAdjacent(sc.chNext);
const int chFw2 = sc.GetRelativeCharacter(2);
const int chFw3 = sc.GetRelativeCharacter(3);
type = -1;
if (IsValidRegOrQPrecede(sc.chPrev)) {
if (sc.ch == 'Q' && valid_adj) {
type = RAKUTYPE_QLANG;
} else if (sc.ch == 'q') {
switch (sc.chNext) {
case 'x':
type = RAKUTYPE_STR_QX;
break;
case 'w':
type = RAKUTYPE_STR_QW;
break;
case 'q':
if (chFw2 == 'x') {
type = RAKUTYPE_STR_QQX;
} else if (chFw2 == 'w') {
if (chFw3 == 'w') {
type = RAKUTYPE_STR_QQWW;
} else {
type = RAKUTYPE_STR_QQW;
}
} else {
type = RAKUTYPE_STR_QQ;
}
break;
default:
type = RAKUTYPE_STR_Q;
}
} else if (sc.ch == '<' && MatchCharInRange(sc, length, '>')) {
type = RAKUTYPE_STR_WQ; // < word quote >
}
}
return type >= 0;
}
/*
* IsRegexStartAtScPos
* - returns true if this is a valid Regex sc position
* - ref: https://docs.raku.org/language/regexes
* - Regex: (rx/s/m/tr/y) :adverb /:adverb /;
* - regex R :adverb //;
* - /:adverb /;
*/
bool IsRegexStartAtScPos(StyleContext &sc, int &type, CharacterSet &set) {
const bool valid_adj = IsValidRegOrQAdjacent(sc.chNext);
type = -1;
if (IsValidRegOrQPrecede(sc.chPrev)) {
switch (sc.ch) {
case 'r':
if (sc.chNext == 'x')
type = RAKUTYPE_REGEX_RX;
break;
case 't':
case 'T':
if (sc.chNext == 'r' || sc.chNext == 'R')
type = RAKUTYPE_REGEX_TR;
break;
case 'm':
if (valid_adj)
type = RAKUTYPE_REGEX_M;
break;
case 's':
case 'S':
if (valid_adj)
type = RAKUTYPE_REGEX_S;
break;
case 'y':
if (valid_adj)
type = RAKUTYPE_REGEX_Y;
break;
case '/':
if (set.Contains(PrevNonWhitespaceChar(sc)))
type = RAKUTYPE_REGEX_NORM;
}
}
return type >= 0;
}
/*
* IsValidIdentPrecede
* - returns if ch is a valid preceeding char to put directly before an identifier
*/
bool IsValidIdentPrecede(int ch) noexcept {
return !(IsAlphaNumeric(ch) || ch == '_' || ch == '@' || ch == '$' || ch == '%');
}
/*
* IsValidDelimiter
* - returns if ch is a valid delimiter (most chars are valid)
* * ref: Q Language: https://docs.raku.org/language/quoting
*/
bool IsValidDelimiter(int ch) noexcept {
return !(IsAlphaNumeric(ch) || ch == ':');
}
/*
* GetDelimiterCloseChar
* - returns the corrisponding close char for a given delimiter (could be the same char)
*/
int GetDelimiterCloseChar(int ch) noexcept {
int ch_end = GetBracketCloseChar(ch);
if (ch_end == 0 && IsValidDelimiter(ch)) {
ch_end = ch;
}
return ch_end;
}
/*
* GetRepeatCharCount
* - returns the occurence count of match
*/
Sci_Position GetRepeatCharCount(StyleContext &sc, int chMatch, Sci_Position length) {
Sci_Position cnt = 0;
while (cnt < length) {
if (sc.GetRelativeCharacter(cnt) != chMatch) {
break;
}
cnt++;
}
return cnt;
}
/*
* LengthToDelimiter
* - returns the length until the end of a delimited string section
* - Ignores nested delimiters (if opener != closer)
* - no trailing char after last closer (default false)
*/
Sci_Position LengthToDelimiter(StyleContext &sc, const DelimPair &dp,
Sci_Position length, bool noTrailing = false) {
short cnt_open = 0; // count open bracket
short cnt_close = 0; // count close bracket
Sci_Position len = 0; // count characters
int chOpener = dp.opener; // look for nested opener / closer
if (dp.opener == dp.closer[0])
chOpener = 0; // no opening delimiter (no nesting possible)
while (len < length) {
const int chPrev = sc.GetRelativeCharacter(len - 1);
const int ch = sc.GetRelativeCharacter(len);
const int chNext = sc.GetRelativeCharacter(len+1);
if (cnt_open == 0 && cnt_close == dp.count) {
return len; // end condition has been met
} else {
if (chPrev != '\\' && ch == chOpener) { // ignore escape sequence
cnt_open++; // open nested bracket
} else if (chPrev != '\\' && dp.isCloser(ch)) { // ignore escape sequence
if ( cnt_open > 0 ) {
cnt_open--; // close nested bracket
} else if (dp.count > 1 && cnt_close < (dp.count - 1)) {
if (cnt_close > 1) {
if (dp.isCloser(chPrev)) {
cnt_close++;
} else { // reset if previous char was not close
cnt_close = 0;
}
} else {
cnt_close++;
}
} else if (!noTrailing || (IsAWhitespace(chNext))) {
cnt_close++; // found last close
if (cnt_close > 1 && !dp.isCloser(chPrev)) {
cnt_close = 0; // reset if previous char was not close
}
} else {
cnt_close = 0; // non handled close: reset
}
} else if (IsANewLine(ch)) {
cnt_open = 0; // reset after each line
cnt_close = 0;
}
}
len++;
}
return -1; // end condition has NOT been met
}
/*
* LengthToEndHeredoc
* - returns the length until the end of a heredoc section
* - delimiter string MUST begin on a new line
*/
Sci_Position LengthToEndHeredoc(const StyleContext &sc, LexAccessor &styler,
const Sci_Position length, const char *delim) {
bool on_new_ln = false;
int i = 0; // str index
for (int n = 0; n < length; n++) {
const char ch = styler.SafeGetCharAt(sc.currentPos + n, 0);
if (on_new_ln) {
if (delim[i] == '\0')
return n; // at end of str, match found!
if (ch != delim[i++])
i = 0; // no char match, reset 'i'ndex
}
if (i == 0) // detect new line
on_new_ln = IsANewLine(ch);
}
return -1; // no match found
}
/*
* LengthToNextChar
* - returns the length until the next character
*/
Sci_Position LengthToNextChar(StyleContext &sc, const Sci_Position length) {
Sci_Position len = 0;
while (++len < length) {
const int ch = sc.GetRelativeCharacter(len);
if (!IsASpaceOrTab(ch) && !IsANewLine(ch)) {
break;
}
}
return len;
}
/*
* GetRelativeString
* - gets a relitive string and sets it in &str
* - resets string before seting
*/
void GetRelativeString(StyleContext &sc, Sci_Position offset, Sci_Position length,
std::string &str) {
Sci_Position pos = offset;
str.clear();
while (pos < length) {
str += sc.GetRelativeCharacter(pos++);
}
}
} // end anonymous namespace
/*----------------------------------------------------------------------------*
* --- class: LexerRaku ---
*----------------------------------------------------------------------------*/
//class LexerRaku : public ILexerWithMetaData {
class LexerRaku : public DefaultLexer {
CharacterSet setWord;
CharacterSet setSigil;
CharacterSet setTwigil;
CharacterSet setOperator;
CharacterSet setSpecialVar;
WordList regexIdent; // identifiers that specify a regex
OptionsRaku options; // Options from config
OptionSetRaku osRaku;
WordList keywords; // Word Lists from config
WordList functions;
WordList typesBasic;
WordList typesComposite;
WordList typesDomainSpecific;
WordList typesExceptions;
WordList adverbs;
public:
// Defined as explicit, so that constructor can not be copied
explicit LexerRaku() :
DefaultLexer("raku", SCLEX_RAKU),
setWord(CharacterSet::setAlphaNum, "-_", 0x80),
setSigil(CharacterSet::setNone, "$&%@"),
setTwigil(CharacterSet::setNone, "!*.:<=?^~"),
setOperator(CharacterSet::setNone, "^&\\()-+=|{}[]:;<>,?!.~"),
setSpecialVar(CharacterSet::setNone, "_/!") {
regexIdent.Set("regex rule token");
}
// Deleted so LexerRaku objects can not be copied.
LexerRaku(const LexerRaku &) = delete;
LexerRaku(LexerRaku &&) = delete;
void operator=(const LexerRaku &) = delete;
void operator=(LexerRaku &&) = delete;
virtual ~LexerRaku() {
}
void SCI_METHOD Release() noexcept override {
delete this;
}
int SCI_METHOD Version() const noexcept override {
return lvRelease5;
}
const char *SCI_METHOD PropertyNames() override {
return osRaku.PropertyNames();
}
int SCI_METHOD PropertyType(const char *name) override {
return osRaku.PropertyType(name);
}
const char *SCI_METHOD DescribeProperty(const char *name) override {
return osRaku.DescribeProperty(name);
}
Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
const char *SCI_METHOD PropertyGet(const char *key) override {
return osRaku.PropertyGet(key);
}
const char *SCI_METHOD DescribeWordListSets() override {
return osRaku.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;
static ILexer5 *LexerFactoryRaku() {
return new LexerRaku();
}
protected:
bool IsOperatorChar(const int ch);
bool IsWordChar(const int ch, bool allowNumber = true);
bool IsWordStartChar(const int ch);
bool IsNumberChar(const int ch, int base = 10);
bool ProcessRegexTwinCapture(StyleContext &sc, const Sci_Position length,
int &type, const DelimPair &dp);
void ProcessStringVars(StyleContext &sc, const Sci_Position length, const int varState);
bool ProcessValidRegQlangStart(StyleContext &sc, Sci_Position length, const int type,
WordList &wordsAdverbs, DelimPair &dp);
Sci_Position LengthToNonWordChar(StyleContext &sc, Sci_Position length,
char *s, const int size, Sci_Position offset = 0);
};
/*----------------------------------------------------------------------------*
* --- METHODS: LexerRaku ---
*----------------------------------------------------------------------------*/
/*
* LexerRaku::IsOperatorChar
* - Test for both ASCII and Unicode operators
* see: https://docs.raku.org/language/unicode_entry
*/
bool LexerRaku::IsOperatorChar(const int ch) {
if (ch > 0x7F) {
switch (ch) {
// Unicode ASCII Equiv.
case 0x2208: // (elem)
case 0x2209: // !(elem)
case 0x220B: // (cont)
case 0x220C: // !(cont)
case 0x2216: // (-)
case 0x2229: // (&)
case 0x222A: // (|)
case 0x2282: // (<)
case 0x2283: // (>)
case 0x2284: // !(<)
case 0x2285: // !(>)
case 0x2286: // (<=)
case 0x2287: // (>=)
case 0x2288: // !(<=)
case 0x2289: // !(>=)
case 0x228D: // (.)
case 0x228E: // (+)
case 0x2296: // (^)
return true;
}
}
return setOperator.Contains(ch);
}
/*
* LexerRaku::IsWordChar
* - Test for both ASCII and Unicode identifier characters
* see: https://docs.raku.org/language/unicode_ascii
* also: ftp://ftp.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
* FIXME: *still* may not contain all valid characters
*/
bool LexerRaku::IsWordChar(const int ch, bool allowNumber) {
// Unicode numbers should not apear in word identifiers
if (ch > 0x7F) {
const CharacterCategory cc = CategoriseCharacter(ch);
switch (cc) {
// Letters
case ccLu:
case ccLl:
case ccLt:
case ccLm:
case ccLo:
return true;
default:
return false;
}
} else if (allowNumber && IsADigit(ch)) {
return true; // an ASCII number type
}
return setWord.Contains(ch);
}
/*
* LexerRaku::IsWordStartChar
* - Test for both ASCII and Unicode identifier "start / first" characters
*/
bool LexerRaku::IsWordStartChar(const int ch) {
return ch != '-' && IsWordChar(ch, false); // no numbers allowed
}
/*
* LexerRaku::IsNumberChar
* - Test for both ASCII and Unicode identifier number characters
* see: https://docs.raku.org/language/unicode_ascii
* also: ftp://ftp.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
* FILTERED by Unicode letters that are NUMBER
* and NOT PARENTHESIZED or CIRCLED
* FIXME: *still* may not contain all valid number characters
*/
bool LexerRaku::IsNumberChar(const int ch, int base) {
if (ch > 0x7F) {
const CharacterCategory cc = CategoriseCharacter(ch);
switch (cc) {
// Numbers
case ccNd:
case ccNl:
case ccNo:
return true;
default:
return false;
}
}
return IsADigit(ch, base);
}
/*
* LexerRaku::PropertySet
* -
*/
Sci_Position SCI_METHOD LexerRaku::PropertySet(const char *key, const char *val) {
if (osRaku.PropertySet(&options, key, val))
return 0;
return -1;
}
/*
* LexerRaku::WordListSet
* -
*/
Sci_Position SCI_METHOD LexerRaku::WordListSet(int n, const char *wl) {
WordList *wordListN = nullptr;
switch (n) {
case 0:
wordListN = &keywords;
break;
case 1:
wordListN = &functions;
break;
case 2:
wordListN = &typesBasic;
break;
case 3:
wordListN = &typesComposite;
break;
case 4:
wordListN = &typesDomainSpecific;
break;
case 5:
wordListN = &typesExceptions;
break;
case 6:
wordListN = &adverbs;
break;
}
Sci_Position firstModification = -1;
if (wordListN) {
WordList wlNew;
wlNew.Set(wl);
if (*wordListN != wlNew) {
wordListN->Set(wl);
firstModification = 0;
}
}
return firstModification;
}
/*
* LexerRaku::ProcessRegexTwinCapture
* - processes the transition between a regex pair (two sets of delimiters)
* - moves to first new delimiter, if a bracket
* - returns true when valid delimiter start found (if bracket)
*/
bool LexerRaku::ProcessRegexTwinCapture(StyleContext &sc, const Sci_Position length,
int &type, const DelimPair &dp) {
if (type == RAKUTYPE_REGEX_S || type == RAKUTYPE_REGEX_TR || type == RAKUTYPE_REGEX_Y) {
type = -1; // clear type
// move past chRegQClose if it was the previous char
if (dp.isCloser(sc.chPrev))
sc.Forward();
// no processing needed for non-bracket
if (dp.isCloser(dp.opener))
return true;
// move to next opening bracket
const Sci_Position len = LengthToNextChar(sc, length);
if (sc.GetRelativeCharacter(len) == dp.opener) {
sc.Forward(len);
return true;
}
}
return false;
}
/*
* LexerRaku::ProcessStringVars
* - processes a string and highlights any valid variables
*/
void LexerRaku::ProcessStringVars(StyleContext &sc, const Sci_Position length, const int varState) {
const int state = sc.state;
for (Sci_Position pos = 0; pos < length; pos++) {
if (sc.state == varState && !IsWordChar(sc.ch)) {
sc.SetState(state);
} else if (sc.chPrev != '\\'
&& (sc.ch == '$' || sc.ch == '@')
&& IsWordStartChar(sc.chNext)) {
sc.SetState(varState);
}
sc.Forward(); // Next character
}
}
/*
* LexerRaku::ProcessValidRegQlangStart
* - processes a section of the document range from after a Regex / Q delimiter
* - returns true on success
* - sets: adverbs, chOpen, chClose, chCount
* ref: https://docs.raku.org/language/regexes
*/
bool LexerRaku::ProcessValidRegQlangStart(StyleContext &sc, Sci_Position length, const int type,
WordList &wordsAdverbs, DelimPair &dp) {
Sci_Position startPos = sc.currentPos;
Sci_Position startLen = length;
const int target_state = sc.state;
int state = SCE_RAKU_DEFAULT;
std::string str;
// find our opening delimiter (and occurrences) / save any adverbs
dp.opener = 0; // adverbs can be after the first delimiter
bool got_all_adverbs = false; // in Regex statements
bool got_ident = false; // regex can have an identifier: 'regex R'
sc.SetState(state); // set state default to avoid pre-highlights
while ((dp.opener == 0 || !got_all_adverbs) && sc.More()) {
// move to the next non-space character
const bool was_space = IsAWhitespace(sc.ch);
if (!got_all_adverbs && was_space) {
sc.Forward(LengthToNextChar(sc, length));
}
length = startLen - (sc.currentPos - startPos); // update length remaining
// parse / eat an identifier (if type == RAKUTYPE_REGEX)
if (dp.opener == 0 && !got_ident && type == RAKUTYPE_REGEX && IsAlphabet(sc.ch)) {
// eat identifier / account for special adverb :sym<name>
bool got_sym = false;
while (sc.More()) {
sc.SetState(SCE_RAKU_IDENTIFIER);
while (sc.More() && (IsAlphaNumeric(sc.chNext)
|| sc.chNext == '_' || sc.chNext == '-')) {
sc.Forward();
}
sc.Forward();
if (got_sym && sc.ch == '>') {
sc.SetState(SCE_RAKU_OPERATOR); // '>'
sc.Forward();
break;
} else if (type == RAKUTYPE_REGEX && sc.Match(":sym<")) {
sc.SetState(SCE_RAKU_ADVERB); // ':sym'
sc.Forward(4);
sc.SetState(SCE_RAKU_OPERATOR); // '<'
sc.Forward();
got_sym = true;
} else {
break;
}
}
sc.SetState(state);
got_ident = true;
}
// parse / save an adverb: RAKUTYPE_REGEX only has adverbs after delim
// >= RAKUTYPE_QLANG only has adverbs before delim
else if (!got_all_adverbs && sc.ch == ':' && (!(dp.opener == 0 && got_ident)
&& !(dp.opener > 0 && type >= RAKUTYPE_QLANG))) {
sc.SetState(SCE_RAKU_ADVERB);
while (IsAlphaNumeric(sc.chNext) && sc.More()) {
sc.Forward();
str += sc.ch;
}
str += ' ';
sc.Forward();
sc.SetState(state);
}
// find starting delimiter
else if (dp.opener == 0 && (was_space || IsValidRegOrQAdjacent(sc.ch))
&& IsValidDelimiter(sc.ch)) { // make sure the delimiter is legal (most are)
sc.SetState((state = target_state));// start state here...
dp.opener = sc.ch; // this is our delimiter, get count
if (type < RAKUTYPE_QLANG) // type is Regex
dp.count = 1; // has only one delimiter
else
dp.count = GetRepeatCharCount(sc, dp.opener, length);
sc.Forward(dp.count);
}
// we must have all the adverbs by now...
else {
if (got_all_adverbs)
break; // prevent infinite loop: occurs on missing open char
got_all_adverbs = true;
}
}
// set word list / find a valid closing delimiter (or bomb!)
wordsAdverbs.Set(str.c_str());
dp.closer[0] = GetDelimiterCloseChar(dp.opener);
dp.closer[1] = 0; // no other closer char
return dp.closer[0] > 0;
}
/*
* LexerRaku::LengthToNonWordChar
* - returns the length until the next non "word" character: AlphaNum + '_'
* - also sets all the parsed chars in 's'
*/
Sci_Position LexerRaku::LengthToNonWordChar(StyleContext &sc, Sci_Position length,
char *s, const int size, Sci_Position offset) {
Sci_Position len = 0;
Sci_Position max_length = size < length ? size : length;
while (len <= max_length) {
const int ch = sc.GetRelativeCharacter(len + offset);
if (!IsWordChar(ch)) {
s[len] = '\0';
break;
}
s[len] = ch;
len++;
}
s[len + 1] = '\0';
return len;
}
/*
* LexerRaku::Lex
* - Main lexer method
*/
void SCI_METHOD LexerRaku::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
LexAccessor styler(pAccess);
DelimPair dpEmbeded; // delimiter pair: embeded comments
DelimPair dpString; // delimiter pair: string
DelimPair dpRegQ; // delimiter pair: Regex / Q Lang
std::string hereDelim; // heredoc delimiter (if in heredoc)
int hereState = 0; // heredoc state to use (Q / QQ)
int numState = 0; // number state / type
short cntDecimal = 0; // number decinal count
std::string wordLast; // last word seen
std::string identLast; // last identifier seen
std::string adverbLast; // last (single) adverb seen
WordList lastAdverbs; // last adverbs seen
Sci_Position len; // temp length value
char s[100]; // temp char string
int typeDetect; // temp type detected (for regex and Q lang)
Sci_Position lengthToEnd; // length until the end of range
// Backtrack to last SCE_RAKU_DEFAULT or 0
Sci_PositionU newStartPos = startPos;
if (initStyle != SCE_RAKU_DEFAULT) {
while (newStartPos > 0) {
newStartPos--;
if (styler.StyleAt(newStartPos) == SCE_RAKU_DEFAULT)
break;
}
}
// Backtrack to start of line before SCE_RAKU_HEREDOC_Q?
if (initStyle == SCE_RAKU_HEREDOC_Q || initStyle == SCE_RAKU_HEREDOC_QQ) {
while (newStartPos > 0) {
if (IsANewLine(styler.SafeGetCharAt(newStartPos - 1)))
break; // Stop if previous char is a new line
newStartPos--;
}
}
// Re-calculate (any) changed startPos, length and initStyle state
if (newStartPos < startPos) {
initStyle = SCE_RAKU_DEFAULT;
length += startPos - newStartPos;
startPos = newStartPos;
}
// init StyleContext
StyleContext sc(startPos, length, initStyle, styler);
// StyleContext Loop
for (; sc.More(); sc.Forward()) {
lengthToEnd = (length - (sc.currentPos - startPos)); // end of range
/* *** Determine if the current state should terminate ************** *
* Everything within the 'switch' statement processes characters up
* until the end of a syntax highlight section / state.
* ****************************************************************** */
switch (sc.state) {
case SCE_RAKU_OPERATOR:
sc.SetState(SCE_RAKU_DEFAULT);
break; // FIXME: better valid operator sequences needed?
case SCE_RAKU_COMMENTLINE:
if (IsANewLine(sc.ch)) {
sc.SetState(SCE_RAKU_DEFAULT);
}
break;
case SCE_RAKU_COMMENTEMBED:
if ((len = LengthToDelimiter(sc, dpEmbeded, lengthToEnd)) >= 0) {
sc.Forward(len); // Move to end delimiter
sc.SetState(SCE_RAKU_DEFAULT);
} else {
sc.Forward(lengthToEnd); // no end delimiter found
}
break;
case SCE_RAKU_POD:
if (sc.atLineStart && sc.Match("=end pod")) {
sc.Forward(8);
sc.SetState(SCE_RAKU_DEFAULT);
}
break;
case SCE_RAKU_STRING:
// Process the string for variables: move to end delimiter
if ((len = LengthToDelimiter(sc, dpString, lengthToEnd)) >= 0) {
if (dpString.interpol) {
ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
} else {
sc.Forward(len);
}
sc.SetState(SCE_RAKU_DEFAULT);
} else {
sc.Forward(lengthToEnd); // no end delimiter found
}
break;
case SCE_RAKU_STRING_Q:
case SCE_RAKU_STRING_QQ:
case SCE_RAKU_STRING_Q_LANG:
// No string: previous char was the delimiter
if (dpRegQ.count == 1 && dpRegQ.isCloser(sc.chPrev)) {
sc.SetState(SCE_RAKU_DEFAULT);
}
// Process the string for variables: move to end delimiter
else if ((len = LengthToDelimiter(sc, dpRegQ, lengthToEnd)) >= 0) {
// set (any) heredoc delimiter string
if (lastAdverbs.InList("to")) {
GetRelativeString(sc, -1, len - dpRegQ.count, hereDelim);
hereState = SCE_RAKU_HEREDOC_Q; // default heredoc state
}
// select variable identifiers
if (sc.state == SCE_RAKU_STRING_QQ || lastAdverbs.InList("qq")) {
ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
hereState = SCE_RAKU_HEREDOC_QQ; // potential heredoc state
} else {
sc.Forward(len);
}
sc.SetState(SCE_RAKU_DEFAULT);
} else {
sc.Forward(lengthToEnd); // no end delimiter found
}
break;
case SCE_RAKU_HEREDOC_Q:
case SCE_RAKU_HEREDOC_QQ:
if ((len = LengthToEndHeredoc(sc, styler, lengthToEnd, hereDelim.c_str())) >= 0) {
// select variable identifiers
if (sc.state == SCE_RAKU_HEREDOC_QQ) {
ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
} else {
sc.Forward(len);
}
sc.SetState(SCE_RAKU_DEFAULT);
} else {
sc.Forward(lengthToEnd); // no end delimiter found
}
hereDelim.clear(); // clear heredoc delimiter
break;
case SCE_RAKU_REGEX:
// account for typeDetect = RAKUTYPE_REGEX_S/TR/Y
while (sc.state == SCE_RAKU_REGEX) {
// No string: previous char was the delimiter
if (dpRegQ.count == 1 && dpRegQ.isCloser(sc.chPrev)) {
if (ProcessRegexTwinCapture(sc, lengthToEnd, typeDetect, dpRegQ))
continue;
sc.SetState(SCE_RAKU_DEFAULT);
break;
}
// Process the string for variables: move to end delimiter
else if ((len = LengthToDelimiter(sc, dpRegQ, lengthToEnd)) >= 0) {
ProcessStringVars(sc, len, SCE_RAKU_REGEX_VAR);
if (ProcessRegexTwinCapture(sc, lengthToEnd, typeDetect, dpRegQ))
continue;
sc.SetState(SCE_RAKU_DEFAULT);
break;
} else {
sc.Forward(lengthToEnd); // no end delimiter found
break;
}
}
break;
case SCE_RAKU_NUMBER:
if (sc.ch == '.') {
if (sc.chNext == '.') { // '..' is an operator
sc.SetState(SCE_RAKU_OPERATOR);
sc.Forward();
if (sc.chNext == '.') // '...' is also an operator
sc.Forward();
break;
} else if (numState > RAKUNUM_FLOAT_EXP
&& (cntDecimal < 1 || numState == RAKUNUM_VERSION)) {
cntDecimal++;
sc.Forward();
} else {
sc.SetState(SCE_RAKU_DEFAULT);
break; // too many decinal places
}
}
switch (numState) {
case RAKUNUM_BINARY:
if (!IsNumberChar(sc.ch, 2))
sc.SetState(SCE_RAKU_DEFAULT);
break;
case RAKUNUM_OCTAL:
if (!IsNumberChar(sc.ch, 8))
sc.SetState(SCE_RAKU_DEFAULT);
break;
case RAKUNUM_HEX:
if (!IsNumberChar(sc.ch, 16))
sc.SetState(SCE_RAKU_DEFAULT);
break;
case RAKUNUM_DECIMAL:
case RAKUNUM_VERSION:
if (!IsNumberChar(sc.ch))
sc.SetState(SCE_RAKU_DEFAULT);
}
break;
case SCE_RAKU_WORD:
case SCE_RAKU_FUNCTION:
case SCE_RAKU_TYPEDEF:
case SCE_RAKU_ADVERB:
sc.SetState(SCE_RAKU_DEFAULT);
break;
case SCE_RAKU_MU:
case SCE_RAKU_POSITIONAL:
case SCE_RAKU_ASSOCIATIVE:
case SCE_RAKU_CALLABLE:
case SCE_RAKU_IDENTIFIER:
case SCE_RAKU_GRAMMAR:
case SCE_RAKU_CLASS:
sc.SetState(SCE_RAKU_DEFAULT);
break;
}
/* *** Determine if a new state should be entered ******************* *
* Everything below here identifies the beginning of a state, all or part
* of the characters within this state are processed here, the rest are
* completed above in the terminate state section.
* ****************************************************************** */
if (sc.state == SCE_RAKU_DEFAULT) {
// --- Single line comment
if (sc.ch == '#') {
sc.SetState(SCE_RAKU_COMMENTLINE);
}
// --- POD block
else if (sc.atLineStart && sc.Match("=begin pod")) {
sc.SetState(SCE_RAKU_POD);
sc.Forward(10);
}
// --- String (normal)
else if (sc.chPrev != '\\' && (IsValidQuoteOpener(sc.ch, dpString, RAKUDELIM_QUOTE))) {
sc.SetState(SCE_RAKU_STRING);
}
// --- String (Q Language) ----------------------------------------
// - https://docs.raku.org/language/quoting
// - Q :adverb :adverb //;
// - q,qx,qw,qq,qqx,qqw,qqww :adverb :adverb //;
else if (IsQLangStartAtScPos(sc, typeDetect, lengthToEnd)) {
int state = SCE_RAKU_STRING_Q_LANG;
Sci_Position forward = 1; // single char ident (default)
if (typeDetect > RAKUTYPE_QLANG) {
state = SCE_RAKU_STRING_Q;
if (typeDetect == RAKUTYPE_STR_WQ)
forward = 0; // no char ident
}
if (typeDetect > RAKUTYPE_STR_Q) {
if (typeDetect == RAKUTYPE_STR_QQ)
state = SCE_RAKU_STRING_QQ;
forward++; // two char ident
}
if (typeDetect > RAKUTYPE_STR_QQ)
forward++; // three char ident
if (typeDetect == RAKUTYPE_STR_QQWW)
forward++; // four char ident
// Proceed: check for a valid character after statement
if (IsValidRegOrQAdjacent(sc.GetRelative(forward)) || typeDetect == RAKUTYPE_QLANG) {
sc.SetState(state);
sc.Forward(forward);
lastAdverbs.Clear();
// Process: adverbs / opening delimiter / adverbs after delim
if (ProcessValidRegQlangStart(sc, lengthToEnd, typeDetect,
lastAdverbs, dpRegQ))
sc.SetState(state);
}
}
// --- Regex (rx/s/m/tr/y) ----------------------------------------
// - https://docs.raku.org/language/regexes
else if ((IsRegexStartAtScPos(sc, typeDetect, setOperator) || regexIdent.InList(wordLast.c_str()))) {
if (typeDetect == -1) { // must be a regex identifier word
wordLast.clear();
typeDetect = RAKUTYPE_REGEX;
}
Sci_Position forward = 0; // no ident (RAKUTYPE_REGEX, RAKUTYPE_REGEX_NORM)
if (typeDetect > 0 && typeDetect != RAKUTYPE_REGEX)
forward++; // single char ident
if (typeDetect > RAKUTYPE_REGEX)
forward++; // two char ident
// Proceed: check for a valid character after statement
if (IsValidRegOrQAdjacent(sc.GetRelative(forward)) || typeDetect == RAKUTYPE_REGEX_NORM) {
sc.SetState(SCE_RAKU_REGEX);
sc.Forward(forward);
lastAdverbs.Clear();
// Process: adverbs / opening delimiter / adverbs after delim
if (ProcessValidRegQlangStart(sc, lengthToEnd, typeDetect,
lastAdverbs, dpRegQ))
sc.SetState(SCE_RAKU_REGEX);
}
}
// --- Numbers ----------------------------------------------------
else if (IsValidIdentPrecede(sc.chPrev) && (IsNumberChar(sc.ch)
|| (sc.ch == 'v' && IsNumberChar(sc.chNext) && wordLast == "use"))) {
numState = RAKUNUM_DECIMAL; // default: decimal (base 10)
cntDecimal = 0;
sc.SetState(SCE_RAKU_NUMBER);
if (sc.ch == 'v') // forward past 'v'
sc.Forward();
if (wordLast == "use") { // package version number
numState = RAKUNUM_VERSION;
} else if (sc.ch == '0') { // other type of number
switch (sc.chNext) {
case 'b': // binary (base 2)
numState = RAKUNUM_BINARY;
break;
case 'o': // octal (base 8)
numState = RAKUNUM_OCTAL;
break;
case 'x': // hexadecimal (base 16)
numState = RAKUNUM_HEX;
}
if (numState != RAKUNUM_DECIMAL)
sc.Forward(); // forward to number type char
}
}
// --- Keywords / functions / types / barewords -------------------
else if ((sc.currentPos == 0 || sc.atLineStart || IsValidIdentPrecede(sc.chPrev))
&& IsWordStartChar(sc.ch)) {
len = LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s));
if (keywords.InList(s)) {
sc.SetState(SCE_RAKU_WORD); // Keywords
} else if(functions.InList(s)) {
sc.SetState(SCE_RAKU_FUNCTION); // Functions
} else if(typesBasic.InList(s)) {
sc.SetState(SCE_RAKU_TYPEDEF); // Types (basic)
} else if(typesComposite.InList(s)) {
sc.SetState(SCE_RAKU_TYPEDEF); // Types (composite)
} else if(typesDomainSpecific.InList(s)) {
sc.SetState(SCE_RAKU_TYPEDEF); // Types (domain-specific)
} else if(typesExceptions.InList(s)) {
sc.SetState(SCE_RAKU_TYPEDEF); // Types (exceptions)
} else {
if (wordLast == "class")
sc.SetState(SCE_RAKU_CLASS); // a Class ident
else if (wordLast == "grammar")
sc.SetState(SCE_RAKU_GRAMMAR); // a Grammar ident
else
sc.SetState(SCE_RAKU_IDENTIFIER); // Bareword
identLast = s; // save identifier
}
if (adverbLast == "sym") { // special adverb ":sym"
sc.SetState(SCE_RAKU_IDENTIFIER); // treat as identifier
identLast = s; // save identifier
}
if (sc.state != SCE_RAKU_IDENTIFIER)
wordLast = s; // save word
sc.Forward(len - 1); // ...forward past word
}
// --- Adverbs ----------------------------------------------------
else if (sc.ch == ':' && IsWordStartChar(sc.chNext)) {
len = LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s), 1);
if (adverbs.InList(s)) {
sc.SetState(SCE_RAKU_ADVERB); // Adverbs (begin with ':')
adverbLast = s; // save word
sc.Forward(len); // ...forward past word (less offset: 1)
}
}
// --- Identifiers: $mu / @positional / %associative / &callable --
// see: https://docs.raku.org/language/variables
else if (setSigil.Contains(sc.ch) && (setTwigil.Contains(sc.chNext)
|| setSpecialVar.Contains(sc.chNext)
|| IsWordStartChar(sc.chNext))) {
// State based on sigil
switch (sc.ch) {
case '$': sc.SetState(SCE_RAKU_MU);
break;
case '@': sc.SetState(SCE_RAKU_POSITIONAL);
break;
case '%': sc.SetState(SCE_RAKU_ASSOCIATIVE);
break;
case '&': sc.SetState(SCE_RAKU_CALLABLE);
}
const int state = sc.state;
sc.Forward();
char ch_delim = 0;
if (setSpecialVar.Contains(sc.ch)
&& !setWord.Contains(sc.chNext)) { // Process Special Var
ch_delim = -1;
} else if (setTwigil.Contains(sc.ch)) { // Process Twigil
sc.SetState(SCE_RAKU_OPERATOR);
if (sc.ch == '<' && setWord.Contains(sc.chNext))
ch_delim = '>';
sc.Forward();
sc.SetState(state);
}
// Process (any) identifier
if (ch_delim >= 0) {
sc.Forward(LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s)) - 1);
if (ch_delim > 0 && sc.chNext == ch_delim) {
sc.Forward();
sc.SetState(SCE_RAKU_OPERATOR);
}
identLast = s; // save identifier
}
}
// --- Operators --------------------------------------------------
else if (IsOperatorChar(sc.ch)) {
// FIXME: better valid operator sequences needed?
sc.SetState(SCE_RAKU_OPERATOR);
}
// --- Heredoc: begin ---------------------------------------------
else if (!hereDelim.empty() && sc.atLineEnd) {
if (IsANewLine(sc.ch))
sc.Forward(); // skip a possible CRLF situation
sc.SetState(hereState);
}
// Reset words: on operator simi-colon OR '}' (end of statement)
if (sc.state == SCE_RAKU_OPERATOR && (sc.ch == ';' || sc.ch == '}')) {
wordLast.clear();
identLast.clear();
adverbLast.clear();
}
}
/* *** Determine if an "embedded comment" is to be entered ********** *
* This type of embedded comment section, or multi-line comment comes
* after a normal comment has begun... e.g: #`[ ... ]
* ****************************************************************** */
else if (sc.state == SCE_RAKU_COMMENTLINE && sc.chPrev == '#' && sc.ch == '`') {
if (IsBracketOpenChar(sc.chNext)) {
sc.Forward(); // Condition met for "embedded comment"
dpEmbeded.opener = sc.ch;
// Find the opposite (termination) closeing bracket (if any)
dpEmbeded.closer[0] = GetBracketCloseChar(dpEmbeded.opener);
if (dpEmbeded.closer[0] > 0) { // Enter "embedded comment"
// Find multiple opening character occurence
dpEmbeded.count = GetRepeatCharCount(sc, dpEmbeded.opener, lengthToEnd);
sc.SetState(SCE_RAKU_COMMENTEMBED);
sc.Forward(dpEmbeded.count - 1); // incremented in the next loop
}
}
}
}
// And we're done...
sc.Complete();
}
/*
* LexerRaku::Lex
* - Main fold method
* NOTE: although Raku uses and supports UNICODE characters, we're only looking
* at normal chars here, using 'SafeGetCharAt' - for folding purposes
* that is all we need.
*/
#define RAKU_HEADFOLD_SHIFT 4
#define RAKU_HEADFOLD_MASK 0xF0
void SCI_METHOD LexerRaku::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
// init LexAccessor / return if fold option is off
if (!options.fold) return;
LexAccessor styler(pAccess);
// init char and line positions
const Sci_PositionU endPos = startPos + length;
Sci_Position lineCurrent = styler.GetLine(startPos);
// Backtrack to last SCE_RAKU_DEFAULT line
if (startPos > 0 && lineCurrent > 0) {
while (lineCurrent > 0 && styler.StyleAt(startPos) != SCE_RAKU_DEFAULT) {
lineCurrent--;
startPos = styler.LineStart(lineCurrent);
}
lineCurrent = styler.GetLine(startPos);
}
Sci_PositionU lineStart = startPos;
Sci_PositionU lineStartNext = styler.LineStart(lineCurrent + 1);
// init line folding level
int levelPrev = SC_FOLDLEVELBASE;
if (lineCurrent > 0)
levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
int levelCurrent = levelPrev;
// init char and style variables
char chNext = styler[startPos];
int stylePrev = styler.StyleAt(startPos - 1);
int styleNext = styler.StyleAt(startPos);
int styleNextStartLine = styler.StyleAt(lineStartNext);
int visibleChars = 0;
bool wasCommentMulti = false;
// main loop
for (Sci_PositionU i = startPos; i < endPos; i++) {
// next char, style and flags
const char ch = chNext;
chNext = styler.SafeGetCharAt(i + 1);
const int style = styleNext;
styleNext = styler.StyleAt(i + 1);
const bool atEOL = i == (lineStartNext - 1);
const bool atLineStart = i == lineStart;
// --- Comments / Multi-line / POD ------------------------------------
if (options.foldComment) {
// Multi-line
if (options.foldCommentMultiline) {
if (style == SCE_RAKU_COMMENTLINE && atLineStart && ch == '#' && chNext == '`'
&& styleNextStartLine == SCE_RAKU_COMMENTEMBED) {
levelCurrent++;
wasCommentMulti = true; // don't confuse line comments
} else if (style == SCE_RAKU_COMMENTEMBED && atLineStart
&& styleNextStartLine != SCE_RAKU_COMMENTEMBED) {
levelCurrent--;
}
}
// Line comments
if (!wasCommentMulti && atEOL && stylePrev == SCE_RAKU_COMMENTLINE
&& IsCommentLine(lineCurrent, styler)) {
if (!IsCommentLine(lineCurrent - 1, styler)
&& IsCommentLine(lineCurrent + 1, styler))
levelCurrent++;
else if (IsCommentLine(lineCurrent - 1, styler)
&& !IsCommentLine(lineCurrent + 1, styler))
levelCurrent--;
}
// POD
if (options.foldCommentPOD && atLineStart && style == SCE_RAKU_POD) {
if (styler.Match(i, "=begin"))
levelCurrent++;
else if (styler.Match(i, "=end"))
levelCurrent--;
}
}
// --- Code block -----------------------------------------------------
if (style == SCE_RAKU_OPERATOR) {
if (ch == '{') {
if (levelCurrent < levelPrev) levelPrev--;
levelCurrent++;
} else if (ch == '}') {
levelCurrent--;
}
}
// --- at end of line / range / apply fold ----------------------------
if (atEOL) {
int level = levelPrev;
// set level flags
level |= levelCurrent << 16;
if (visibleChars == 0 && options.foldCompact)
level |= SC_FOLDLEVELWHITEFLAG;
if ((levelCurrent > levelPrev) && (visibleChars > 0))
level |= SC_FOLDLEVELHEADERFLAG;
if (level != styler.LevelAt(lineCurrent)) {
styler.SetLevel(lineCurrent, level);
}
lineCurrent++;
lineStart = lineStartNext;
lineStartNext = styler.LineStart(lineCurrent + 1);
styleNextStartLine = styler.StyleAt(lineStartNext);
levelPrev = levelCurrent;
visibleChars = 0;
wasCommentMulti = false;
}
// increment visibleChars / set previous char
if (!isspacechar(ch))
visibleChars++;
stylePrev = style;
}
// Done: set real level of the next line
int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
styler.SetLevel(lineCurrent, levelPrev | flagsNext);
}
/*----------------------------------------------------------------------------*
* --- Scintilla: LexerModule ---
*----------------------------------------------------------------------------*/
LexerModule lmRaku(SCLEX_RAKU, LexerRaku::LexerFactoryRaku, "raku", rakuWordLists);
Reference in New Issue View Git Blame Copy Permalink