Fix bugs with hl line data structures
This commit is contained in:
@@ -3,69 +3,7 @@
|
||||
|
||||
#include "io/knot.h"
|
||||
#include "io/sysio.h"
|
||||
|
||||
struct Trie {
|
||||
struct TrieNode {
|
||||
bool is_word = false;
|
||||
std::array<TrieNode *, 128> children{};
|
||||
TrieNode() { children.fill(nullptr); }
|
||||
};
|
||||
|
||||
Trie() : root(new TrieNode()) {}
|
||||
~Trie() { clear_trie(root); }
|
||||
|
||||
void build(const std::vector<std::string> &words) {
|
||||
for (const auto &word : words) {
|
||||
TrieNode *node = root;
|
||||
for (char c : word) {
|
||||
unsigned char uc = static_cast<unsigned char>(c);
|
||||
if (!node->children[uc])
|
||||
node->children[uc] = new TrieNode();
|
||||
node = node->children[uc];
|
||||
}
|
||||
node->is_word = true;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t match(const char *text, uint32_t pos, uint32_t len,
|
||||
bool (*is_word_char)(char c)) const {
|
||||
const TrieNode *node = root;
|
||||
uint32_t max_len = 0;
|
||||
for (uint32_t i = pos; i < len; ++i) {
|
||||
unsigned char uc = static_cast<unsigned char>(text[i]);
|
||||
if (uc >= 128)
|
||||
return 0;
|
||||
if (!node->children[uc]) {
|
||||
if (node->is_word && !is_word_char(text[i]))
|
||||
return i - pos;
|
||||
break;
|
||||
}
|
||||
node = node->children[uc];
|
||||
if (node->is_word)
|
||||
max_len = i - pos + 1;
|
||||
}
|
||||
if (max_len > 0)
|
||||
if (pos + max_len < len && is_word_char(text[pos + max_len]))
|
||||
return 0;
|
||||
return max_len;
|
||||
}
|
||||
|
||||
void clear() {
|
||||
clear_trie(root);
|
||||
root = new TrieNode();
|
||||
}
|
||||
|
||||
private:
|
||||
TrieNode *root;
|
||||
|
||||
void clear_trie(TrieNode *node) {
|
||||
if (!node)
|
||||
return;
|
||||
for (auto *child : node->children)
|
||||
clear_trie(child);
|
||||
delete node;
|
||||
}
|
||||
};
|
||||
#include "syntax/trie.h"
|
||||
|
||||
struct Highlight {
|
||||
uint32_t fg;
|
||||
|
||||
490
include/syntax/extras.h
Normal file
490
include/syntax/extras.h
Normal file
@@ -0,0 +1,490 @@
|
||||
#ifndef SYNTAX_EXTRAS_H
|
||||
#define SYNTAX_EXTRAS_H
|
||||
|
||||
#include "io/knot.h"
|
||||
#include "syntax/decl.h"
|
||||
#include "utils/utils.h"
|
||||
|
||||
inline static const std::vector<std::pair<std::string, uint32_t>> color_map = {
|
||||
{"AliceBlue", 0xF0F8FF},
|
||||
{"AntiqueWhite", 0xFAEBD7},
|
||||
{"Aqua", 0x00FFFF},
|
||||
{"Aquamarine", 0x7FFFD4},
|
||||
{"Azure", 0xF0FFFF},
|
||||
{"Beige", 0xF5F5DC},
|
||||
{"Bisque", 0xFFE4C4},
|
||||
{"Black", 0x000000},
|
||||
{"BlanchedAlmond", 0xFFEBCD},
|
||||
{"Blue", 0x0000FF},
|
||||
{"BlueViolet", 0x8A2BE2},
|
||||
{"Brown", 0xA52A2A},
|
||||
{"BurlyWood", 0xDEB887},
|
||||
{"CadetBlue", 0x5F9EA0},
|
||||
{"Chartreuse", 0x7FFF00},
|
||||
{"Chocolate", 0xD2691E},
|
||||
{"Coral", 0xFF7F50},
|
||||
{"CornflowerBlue", 0x6495ED},
|
||||
{"Cornsilk", 0xFFF8DC},
|
||||
{"Crimson", 0xDC143C},
|
||||
{"Cyan", 0x00FFFF},
|
||||
{"DarkBlue", 0x00008B},
|
||||
{"DarkCyan", 0x008B8B},
|
||||
{"DarkGoldenRod", 0xB8860B},
|
||||
{"DarkGray", 0xA9A9A9},
|
||||
{"DarkGrey", 0xA9A9A9},
|
||||
{"DarkGreen", 0x006400},
|
||||
{"DarkKhaki", 0xBDB76B},
|
||||
{"DarkMagenta", 0x8B008B},
|
||||
{"DarkOliveGreen", 0x556B2F},
|
||||
{"DarkOrange", 0xFF8C00},
|
||||
{"DarkOrchid", 0x9932CC},
|
||||
{"DarkRed", 0x8B0000},
|
||||
{"DarkSalmon", 0xE9967A},
|
||||
{"DarkSeaGreen", 0x8FBC8F},
|
||||
{"DarkSlateBlue", 0x483D8B},
|
||||
{"DarkSlateGray", 0x2F4F4F},
|
||||
{"DarkSlateGrey", 0x2F4F4F},
|
||||
{"DarkTurquoise", 0x00CED1},
|
||||
{"DarkViolet", 0x9400D3},
|
||||
{"DeepPink", 0xFF1493},
|
||||
{"DeepSkyBlue", 0x00BFFF},
|
||||
{"DimGray", 0x696969},
|
||||
{"DimGrey", 0x696969},
|
||||
{"DodgerBlue", 0x1E90FF},
|
||||
{"FireBrick", 0xB22222},
|
||||
{"FloralWhite", 0xFFFAF0},
|
||||
{"ForestGreen", 0x228B22},
|
||||
{"Fuchsia", 0xFF00FF},
|
||||
{"Gainsboro", 0xDCDCDC},
|
||||
{"GhostWhite", 0xF8F8FF},
|
||||
{"Gold", 0xFFD700},
|
||||
{"GoldenRod", 0xDAA520},
|
||||
{"Gray", 0x808080},
|
||||
{"Grey", 0x808080},
|
||||
{"Green", 0x008000},
|
||||
{"GreenYellow", 0xADFF2F},
|
||||
{"HoneyDew", 0xF0FFF0},
|
||||
{"HotPink", 0xFF69B4},
|
||||
{"IndianRed", 0xCD5C5C},
|
||||
{"Indigo", 0x4B0082},
|
||||
{"Ivory", 0xFFFFF0},
|
||||
{"Khaki", 0xF0E68C},
|
||||
{"Lavender", 0xE6E6FA},
|
||||
{"LavenderBlush", 0xFFF0F5},
|
||||
{"LawnGreen", 0x7CFC00},
|
||||
{"LemonChiffon", 0xFFFACD},
|
||||
{"LightBlue", 0xADD8E6},
|
||||
{"LightCoral", 0xF08080},
|
||||
{"LightCyan", 0xE0FFFF},
|
||||
{"LightGoldenRodYellow", 0xFAFAD2},
|
||||
{"LightGray", 0xD3D3D3},
|
||||
{"LightGrey", 0xD3D3D3},
|
||||
{"LightGreen", 0x90EE90},
|
||||
{"LightPink", 0xFFB6C1},
|
||||
{"LightSalmon", 0xFFA07A},
|
||||
{"LightSeaGreen", 0x20B2AA},
|
||||
{"LightSkyBlue", 0x87CEFA},
|
||||
{"LightSlateGray", 0x778899},
|
||||
{"LightSlateGrey", 0x778899},
|
||||
{"LightSteelBlue", 0xB0C4DE},
|
||||
{"LightYellow", 0xFFFFE0},
|
||||
{"Lime", 0x00FF00},
|
||||
{"LimeGreen", 0x32CD32},
|
||||
{"Linen", 0xFAF0E6},
|
||||
{"Magenta", 0xFF00FF},
|
||||
{"Maroon", 0x800000},
|
||||
{"MediumAquaMarine", 0x66CDAA},
|
||||
{"MediumBlue", 0x0000CD},
|
||||
{"MediumOrchid", 0xBA55D3},
|
||||
{"MediumPurple", 0x9370DB},
|
||||
{"MediumSeaGreen", 0x3CB371},
|
||||
{"MediumSlateBlue", 0x7B68EE},
|
||||
{"MediumSpringGreen", 0x00FA9A},
|
||||
{"MediumTurquoise", 0x48D1CC},
|
||||
{"MediumVioletRed", 0xC71585},
|
||||
{"MidnightBlue", 0x191970},
|
||||
{"MintCream", 0xF5FFFA},
|
||||
{"MistyRose", 0xFFE4E1},
|
||||
{"Moccasin", 0xFFE4B5},
|
||||
{"NavajoWhite", 0xFFDEAD},
|
||||
{"Navy", 0x000080},
|
||||
{"OldLace", 0xFDF5E6},
|
||||
{"Olive", 0x808000},
|
||||
{"OliveDrab", 0x6B8E23},
|
||||
{"Orange", 0xFFA500},
|
||||
{"OrangeRed", 0xFF4500},
|
||||
{"Orchid", 0xDA70D6},
|
||||
{"PaleGoldenRod", 0xEEE8AA},
|
||||
{"PaleGreen", 0x98FB98},
|
||||
{"PaleTurquoise", 0xAFEEEE},
|
||||
{"PaleVioletRed", 0xDB7093},
|
||||
{"PapayaWhip", 0xFFEFD5},
|
||||
{"PeachPuff", 0xFFDAB9},
|
||||
{"Peru", 0xCD853F},
|
||||
{"Pink", 0xFFC0CB},
|
||||
{"Plum", 0xDDA0DD},
|
||||
{"PowderBlue", 0xB0E0E6},
|
||||
{"Purple", 0x800080},
|
||||
{"RebeccaPurple", 0x663399},
|
||||
{"Red", 0xFF0000},
|
||||
{"RosyBrown", 0xBC8F8F},
|
||||
{"RoyalBlue", 0x4169E1},
|
||||
{"SaddleBrown", 0x8B4513},
|
||||
{"Salmon", 0xFA8072},
|
||||
{"SandyBrown", 0xF4A460},
|
||||
{"SeaGreen", 0x2E8B57},
|
||||
{"SeaShell", 0xFFF5EE},
|
||||
{"Sienna", 0xA0522D},
|
||||
{"Silver", 0xC0C0C0},
|
||||
{"SkyBlue", 0x87CEEB},
|
||||
{"SlateBlue", 0x6A5ACD},
|
||||
{"SlateGray", 0x708090},
|
||||
{"SlateGrey", 0x708090},
|
||||
{"Snow", 0xFFFAFA},
|
||||
{"SpringGreen", 0x00FF7F},
|
||||
{"SteelBlue", 0x4682B4},
|
||||
{"Tan", 0xD2B48C},
|
||||
{"Teal", 0x008080},
|
||||
{"Thistle", 0xD8BFD8},
|
||||
{"Tomato", 0xFF6347},
|
||||
{"Turquoise", 0x40E0D0},
|
||||
{"Violet", 0xEE82EE},
|
||||
{"Wheat", 0xF5DEB3},
|
||||
{"White", 0xFFFFFF},
|
||||
{"WhiteSmoke", 0xF5F5F5},
|
||||
{"Yellow", 0xFFFF00},
|
||||
{"YellowGreen", 0x9ACD32},
|
||||
};
|
||||
|
||||
// Add word under cursor to this
|
||||
|
||||
struct ExtraHighlighter {
|
||||
std::vector<uint32_t> colors;
|
||||
std::array<std::vector<uint32_t>, 50> lines;
|
||||
Trie<uint32_t> css_colors = Trie<uint32_t>();
|
||||
uint32_t start = 0;
|
||||
|
||||
ExtraHighlighter() { css_colors.build(color_map, false); }
|
||||
|
||||
void render(Knot *root, uint32_t n_start, std::string word, bool is_css) {
|
||||
start = n_start;
|
||||
for (auto &line : lines)
|
||||
line.clear();
|
||||
LineIterator *it = begin_l_iter(root, start);
|
||||
if (!it)
|
||||
return;
|
||||
uint32_t idx = 0;
|
||||
uint32_t len;
|
||||
char *line;
|
||||
while (idx < 50 && (line = next_line(it, &len))) {
|
||||
lines[idx].assign(len, UINT32_MAX - 1);
|
||||
uint32_t i = 0;
|
||||
while (i < len) {
|
||||
if (is_css) {
|
||||
std::optional<uint32_t> color;
|
||||
uint32_t color_len = css_colors.match(
|
||||
line, i, len, [](char c) { return isalnum(c) || c == '_'; },
|
||||
&color);
|
||||
if (color) {
|
||||
for (uint32_t j = 0; j < color_len; j++)
|
||||
lines[idx][i + j] = *color;
|
||||
i += color_len;
|
||||
continue;
|
||||
} else if (i + 5 < len && (line[i] == 'r' || line[i] == 'R') &&
|
||||
(line[i + 1] == 'g' || line[i + 1] == 'G') &&
|
||||
(line[i + 2] == 'b' || line[i + 2] == 'B')) {
|
||||
uint32_t start = i;
|
||||
i += 3;
|
||||
if (line[i] == 'a' || line[i] == 'A')
|
||||
i++;
|
||||
if (line[i] == '(') {
|
||||
i++;
|
||||
bool is_percent = false;
|
||||
std::string r = "";
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
r += line[i++];
|
||||
if (r.empty())
|
||||
continue;
|
||||
while (i < len &&
|
||||
(line[i] == '.' || (line[i] >= '0' && line[i] <= '9')))
|
||||
i++;
|
||||
if (line[i] == '%') {
|
||||
is_percent = true;
|
||||
i++;
|
||||
}
|
||||
while (i < len && (line[i] == ',' || line[i] == ' '))
|
||||
i++;
|
||||
std::string g = "";
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
g += line[i++];
|
||||
if (g.empty())
|
||||
continue;
|
||||
while (i < len &&
|
||||
(line[i] == '.' || (line[i] >= '0' && line[i] <= '9')))
|
||||
i++;
|
||||
while (i < len &&
|
||||
(line[i] == ',' || line[i] == ' ' || line[i] == '%'))
|
||||
i++;
|
||||
std::string b = "";
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
b += line[i++];
|
||||
if (b.empty())
|
||||
continue;
|
||||
while (i < len &&
|
||||
(line[i] == ',' || line[i] == ' ' || line[i] == '.' ||
|
||||
line[i] == '/' || line[i] == '%' ||
|
||||
(line[i] >= '0' && line[i] <= '9')))
|
||||
i++;
|
||||
if (i < len && line[i] == ')')
|
||||
i++;
|
||||
else
|
||||
continue;
|
||||
uint32_t rr, gg, bb;
|
||||
if (is_percent) {
|
||||
rr = std::stoul(r) * 255 / 100;
|
||||
gg = std::stoul(g) * 255 / 100;
|
||||
bb = std::stoul(b) * 255 / 100;
|
||||
} else {
|
||||
rr = std::stoul(r);
|
||||
gg = std::stoul(g);
|
||||
bb = std::stoul(b);
|
||||
}
|
||||
rr = rr > 255 ? 255 : rr;
|
||||
gg = gg > 255 ? 255 : gg;
|
||||
bb = bb > 255 ? 255 : bb;
|
||||
uint32_t color = (rr << 16) | (gg << 8) | bb;
|
||||
for (uint32_t j = start; j < i; j++)
|
||||
lines[idx][j] = color;
|
||||
}
|
||||
continue;
|
||||
} else if (i + 5 < len && (line[i] == 'h' || line[i] == 'H') &&
|
||||
(line[i + 1] == 's' || line[i + 1] == 'S') &&
|
||||
(line[i + 2] == 'l' || line[i + 2] == 'L')) {
|
||||
uint32_t start = i;
|
||||
i += 3;
|
||||
if (line[i] == 'a' || line[i] == 'A')
|
||||
i++;
|
||||
if (line[i] == '(') {
|
||||
i++;
|
||||
std::string h = "";
|
||||
std::string h_unit = "";
|
||||
enum unit : uint8_t { deg, grad, rad, turn };
|
||||
unit u = deg;
|
||||
bool negative = false;
|
||||
if (i < len && (line[i] == '-' || line[i] == '+')) {
|
||||
negative = line[i] == '-';
|
||||
i++;
|
||||
}
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
h += line[i++];
|
||||
if (i < len && line[i] == '.') {
|
||||
h += '.';
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
h += line[i++];
|
||||
}
|
||||
if (h.empty())
|
||||
continue;
|
||||
while (i < len && ((line[i] >= 'a' && line[i] <= 'z') ||
|
||||
(line[i] >= 'A' && line[i] <= 'Z')))
|
||||
h_unit += line[i++];
|
||||
for (size_t x = 0; x < h_unit.size(); x++)
|
||||
h_unit[x] = tolower(h_unit[x]);
|
||||
if (h_unit.empty())
|
||||
u = deg;
|
||||
else if (h_unit == "deg")
|
||||
u = deg;
|
||||
else if (h_unit == "grad")
|
||||
u = grad;
|
||||
else if (h_unit == "rad")
|
||||
u = rad;
|
||||
else if (h_unit == "turn")
|
||||
u = turn;
|
||||
else
|
||||
continue;
|
||||
double hue = std::stod(h);
|
||||
if (negative)
|
||||
hue = -hue;
|
||||
switch (u) {
|
||||
case deg:
|
||||
break;
|
||||
case grad:
|
||||
hue = hue * 360.0 / 400.0;
|
||||
break;
|
||||
case rad:
|
||||
hue = hue * 180.0 / M_PI;
|
||||
break;
|
||||
case turn:
|
||||
hue = hue * 360.0;
|
||||
break;
|
||||
}
|
||||
hue = fmod(hue, 360.0);
|
||||
if (hue < 0)
|
||||
hue += 360.0;
|
||||
double h_final = hue / 360.0;
|
||||
while (i < len && (line[i] == ',' || line[i] == ' '))
|
||||
i++;
|
||||
std::string s = "";
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
s += line[i++];
|
||||
if (s.empty())
|
||||
continue;
|
||||
if (i < len && line[i] == '%')
|
||||
i++;
|
||||
else
|
||||
continue;
|
||||
while (i < len && (line[i] == ',' || line[i] == ' '))
|
||||
i++;
|
||||
std::string l = "";
|
||||
while (i < len && line[i] >= '0' && line[i] <= '9')
|
||||
l += line[i++];
|
||||
if (l.empty())
|
||||
continue;
|
||||
if (i < len && line[i] == '%')
|
||||
i++;
|
||||
else
|
||||
continue;
|
||||
while (i < len &&
|
||||
(line[i] == ',' || line[i] == ' ' || line[i] == '.' ||
|
||||
line[i] == '/' || line[i] == '%' ||
|
||||
(line[i] >= '0' && line[i] <= '9')))
|
||||
i++;
|
||||
if (i < len && line[i] == ')')
|
||||
i++;
|
||||
double s_val = std::stod(s) / 100.0;
|
||||
double l_val = std::stod(l) / 100.0;
|
||||
uint32_t color = hslToRgb(h_final, s_val, l_val);
|
||||
for (uint32_t j = start; j < i; j++)
|
||||
lines[idx][j] = color;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (i + 4 < len && line[i] == '#') {
|
||||
i++;
|
||||
uint32_t start = i;
|
||||
while (i < len && isxdigit(line[i]))
|
||||
i++;
|
||||
uint32_t color = 0;
|
||||
if (is_css && (i - start == 3 || i - start == 4)) {
|
||||
uint32_t r =
|
||||
std::stoul(std::string(line + start, 1), nullptr, 16) * 0x11;
|
||||
uint32_t g =
|
||||
std::stoul(std::string(line + start + 1, 1), nullptr, 16) *
|
||||
0x11;
|
||||
uint32_t b =
|
||||
std::stoul(std::string(line + start + 2, 1), nullptr, 16) *
|
||||
0x11;
|
||||
color = (r << 16) | (g << 8) | b;
|
||||
} else if ((is_css && (i - start == 8)) || i - start == 6) {
|
||||
uint32_t r = std::stoul(std::string(line + start, 2), nullptr, 16);
|
||||
uint32_t g =
|
||||
std::stoul(std::string(line + start + 2, 2), nullptr, 16);
|
||||
uint32_t b =
|
||||
std::stoul(std::string(line + start + 4, 2), nullptr, 16);
|
||||
color = (r << 16) | (g << 8) | b;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
for (uint32_t j = start - 1; j < i; j++)
|
||||
lines[idx][j] = color;
|
||||
continue;
|
||||
} else if (i + 5 < len && line[i] == '0' && line[i + 1] == 'x') {
|
||||
i += 2;
|
||||
uint32_t start = i;
|
||||
while (i < len && isxdigit(line[i]))
|
||||
i++;
|
||||
uint32_t color = 0;
|
||||
if (i - start == 6) {
|
||||
uint32_t r = std::stoul(std::string(line + start, 2), nullptr, 16);
|
||||
uint32_t g =
|
||||
std::stoul(std::string(line + start + 2, 2), nullptr, 16);
|
||||
uint32_t b =
|
||||
std::stoul(std::string(line + start + 4, 2), nullptr, 16);
|
||||
color = (r << 16) | (g << 8) | b;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
if (color)
|
||||
color--;
|
||||
else
|
||||
color++;
|
||||
for (uint32_t j = start - 2; j < i; j++)
|
||||
lines[idx][j] = color;
|
||||
continue;
|
||||
}
|
||||
if (i < len && (isalnum(line[i]) || line[i] == '_')) {
|
||||
uint32_t start = i;
|
||||
uint32_t x = 0;
|
||||
bool found = true;
|
||||
while (i < len && (isalnum(line[i]) || line[i] == '_')) {
|
||||
if (x < word.size() && line[i] == word[x]) {
|
||||
i++;
|
||||
x++;
|
||||
} else {
|
||||
found = false;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (found && x == word.size())
|
||||
for (uint32_t j = start; j < i; j++)
|
||||
lines[idx][j] = UINT32_MAX;
|
||||
} else {
|
||||
i += utf8_codepoint_width(line[i]);
|
||||
}
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
free(it->buffer);
|
||||
free(it);
|
||||
}
|
||||
|
||||
std::optional<std::pair<uint32_t, uint32_t>> get(Coord pos) {
|
||||
uint32_t val;
|
||||
if (pos.row < start || pos.row >= start + 50 ||
|
||||
pos.col >= lines[pos.row - start].size() ||
|
||||
(val = lines[pos.row - start][pos.col]) == UINT32_MAX - 1)
|
||||
return std::nullopt;
|
||||
return (std::pair<uint32_t, uint32_t>){fg_for_bg(val), val};
|
||||
}
|
||||
|
||||
private:
|
||||
uint32_t fg_for_bg(uint32_t color) {
|
||||
uint8_t r = (color >> 16) & 0xFF;
|
||||
uint8_t g = (color >> 8) & 0xFF;
|
||||
uint8_t b = color & 0xFF;
|
||||
double luminance = 0.299 * r + 0.587 * g + 0.114 * b;
|
||||
return (luminance > 128) ? 0x000000 : 0xFFFFFF;
|
||||
}
|
||||
|
||||
uint32_t hslToRgb(double h, double s, double l) {
|
||||
double r, g, b;
|
||||
if (s == 0.0) {
|
||||
r = g = b = l;
|
||||
} else {
|
||||
auto hue2rgb = [](double p, double q, double t) -> double {
|
||||
if (t < 0)
|
||||
t += 1;
|
||||
if (t > 1)
|
||||
t -= 1;
|
||||
if (t < 1.0 / 6)
|
||||
return p + (q - p) * 6 * t;
|
||||
if (t < 1.0 / 2)
|
||||
return q;
|
||||
if (t < 2.0 / 3)
|
||||
return p + (q - p) * (2.0 / 3 - t) * 6;
|
||||
return p;
|
||||
};
|
||||
double q = l < 0.5 ? l * (1 + s) : l + s - l * s;
|
||||
double p = 2 * l - q;
|
||||
r = hue2rgb(p, q, h + 1.0 / 3);
|
||||
g = hue2rgb(p, q, h);
|
||||
b = hue2rgb(p, q, h - 1.0 / 3);
|
||||
}
|
||||
uint32_t R = static_cast<uint32_t>(std::clamp(r, 0.0, 1.0) * 255);
|
||||
uint32_t G = static_cast<uint32_t>(std::clamp(g, 0.0, 1.0) * 255);
|
||||
uint32_t B = static_cast<uint32_t>(std::clamp(b, 0.0, 1.0) * 255);
|
||||
return (R << 16) | (G << 8) | B;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -74,10 +74,14 @@ struct LineTree {
|
||||
}
|
||||
void insert(uint32_t x, uint32_t y) {
|
||||
std::unique_lock lock(mtx);
|
||||
if (x > subtree_size(root))
|
||||
x = subtree_size(root);
|
||||
root = insert_node(root, x, y);
|
||||
}
|
||||
void erase(uint32_t x, uint32_t y) {
|
||||
std::unique_lock lock(mtx);
|
||||
if (x + y > subtree_size(root))
|
||||
x = subtree_size(root) - y;
|
||||
root = erase_node(root, x, y);
|
||||
}
|
||||
uint32_t count() {
|
||||
@@ -116,18 +120,26 @@ private:
|
||||
std::shared_mutex mtx;
|
||||
static constexpr uint32_t LEAF_TARGET = 256;
|
||||
LineTree::LineNode *erase_node(LineNode *n, uint32_t x, uint32_t y) {
|
||||
if (!n)
|
||||
return nullptr;
|
||||
if (!n->left && !n->right) {
|
||||
n->data.erase(n->data.begin() + x, n->data.begin() + x + y);
|
||||
fix(n);
|
||||
if (!n || y == 0)
|
||||
return n;
|
||||
uint32_t left_sz = subtree_size(n->left);
|
||||
uint32_t mid_sz = n->data.size();
|
||||
if (x < left_sz) {
|
||||
uint32_t len = std::min(y, left_sz - x);
|
||||
n->left = erase_node(n->left, x, len);
|
||||
y -= len;
|
||||
x = left_sz;
|
||||
}
|
||||
if (y > 0 && x < left_sz + mid_sz) {
|
||||
uint32_t mid_x = x - left_sz;
|
||||
uint32_t len = std::min(y, mid_sz - mid_x);
|
||||
n->data.erase(n->data.begin() + mid_x, n->data.begin() + mid_x + len);
|
||||
y -= len;
|
||||
x += len;
|
||||
}
|
||||
if (y > 0) {
|
||||
n->right = erase_node(n->right, x - left_sz - n->data.size(), y);
|
||||
}
|
||||
uint32_t left_size = subtree_size(n->left);
|
||||
if (x < left_size)
|
||||
n->left = erase_node(n->left, x, y);
|
||||
else
|
||||
n->right = erase_node(n->right, x - left_size - n->data.size(), y);
|
||||
if (n->left && n->right &&
|
||||
subtree_size(n->left) + subtree_size(n->right) < 256) {
|
||||
return merge(n->left, n->right);
|
||||
@@ -142,7 +154,7 @@ private:
|
||||
return leaf;
|
||||
}
|
||||
if (!n->left && !n->right) {
|
||||
n->data.insert(n->data.begin() + x, y, LineData{});
|
||||
n->data.insert(n->data.begin() + x, y, LineData());
|
||||
fix(n);
|
||||
if (n->data.size() > 512)
|
||||
return split_leaf(n);
|
||||
|
||||
@@ -5,8 +5,7 @@
|
||||
#include "syntax/line_tree.h"
|
||||
|
||||
struct Parser {
|
||||
Knot *root;
|
||||
std::shared_mutex *knot_mutex;
|
||||
struct Editor *editor = nullptr;
|
||||
std::string lang;
|
||||
std::shared_ptr<void> (*parse_func)(std::vector<Token> *tokens,
|
||||
std::shared_ptr<void> in_state,
|
||||
@@ -19,10 +18,8 @@ struct Parser {
|
||||
LineTree line_tree;
|
||||
std::set<uint32_t> dirty_lines;
|
||||
|
||||
Parser(Knot *n_root, std::shared_mutex *n_knot_mutex, std::string n_lang,
|
||||
uint32_t n_scroll_max);
|
||||
void edit(Knot *n_root, uint32_t start_line, uint32_t old_end_line,
|
||||
uint32_t new_end_line);
|
||||
Parser(Editor *editor, std::string n_lang, uint32_t n_scroll_max);
|
||||
void edit(uint32_t start_line, uint32_t old_end_line, uint32_t inserted_rows);
|
||||
void work();
|
||||
void scroll(uint32_t line);
|
||||
};
|
||||
|
||||
140
include/syntax/trie.h
Normal file
140
include/syntax/trie.h
Normal file
@@ -0,0 +1,140 @@
|
||||
#ifndef SYNTAX_TRIE_H
|
||||
#define SYNTAX_TRIE_H
|
||||
|
||||
#include "utils/utils.h"
|
||||
|
||||
template <typename T> struct Trie {
|
||||
struct TrieNode {
|
||||
bool is_word = false;
|
||||
std::array<TrieNode *, 128> children{};
|
||||
std::conditional_t<std::is_void_v<T>, char, std::optional<T>> value;
|
||||
TrieNode() { children.fill(nullptr); }
|
||||
};
|
||||
|
||||
Trie() {}
|
||||
~Trie() { clear_trie(root); }
|
||||
|
||||
void build(const std::vector<std::string> &words, bool cs = true) {
|
||||
static_assert(std::is_void_v<T>, "This build() is for Trie<void> only");
|
||||
case_sensitive = cs;
|
||||
for (auto &w : words)
|
||||
insert(w);
|
||||
}
|
||||
|
||||
template <typename U = T>
|
||||
std::enable_if_t<!std::is_void_v<U>>
|
||||
build(const std::vector<std::pair<std::string, U>> &words, bool cs = true) {
|
||||
static_assert(!std::is_void_v<T>, "This build() is for typed Trie only");
|
||||
case_sensitive = cs;
|
||||
for (auto &[w, v] : words)
|
||||
insert(w, v);
|
||||
}
|
||||
|
||||
uint32_t match(const char *text, uint32_t pos, uint32_t len,
|
||||
bool (*is_word_char)(char c)) const {
|
||||
const TrieNode *node = root;
|
||||
uint32_t max_len = 0;
|
||||
for (uint32_t i = pos; i < len; ++i) {
|
||||
unsigned char uc = static_cast<unsigned char>(text[i]);
|
||||
if (uc >= 128)
|
||||
return 0;
|
||||
if (!case_sensitive && uc >= 'A' && uc <= 'Z')
|
||||
uc = uc - 'A' + 'a';
|
||||
if (!node->children[uc]) {
|
||||
if (node->is_word && !is_word_char(text[i]))
|
||||
return i - pos;
|
||||
break;
|
||||
}
|
||||
node = node->children[uc];
|
||||
if (node->is_word)
|
||||
max_len = i - pos + 1;
|
||||
}
|
||||
if (max_len > 0)
|
||||
if (pos + max_len < len && is_word_char(text[pos + max_len]))
|
||||
return 0;
|
||||
return max_len;
|
||||
}
|
||||
|
||||
template <typename U = T>
|
||||
uint32_t
|
||||
match(const char *text, uint32_t pos, uint32_t len,
|
||||
bool (*is_word_char)(char c),
|
||||
std::conditional_t<std::is_void_v<T>, void *, std::optional<T> *>
|
||||
out_val = nullptr) const {
|
||||
const TrieNode *node = root;
|
||||
const TrieNode *last_word_node = nullptr;
|
||||
uint32_t max_len = 0;
|
||||
for (uint32_t i = pos; i < len; ++i) {
|
||||
unsigned char uc = static_cast<unsigned char>(text[i]);
|
||||
if (uc >= 128)
|
||||
break;
|
||||
if (!case_sensitive && uc >= 'A' && uc <= 'Z')
|
||||
uc = uc - 'A' + 'a';
|
||||
if (!node->children[uc])
|
||||
break;
|
||||
node = node->children[uc];
|
||||
if (node->is_word) {
|
||||
last_word_node = node;
|
||||
max_len = i - pos + 1;
|
||||
}
|
||||
}
|
||||
if (!last_word_node) {
|
||||
if (out_val)
|
||||
*out_val = std::nullopt;
|
||||
return 0;
|
||||
}
|
||||
if (pos + max_len < len && is_word_char(text[pos + max_len])) {
|
||||
if (out_val)
|
||||
*out_val = std::nullopt;
|
||||
return 0;
|
||||
}
|
||||
if (out_val)
|
||||
*out_val = last_word_node->value;
|
||||
return max_len;
|
||||
}
|
||||
|
||||
private:
|
||||
TrieNode *root = new TrieNode();
|
||||
bool case_sensitive = true;
|
||||
|
||||
void insert(const std::string &word) {
|
||||
TrieNode *node = root;
|
||||
for (char c : word) {
|
||||
unsigned char uc = static_cast<unsigned char>(c);
|
||||
if (uc >= 128)
|
||||
return;
|
||||
if (!case_sensitive && uc >= 'A' && uc <= 'Z')
|
||||
uc = uc - 'A' + 'a';
|
||||
if (!node->children[uc])
|
||||
node->children[uc] = new TrieNode();
|
||||
node = node->children[uc];
|
||||
}
|
||||
node->is_word = true;
|
||||
}
|
||||
|
||||
template <typename U = T>
|
||||
std::enable_if_t<!std::is_void_v<U>> insert(const std::string &word,
|
||||
const U &val) {
|
||||
TrieNode *node = root;
|
||||
for (char c : word) {
|
||||
unsigned char uc = static_cast<unsigned char>(c);
|
||||
if (!case_sensitive && uc >= 'A' && uc <= 'Z')
|
||||
uc = uc - 'A' + 'a';
|
||||
if (!node->children[uc])
|
||||
node->children[uc] = new TrieNode();
|
||||
node = node->children[uc];
|
||||
}
|
||||
node->is_word = true;
|
||||
node->value = val;
|
||||
}
|
||||
|
||||
void clear_trie(TrieNode *node) {
|
||||
if (!node)
|
||||
return;
|
||||
for (auto *child : node->children)
|
||||
clear_trie(child);
|
||||
delete node;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user