kme-devline/libregexis024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed vm bugs, refactored the entire broject to use regexis024 namespace, removed some junk, added tests

Browse Source
This commit is contained in:
Андреев Григорий 2024-07-30 01:02:07 +03:00
parent b11afa72ea
commit 76f3742521
79 changed files with 4988 additions and 4875 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
building/main.cpp
View File

@ -72,7 +72,6 @@ struct Libregexis024BuildSystem {
"libregexis024fa/graph_to_bytecode/core.cpp",
"libregexis024sol/common_codesets.cpp",
"libregexis024sol/part_of_expr_that_tracks.cpp",
"libregexis024sol/expr_compiler.cpp",
"libregexis024sol/square_bracket_expression.cpp",
"libregexis024sol/sol_misc_base.cpp",

82
src/debugging_regexis024/debug_through_graphviz.cpp
View File

@ -10,19 +10,20 @@
#include <libregexis024vm/vm_opcodes.h>
#include <libregexis024fa/tracking_fa_nodes.h>
const char* one_char_read_color = "black";
const char* forking_color = "darkorchid1";
const char* look_one_behind_color = "darkslateblue";
const char* look_one_ahead_color = "coral1";
const char* track_array_mov_imm_color = "lightblue2";
const char* track_array_mov_halfinvariant_color = "lightseagreen";
const char* match_pending_lob_color = "darkgoldenrod2";
const char* match_color = "gold";
const char* det_char_crossroads_color = "navy";
const char* error_color = "crimson";
const char* STAR = "★";
namespace regexis024 {
const char* one_char_read_color = "black";
const char* forking_color = "darkorchid1";
const char* look_one_behind_color = "darkslateblue";
const char* look_one_ahead_color = "coral1";
const char* track_array_mov_imm_color = "lightblue2";
const char* track_array_mov_halfinvariant_color = "lightseagreen";
const char* match_pending_lob_color = "darkgoldenrod2";
const char* match_color = "gold";
const char* det_char_crossroads_color = "navy";
const char* error_color = "crimson";
const char* STAR = "★";
const char* get_associated_color(FA_Node* node){
const char* get_associated_color(FA_Node* node){
switch (node->type) {
#define ccase(tn) case tn: return tn##_color;
ccase(one_char_read)
@ -38,20 +39,20 @@ const char* get_associated_color(FA_Node* node){
return "black";
#undef ccase
}
}
}
struct NodesProblems{
struct NodesProblems{
size_t actual_refcount = 0;
bool refcount_problem = false;
size_t edges_point_to_null = 0;
};
};
struct EdgesProblems {
struct EdgesProblems {
bool points_to_null = false;
explicit EdgesProblems(bool points_to_null): points_to_null(points_to_null) {}
};
};
std::string get_applied_edge_attributes(FA_Node* node, const NodesProblems& np, const EdgesProblems& ep){
std::string get_applied_edge_attributes(FA_Node* node, const NodesProblems& np, const EdgesProblems& ep){
std::string res = "color=";
if (ep.points_to_null) {
res += error_color;
@ -61,9 +62,9 @@ std::string get_applied_edge_attributes(FA_Node* node, const NodesProblems& np,
res += " style=bold";
}
return res;
}
}
std::string get_applied_node_attributes(FA_Node* node, const NodesProblems& bd){
std::string get_applied_node_attributes(FA_Node* node, const NodesProblems& bd){
std::string res = "color=";
res += get_associated_color(node);
if (bd.refcount_problem)
@ -72,9 +73,9 @@ std::string get_applied_node_attributes(FA_Node* node, const NodesProblems& bd){
(node->type == det_char_crossroads && dynamic_cast<FA_NodeOfDetCharCrossroads*>(node)->matching))
res += " shape=doublecircle";
return res;
}
}
void append_reverse_hex(std::string& res, uint32_t num){
void append_reverse_hex(std::string& res, uint32_t num){
if (num == 0){
res += "0";
} else {
@ -84,9 +85,9 @@ void append_reverse_hex(std::string& res, uint32_t num){
num >>= 4;
}
}
}
}
std::string stringify_codeset(const codeset_t& cs){
std::string stringify_codeset(const codeset_t& cs){
std::string res;
for (long i = static_cast<long>(cs.size()) - 1; i >= 0; i--) {
uint64_t start = cs[i].first, end = cs[i].second;
@ -102,9 +103,9 @@ std::string stringify_codeset(const codeset_t& cs){
}
std::reverse(res.begin(), res.end()); /* ascii works wonders */
return res;
}
}
std::string get_extended_node_lable(FA_Node* node){
std::string get_extended_node_lable(FA_Node* node){
if ((node->type == one_char_read && dynamic_cast<FA_NodeOfOneCharRead*>(node)->second_ns) ||
(node->type == det_char_crossroads && dynamic_cast<FA_NodeOfDetCharCrossroads*>(node)->second_ns)) {
return std::string(" ") + STAR;
@ -115,9 +116,9 @@ std::string get_extended_node_lable(FA_Node* node){
return std::string(" pending loa ") + stringify_codeset(mn->pending_filter);
}
return "";
}
}
std::string get_node_lable(FA_Node* node, const NodesProblems& bd){
std::string get_node_lable(FA_Node* node, const NodesProblems& bd){
std::string res;
switch (node->type) {
#define tcase(tn, str) case tn: res = str; break;
@ -135,9 +136,9 @@ std::string get_node_lable(FA_Node* node, const NodesProblems& bd){
if (bd.refcount_problem)
res += ("!refcount: " + std::to_string(node->refs) + "!");
return res;
}
}
void print_edge(FA_Node* start, const FA_Node* dest, const std::string& label, FILE* fd, NodesProblems& np){
void print_edge(FA_Node* start, const FA_Node* dest, const std::string& label, FILE* fd, NodesProblems& np){
if (!dest){
fprintf(stderr, "NULL transition going from node %lu\n", start->nodeId);
fprintf(fd, "%lu->NULL_%lu_%lu [label=\"%s\" color=crimson]", start->nodeId,
@ -146,9 +147,9 @@ void print_edge(FA_Node* start, const FA_Node* dest, const std::string& label, F
}
fprintf(fd, "%lu->%lu [label=\"%s\" %s]\n", start->nodeId, dest->nodeId, label.c_str(),
get_applied_edge_attributes(start, np, EdgesProblems(false)).c_str());
}
}
void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
const RegexPriorityTable& priority_table){
assert(fa.start);
assert(fd);
@ -184,7 +185,7 @@ void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
/* Two Infoboxes */
auto stringifyTrackingVarType = [](tracking_var_type type) -> std::string {
auto stringifyTrackingVarType = [](tracking_var_type_t type) -> std::string {
switch (type) {
case tracking_var_types::range:
return "range";
@ -199,7 +200,7 @@ void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
for (auto& p: ktr.track_names){
const SubtrackingNameInfo& tu = ktr.retrieval_info[p.second];
auto getRole = [](bool presence, tracking_var_type type, int first, int second,
auto getRole = [](bool presence, tracking_var_type_t type, int first, int second,
const std::string& ARR_NAME) -> std::string {
if (!presence) {
assert(first == -1 && second == -1);
@ -264,7 +265,7 @@ void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
if (!isImmMovOpcode(cn->operation))
fprintf(stderr, "bad operation in node %lu\n", node->nodeId);
snprintf(buf, 1024, "%s %hu %lu",
regex024_opcode_tostr(cn->operation), cn->key, cn->imm_value);
opcode_to_str(cn->operation), cn->key, cn->imm_value);
print_edge(node, cn->nxt_node,std::string(buf), fd, bd);
} else if (node->type == track_array_mov_halfinvariant){
FA_NodeOfTrackArrayMovHalfinvariant* cn = dynamic_cast<FA_NodeOfTrackArrayMovHalfinvariant *>(node);
@ -272,7 +273,7 @@ void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
if (!isCurPosMovOpcode(cn->operation))
fprintf(stderr, "bad operation in node %lu\n", node->nodeId);
snprintf(buf, 1024, "%s %hu",
regex024_opcode_tostr(cn->operation), cn->key);
opcode_to_str(cn->operation), cn->key);
print_edge(node, cn->nxt_node,std::string(buf), fd, bd);
} else if (node->type == det_char_crossroads){
FA_NodeOfDetCharCrossroads* cn = dynamic_cast<FA_NodeOfDetCharCrossroads *>(node);
@ -284,9 +285,9 @@ void print_fa(const FA_Container& fa, FILE* fd, const KnownTrackingTools& ktr,
}
}
fprintf(fd, "}\n");
}
}
FILE* get_fd(const char* apath){
FILE* get_fd(const char* apath){
errno = 0;
FILE *fd = fopen(apath, "w");
if (!fd)
@ -297,9 +298,9 @@ FILE* get_fd(const char* apath){
if (!fd)
perror("fopen a");
return fd;
}
}
void show_fa_with_sxiv_after_dot(const FA_Container& fa, const KnownTrackingTools& ktr,
void show_fa_with_sxiv_after_dot(const FA_Container& fa, const KnownTrackingTools& ktr,
const RegexPriorityTable& priority_table) {
const char* temp_gv = "FAGraph.gv";
const char* temp_png = "FAGraph.png";
@ -322,4 +323,5 @@ void show_fa_with_sxiv_after_dot(const FA_Container& fa, const KnownTrackingTool
assert(chw >= 0);
unlink(temp_gv);
unlink(temp_png);
}
}

6
src/debugging_regexis024/debug_through_graphviz.h
View File

@ -5,8 +5,10 @@
#include <libregexis024sol/part_of_expr_that_tracks.h>
#include <libregexis024fa/selarr_priority_table.h>
/* Uses temporary file FAGraph.gv,png, dot command and sxiv */
void show_fa_with_sxiv_after_dot(const FA_Container& fa, const KnownTrackingTools& ktr,
namespace regexis024 {
/* Uses temporary file FAGraph.gv,png, dot command and sxiv */
void show_fa_with_sxiv_after_dot(const FA_Container& fa, const KnownTrackingTools& ktr,
const RegexPriorityTable& priority_table);
}
#endif

56
src/debugging_regexis024/prettyprint/prettyprint_util.cpp
View File

@ -2,40 +2,38 @@
#include <functional>
#include <libregexis024vm/utils.h>
TreeWithStringsNode::TreeWithStringsNode(const std::string &val): val(val) {
}
namespace regexis024 {
static const char* ch_empty = " ";
static const char* ch_passing_by = "\u2502 ";
static const char* ch_connect_right_and_forward = "\u251c\u2500\u2500\u2500";
static const char* ch_connect_right_last = "\u2514\u2500\u2500\u2500";
static const char* ch_empty = " ";
static const char* ch_passing_by = "\u2502 ";
static const char* ch_connect_right_and_forward = "\u251c\u2500\u2500\u2500";
static const char* ch_connect_right_last = "\u2514\u2500\u2500\u2500";
static const char* ch_box_left_side = "\u2551";
static const char* ch_box_right_side = "\u2551";
static const char* ch_box_top_side = "\u2550";
static const char* ch_box_bottom_side = "\u2550";
static const char* ch_box_crn_top_left = "\u2554";
static const char* ch_box_crn_top_right = "\u2557";
static const char* ch_box_crn_bottom_left = "\u255A";
static const char* ch_box_crn_bottom_right = "\u255D";
static const char* ch_box_left_side = "\u2551";
static const char* ch_box_right_side = "\u2551";
static const char* ch_box_top_side = "\u2550";
static const char* ch_box_bottom_side = "\u2550";
static const char* ch_box_crn_top_left = "\u2554";
static const char* ch_box_crn_top_right = "\u2557";
static const char* ch_box_crn_bottom_left = "\u255A";
static const char* ch_box_crn_bottom_right = "\u255D";
size_t length_of_line(const std::string& str) {
size_t length_of_line(const std::string& str) {
size_t ch = 0;
size_t pos = 0;
while (pos < str.size()) {
int32_t code;
size_t adj;
utf8_string_iterat(code, adj, pos, reinterpret_cast<const uint8_t*>(str.data()), str.size());
utf8_string_iterat(code, adj, pos, str.data(), str.size());
if (code < 0)
return ch;
ch++;
pos += adj;
}
return ch;
}
}
/* Warning: recursion used */
void toLines_dfs(const TreeWithStringsNode& node, lines& out, std::vector<bool>& prefix) {
/* Warning: recursion used */
void toLines_dfs(const TreeWithStringsNode& node, lines& out, std::vector<bool>& prefix) {
out.push_back("");
size_t n = prefix.size();
for (size_t i = 0; i < n; i++) {
@ -54,21 +52,21 @@ void toLines_dfs(const TreeWithStringsNode& node, lines& out, std::vector<bool>&
toLines_dfs(node.childeren[i], out, prefix);
}
prefix.pop_back();
}
}
void TreeWithStringsNode::toLines(lines &out) const {
void TreeWithStringsNode::toLines(lines &out) const {
std::vector<bool> prefix;
toLines_dfs(*this, out, prefix);
}
}
std::string strMul(size_t n, const char* str) {
std::string strMul(size_t n, const char* str) {
std::string res;
for (size_t i = 0; i < n; i++)
res += str;
return res;
}
}
lines wrapWithBox(const lines &in) {
lines wrapWithBox(const lines &in) {
lines out;
size_t max_width = 0;
for (auto& l: in)
@ -80,10 +78,10 @@ lines wrapWithBox(const lines &in) {
}
out.push_back(ch_box_crn_bottom_left + strMul(max_width, ch_box_bottom_side) + ch_box_crn_bottom_right);
return out;
}
}
void printLines(const lines &in) {
void printLines(const lines &in) {
for (auto& l: in)
printf("%s\n", l.c_str());
}
}

15
src/debugging_regexis024/prettyprint/prettyprint_util.h
View File

@ -6,20 +6,19 @@
#include <vector>
#include <string>
typedef std::vector<std::string> lines;
namespace regexis024 {
typedef std::vector<std::string> lines;
struct TreeWithStringsNode {
struct TreeWithStringsNode {
std::string val;
std::vector<TreeWithStringsNode> childeren;
explicit TreeWithStringsNode(const std::string &val);
TreeWithStringsNode() = default;
void toLines(lines& out) const;
};
};
lines wrapWithBox(const lines& in);
lines wrapWithBox(const lines& in);
void printLines(const lines& in);
void printLines(const lines& in);
}
#endif

20
src/debugging_regexis024/vm/libregexis024vm_debug.cpp
View File

@ -2,15 +2,16 @@
#include <stdio.h>
#include <string>
std::string thread_to_str(const REGEX_IS024_Thread& thread){
namespace regexis024 {
std::string thread_to_str(const Thread& thread){
if (!(thread.slot_occupation_status & SLOT_OCCUPIED))
return "{ unoccupied }";
char buf[1024];
snprintf(buf, 1024, "{ IP = %lu }", thread.IP);
return buf;
}
}
std::string stack_to_str(const REGEX_IS024_Stack& stack){
std::string stack_to_str(const SSID_Stack& stack){
std::string res = "{ ";
for (uint32_t i = 0; i < stack.sz; i++){
if (i != 0)
@ -19,9 +20,9 @@ std::string stack_to_str(const REGEX_IS024_Stack& stack){
}
res += " }";
return res;
}
}
std::string slots_to_str(const REGEX_IS024_CONTEXT& ctx){
std::string slots_to_str(const VMContext& ctx){
if (!ctx.initialized)
return "uninitialized";
std::string READ_slots;
@ -41,18 +42,19 @@ std::string slots_to_str(const REGEX_IS024_CONTEXT& ctx){
stack_to_str(ctx.READ_halted_stack_new_second).c_str(),
stack_to_str(ctx.READ_halted_stack_old).c_str(), stack_to_str(ctx.FORK_halted_stack).c_str());
return buf;
}
}
void debug_print_context(const REGEX_IS024_CONTEXT& ctx, const char* place) {
void debug_print_context(const VMContext& ctx, const char* place) {
printf("== DEBUG `%s` ==\n", place);
printf("Active thread: %s, sifting_with: %s, match: %s\n%s\n",
thread_to_str(ctx.active_thread).c_str(),
ctx.sifting_with ? thread_to_str(*ctx.sifting_with).c_str() : "NO", thread_to_str(ctx.matched_thread).c_str(),
slots_to_str(ctx).c_str());
}
}
void debug_print_thread(const REGEX_IS024_Thread& thr, const char *place) {
void debug_print_thread(const Thread& thr, const char *place) {
printf("== DEBUG `%s` ==\n", place);
printf("This thread: %s\n", thread_to_str(thr).c_str());
}
}

6
src/debugging_regexis024/vm/libregexis024vm_debug.h
View File

@ -4,8 +4,10 @@
#include <libregexis024vm/libregexis024vm.h>
#include <libregexis024vm/instruction_implementation.h>
void debug_print_context(const REGEX_IS024_CONTEXT& ctx, const char* place);
namespace regexis024 {
void debug_print_context(const VMContext& ctx, const char* place);
void debug_print_thread(const REGEX_IS024_Thread& thr, const char *place);
void debug_print_thread(const Thread& thr, const char *place);
}
#endif

36
src/libregexis024fa/codeset.cpp
View File

@ -1,7 +1,8 @@
#include <libregexis024fa/codeset.h>
#include <assert.h>
codeset_t invert_set(const codeset_t &X) {
namespace regexis024 {
codeset_t invert_set(const codeset_t &X) {
if (X.empty())
return {{0, UINT32_MAX}};
codeset_t res;
@ -13,7 +14,7 @@ codeset_t invert_set(const codeset_t &X) {
if (X.back().second != UINT32_MAX)
res.emplace_back(X.back().second + 1, UINT32_MAX);
return res;
}
}
#define elA (A[i])
#define elB (B[j])
@ -23,7 +24,7 @@ codeset_t invert_set(const codeset_t &X) {
#define Aended (i == An)
#define Bended (j == Bn)
codeset_t merge_sets(const codeset_t &A, const codeset_t &B) {
codeset_t merge_sets(const codeset_t &A, const codeset_t &B) {
codeset_t res;
prepare
std::pair<uint32_t, uint32_t> cur;
@ -63,9 +64,9 @@ codeset_t merge_sets(const codeset_t &A, const codeset_t &B) {
}
}
return res;
}
}
codeset_t intersect_sets(const codeset_t &A, const codeset_t &B) {
codeset_t intersect_sets(const codeset_t &A, const codeset_t &B) {
codeset_t res;
prepare
while (true){
@ -82,34 +83,34 @@ codeset_t intersect_sets(const codeset_t &A, const codeset_t &B) {
Binc;
}
return res;
}
}
codeset_t subtract_sets(const codeset_t &A, const codeset_t &B) {
codeset_t subtract_sets(const codeset_t &A, const codeset_t &B) {
return intersect_sets(A, invert_set(B));
}
}
bool is_inside(uint32_t start, uint32_t end, codeset_t &X) {
bool is_inside(uint32_t start, uint32_t end, codeset_t &X) {
for (auto& p: X){
if (p.first <= start && end <= p.second)
return true;
assert(end < p.first || p.second < start);
}
return false;
}
}
codeset_t set_add_char(const codeset_t& X, uint32_t cp) {
codeset_t set_add_char(const codeset_t& X, uint32_t cp) {
return merge_sets(X, {{cp, cp}});
}
}
codeset_t set_add_range(const codeset_t& X, uint32_t start, uint32_t end) {
codeset_t set_add_range(const codeset_t& X, uint32_t start, uint32_t end) {
return merge_sets(X, {{start, end}});
}
}
codeset_t codeset_of_one_char(uint32_t ch) {
codeset_t codeset_of_one_char(uint32_t ch) {
return codeset_t({{ch, ch}});
}
}
std::string stringifyCodesetBase10(const codeset_t& CS) {
std::string stringifyCodesetBase10(const codeset_t& CS) {
std::string cs;
for (auto p: CS) {
if (!cs.empty())
@ -117,4 +118,5 @@ std::string stringifyCodesetBase10(const codeset_t& CS) {
cs += std::to_string(p.first) + "-" + std::to_string(p.second);
}
return cs;
}
}

24
src/libregexis024fa/codeset.h
View File

@ -6,22 +6,24 @@
#include <stdint.h>
#include <string>
typedef std::vector<std::pair<uint32_t, uint32_t>> codeset_t;
namespace regexis024 {
typedef std::vector<std::pair<uint32_t, uint32_t>> codeset_t;
codeset_t invert_set(const codeset_t& X);
codeset_t merge_sets(const codeset_t& A, const codeset_t& B);
codeset_t intersect_sets(const codeset_t& A, const codeset_t& B);
codeset_t subtract_sets(const codeset_t& A, const codeset_t& B);
codeset_t invert_set(const codeset_t& X);
codeset_t merge_sets(const codeset_t& A, const codeset_t& B);
codeset_t intersect_sets(const codeset_t& A, const codeset_t& B);
codeset_t subtract_sets(const codeset_t& A, const codeset_t& B);
/* Aborts if segment in question hit the edge (unsafe function) */
bool is_inside(uint32_t start, uint32_t end, codeset_t& X);
/* Aborts if segment in question hit the edge (unsafe function) */
bool is_inside(uint32_t start, uint32_t end, codeset_t& X);
codeset_t set_add_char(const codeset_t& X, uint32_t cp);
codeset_t set_add_range(const codeset_t& X, uint32_t start, uint32_t end);
codeset_t set_add_char(const codeset_t& X, uint32_t cp);
codeset_t set_add_range(const codeset_t& X, uint32_t start, uint32_t end);
codeset_t codeset_of_one_char(uint32_t ch);
codeset_t codeset_of_one_char(uint32_t ch);
#define codeset_of_all codeset_t({{0, UINT32_MAX}})
std::string stringifyCodesetBase10(const codeset_t& CS);
std::string stringifyCodesetBase10(const codeset_t& CS);
}
#endif //LIBREGEXIS024_CODESET_H

42
src/libregexis024fa/colored_codeset.cpp
View File

@ -2,13 +2,14 @@
#include <assert.h>
ColoredCodesetSegment::ColoredCodesetSegment(uint32_t color, uint32_t right_code): color(color), right_code(right_code) {}
namespace regexis024 {
ColoredCodesetSegment::ColoredCodesetSegment(uint32_t color, uint32_t right_code): color(color), right_code(right_code) {}
ColoredCodesetSegmentList::ColoredCodesetSegmentList() {
ColoredCodesetSegmentList::ColoredCodesetSegmentList() {
first = new ColoredCodesetSegment(0, UINT32_MAX);
}
}
void ColoredCodesetSegmentList::replace_myself(const ColoredCodesetSegmentList &other) {
void ColoredCodesetSegmentList::replace_myself(const ColoredCodesetSegmentList &other) {
assert(other.first);
ColoredCodesetSegment** in_cur = &first;
ColoredCodesetSegment* in_other = other.first;
@ -17,36 +18,36 @@ void ColoredCodesetSegmentList::replace_myself(const ColoredCodesetSegmentList &
in_cur = &((**in_cur).next);
in_other = in_other->next;
}
}
}
ColoredCodesetSegmentList::ColoredCodesetSegmentList(const ColoredCodesetSegmentList &other) {
ColoredCodesetSegmentList::ColoredCodesetSegmentList(const ColoredCodesetSegmentList &other) {
replace_myself(other);
}
}
void ColoredCodesetSegmentList::free_myself() {
void ColoredCodesetSegmentList::free_myself() {
ColoredCodesetSegment* cur = first;
while (cur) {
ColoredCodesetSegment* nxt = cur->next;
delete cur;
cur = nxt;
}
}
}
ColoredCodesetSegmentList::~ColoredCodesetSegmentList() {
ColoredCodesetSegmentList::~ColoredCodesetSegmentList() {
free_myself();
}
}
ColoredCodesetSegmentList& ColoredCodesetSegmentList::operator=(const ColoredCodesetSegmentList &other) {
ColoredCodesetSegmentList& ColoredCodesetSegmentList::operator=(const ColoredCodesetSegmentList &other) {
free_myself();
replace_myself(other);
return *this;
}
}
ColoredCodeset::ColoredCodeset(uint64_t dummy_n): DummyN(dummy_n) {
ColoredCodeset::ColoredCodeset(uint64_t dummy_n): DummyN(dummy_n) {
requests = {{}};
}
}
void ColoredCodeset::split_phase(const codeset_t &X) {
void ColoredCodeset::split_phase(const codeset_t &X) {
uint32_t cA = 0;
ColoredCodesetSegment* cur_seg = list.first;
@ -106,9 +107,9 @@ void ColoredCodeset::split_phase(const codeset_t &X) {
advance_old();
}
}
}
}
void ColoredCodeset::apply_divisor(const codeset_t &X) {
void ColoredCodeset::apply_divisor(const codeset_t &X) {
split_phase(X);
size_t X_id = nxt_request_id++;
size_t m = requests.size();
@ -154,9 +155,9 @@ void ColoredCodeset::apply_divisor(const codeset_t &X) {
cur = cur->next;
}
}
}
}
void ColoredCodeset::get_splits_of_non_dummy(std::vector<codeset_t> &res_input,
void ColoredCodeset::get_splits_of_non_dummy(std::vector<codeset_t> &res_input,
std::vector<std::vector<size_t>> &res_color_to_requests) {
size_t n = requests.size();
std::vector<ssize_t> nonclean_to_clean(n, -1);
@ -180,4 +181,5 @@ void ColoredCodeset::get_splits_of_non_dummy(std::vector<codeset_t> &res_input,
L = cur->right_code + 1;
cur = cur->next;
}
}
}

24
src/libregexis024fa/colored_codeset.h
View File

@ -7,9 +7,9 @@
#include <libregexis024fa/codeset.h>
/* Used for determinizer. Nowhere else */
struct ColoredCodesetSegment {
namespace regexis024 {
/* Used for determinizer. Nowhere else */
struct ColoredCodesetSegment {
uint32_t color;
uint32_t right_code;
ColoredCodesetSegment* next = NULL;
@ -18,11 +18,11 @@ struct ColoredCodesetSegment {
bool divisor_on_left = false;
ColoredCodesetSegment(uint32_t color, uint32_t right_code);
};
};
/* Warning!!! This stupid class is OOM-unsafe!!!
/* Warning!!! This stupid class is OOM-unsafe!!!
* This is not an issue as far as you don't show any of it's instance to the user of libregexis024 */
struct ColoredCodesetSegmentList {
struct ColoredCodesetSegmentList {
ColoredCodesetSegment* first = NULL;
ColoredCodesetSegmentList();
@ -38,10 +38,10 @@ struct ColoredCodesetSegmentList {
~ColoredCodesetSegmentList();
ColoredCodesetSegmentList& operator=(const ColoredCodesetSegmentList& other);
};
};
/* Highly unoptimized algorithm on this data structure O(C^2) time*/
class ColoredCodeset {
/* Highly unoptimized algorithm on this data structure O(C^2) time*/
class ColoredCodeset {
ColoredCodesetSegmentList list;
/* Size of this vector is equal to the number of colors */
std::vector<std::vector<size_t>> requests;
@ -49,7 +49,7 @@ class ColoredCodeset {
size_t nxt_request_id = 0;
void split_phase(const codeset_t& X);
public:
public:
/* First dummy_n split requests will be viewed as 'dummy requests', when complete map of splits is requested,
* colors that are registed indide only dummy requests won't be returned. */
ColoredCodeset(uint64_t dummy_n);
@ -60,7 +60,7 @@ public:
/* Returned 'requests' mapping will feature request id's with DummyN substituted from them */
void get_splits_of_non_dummy(std::vector<codeset_t>& res_input,
std::vector<std::vector<size_t>>& res_color_to_requests);
};
};
}
#endif

14
src/libregexis024fa/fa_first_stage_fix.cpp
View File

@ -7,7 +7,8 @@
// #include <debugging_regexis024/debug_through_graphviz.h>
// #endif
REGEX_IS024_FA_FirstStageFixInfo first_stage_fix_fa(FA_Container& sourceFa, FA_Container& resultFa) {
namespace regexis024 {
REGEX_IS024_FA_FirstStageFixInfo first_stage_fix_fa(FA_Container& sourceFa, FA_Container& resultFa) {
assert(sourceFa.start);
REGEX_IS024_FA_FirstStageFixInfo info;
@ -140,19 +141,19 @@ REGEX_IS024_FA_FirstStageFixInfo first_stage_fix_fa(FA_Container& sourceFa, FA_C
d->search_mark = -1;
}
return info;
}
}
FA_NodeOfOneCharRead* generate_alt_ending(const codeset_t& restriction, FA_Container& fa){
FA_NodeOfOneCharRead* generate_alt_ending(const codeset_t& restriction, FA_Container& fa){
FA_NodeOfOneCharRead* n1 = fa.makeOneCharRead(restriction, true);
FA_NodeOfMatch* n2 = fa.makeMatch();
n2->ext_filter_added = true; // Won't actually be used
reattach_fa_node_edge(&(n1->nxt_node), n2);
return n1;
}
}
void regular_second_stage_fix(const FA_Container& sourceFa, FA_Container& resultFa,
void regular_second_stage_fix(const FA_Container& sourceFa, FA_Container& resultFa,
const REGEX_IS024_FA_FirstStageFixInfo &info1)
{
{
assert(resultFa.all.empty() && !resultFa.start);
if (!sourceFa.start)
return;
@ -192,4 +193,5 @@ void regular_second_stage_fix(const FA_Container& sourceFa, FA_Container& result
FA_NodeOfOneCharRead* ns = resultFa.makeOneCharRead(codeset_of_all, true);
yay_new_start(resultFa, ns);
}
}
}

12
src/libregexis024fa/fa_first_stage_fix.h
View File

@ -3,16 +3,18 @@
#include "finite_automaton.h"
struct REGEX_IS024_FA_FirstStageFixInfo{
namespace regexis024 {
struct REGEX_IS024_FA_FirstStageFixInfo{
bool fed_chars_extend_one_left = false;
bool fed_chars_extend_one_right = false;
};
};
/* Will look for look_one_ahead nodes and apply their filter to reading filters ahead *
/* Will look for look_one_ahead nodes and apply their filter to reading filters ahead *
* sourceFa will be ruined. The output will be in resultFa */
REGEX_IS024_FA_FirstStageFixInfo first_stage_fix_fa(FA_Container& sourceFa, FA_Container& resultFa);
REGEX_IS024_FA_FirstStageFixInfo first_stage_fix_fa(FA_Container& sourceFa, FA_Container& resultFa);
void regular_second_stage_fix(const FA_Container& sourceFa, FA_Container& resultFa,
void regular_second_stage_fix(const FA_Container& sourceFa, FA_Container& resultFa,
const REGEX_IS024_FA_FirstStageFixInfo &info1);
}
#endif //LIBREGEXIS024_FA_FIRST_STAGE_FIX_H

117
src/libregexis024fa/fa_make_deterministic.cpp
View File

@ -1,6 +1,5 @@
#include <libregexis024fa/fa_make_deterministic.h>
#include <libregexis024fa/misc_fa_funcs.h>
#include <libregexis024vm/utils.h> /* to get exitf */
#include <assert.h>
#include <libregexis024fa/tracking_fa_nodes.h>
#include <vector>
@ -17,38 +16,38 @@
#define PR_DEB
#endif
/* debug nonsence */
void input_fa_assert(const FA_Container& fa){
namespace regexis024 {
/* debug nonsence */
void input_fa_assert(const FA_Container& fa){
assert(fa.start);
for (FA_Node* node: fa.all){
if (node->type == one_char_read){
assert(!dynamic_cast<FA_NodeOfOneCharRead*>(node)->second_ns);
} else if (node->type == look_one_ahead ||
node->type == det_char_crossroads){
exitf("not allowed at this stage\n");
} else if (node->type == look_one_ahead || node->type == det_char_crossroads) {
assert(false);
}
}
}
}
struct OperHistoryNodeTransition {
struct OperHistoryNodeTransition {
TrackingOperationInFa op;
size_t u;
OperHistoryNodeTransition(const TrackingOperationInFa &op, size_t u): op(op), u(u) {}
};
};
struct OperHistoryNode {
struct OperHistoryNode {
std::vector<OperHistoryNodeTransition> next;
/* When it is part of clean history, this */
std::vector<uint64_t> compressed_selarr;
std::vector<uint64_t> raisin;
OperHistoryNode() = default;
};
};
/* This object can describe an empty superstate (needed to describe clean history nodes without raisin)
/* This object can describe an empty superstate (needed to describe clean history nodes without raisin)
* If det_stops is empty, interpret it as empty superstate */
struct SuperState {
struct SuperState {
std::vector<uint64_t> sorted_raisin;
std::vector<uint64_t> double_compressed_selarr;
@ -74,33 +73,33 @@ struct SuperState {
return "sorted_raisin: {" + f1_raisin + "}, double_comp_selarr: {" + f2_selarr + "}";
}
#endif
};
};
struct CleanOperHistoryNode {
struct CleanOperHistoryNode {
std::vector<OperHistoryNodeTransition> next;
SuperState exit;
};
};
struct SelarrCompressionScheme {
struct SelarrCompressionScheme {
size_t SN1, SN2 = 0, SN3 = 0;
std::vector<int32_t> S1_to_S2;
std::vector<regex_tai_t> S2_to_sifter;
std::vector<regex_tai_t> S3_to_sifter;
std::vector<tai_t> S2_to_sifter;
std::vector<tai_t> S3_to_sifter;
const RegexPriorityTable& sifter;
SelarrCompressionScheme(size_t sn1, const RegexPriorityTable &sifter) : SN1(sn1), sifter(sifter) {
assert(sifter.size() <= UINT32_MAX);
S1_to_S2.assign(SN1, -1);
for (regex_tai_t i = 0; i < sifter.size(); i++) {
for (tai_t i = 0; i < sifter.size(); i++) {
auto& act = sifter[i].pos;
regex_tai_t first_on_s2 = S2_to_sifter.size();
tai_t first_on_s2 = S2_to_sifter.size();
S2_to_sifter.push_back(i);
S1_to_S2[act.first] = first_on_s2;
if (act.type != tracking_var_types::dot_cur_pos) {
S3_to_sifter.push_back(i);
}
if (act.type == tracking_var_types::range) {
regex_tai_t second_on_s2 = S2_to_sifter.size();
tai_t second_on_s2 = S2_to_sifter.size();
S2_to_sifter.push_back(i);
S1_to_S2[act.second] = second_on_s2;
}
@ -110,9 +109,9 @@ struct SelarrCompressionScheme {
assert(SN3 <= SN2 && SN2 <= SN1 && SN1 <= UINT16_MAX);
}
};
};
std::vector<uint64_t> compress_compressed_selarr(const std::vector<uint64_t>& S2,
std::vector<uint64_t> compress_compressed_selarr(const std::vector<uint64_t>& S2,
const SelarrCompressionScheme& cmp) {
std::vector<uint64_t> S3(cmp.SN3);
for (size_t i = 0; i < cmp.SN3; i++) {
@ -127,9 +126,9 @@ std::vector<uint64_t> compress_compressed_selarr(const std::vector<uint64_t>& S2
}
}
return S3;
}
}
bool compressed_selarr_A_outranks_B(const std::vector<uint64_t>& A, const std::vector<uint64_t>& B,
bool compressed_selarr_A_outranks_B(const std::vector<uint64_t>& A, const std::vector<uint64_t>& B,
const SelarrCompressionScheme& cmp) {
for (const RegexPriorityTableAction& act: cmp.sifter) {
uint64_t valA = A[cmp.S1_to_S2[act.pos.first]];
@ -145,11 +144,11 @@ bool compressed_selarr_A_outranks_B(const std::vector<uint64_t>& A, const std::v
return (valA < valB) == act.minimize;
}
return false;
}
}
/* Beacuse of the way wash_history_bush builds this structure, root is te last node.
/* Beacuse of the way wash_history_bush builds this structure, root is te last node.
* rankdir is from left to right (guaranteed). Can be empty if original history contained no raisin */
struct RaisinBush {
struct RaisinBush {
std::vector<CleanOperHistoryNode> clean_history;
ssize_t start = -1;
@ -201,9 +200,9 @@ struct RaisinBush {
printLines(wrapWithBox(text));
}
#endif
};
};
void wash_history_bush(const std::vector<OperHistoryNode>& history, RaisinBush& answer,
void wash_history_bush(const std::vector<OperHistoryNode>& history, RaisinBush& answer,
const SelarrCompressionScheme& cmp) {
assert(!history.empty());
std::vector<bool> has_raisin(history.size());
@ -252,14 +251,14 @@ void wash_history_bush(const std::vector<OperHistoryNode>& history, RaisinBush&
answer.start = dirty_to_clean[0];
}
}
}
/* If is_it_after_read is false, unknown selarr range variable border and cur pos are evaluated to 0.
/* If is_it_after_read is false, unknown selarr range variable border and cur pos are evaluated to 0.
* Otherwise, cur pos considered to be greater than previous values of selarr ange variable boundaries */
void building_detour(const SelarrCompressionScheme& cmp,
void building_detour(const SelarrCompressionScheme& cmp,
const std::vector<uint64_t>& outer_selarr, const std::vector<FA_Node*>& zeroeps, const codeset_t& I,
RaisinBush& answer, bool is_it_after_read)
{
{
#ifdef PR_DEB
printf("Det Debug: build_detour started with zeroeps:{");
for (FA_Node* node: zeroeps)
@ -368,7 +367,7 @@ void building_detour(const SelarrCompressionScheme& cmp,
val2[key_s2] = tv->imm_value;
}
}
add_history_update(TrackingOperationInFa(tv->operation, tv->key, tv->imm_value), Hop, Hv);
add_history_update(TrackingOperationInFa{tv->operation, tv->key, tv->imm_value}, Hop, Hv);
} else if (v->type == track_array_mov_halfinvariant) {
FA_NodeOfTrackArrayMovHalfinvariant* tv = dynamic_cast<FA_NodeOfTrackArrayMovHalfinvariant*>(v);
if (isSelarrOpcode(tv->operation)) {
@ -383,7 +382,7 @@ void building_detour(const SelarrCompressionScheme& cmp,
}
}
}
add_history_update(TrackingOperationInFa(tv->operation, tv->key), Hop, Hv);
add_history_update(TrackingOperationInFa{tv->operation, tv->key}, Hop, Hv);
}
} else if (v->type == match || v->type == one_char_read) {
// Determinization stop
@ -414,22 +413,22 @@ void building_detour(const SelarrCompressionScheme& cmp,
}
/* Packaging the answer (we do a little bit of dfs here) */
wash_history_bush(history, answer, cmp);
}
}
void update_had_to_fork_status(const RaisinBush& bush, int& had_to_fork) {
void update_had_to_fork_status(const RaisinBush& bush, int& had_to_fork) {
for (const CleanOperHistoryNode& node: bush.clean_history) {
if (node.next.size() > 1 || (!node.next.empty() && !node.exit.empty())) {
had_to_fork = 1;
return;
}
}
}
}
typedef size_t superstate_id_t;
typedef size_t superstate_id_t;
typedef std::vector<std::pair<FA_Node**, superstate_id_t>> homework_t;
typedef std::vector<std::pair<FA_Node**, superstate_id_t>> homework_t;
struct LessSuperState {
struct LessSuperState {
bool operator()(const SuperState& A, const SuperState& B) const {
std::less<std::vector<uint64_t>> f1L;
if (f1L(A.sorted_raisin, B.sorted_raisin))
@ -438,17 +437,17 @@ struct LessSuperState {
return false;
return f1L(A.double_compressed_selarr, B.double_compressed_selarr);
}
};
};
struct GlobalDetourProgress {
struct GlobalDetourProgress {
std::map<SuperState, superstate_id_t, LessSuperState> superstates;
/* Each element is a root of some megabush in resFa */
std::vector<FA_Node*> superstate_megabush_constructed;
std::vector<SuperState> todo_superstaes;
};
};
/* If x was not previously achieved, it will also add it to t o d o list of global detour */
superstate_id_t convertSuperstateToId(const SuperState& x, GlobalDetourProgress& gdp) {
/* If x was not previously achieved, it will also add it to t o d o list of global detour */
superstate_id_t convertSuperstateToId(const SuperState& x, GlobalDetourProgress& gdp) {
if (gdp.superstates.count(x)) {
return gdp.superstates[x];
}
@ -457,13 +456,13 @@ superstate_id_t convertSuperstateToId(const SuperState& x, GlobalDetourProgress&
gdp.todo_superstaes.push_back(x);
gdp.superstate_megabush_constructed.push_back(NULL);
return n;
}
}
FA_Node* build_dead_end(FA_Container& resFa) {
FA_Node* build_dead_end(FA_Container& resFa) {
return resFa.makeForking();
}
}
void build_bush(const RaisinBush& alpha, FA_Node** sowing_location, FA_Container& resFa,
void build_bush(const RaisinBush& alpha, FA_Node** sowing_location, FA_Container& resFa,
homework_t& homework, GlobalDetourProgress& gdp) {
size_t n = alpha.clean_history.size();
if (n == 0) {
@ -504,9 +503,9 @@ void build_bush(const RaisinBush& alpha, FA_Node** sowing_location, FA_Container
reattach_fa_node_edge(sl, forker);
}
}
}
}
ColoredCodeset get_pretreated_cc(FA_Container& sourceFa) {
ColoredCodeset get_pretreated_cc(FA_Container& sourceFa) {
std::set<codeset_t> little_insects;
for (FA_Node* v: sourceFa.all) {
if (v->type == look_one_behind) {
@ -518,12 +517,12 @@ ColoredCodeset get_pretreated_cc(FA_Container& sourceFa) {
pretreated_cc.apply_divisor(cs);
}
return pretreated_cc;
}
}
// todo add a check on size of dfa
void try_determinize_fa(FA_Container &sourceFa, const RegexPriorityTable &sifter, regex_tai_t selarr_sz,
// todo add a check on size of dfa
void try_determinize_fa(FA_Container &sourceFa, const RegexPriorityTable &sifter, tai_t selarr_sz,
const REGEX_IS024_FA_FirstStageFixInfo &info1, FA_Container &resFa, int &error, int& had_to_fork)
{
{
/* During execuion, i will create pointers to field res.start and store them (inside the scope of this function)
* Luckily res argument is already immovable in this scope. */
error = 0;
@ -661,5 +660,5 @@ void try_determinize_fa(FA_Container &sourceFa, const RegexPriorityTable &sifter
for (auto& p: homework) {
reattach_fa_node_edge(p.first, gdp.superstate_megabush_constructed[p.second]);
}
}
}

4
src/libregexis024fa/fa_make_deterministic.h
View File

@ -4,7 +4,9 @@
#include <libregexis024fa/fa_first_stage_fix.h>
#include <libregexis024fa/selarr_priority_table.h>
void try_determinize_fa(FA_Container &sourceFa, const RegexPriorityTable &sifter, regex_tai_t selarr_sz,
namespace regexis024 {
void try_determinize_fa(FA_Container &sourceFa, const RegexPriorityTable &sifter, tai_t selarr_sz,
const REGEX_IS024_FA_FirstStageFixInfo &info1, FA_Container &resFa, int &error, int& had_to_fork);
}
#endif //LIBREGEXIS024_FA_MAKE_DETERMINISTIC_H

126
src/libregexis024fa/finite_automaton.cpp
View File

@ -2,140 +2,142 @@
#include <libregexis024vm/utils.h>
#include <assert.h>
bool FA_Node::empty() {
namespace regexis024 {
bool FA_Node::empty() {
return type != one_char_read && type != det_char_crossroads;
}
}
void FA_Node::apply_lookahead_restriction(const codeset_t &restriction) {}
void FA_Node::apply_lookahead_restriction(const codeset_t &restriction) {}
void FA_Node::reAdd_references() {
void FA_Node::reAdd_references() {
for (FA_Node** nxtPtr: get_all_transitions()){
if (*nxtPtr)
(**nxtPtr).refs++;
}
}
}
std::vector<FA_Node **> FA_Node::get_all_transitions() {
std::vector<FA_Node **> FA_Node::get_all_transitions() {
return {};
}
}
std::vector<FA_Node **> FA_Node::get_all_empty_valid_transitions() {
std::vector<FA_Node **> FA_Node::get_all_empty_valid_transitions() {
return {};
}
}
std::vector<FA_Node **> FA_NodePathPart::get_all_transitions() {
std::vector<FA_Node **> FA_NodePathPart::get_all_transitions() {
return {&nxt_node};
}
}
std::vector<FA_Node **> FA_NodePathPart::get_all_empty_valid_transitions() {
std::vector<FA_Node **> FA_NodePathPart::get_all_empty_valid_transitions() {
if (nxt_node)
return {&nxt_node};
return {};
}
}
FA_NodeOfMatch::FA_NodeOfMatch() {type = match;}
FA_NodeOfMatch::FA_NodeOfMatch() {type = match;}
void FA_NodeOfMatch::apply_lookahead_restriction(const codeset_t &restriction) {
void FA_NodeOfMatch::apply_lookahead_restriction(const codeset_t &restriction) {
ext_filter_added = true;
pending_filter = restriction;
}
}
FA_NodeOfOneCharRead::FA_NodeOfOneCharRead(const codeset_t &filter, bool second_namespace) : filter(filter),
FA_NodeOfOneCharRead::FA_NodeOfOneCharRead(const codeset_t &filter, bool second_namespace) : filter(filter),
second_ns(second_namespace) { type = one_char_read;}
void FA_NodeOfOneCharRead::apply_lookahead_restriction(const codeset_t &restriction) {
void FA_NodeOfOneCharRead::apply_lookahead_restriction(const codeset_t &restriction) {
filter = intersect_sets(filter, restriction);
}
}
std::vector<FA_Node **> FA_NodeOfOneCharRead::get_all_empty_valid_transitions() {
std::vector<FA_Node **> FA_NodeOfOneCharRead::get_all_empty_valid_transitions() {
return {};
}
}
FA_NodeOfForking::FA_NodeOfForking() {type = forking;}
FA_NodeOfForking::FA_NodeOfForking() {type = forking;}
std::vector<FA_Node **> FA_NodeOfForking::get_all_empty_valid_transitions() {
std::vector<FA_Node **> FA_NodeOfForking::get_all_empty_valid_transitions() {
std::vector<FA_Node**> res;
for (size_t i = 0; i < nxt_options.size(); i++)
if (nxt_options[i])
res.push_back(&nxt_options[i]);
return res;
}
}
std::vector<FA_Node **> FA_NodeOfForking::get_all_transitions() {
std::vector<FA_Node **> FA_NodeOfForking::get_all_transitions() {
std::vector<FA_Node**> res;
for (size_t i = 0; i < nxt_options.size(); i++)
res.push_back(&nxt_options[i]);
return res;
}
}
FA_NodeOfLookOneBehind::FA_NodeOfLookOneBehind(const codeset_t &filter) : filter(filter) {type = look_one_behind;}
FA_NodeOfLookOneBehind::FA_NodeOfLookOneBehind(const codeset_t &filter) : filter(filter) {type = look_one_behind;}
FA_NodeOfLookOneAhead::FA_NodeOfLookOneAhead(const codeset_t &restriction) : restriction(restriction) {
FA_NodeOfLookOneAhead::FA_NodeOfLookOneAhead(const codeset_t &restriction) : restriction(restriction) {
type = look_one_ahead;
}
}
FA_NodeOfTrackArrayMovImm::FA_NodeOfTrackArrayMovImm(regex024_opcode operation, uint16_t key, uint64_t immValue) :
FA_NodeOfTrackArrayMovImm::FA_NodeOfTrackArrayMovImm(opcode_t operation, uint16_t key, uint64_t immValue) :
operation(operation), key(key), imm_value(immValue) {type = track_array_mov_imm;}
//
//
FA_NodeOfTrackArrayMovHalfinvariant::FA_NodeOfTrackArrayMovHalfinvariant(regex024_opcode operation, uint16_t key):
FA_NodeOfTrackArrayMovHalfinvariant::FA_NodeOfTrackArrayMovHalfinvariant(opcode_t operation, uint16_t key):
operation(operation), key(key){type = track_array_mov_halfinvariant;}
//
//
void FA_NodeOfDetCharCrossroads::apply_lookahead_restriction(const codeset_t &restriction) {
exitf("What?? Oh, no, no. I am NOT doing it");
}
void FA_NodeOfDetCharCrossroads::apply_lookahead_restriction(const codeset_t &restriction) {
assert(false);
}
FA_NodeOfDetCharCrossroads::FA_NodeOfDetCharCrossroads(const std::vector<DFA_CrossroadPath> &crossroads)
FA_NodeOfDetCharCrossroads::FA_NodeOfDetCharCrossroads(const std::vector<DFA_CrossroadPath> &crossroads)
: crossroads(crossroads) {type = det_char_crossroads;}
std::vector<FA_Node **> FA_NodeOfDetCharCrossroads::get_all_empty_valid_transitions() {
std::vector<FA_Node **> FA_NodeOfDetCharCrossroads::get_all_empty_valid_transitions() {
return {};
}
}
std::vector<FA_Node **> FA_NodeOfDetCharCrossroads::get_all_transitions() {
std::vector<FA_Node **> FA_NodeOfDetCharCrossroads::get_all_transitions() {
std::vector<FA_Node**> res;
for (auto& tr: crossroads)
res.push_back(&tr.nxt_node);
return res;
}
}
/* If transferring ownership of node to container has failed, node is freed (which means it is ivalidated)
/* If transferring ownership of node to container has failed, node is freed (which means it is ivalidated)
* If this semi-ownership transfer succeded (no std::bad_alloc), then node is still valid to use, and at the end
* of FA_Container lifetime it is guaranteed to be deleted
*/
void FA_Container::registerNew(FA_Node *node) {
void FA_Container::registerNew(FA_Node *node) {
try {
node->nodeId = (int64_t)all.size();
all.push_back(node);
} catch (const std::bad_alloc& ba) {
} catch (const std::exception& ba) {
delete node;
throw;
}
}
}
DFA_CrossroadPath::DFA_CrossroadPath(const codeset_t &input, FA_Node *nxt_node): input(input),nxt_node(nxt_node) {}
//
DFA_CrossroadPath::DFA_CrossroadPath(const codeset_t &input, FA_Node *nxt_node): input(input),nxt_node(nxt_node) {}
//
FA_Container::~FA_Container() {
FA_Container::~FA_Container() {
for (FA_Node* n: all)
delete n;
}
}
#define bs(name, args, params) \
FA_NodeOf ## name *FA_Container::make ## name(args) { \
FA_NodeOf ## name *node = new FA_NodeOf ## name(params); \
registerNew(node); \
return node; \
}
FA_NodeOf ## name *FA_Container::make ## name(args) { \
FA_NodeOf ## name *node = new FA_NodeOf ## name(params); \
registerNew(node); \
return node; \
}
#define COMMA ,
bs(Match, , )
bs(OneCharRead, const codeset_t& filter COMMA bool second_namespace, filter COMMA second_namespace)
bs(Forking, , )
bs(LookOneBehind, const codeset_t& filter, filter)
bs(LookOneAhead, const codeset_t& filter, filter)
bs(TrackArrayMovImm, regex024_opcode operation COMMA uint16_t key COMMA uint64_t immValue,
bs(Match, , )
bs(OneCharRead, const codeset_t& filter COMMA bool second_namespace, filter COMMA second_namespace)
bs(Forking, , )
bs(LookOneBehind, const codeset_t& filter, filter)
bs(LookOneAhead, const codeset_t& filter, filter)
bs(TrackArrayMovImm, opcode_t operation COMMA uint16_t key COMMA uint64_t immValue,
operation COMMA key COMMA immValue)
bs(TrackArrayMovHalfinvariant, regex024_opcode operation COMMA uint16_t key, operation COMMA key)
bs(DetCharCrossroads, ,{})
bs(TrackArrayMovHalfinvariant, opcode_t operation COMMA uint16_t key, operation COMMA key)
bs(DetCharCrossroads, ,{})
}

80
src/libregexis024fa/finite_automaton.h
View File

@ -6,7 +6,8 @@
#include <libregexis024fa/codeset.h>
#include <libregexis024vm/vm_opcodes.h>
enum FA_Node_type: uint8_t {
namespace regexis024 {
enum FA_Node_type: uint8_t {
match,
one_char_read,
forking,
@ -16,9 +17,9 @@ enum FA_Node_type: uint8_t {
track_array_mov_halfinvariant,
/* Used for DFA */
det_char_crossroads,
};
};
struct FA_Node{
struct FA_Node{
size_t refs = 0;
/* If node is not in searched subset (at least yet), `search mark == -1`, otherwise
* it is an index (for that particular node) in the vector that captures all nodes in
@ -33,35 +34,35 @@ struct FA_Node{
void reAdd_references();
virtual ~FA_Node() = default;
virtual std::vector<FA_Node**> get_all_transitions();
};
};
struct FA_NodePathPart: public FA_Node{
struct FA_NodePathPart: public FA_Node{
FA_Node* nxt_node = NULL;
std::vector<FA_Node **> get_all_empty_valid_transitions() override;
std::vector<FA_Node **> get_all_transitions() override;
};
};
struct FA_NodeOfMatch: public FA_Node{
struct FA_NodeOfMatch: public FA_Node{
bool ext_filter_added = false;
codeset_t pending_filter;
explicit FA_NodeOfMatch();
void apply_lookahead_restriction(const codeset_t &restriction) override;
};
};
/* .type == one_char_read */
struct FA_NodeOfOneCharRead: public FA_NodePathPart{
/* .type == one_char_read */
struct FA_NodeOfOneCharRead: public FA_NodePathPart{
codeset_t filter;
bool second_ns = false;
FA_NodeOfOneCharRead(const codeset_t &filter, bool second_namespace);
void apply_lookahead_restriction(const codeset_t &restriction) override;
std::vector<FA_Node **> get_all_empty_valid_transitions() override;
};
};
/* .type == forking */
struct FA_NodeOfForking: public FA_Node{
/* .type == forking */
struct FA_NodeOfForking: public FA_Node{
/* Won't be modified after init (in regexp compilation into NFA) */
std::vector<FA_Node*> nxt_options;
int64_t stopId = -1;
@ -69,51 +70,51 @@ struct FA_NodeOfForking: public FA_Node{
explicit FA_NodeOfForking();
std::vector<FA_Node **> get_all_empty_valid_transitions() override;
std::vector<FA_Node **> get_all_transitions() override;
};
};
/* .type == look_one_behind */
struct FA_NodeOfLookOneBehind: public FA_NodePathPart{
/* .type == look_one_behind */
struct FA_NodeOfLookOneBehind: public FA_NodePathPart{
/* [0; UINT32_MAX] is equivalent to no filter */
codeset_t filter;
explicit FA_NodeOfLookOneBehind(const codeset_t &filter);
};
};
/* .type == look_one_ahead */
struct FA_NodeOfLookOneAhead: public FA_NodePathPart{
/* .type == look_one_ahead */
struct FA_NodeOfLookOneAhead: public FA_NodePathPart{
/* [0; UINT32_MAX] is equivalent to no restriction */
codeset_t restriction;
explicit FA_NodeOfLookOneAhead(const codeset_t &restriction);
};
};
/* .type == track_array_mov_imm */
struct FA_NodeOfTrackArrayMovImm: public FA_NodePathPart{
regex024_opcode operation;
/* .type == track_array_mov_imm */
struct FA_NodeOfTrackArrayMovImm: public FA_NodePathPart{
opcode_t operation;
uint16_t key;
uint64_t imm_value;
FA_NodeOfTrackArrayMovImm(regex024_opcode operation, uint16_t key, uint64_t immValue);
};
FA_NodeOfTrackArrayMovImm(opcode_t operation, uint16_t key, uint64_t immValue);
};
/* .type == track_array_mov_halfinvariant */
struct FA_NodeOfTrackArrayMovHalfinvariant: public FA_NodePathPart{
regex024_opcode operation;
/* .type == track_array_mov_halfinvariant */
struct FA_NodeOfTrackArrayMovHalfinvariant: public FA_NodePathPart{
opcode_t operation;
uint16_t key;
FA_NodeOfTrackArrayMovHalfinvariant(regex024_opcode operation, uint16_t key);
};
FA_NodeOfTrackArrayMovHalfinvariant(opcode_t operation, uint16_t key);
};
struct DFA_CrossroadPath{
struct DFA_CrossroadPath{
codeset_t input;
FA_Node* nxt_node = NULL;
DFA_CrossroadPath(const codeset_t &input, FA_Node *nxt_node);
DFA_CrossroadPath() = default;
};
};
/* .type == det_char_crossroads */
struct FA_NodeOfDetCharCrossroads: public FA_Node{
/* .type == det_char_crossroads */
struct FA_NodeOfDetCharCrossroads: public FA_Node{
std::vector<DFA_CrossroadPath> crossroads;
bool matching = false;
bool second_ns = false;
@ -122,9 +123,9 @@ struct FA_NodeOfDetCharCrossroads: public FA_Node{
void apply_lookahead_restriction(const codeset_t &restriction) override;
std::vector<FA_Node **> get_all_empty_valid_transitions() override;
std::vector<FA_Node **> get_all_transitions() override;
};
};
struct FA_Container{
struct FA_Container{
FA_Container(const FA_Container&) = delete;
FA_Container& operator=(const FA_Container&) = delete;
FA_Container() = default;
@ -139,11 +140,12 @@ struct FA_Container{
FA_NodeOfForking* makeForking();
FA_NodeOfLookOneBehind* makeLookOneBehind(const codeset_t& filter);
FA_NodeOfLookOneAhead* makeLookOneAhead(const codeset_t& filter);
FA_NodeOfTrackArrayMovImm* makeTrackArrayMovImm(regex024_opcode operation, uint16_t key, uint64_t immValue);
FA_NodeOfTrackArrayMovHalfinvariant* makeTrackArrayMovHalfinvariant(regex024_opcode operation, uint16_t key);
FA_NodeOfTrackArrayMovImm* makeTrackArrayMovImm(opcode_t operation, uint16_t key, uint64_t immValue);
FA_NodeOfTrackArrayMovHalfinvariant* makeTrackArrayMovHalfinvariant(opcode_t operation, uint16_t key);
FA_NodeOfDetCharCrossroads* makeDetCharCrossroads();
~FA_Container();
};
};
}
#endif //LIBREGEXIS024_FINITE_AUTOMATON_H

9
src/libregexis024fa/graph_to_bytecode/core.cpp
View File

@ -5,11 +5,11 @@
#include <libregexis024fa/graph_to_bytecode/filter.h>
namespace regexis024 {
#define nonthrowing_assert(expr) if (!(expr)) {error = -1; return; }
void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_bookmarks& bookmark_manager,
void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_bookmarks& bookmark_manager,
size_t& first_read_ns, size_t& second_read_ns, size_t& fork_ss_ns, int& error)
{
{
bookmark_id_t node_start_bm_offset = bookmark_manager.new_range_of_bookmarks(fa.all.size());
std::vector<size_t> not_yet_dedicated_second_read_ns_ssids;
first_read_ns = 0;
@ -72,7 +72,7 @@ void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_b
}
if (nxt_options.size() >= 2) {
nonthrowing_assert(fork_ss_ns < UINT32_MAX);
regex_sslot_id_t sslot = fork_ss_ns++;
sslot_id_t sslot = fork_ss_ns++;
for (size_t i = 0; i + 1 < nxt_options.size(); i++) {
cmd_FORK(result, bookmark_manager, sslot, nodesBookmark(nxt_options[i]));
addBranching(nxt_options[i]);
@ -114,4 +114,5 @@ void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_b
for (size_t j = 0; j < not_yet_dedicated_second_read_ns_ssids.size(); j++) {
belated_sslot_id(result, not_yet_dedicated_second_read_ns_ssids[j], j + first_read_ns);
}
}
}

4
src/libregexis024fa/graph_to_bytecode/core.h
View File

@ -4,7 +4,9 @@
#include <libregexis024fa/finite_automaton.h>
#include <libregexis024fa/graph_to_bytecode/natural_compiler_utils.h>
void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_bookmarks& bookmark_manager,
namespace regexis024 {
void compilation_core(std::vector<uint8_t>& result, FA_Container& fa, explicit_bookmarks& bookmark_manager,
size_t& first_read_ns, size_t& second_read_ns, size_t& fork_ss_ns, int& error);
}
#endif

48
src/libregexis024fa/graph_to_bytecode/fa_compiler.cpp
View File

@ -7,74 +7,75 @@
#include <libregexis024fa/graph_to_bytecode/core.h>
void write_priority_table_actions(std::vector<uint8_t>& result, RegexPriorityTable &priority_table) {
namespace regexis024 {
void write_priority_table_actions(std::vector<uint8_t>& result, RegexPriorityTable &priority_table) {
for (RegexPriorityTableAction& act: priority_table) {
if (act.pos.isForRange()) {
write_byte(result, regex024_opcodes::DDIST_RABX_SELARR);
write_byte(result, opcodes::DDIST_RABX_SELARR);
write_tai(result, act.pos.first);
write_tai(result, act.pos.second);
} else {
write_byte(result, regex024_opcodes::DMOV_RABX_SELARR);
write_byte(result, opcodes::DMOV_RABX_SELARR);
write_tai(result, act.pos.first);
}
write_byte(result, act.minimize ?
regex024_opcodes::SIFTPRIOR_MIN_RABX :
regex024_opcodes::SIFTPRIOR_MAX_RABX);
opcodes::SIFTPRIOR_MIN_RABX :
opcodes::SIFTPRIOR_MAX_RABX);
}
write_byte(result, opcodes::SIFT_DONE);
}
write_byte(result, regex024_opcodes::SIFT_DONE);
}
struct belate_initialization_parameters {
struct belate_initialization_parameters {
size_t todo_pos_read_ss_n;
size_t todo_pos_fork_ss_n;
size_t todo_pos_second_ns_size;
void complete_it(std::vector<uint8_t>& result,
regex_sslot_id_t first_read_ns, regex_sslot_id_t second_read_ns, regex_sslot_id_t fork_ss_ns)
sslot_id_t first_read_ns, sslot_id_t second_read_ns, sslot_id_t fork_ss_ns)
{
assert((uint64_t)first_read_ns + (uint64_t)second_read_ns <= UINT32_MAX);
belated_sslot_id(result, todo_pos_read_ss_n , first_read_ns + second_read_ns);
belated_sslot_id(result, todo_pos_fork_ss_n, fork_ss_ns);
belated_sslot_id(result, todo_pos_second_ns_size, second_read_ns);
}
};
};
/* when I compile initializational part of program, I don't yet know what to put in
/* when I compile initializational part of program, I don't yet know what to put in
* PARAM_READ_SS_NUMBER, PARAM_FORK_SS_NUMBER and MSG_FED_INPUT_EXTENDED (second namespace size).
* These values are belate. */
belate_initialization_parameters write_some_normal_initialization(std::vector<uint8_t>& result,
belate_initialization_parameters write_some_normal_initialization(std::vector<uint8_t>& result,
size_t selarr_size, const REGEX_IS024_FA_FirstStageFixInfo& info1)
{
{
belate_initialization_parameters todo;
write_byte(result, regex024_opcodes::PARAM_READ_SS_NUMBER);
write_byte(result, opcodes::PARAM_READ_SS_NUMBER);
todo.todo_pos_read_ss_n = result.size();
write_sslot_id(result, 0); // Belate
write_byte(result, regex024_opcodes::PARAM_FORK_SS_NUMBER);
write_byte(result, opcodes::PARAM_FORK_SS_NUMBER);
todo.todo_pos_fork_ss_n = result.size();
write_sslot_id(result, 0); // Belate
write_byte(result, regex024_opcodes::PARAM_SELARR_LEN);
write_byte(result, opcodes::PARAM_SELARR_LEN);
write_tai(result, selarr_size);
write_byte(result, regex024_opcodes::MSG_MULTISTART_ALLOWED);
write_byte(result, opcodes::MSG_MULTISTART_ALLOWED);
write_byte(result, 1);
write_byte(result, regex024_opcodes::MSG_FED_INPUT_EXTENDED);
write_byte(result, opcodes::MSG_FED_INPUT_EXTENDED);
write_byte(result, info1.fed_chars_extend_one_left ? 1 : 0);
write_byte(result, info1.fed_chars_extend_one_right ? 1 : 0);
todo.todo_pos_second_ns_size = result.size();
write_sslot_id(result, 0); // Belate
write_byte(result, regex024_opcodes::INIT);
write_byte(result, opcodes::INIT);
return todo;
}
}
void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result,
void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result,
FA_Container &fa, RegexPriorityTable &priority_table,
size_t selarr_size, const REGEX_IS024_FA_FirstStageFixInfo& info1, int& error)
{
{
error = 0;
explicit_bookmarks bookmark_manager;
@ -87,7 +88,7 @@ void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result,
write_priority_table_actions(result, priority_table);
bookmark_manager.land_bookmark(result, BM_after_sift);
write_byte(result, regex024_opcodes::PARAM_COLSIFTFUNC_SET);
write_byte(result, opcodes::PARAM_COLSIFTFUNC_SET);
bookmark_manager.write_unresolved_reference(result, BM_sift_function);
}
@ -99,4 +100,5 @@ void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result,
return;
init_param_todo.complete_it(result, first_read_ns, second_read_ns, fork_ss_ns);
bookmark_manager.finish(result);
}
}

4
src/libregexis024fa/graph_to_bytecode/fa_compiler.h
View File

@ -7,8 +7,10 @@
#include <libregexis024fa/selarr_priority_table.h>
#include <libregexis024fa/fa_first_stage_fix.h>
void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result, FA_Container& fa, RegexPriorityTable& priority_table,
namespace regexis024 {
void compile_fa_to_regexis024_bytecode(std::vector<uint8_t>& result, FA_Container& fa, RegexPriorityTable& priority_table,
size_t selarr_size, const REGEX_IS024_FA_FirstStageFixInfo& info1, int& error);
}
#endif

35
src/libregexis024fa/graph_to_bytecode/filter.cpp
View File

@ -4,42 +4,43 @@
#include <algorithm>
#include <libregexis024fa/graph_to_bytecode/writing_commands.h>
std::vector<FilterSegment> convert_to_compSeg(const std::vector<codeset_t>& crossroad_codesets)
{
namespace regexis024 {
std::vector<FilterSegment> convert_to_compSeg(const std::vector<codeset_t>& crossroad_codesets)
{
std::vector<FilterSegment> compSeg;
std::vector<FilterSegment> seg;
for (size_t i = 0; i < crossroad_codesets.size(); i++) {
for (auto& p: crossroad_codesets[i]) {
seg.emplace_back(i, p.first, p.second);
seg.push_back({(ssize_t)i, p.first, p.second});
}
}
std::sort(seg.begin(), seg.end(),
[](const FilterSegment& a, const FilterSegment& b)->bool{return a.L < b.L;});
if (seg.empty()) {
compSeg.emplace_back(-1, 0, UINT32_MAX);
compSeg.push_back({-1, 0, UINT32_MAX});
} else {
if (seg[0].L > 0)
compSeg.emplace_back(-1, 0, seg[0].L - 1);
compSeg.push_back({-1, 0, seg[0].L - 1});
size_t N = seg.size();
for (size_t i = 0; i + 1 < N; i++) {
compSeg.push_back(seg[i]);
assert(seg[i].R < seg[i + 1].L);
if (seg[i].R + 1 < seg[i + 1].L)
compSeg.emplace_back(-1, seg[i].R + 1, seg[i + 1].L - 1);
compSeg.push_back({-1, seg[i].R + 1, seg[i + 1].L - 1});
}
compSeg.push_back(seg.back());
if (seg.back().R < UINT32_MAX)
compSeg.emplace_back(-1, seg[N - 1].R + 1, UINT32_MAX);
compSeg.push_back({-1, seg[N - 1].R + 1, UINT32_MAX});
}
assert(!compSeg.empty());
return compSeg;
}
}
/* Return whether the resulting bytecode relies on me placing [0]'th node at the end */
void write_filter_exit(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
/* Return whether the resulting bytecode relies on me placing [0]'th node at the end */
void write_filter_exit(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
const std::vector<bookmark_id_t>& crossroad_marks,
ssize_t color, bool at_the_end, bool& relies_on_proper_ending)
{
{
if (color < 0) {
cmd_DIE(result);
} else if (color != 0 || !at_the_end) {
@ -47,12 +48,12 @@ void write_filter_exit(std::vector<uint8_t>& result, explicit_bookmarks& bookmar
} else {
relies_on_proper_ending = true;
}
}
}
// todo: use return value of this function
bool write_filter(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
// todo: use return value of this function
bool write_filter(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
const std::vector<codeset_t>& crossroad_codesets, const std::vector<bookmark_id_t>& crossroad_marks)
{
{
bool relies_on_proper_ending = false;
std::vector<FilterSegment> compSeg = convert_to_compSeg(crossroad_codesets);
@ -114,7 +115,5 @@ bool write_filter(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_man
}
}
return relies_on_proper_ending;
}
}
FilterSegment::FilterSegment(ssize_t color, uint32_t l, uint32_t r): color(color), L(l), R(r) {}
//

15
src/libregexis024fa/graph_to_bytecode/filter.h
View File

@ -6,16 +6,17 @@
#include <libregexis024fa/codeset.h>
#include <libregexis024fa/graph_to_bytecode/natural_compiler_utils.h>
struct FilterSegment {
namespace regexis024 {
struct FilterSegment {
ssize_t color;
uint32_t L, R;
uint32_t L;
uint32_t R;
};
FilterSegment(ssize_t color, uint32_t l, uint32_t r);
};
/* Return whether user of function must place [0]'th option after the filter
/* Return whether user of function must place [0]'th option after the filter
* The filter can end up being written in such a way that the end will never be reached */
bool write_filter(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
bool write_filter(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager,
const std::vector<codeset_t>& crossroad_codesets, const std::vector<bookmark_id_t>& crossroad_marks);
}
#endif

81
src/libregexis024fa/graph_to_bytecode/natural_compiler_utils.cpp
View File

@ -2,93 +2,93 @@
#include <assert.h>
#include <libregexis024vm/vm_opcodes.h>
namespace regexis024 {
#define push_to_res_least_signif result.push_back(x & 0xffLU); x >>= 8
void write_byte(std::vector<uint8_t>& result, uint8_t x) {
void write_byte(std::vector<uint8_t>& result, uint8_t x) {
result.push_back(x);
}
}
void write_word(std::vector<uint8_t>& result, uint16_t x) {
void write_word(std::vector<uint8_t>& result, uint16_t x) {
push_to_res_least_signif; push_to_res_least_signif;
}
}
void write_doubleword(std::vector<uint8_t>& result, uint32_t x) {
void write_doubleword(std::vector<uint8_t>& result, uint32_t x) {
push_to_res_least_signif; push_to_res_least_signif; push_to_res_least_signif; push_to_res_least_signif;
}
}
void write_quadword(std::vector<uint8_t>& result, uint64_t x) {
void write_quadword(std::vector<uint8_t>& result, uint64_t x) {
for (int i = 0; i < 8; i++) {
push_to_res_least_signif;
}
}
}
#undef push_to_res_least_signif
#define put_belated_to_res assert(result[pos] == 0); result[pos++] = value & 0xffLU; value >>= 8
void belated_byte(std::vector<uint8_t>& result, size_t pos, uint8_t value) {
void belated_byte(std::vector<uint8_t>& result, size_t pos, uint8_t value) {
assert(pos < result.size());
result[pos] = value;
}
}
void belated_word(std::vector<uint8_t>& result, size_t pos, uint16_t value) {
void belated_word(std::vector<uint8_t>& result, size_t pos, uint16_t value) {
assert(pos + 2 <= result.size());
put_belated_to_res; put_belated_to_res;
}
}
void belated_doubleword(std::vector<uint8_t>& result, size_t pos, uint32_t value) {
void belated_doubleword(std::vector<uint8_t>& result, size_t pos, uint32_t value) {
assert(pos + 4 <= result.size());
put_belated_to_res; put_belated_to_res; put_belated_to_res; put_belated_to_res;
}
}
void belated_quadword(std::vector<uint8_t>& result, size_t pos, uint64_t value) {
void belated_quadword(std::vector<uint8_t>& result, size_t pos, uint64_t value) {
assert(pos + 8 <= result.size());
for (int i = 0; i < 8; i++) {
put_belated_to_res;
}
}
}
#undef put_belated_to_res
void write_sslot_id(std::vector<uint8_t>& result, regex_sslot_id_t x) {
void write_sslot_id(std::vector<uint8_t>& result, sslot_id_t x) {
write_doubleword(result, x);
}
}
void write_tai(std::vector<uint8_t>& result, regex_tai_t x) {
void write_tai(std::vector<uint8_t>& result, tai_t x) {
write_word(result, x);
}
}
void write_near_ptr(std::vector<uint8_t>& result, regex_near_ptr_t x) {
void write_near_ptr(std::vector<uint8_t>& result, near_ptr_t x) {
write_quadword(result, x);
}
}
void belated_sslot_id(std::vector<uint8_t>& result, size_t pos, regex_sslot_id_t value) {
void belated_sslot_id(std::vector<uint8_t>& result, size_t pos, sslot_id_t value) {
belated_doubleword(result, pos, value);
}
}
void belated_tai(std::vector<uint8_t>& result, size_t pos, regex_tai_t value) {
void belated_tai(std::vector<uint8_t>& result, size_t pos, tai_t value) {
belated_word(result, pos, value);
}
}
void belated_near_ptr(std::vector<uint8_t>& result, size_t pos, regex_near_ptr_t value) {
void belated_near_ptr(std::vector<uint8_t>& result, size_t pos, near_ptr_t value) {
belated_quadword(result, pos, value);
}
}
bookmark_id_t explicit_bookmarks::new_bookmark() {
bookmark_id_t explicit_bookmarks::new_bookmark() {
pile.emplace_back();
return free_bid++;
}
}
void explicit_bookmarks::write_unresolved_reference(std::vector<uint8_t> &result, bookmark_id_t bm) {
void explicit_bookmarks::write_unresolved_reference(std::vector<uint8_t> &result, bookmark_id_t bm) {
size_t where_to_fill_later = result.size();
write_near_ptr(result, 0);
pile[bm].positions_of_belated_refs.push_back(where_to_fill_later);
}
}
void explicit_bookmarks::land_bookmark(std::vector<uint8_t> &result, bookmark_id_t bm) {
void explicit_bookmarks::land_bookmark(std::vector<uint8_t> &result, bookmark_id_t bm) {
assert(!pile[bm].placed_somewhere);
pile[bm].placed_somewhere = true;
pile[bm].actual_position = result.size();
}
}
void explicit_bookmarks::finish(std::vector<uint8_t> &result) {
void explicit_bookmarks::finish(std::vector<uint8_t> &result) {
for (explicit_bookmark_info& bmi: pile) {
assert(bmi.positions_of_belated_refs.empty() || bmi.placed_somewhere);
if (bmi.placed_somewhere) {
@ -97,19 +97,20 @@ void explicit_bookmarks::finish(std::vector<uint8_t> &result) {
}
}
}
}
}
bookmark_id_t explicit_bookmarks::new_range_of_bookmarks(size_t n) {
bookmark_id_t explicit_bookmarks::new_range_of_bookmarks(size_t n) {
bookmark_id_t offset = free_bid;
free_bid += n;
for (size_t i = 0; i < n; i++) {
pile.emplace_back();
}
return offset;
}
}
bool explicit_bookmarks::has_landed(bookmark_id_t bm) {
bool explicit_bookmarks::has_landed(bookmark_id_t bm) {
return pile[bm].placed_somewhere;
}
}
#undef put_belated_to_res

50
src/libregexis024fa/graph_to_bytecode/natural_compiler_utils.h
View File

@ -4,40 +4,40 @@
#include <stdint.h>
#include <libregexis024vm/vm_opcodes_types.h>
#include <vector>
namespace regexis024 {
void write_byte(std::vector<uint8_t>& result, uint8_t x);
void write_word(std::vector<uint8_t>& result, uint16_t x);
void write_doubleword(std::vector<uint8_t>& result, uint32_t x);
void write_quadword(std::vector<uint8_t>& result, uint64_t x);
void write_byte(std::vector<uint8_t>& result, uint8_t x);
void write_word(std::vector<uint8_t>& result, uint16_t x);
void write_doubleword(std::vector<uint8_t>& result, uint32_t x);
void write_quadword(std::vector<uint8_t>& result, uint64_t x);
void belated_byte(std::vector<uint8_t>& result, size_t pos, uint8_t value);
void belated_word(std::vector<uint8_t>& result, size_t pos, uint16_t value);
void belated_doubleword(std::vector<uint8_t>& result, size_t pos, uint32_t value);
void belated_quadword(std::vector<uint8_t>& result, size_t pos, uint64_t value);
void belated_byte(std::vector<uint8_t>& result, size_t pos, uint8_t value);
void belated_word(std::vector<uint8_t>& result, size_t pos, uint16_t value);
void belated_doubleword(std::vector<uint8_t>& result, size_t pos, uint32_t value);
void belated_quadword(std::vector<uint8_t>& result, size_t pos, uint64_t value);
void write_sslot_id(std::vector<uint8_t>& result, regex_sslot_id_t x);
void write_tai(std::vector<uint8_t>& result, regex_tai_t x);
void write_near_ptr(std::vector<uint8_t>& result, regex_near_ptr_t x);
void write_sslot_id(std::vector<uint8_t>& result, sslot_id_t x);
void write_tai(std::vector<uint8_t>& result, tai_t x);
void write_near_ptr(std::vector<uint8_t>& result, near_ptr_t x);
void belated_sslot_id(std::vector<uint8_t>& result, size_t pos, regex_sslot_id_t value);
void belated_tai(std::vector<uint8_t>& result, size_t pos, regex_tai_t value);
void belated_near_ptr(std::vector<uint8_t>& result, size_t pos, regex_near_ptr_t value);
void belated_sslot_id(std::vector<uint8_t>& result, size_t pos, sslot_id_t value);
void belated_tai(std::vector<uint8_t>& result, size_t pos, tai_t value);
void belated_near_ptr(std::vector<uint8_t>& result, size_t pos, near_ptr_t value);
// constexpr uint64_t INSTRUCTION_SZ = REGEX024_BYTECODE_INSTRUCTION_SZ;
// constexpr uint64_t SSLOT_ID_SZ = REGEX024_BYTECODE_SSLOT_ID_SZ;
// constexpr uint64_t TRACK_ARRAY_INDEX_ID_SZ = REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ;
// constexpr uint64_t NEAR_POINTER_SZ = REGEX024_BYTECODE_NEAR_POINTER_SZ;
// constexpr uint64_t INSTRUCTION_SZ = REGEX024_BYTECODE_INSTRUCTION_SZ;
// constexpr uint64_t SSLOT_ID_SZ = REGEX024_BYTECODE_SSLOT_ID_SZ;
// constexpr uint64_t TRACK_ARRAY_INDEX_ID_SZ = REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ;
// constexpr uint64_t NEAR_POINTER_SZ = REGEX024_BYTECODE_NEAR_POINTER_SZ;
typedef size_t bookmark_id_t;
typedef size_t bookmark_id_t;
struct explicit_bookmark_info {
struct explicit_bookmark_info {
std::vector<size_t> positions_of_belated_refs;
bool placed_somewhere = false;
size_t actual_position;
};
};
struct explicit_bookmarks {
struct explicit_bookmarks {
bookmark_id_t free_bid = 0;
/* For each named explicit bookmark there is an element in PILE */
std::vector<explicit_bookmark_info> pile;
@ -57,7 +57,7 @@ struct explicit_bookmarks {
bookmark_id_t new_range_of_bookmarks(size_t n);
bool has_landed(bookmark_id_t bm);
};
};
}
#endif

66
src/libregexis024fa/graph_to_bytecode/writing_commands.cpp
View File

@ -2,22 +2,23 @@
#include <libregexis024vm/vm_opcodes.h>
#include <assert.h>
void cmd_JUMP(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, bookmark_id_t dest) {
write_byte(result, regex024_opcodes::JUMP);
namespace regexis024 {
void cmd_JUMP(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, bookmark_id_t dest) {
write_byte(result, opcodes::JUMP);
bookmark_manager.write_unresolved_reference(result, dest);
}
}
constexpr regex024_opcode cmp_EQUAL[4] = {regex024_opcodes::JCEQUAL_B, regex024_opcodes::JCEQUAL_W,
regex024_opcodes::JCEQUAL_DW, regex024_opcodes::JCEQUAL_QW};
constexpr regex024_opcode cmp_LESS[4] = {regex024_opcodes::JCLESS_B, regex024_opcodes::JCLESS_W,
regex024_opcodes::JCLESS_DW, regex024_opcodes::JCLESS_QW};
constexpr regex024_opcode cmp_GRTR[4] = {regex024_opcodes::JCGRTR_B, regex024_opcodes::JCGRTR_W,
regex024_opcodes::JCGRTR_DW, regex024_opcodes::JCGRTR_QW};
constexpr opcode_t cmp_EQUAL[4] = {opcodes::JCEQUAL_B, opcodes::JCEQUAL_W,
opcodes::JCEQUAL_DW, opcodes::JCEQUAL_QW};
constexpr opcode_t cmp_LESS[4] = {opcodes::JCLESS_B, opcodes::JCLESS_W,
opcodes::JCLESS_DW, opcodes::JCLESS_QW};
constexpr opcode_t cmp_GRTR[4] = {opcodes::JCGRTR_B, opcodes::JCGRTR_W,
opcodes::JCGRTR_DW, opcodes::JCGRTR_QW};
void cmd_JC(const regex024_opcode cmpT[4],
void cmd_JC(const opcode_t cmpT[4],
std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest)
{
{
if (val <= UINT8_MAX) {
write_byte(result, cmpT[0]);
write_byte(result, static_cast<uint8_t>(val));
@ -32,44 +33,45 @@ void cmd_JC(const regex024_opcode cmpT[4],
write_quadword(result, val);
}
bookmark_manager.write_unresolved_reference(result, dest);
}
}
void cmd_JCEQUAL(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
void cmd_JCEQUAL(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
cmd_JC(cmp_EQUAL, result, bookmark_manager, val, dest);
}
}
void cmd_JCLESS(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
void cmd_JCLESS(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
cmd_JC(cmp_LESS, result, bookmark_manager, val, dest);
}
}
void cmd_JCGRTR(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
void cmd_JCGRTR(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest) {
cmd_JC(cmp_GRTR, result, bookmark_manager, val, dest);
}
}
void cmd_DIE(std::vector<uint8_t> &result) {
write_byte(result, regex024_opcodes::DIE);
}
void cmd_DIE(std::vector<uint8_t> &result) {
write_byte(result, opcodes::DIE);
}
void cmd_MATCH(std::vector<uint8_t> &result) {
write_byte(result, regex024_opcodes::MATCH);
}
void cmd_MATCH(std::vector<uint8_t> &result) {
write_byte(result, opcodes::MATCH);
}
void cmd_READ_first_ns(std::vector<uint8_t>& result, size_t slot) {
void cmd_READ_first_ns(std::vector<uint8_t>& result, size_t slot) {
assert(slot <= UINT32_MAX);
write_byte(result, regex024_opcodes::READ);
write_byte(result, opcodes::READ);
write_sslot_id(result, slot);
}
}
void cmd_FORK(std::vector<uint8_t> &result, explicit_bookmarks& bookmark_manager, size_t slot, bookmark_id_t dest) {
void cmd_FORK(std::vector<uint8_t> &result, explicit_bookmarks& bookmark_manager, size_t slot, bookmark_id_t dest) {
assert(slot <= UINT32_MAX);
write_byte(result, regex024_opcodes::FORK);
write_byte(result, opcodes::FORK);
write_sslot_id(result, slot);
bookmark_manager.write_unresolved_reference(result, dest);
}
}
void cmd_READ_second_ns(std::vector<uint8_t>& result, std::vector<size_t>& belate_second_read_ns_slot_args) {
write_byte(result, regex024_opcodes::READ);
void cmd_READ_second_ns(std::vector<uint8_t>& result, std::vector<size_t>& belate_second_read_ns_slot_args) {
write_byte(result, opcodes::READ);
belate_second_read_ns_slot_args.push_back(result.size());
write_sslot_id(result, 0);
}
}

20
src/libregexis024fa/graph_to_bytecode/writing_commands.h
View File

@ -4,17 +4,19 @@
#include <libregexis024fa/graph_to_bytecode/natural_compiler_utils.h>
#include <libregexis024vm/vm_opcodes.h>
void cmd_JUMP(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, bookmark_id_t dest);
namespace regexis024 {
void cmd_JUMP(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, bookmark_id_t dest);
void cmd_JCEQUAL(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_JCLESS(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_JCGRTR(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_JCEQUAL(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_JCLESS(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_JCGRTR(std::vector<uint8_t>& result, explicit_bookmarks& bookmark_manager, uint64_t val, bookmark_id_t dest);
void cmd_DIE(std::vector<uint8_t>& result);
void cmd_MATCH(std::vector<uint8_t>& result);
void cmd_DIE(std::vector<uint8_t>& result);
void cmd_MATCH(std::vector<uint8_t>& result);
void cmd_READ_first_ns(std::vector<uint8_t>& result, size_t slot);
void cmd_READ_second_ns(std::vector<uint8_t>& result, std::vector<size_t>& belate_second_read_ns_slot_args);
void cmd_FORK(std::vector<uint8_t> &result, explicit_bookmarks& bookmark_manager, size_t slot, bookmark_id_t dest);
void cmd_READ_first_ns(std::vector<uint8_t>& result, size_t slot);
void cmd_READ_second_ns(std::vector<uint8_t>& result, std::vector<size_t>& belate_second_read_ns_slot_args);
void cmd_FORK(std::vector<uint8_t> &result, explicit_bookmarks& bookmark_manager, size_t slot, bookmark_id_t dest);
}
#endif

33
src/libregexis024fa/misc_fa_funcs.cpp
View File

@ -3,7 +3,8 @@
#include <assert.h>
#include <libregexis024vm/utils.h>
void reattach_fa_node_edge(FA_Node **old_node_ptr, FA_Node *new_node) {
namespace regexis024 {
void reattach_fa_node_edge(FA_Node **old_node_ptr, FA_Node *new_node) {
assert(old_node_ptr);
if (*old_node_ptr){
assert((**old_node_ptr).refs);
@ -12,28 +13,27 @@ void reattach_fa_node_edge(FA_Node **old_node_ptr, FA_Node *new_node) {
if (new_node)
new_node->refs++;
*old_node_ptr = new_node;
}
}
/* We basically reattch fa.start to node */
void yay_new_start(FA_Container &fa, FA_NodePathPart *node) {
/* We basically reattch fa.start to node */
void yay_new_start(FA_Container &fa, FA_NodePathPart *node) {
assert(node);
node->refs++;
node->nxt_node = fa.start;
fa.start = node;
}
}
void add_option_to_fork_node(FA_NodeOfForking *fnode, FA_Node *transition_dest) {
void add_option_to_fork_node(FA_NodeOfForking *fnode, FA_Node *transition_dest) {
fnode->nxt_options.push_back(transition_dest);
if(transition_dest)
transition_dest->refs++;
}
}
void reattach_nxt_node(FA_NodePathPart *node, FA_Node *dest) {
void reattach_nxt_node(FA_NodePathPart *node, FA_Node *dest) {
reattach_fa_node_edge(&(node->nxt_node), dest);
}
}
// todo: get rid of exitf in the whole project
FA_Node* copy_node_no_container_adjustments(FA_Node& node){
FA_Node* copy_node_no_container_adjustments(FA_Node& node){
FA_Node* res;
/* Using implicitly defined copy constructors */
#define typeCase(etype, ctype) case etype: res = new ctype((ctype&)node); break;
@ -53,19 +53,20 @@ FA_Node* copy_node_no_container_adjustments(FA_Node& node){
res->refs = 0;
res->search_mark = -1;
return res;
}
}
/* In case when transferring the ownership of this new raw pointer has failed, node is destroyed, exception is thrown */
FA_Node *copy_fa_node(FA_Node& node, FA_Container &fa) {
/* In case when transferring the ownership of this new raw pointer has failed, node is destroyed, exception is thrown */
FA_Node *copy_fa_node(FA_Node& node, FA_Container &fa) {
FA_Node* res = copy_node_no_container_adjustments(node);
/* Can invalidate ponter res (in which case it also throws exeption, so none of this matters in the end) */
fa.registerNew(res);
res->reAdd_references();
return res;
}
}
FA_Node *copy_fa_node_to_another_fa(FA_Node& node, FA_Container &resultFa) {
FA_Node *copy_fa_node_to_another_fa(FA_Node& node, FA_Container &resultFa) {
FA_Node* res = copy_node_no_container_adjustments(node);
resultFa.registerNew(res);
return res;
}
}

16
src/libregexis024fa/misc_fa_funcs.h
View File

@ -4,14 +4,16 @@
#include "finite_automaton.h"
#include "fa_first_stage_fix.h"
FA_Node* copy_fa_node(FA_Node& node, FA_Container& fa);
void yay_new_start(FA_Container& fa, FA_NodePathPart* node);
void reattach_fa_node_edge(FA_Node** old_node_ptr, FA_Node* new_node);
void add_option_to_fork_node(FA_NodeOfForking* fnode, FA_Node* transition_dest);
void reattach_nxt_node(FA_NodePathPart* node, FA_Node* dest);
namespace regexis024 {
FA_Node* copy_fa_node(FA_Node& node, FA_Container& fa);
void yay_new_start(FA_Container& fa, FA_NodePathPart* node);
void reattach_fa_node_edge(FA_Node** old_node_ptr, FA_Node* new_node);
void add_option_to_fork_node(FA_NodeOfForking* fnode, FA_Node* transition_dest);
void reattach_nxt_node(FA_NodePathPart* node, FA_Node* dest);
/* This is a one weird operation. New node in resultFa will still point to nodes in sourceFa,
/* This is a one weird operation. New node in resultFa will still point to nodes in sourceFa,
* without increasing refcount of those nodes. YOU HAVE TO FIX IT ASAP */
FA_Node* copy_fa_node_to_another_fa(FA_Node& node, FA_Container& resultFa);
FA_Node* copy_fa_node_to_another_fa(FA_Node& node, FA_Container& resultFa);
}
#endif //LIBREGEXIS024_MISC_FA_FUNCS_H

15
src/libregexis024fa/selarr_priority_table.cpp
View File

@ -1,15 +1,16 @@
#include <libregexis024fa/selarr_priority_table.h>
#include <assert.h>
bool RegexPriorityTableAction_Pos::isForRange() const {
namespace regexis024 {
bool RegexPriorityTableAction_Pos::isForRange() const {
return second >= 0;
}
}
RegexPriorityTableAction_Pos::RegexPriorityTableAction_Pos(int first, int second, tracking_var_type type):
RegexPriorityTableAction_Pos::RegexPriorityTableAction_Pos(int first, int second, tracking_var_type_t type):
first(first),second(second), type(type) {}
//
//
RegexPriorityTableAction::RegexPriorityTableAction(bool minimize, int first, int second, tracking_var_type type):
RegexPriorityTableAction::RegexPriorityTableAction(bool minimize, int first, int second, tracking_var_type_t type):
minimize(minimize), pos(first, second, type) {}
//
//
}

18
src/libregexis024fa/selarr_priority_table.h
View File

@ -5,22 +5,24 @@
#include <vector>
#include <libregexis024fa/tracking_variables.h>
struct RegexPriorityTableAction_Pos{
namespace regexis024 {
struct RegexPriorityTableAction_Pos{
/* first and second are indexes in selarr (but second can be -1 if it is unused) */
int first;
int second;
tracking_var_type type;
tracking_var_type_t type;
bool isForRange() const;
RegexPriorityTableAction_Pos(int first, int second, tracking_var_type type);
};
RegexPriorityTableAction_Pos(int first, int second, tracking_var_type_t type);
};
struct RegexPriorityTableAction{
struct RegexPriorityTableAction{
bool minimize;
RegexPriorityTableAction_Pos pos;
RegexPriorityTableAction(bool minimize, int first, int second, tracking_var_type type);
};
RegexPriorityTableAction(bool minimize, int first, int second, tracking_var_type_t type);
};
typedef std::vector<RegexPriorityTableAction> RegexPriorityTable;
typedef std::vector<RegexPriorityTableAction> RegexPriorityTable;
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024FA_SELARR_PRIORITY_TABLE_H

51
src/libregexis024fa/tracking_fa_nodes.cpp
View File

@ -1,53 +1,48 @@
#include <libregexis024fa/tracking_fa_nodes.h>
#include <assert.h>
bool isImmMovOpcode(regex024_opcode inst) {
return inst == regex024_opcodes::MOV_COLARR_IMM || inst == regex024_opcodes::MOV_SELARR_IMM;
}
namespace regexis024 {
bool isImmMovOpcode(opcode_t inst) {
return inst == opcodes::MOV_COLARR_IMM || inst == opcodes::MOV_SELARR_IMM;
}
bool isCurPosMovOpcode(regex024_opcode inst) {
return inst == regex024_opcodes::MOV_COLARR_BTPOS || inst == regex024_opcodes::MOV_SELARR_CHPOS;
}
bool isCurPosMovOpcode(opcode_t inst) {
return inst == opcodes::MOV_COLARR_BTPOS || inst == opcodes::MOV_SELARR_CHPOS;
}
bool isColarrOpcode(regex024_opcode inst) {
return inst == regex024_opcodes::MOV_COLARR_IMM || inst == regex024_opcodes::MOV_COLARR_BTPOS;
}
bool isColarrOpcode(opcode_t inst) {
return inst == opcodes::MOV_COLARR_IMM || inst == opcodes::MOV_COLARR_BTPOS;
}
bool isSelarrOpcode(regex024_opcode inst) {
return inst == regex024_opcodes::MOV_SELARR_IMM || inst == regex024_opcodes::MOV_SELARR_CHPOS;
}
bool isSelarrOpcode(opcode_t inst) {
return inst == opcodes::MOV_SELARR_IMM || inst == opcodes::MOV_SELARR_CHPOS;
}
bool isTrackingFaNode(const FA_Node *n) {
bool isTrackingFaNode(const FA_Node *n) {
return n->type == track_array_mov_imm || n->type == track_array_mov_halfinvariant;
}
}
TrackingOperationInFa::TrackingOperationInFa(regex024_opcode opcode, regex_tai_t key, uint64_t imm_value)
: opcode(opcode), key(key), immValue(imm_value) {}
TrackingOperationInFa::TrackingOperationInFa(regex024_opcode opcode, regex_tai_t key)
: opcode(opcode), key(key) {}
std::string TrackingOperationInFa::toString() const {
std::string TrackingOperationInFa::toString() const {
switch (opcode){
case regex024_opcodes::MOV_COLARR_IMM:
case opcodes::MOV_COLARR_IMM:
return "colarr[" + std::to_string(key) + "] := " + std::to_string(immValue);
case regex024_opcodes::MOV_SELARR_IMM:
case opcodes::MOV_SELARR_IMM:
return "selarr[" + std::to_string(key) + "] := " + std::to_string(immValue);
case regex024_opcodes::MOV_COLARR_BTPOS:
case opcodes::MOV_COLARR_BTPOS:
return "colarr[" + std::to_string(key) + "] := cur byte position";
case regex024_opcodes::MOV_SELARR_CHPOS:
case opcodes::MOV_SELARR_CHPOS:
return "selarr[" + std::to_string(key) + "] := cur char position";
default:
return "wrong collection operation";
}
}
}
FA_NodePathPart* convert_to_node(const TrackingOperationInFa& op, FA_Container& fa) {
FA_NodePathPart* convert_to_node(const TrackingOperationInFa& op, FA_Container& fa) {
if (isImmMovOpcode(op.opcode)) {
return fa.makeTrackArrayMovImm(op.opcode, op.key, op.immValue);
}
assert(isCurPosMovOpcode(op.opcode));
return fa.makeTrackArrayMovHalfinvariant(op.opcode, op.key);
}
}

27
src/libregexis024fa/tracking_fa_nodes.h
View File

@ -5,27 +5,24 @@
#include <libregexis024fa/finite_automaton.h>
#include <string>
bool isImmMovOpcode(regex024_opcode inst);
bool isCurPosMovOpcode(regex024_opcode inst);
bool isColarrOpcode(regex024_opcode inst);
bool isSelarrOpcode(regex024_opcode inst);
namespace regexis024 {
bool isImmMovOpcode(opcode_t inst);
bool isCurPosMovOpcode(opcode_t inst);
bool isColarrOpcode(opcode_t inst);
bool isSelarrOpcode(opcode_t inst);
bool isTrackingFaNode(const FA_Node* n);
bool isTrackingFaNode(const FA_Node* n);
struct TrackingOperationInFa {
regex024_opcode opcode;
regex_tai_t key;
struct TrackingOperationInFa {
opcode_t opcode;
tai_t key;
/* Not needed for halfinvariant operations */
uint64_t immValue;
TrackingOperationInFa(regex024_opcode opcode, regex_tai_t key, uint64_t imm_value);
TrackingOperationInFa(regex024_opcode opcode, regex_tai_t key);
std::string toString() const;
};
FA_NodePathPart* convert_to_node(const TrackingOperationInFa& op, FA_Container& fa);
};
FA_NodePathPart* convert_to_node(const TrackingOperationInFa& op, FA_Container& fa);
}
#endif

8
src/libregexis024fa/tracking_variables.h
View File

@ -1,14 +1,16 @@
#ifndef LIBREGEXIS024_SRC_LIBREGEXIS024FA_TRACKING_VARIABLES_H
#define LIBREGEXIS024_SRC_LIBREGEXIS024FA_TRACKING_VARIABLES_H
namespace tracking_var_types {
namespace regexis024 {
namespace tracking_var_types {
enum tracking_var_type_I {
range,
dot_cur_pos,
dot_immediate
};
}
typedef tracking_var_types::tracking_var_type_I tracking_var_type_t;
}
typedef tracking_var_types::tracking_var_type_I tracking_var_type;
#endif

16
src/libregexis024sol/backslash_expression.cpp
View File

@ -2,7 +2,8 @@
#include <libregexis024sol/sol_misc_base.h>
#include <assert.h>
uint32_t read_hex(REGEX_IS024_MeaningContext& ctx, int sz){
namespace regexis024 {
uint32_t read_hex(REGEX_IS024_MeaningContext& ctx, int sz){
uint32_t res = 0;
for (int i = 0; i < sz; i++){
int32_t ch = peep(ctx);
@ -19,19 +20,19 @@ uint32_t read_hex(REGEX_IS024_MeaningContext& ctx, int sz){
readChar(ctx);
}
return res;
}
}
void unicode_in_bs_case(REGEX_IS024_MeaningContext &ctx, bool &ret_is_multicode, codeset_t &ret_set, int sz){
void unicode_in_bs_case(REGEX_IS024_MeaningContext &ctx, bool &ret_is_multicode, codeset_t &ret_set, int sz){
ret_is_multicode = false;
readChar(ctx);
uint32_t hc = read_hex(ctx, sz); // Might create an error
ret_set = codeset_of_one_char(hc);
}
}
void
backslash_expression_parsing_try_regular(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc,
void
backslash_expression_parsing_try_regular(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc,
bool &ret_is_multicode, codeset_t &ret_set)
{
{
int32_t leader = peep(ctx);
if (ctx.error)
return;
@ -59,4 +60,5 @@ backslash_expression_parsing_try_regular(REGEX_IS024_MeaningContext &ctx, const
report(ctx, "backslash in the wrong place");
}
}
}
}

48
src/libregexis024sol/command_expression.cpp
View File

@ -5,32 +5,33 @@
#include <assert.h>
#include <memory>
struct ParseCall{
namespace regexis024 {
struct ParseCall{
virtual ~ParseCall() = default;
virtual std::unique_ptr<ParseCall> afterReceive(REGEX_IS024_MeaningContext& ctx) { assert(false); }
virtual std::unique_ptr<ParseCall> firstTime(REGEX_IS024_MeaningContext& ctx) { assert(false); }
};
};
struct Top_ParseCall: public ParseCall{
struct Top_ParseCall: public ParseCall{
Command& res;
explicit Top_ParseCall(Command &res) : res(res) {}
std::unique_ptr<ParseCall> firstTime(REGEX_IS024_MeaningContext &ctx) override;
std::unique_ptr<ParseCall> afterReceive(REGEX_IS024_MeaningContext &ctx) override;
};
};
struct Bracker_ParseCall: public ParseCall{
struct Bracker_ParseCall: public ParseCall{
std::vector<CommandArgument>& res;
bool closingBraceEnded = false;
explicit Bracker_ParseCall(std::vector<CommandArgument> &res) : res(res) {}
std::unique_ptr<ParseCall> argReadProc(REGEX_IS024_MeaningContext& ctx);
std::unique_ptr<ParseCall> firstTime(REGEX_IS024_MeaningContext &ctx) override;
std::unique_ptr<ParseCall> afterReceive(REGEX_IS024_MeaningContext &ctx) override;
};
};
#define call_ERROR_CHECK do { if (ctx.error) { return NULL; } } while (0)
#define call_THROW(str) do { report(ctx, "command expression: " str); return NULL; } while (0)
std::unique_ptr<ParseCall> Top_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx) {
std::unique_ptr<ParseCall> Top_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx) {
assert(readChar(ctx) == U'!');
int32_t ch = peep(ctx); call_ERROR_CHECK;
if (ch == U'~'){
@ -50,23 +51,23 @@ std::unique_ptr<ParseCall> Top_ParseCall::firstTime(REGEX_IS024_MeaningContext &
return std::make_unique<Bracker_ParseCall>(res.arguments);
}
call_THROW("top lvl: command call should be ended with ';' or '{...}'");
}
}
std::unique_ptr<ParseCall> Top_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx) {
std::unique_ptr<ParseCall> Top_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx) {
return NULL;
}
}
std::unique_ptr<ParseCall> Bracker_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx) {
std::unique_ptr<ParseCall> Bracker_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx) {
assert(readChar(ctx) == U'{');
return argReadProc(ctx);
}
}
std::unique_ptr<ParseCall> Bracker_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx) {
std::unique_ptr<ParseCall> Bracker_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx) {
closingBraceEnded = true;
return argReadProc(ctx);
}
}
std::unique_ptr<ParseCall> Bracker_ParseCall::argReadProc(REGEX_IS024_MeaningContext &ctx) {
std::unique_ptr<ParseCall> Bracker_ParseCall::argReadProc(REGEX_IS024_MeaningContext &ctx) {
repeat:
int32_t ch = peep(ctx); call_ERROR_CHECK;
if (ch == U';'){
@ -98,9 +99,9 @@ std::unique_ptr<ParseCall> Bracker_ParseCall::argReadProc(REGEX_IS024_MeaningCon
call_THROW("brace lvl: argument ends with ';' or {...}");
}
call_THROW("brace lvl: argument starts with ';' or it's name");
}
}
Command command_expr_parse(REGEX_IS024_MeaningContext &ctx) {
Command command_expr_parse(REGEX_IS024_MeaningContext &ctx) {
std::vector<std::unique_ptr<ParseCall>> callStack;
Command res;
callStack.push_back(std::make_unique<Top_ParseCall>(res));
@ -118,16 +119,16 @@ Command command_expr_parse(REGEX_IS024_MeaningContext &ctx) {
}
}
return res;
}
}
const char* commands_for_codesets[] = {"word", "space", "digit", "variable", "any", "A", NULL};
const char* commands_for_codesets[] = {"word", "space", "digit", "variable", "any", "A", NULL};
bool is_command_for_charset(const Command &cmd) {
bool is_command_for_charset(const Command &cmd) {
return !cmd.tilda && cmd.arguments.empty() && is_string_in_stringset(cmd.name.c_str(), commands_for_codesets);
}
}
void interpret_command_as_charset_giving(const CommonCodesets& cc, const Command &cmd, codeset_t& ret)
{
void interpret_command_as_charset_giving(const CommonCodesets& cc, const Command &cmd, codeset_t& ret)
{
if (cmd.name == "word")
ret = cc.word_constituents;
else if (cmd.name == "space")
@ -140,4 +141,5 @@ void interpret_command_as_charset_giving(const CommonCodesets& cc, const Command
ret = codeset_of_all;
else
assert(false);
}
}

4
src/libregexis024sol/common_codesets.cpp
View File

@ -1,6 +1,7 @@
#include <libregexis024sol/common_codesets.h>
CommonCodesets::CommonCodesets() {
namespace regexis024 {
CommonCodesets::CommonCodesets() {
spaces = set_add_char(spaces, U'\n');
spaces = set_add_char(spaces, U' ');
spaces = set_add_char(spaces, U'\t');
@ -10,4 +11,5 @@ CommonCodesets::CommonCodesets() {
digits = codeset_t({{'0', '9'}});
variable_constituents = set_add_char(word_constituents, U'-');
variable_constituents = merge_sets(variable_constituents, digits);
}
}

6
src/libregexis024sol/common_codesets.h
View File

@ -3,12 +3,14 @@
#include <libregexis024fa/codeset.h>
struct CommonCodesets {
namespace regexis024 {
struct CommonCodesets {
codeset_t spaces;
codeset_t word_constituents;
codeset_t digits;
codeset_t variable_constituents;
CommonCodesets();
};
};
}
#endif

64
src/libregexis024sol/expr_compiler.cpp
View File

@ -23,12 +23,13 @@
#define aux_ERROR_CHECK do { if (ctx.error) { return; } } while (0)
#define aux_THROW(str) do { report(ctx, "regex: " str); return; } while (0)
/* ****************************** Top */
namespace regexis024 {
/* ****************************** Top */
const char* dfa_arg_aliases_condone[] = {"forgive", "condone", "okay", "optional", "nonimportant", "ifpossible", NULL};
const char* dfa_arg_aliases_acerbic[] = {"acerbic", "angry", "pedantic", "nofork", "pure", "important", "fierce", NULL};
const char* dfa_arg_aliases_condone[] = {"forgive", "condone", "okay", "optional", "nonimportant", "ifpossible", NULL};
const char* dfa_arg_aliases_acerbic[] = {"acerbic", "angry", "pedantic", "nofork", "pure", "important", "fierce", NULL};
void dfa_command_processing(REGEX_IS024_MeaningContext &ctx, ParsingContext& pctx, const Command& cmdBuf){
void dfa_command_processing(REGEX_IS024_MeaningContext &ctx, ParsingContext& pctx, const Command& cmdBuf){
if (pctx.dfa_cmd_activated){
report(ctx, "repeating !dfa command");
return;
@ -48,9 +49,9 @@ void dfa_command_processing(REGEX_IS024_MeaningContext &ctx, ParsingContext& pct
}
}
report(ctx, "wrong arguments in !dfa command");
}
}
void select_command_processing(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, const Command& cmdBuf){
void select_command_processing(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, const Command& cmdBuf){
if (pctx.select_cmd_encountered)
aux_THROW("repeating !select command");
pctx.select_cmd_encountered = true;
@ -89,9 +90,9 @@ void select_command_processing(REGEX_IS024_MeaningContext& ctx, ParsingContext&
pctx.is_inside_of_these_sa_subexpressions.assign(ctx.ktr.retrieval_info.size(), false);
/* Other info will be filled once a tracking-unit with such name will be actually found in regex */
}
}
}
void jump_into_madness(ctx_t& ctx, ParsingContext& pctx, FA_Container &fa, int hn){
void jump_into_madness(ctx_t& ctx, ParsingContext& pctx, FA_Container &fa, int hn){
while (true){
int32_t pch = peep(ctx); aux_ERROR_CHECK;
if (pch != U'!'){
@ -115,26 +116,26 @@ void jump_into_madness(ctx_t& ctx, ParsingContext& pctx, FA_Container &fa, int h
break;
}
}
}
}
chekushka TopLvl_ParseCall::firstTime(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) {
chekushka TopLvl_ParseCall::firstTime(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) {
result.assertDefault();
jump_into_madness(ctx, pctx, fa, 1);
if (ctx.have_comment_tail)
return NULL;
return std::make_unique<ForkLvl_ParseCall>(result);
}
}
chekushka TopLvl_ParseCall::afterReceive(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) {
chekushka TopLvl_ParseCall::afterReceive(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) {
jump_into_madness(ctx, pctx, fa, 2);
if (!isEnd(ctx))
call_THROW("top lvl: EOF expected");
return NULL;
}
}
/* ********************************* Bracket */
/* ********************************* Bracket */
chekushka BracketLvl_ParseCall::firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
chekushka BracketLvl_ParseCall::firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
result.assertDefault();
assert(readChar(ctx) == U'(');
/* sequence lvl already took care about resolving name and configuring SubtrackingNameInfo */
@ -148,9 +149,9 @@ chekushka BracketLvl_ParseCall::firstTime(REGEX_IS024_MeaningContext& ctx, Parsi
}
}
return std::make_unique<ForkLvl_ParseCall>(tmp_ret_buff);
}
}
chekushka BracketLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
chekushka BracketLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
if (peep(ctx) != U')')
call_THROW("missing ')'");
readChar(ctx);
@ -161,32 +162,32 @@ chekushka BracketLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, Pa
assert(tai_slots.colarr_first >= 0 && tai_slots.colarr_first < UINT16_MAX);
assert(tai_slots.colarr_second >= 0 && tai_slots.colarr_second < UINT16_MAX);
result = join(subexpression_from_path(fa.makeTrackArrayMovHalfinvariant(
regex024_opcodes::MOV_COLARR_BTPOS, tai_slots.colarr_first)), result);
opcodes::MOV_COLARR_BTPOS, tai_slots.colarr_first)), result);
result = join(result, subexpression_from_path(fa.makeTrackArrayMovHalfinvariant(
regex024_opcodes::MOV_COLARR_BTPOS, tai_slots.colarr_second)));
opcodes::MOV_COLARR_BTPOS, tai_slots.colarr_second)));
}
if (tai_slots.stored_in_sa){
assert(tai_slots.selarr_first >= 0 && tai_slots.selarr_first < UINT16_MAX);
assert(tai_slots.selarr_second >= 0 && tai_slots.selarr_second < UINT16_MAX);
result = join(subexpression_from_path(fa.makeTrackArrayMovHalfinvariant(
regex024_opcodes::MOV_SELARR_CHPOS, tai_slots.selarr_first)), result);
opcodes::MOV_SELARR_CHPOS, tai_slots.selarr_first)), result);
result = join(result, subexpression_from_path(fa.makeTrackArrayMovHalfinvariant(
regex024_opcodes::MOV_SELARR_CHPOS, tai_slots.selarr_second)));
opcodes::MOV_SELARR_CHPOS, tai_slots.selarr_second)));
pctx.is_inside_of_these_sa_subexpressions[namedSubexpressionId] = false;
}
}
return NULL;
}
}
/* ******************************* Fork */
/* ******************************* Fork */
chekushka ForkLvl_ParseCall::firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
chekushka ForkLvl_ParseCall::firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
result.assertDefault();
options.emplace_back(); // Default one contains nothing. It will be overwritten
return std::make_unique<Sequence_ParseCall>(options.back());
}
}
chekushka ForkLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
chekushka ForkLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) {
int32_t end_reason = peep(ctx); call_ERROR_CHECK;
if (end_reason == U'|'){
readChar(ctx);
@ -194,9 +195,9 @@ chekushka ForkLvl_ParseCall::afterReceive(REGEX_IS024_MeaningContext& ctx, Parsi
}
result = forkify(options, fa);
return NULL;
}
}
void parseBody(REGEX_IS024_MeaningContext& ctx, FA_Container& fa, SubExprCompiled& result, ParsingContext& pctx){
void parseBody(REGEX_IS024_MeaningContext& ctx, FA_Container& fa, SubExprCompiled& result, ParsingContext& pctx){
std::vector<std::shared_ptr<ParseCall>> callStack;
callStack.push_back(std::make_unique<TopLvl_ParseCall>(result));
bool first_time = true;
@ -222,10 +223,10 @@ void parseBody(REGEX_IS024_MeaningContext& ctx, FA_Container& fa, SubExprCompile
pctx.priority_table.emplace_back(sni.minimizing, sni.selarr_first, sni.selarr_second, sni.type);
}
}
}
}
REGEX_IS024_MeaningContext::REGEX_IS024_MeaningContext(size_t inputSize, const char *input) : input_size(inputSize),
input(reinterpret_cast<const uint8_t *>(input)) {
REGEX_IS024_MeaningContext::REGEX_IS024_MeaningContext(size_t inputSize, const char *input) : input_size(inputSize),
input(input) {
CommonCodesets codeset_collection;
FA_Container fa;
FA_Container fa_1f;
@ -277,4 +278,5 @@ REGEX_IS024_MeaningContext::REGEX_IS024_MeaningContext(size_t inputSize, const c
report(*this, "Failed to compile graph representation to bytecode representation");
return;
}
}
}

13
src/libregexis024sol/expr_compiler.h
View File

@ -5,14 +5,11 @@
#include <vector>
#include <stdint.h>
// todo: SUPER HIGHT PRIORITY: MOVE all this spaces digits variable_constituents junk out of this class
// todo: also PLEEEASE, write static before literally nearly every single one little stupid function in this library
#include <libregexis024sol/part_of_expr_that_tracks.h>
struct REGEX_IS024_MeaningContext{
namespace regexis024 {
struct REGEX_IS024_MeaningContext{
size_t input_size;
const uint8_t* input;
const char* input;
bool error = false;
std::string error_msg;
@ -29,6 +26,6 @@ struct REGEX_IS024_MeaningContext{
uint16_t free_colarr_tai = 0;
REGEX_IS024_MeaningContext(size_t inputSize, const char *input);
};
};
}
#endif //LIBREGEXIS024_EXPR_COMPILER_H

20
src/libregexis024sol/expr_parse_functions/command_recognition.cpp
View File

@ -6,23 +6,24 @@
#define aux_ERROR_CHECK do { if (ctx.error) { return; } } while (0)
#define aux_THROW(str) do { report(ctx, "regex: " str); return; } while (0)
const char* header_command_dfa_names[] = {"dfa", "determinize", NULL};
namespace regexis024 {
const char* header_command_dfa_names[] = {"dfa", "determinize", NULL};
const char* header_command_select_names[] = {"s", "select", "selarr", "selectional", NULL};
const char* header_command_select_names[] = {"s", "select", "selarr", "selectional", NULL};
bool is_header_cmd(const Command &cmd) {
bool is_header_cmd(const Command &cmd) {
return cmd.tilda || is_header_dfa_cmd(cmd), is_header_dfa_cmd(cmd);
}
}
bool is_header_dfa_cmd(const Command &cmd) {
bool is_header_dfa_cmd(const Command &cmd) {
return is_string_in_stringset(cmd.name.c_str(), header_command_dfa_names);
}
}
bool is_header_select_cmd(const Command &cmd) {
bool is_header_select_cmd(const Command &cmd) {
return is_string_in_stringset(cmd.name.c_str(), header_command_select_names);
}
}
void int_parse_with_limit_concern(const std::string &str, REGEX_IS024_MeaningContext &ctx, size_t &res, int lim) {
void int_parse_with_limit_concern(const std::string &str, REGEX_IS024_MeaningContext &ctx, size_t &res, int lim) {
res = 0;
for (char ch: str){
if (!('0' <= ch && ch <= '9'))
@ -31,4 +32,5 @@ void int_parse_with_limit_concern(const std::string &str, REGEX_IS024_MeaningCon
if (res > (size_t)lim)
aux_THROW("integer is too big");
}
}
}

11
src/libregexis024sol/expr_parse_functions/command_recognition.h
View File

@ -4,10 +4,11 @@
#include <libregexis024sol/special_terminals.h>
bool is_header_cmd(const Command& cmd);
bool is_header_dfa_cmd(const Command& cmd);
bool is_header_select_cmd(const Command& cmd);
void int_parse_with_limit_concern(const std::string& str, REGEX_IS024_MeaningContext &ctx, size_t& res, int lim);
namespace regexis024 {
bool is_header_cmd(const Command& cmd);
bool is_header_dfa_cmd(const Command& cmd);
bool is_header_select_cmd(const Command& cmd);
void int_parse_with_limit_concern(const std::string& str, REGEX_IS024_MeaningContext &ctx, size_t& res, int lim);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_EXPR_PARSE_FUNCTIONS_COMMAND_RECOGNITION_H

30
src/libregexis024sol/expr_parse_functions/ep_sequence.cpp
View File

@ -14,9 +14,10 @@
#define aux_ERROR_CHECK do { if (ctx.error) { return; } } while (0)
#define aux_THROW(str) do { report(ctx, "regex: " str); return; } while (0)
/* **************************** Sequence */
namespace regexis024 {
/* **************************** Sequence */
void in_case_of_backslash(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc, FA_Container &fa, SubExprCompiled& backPart) {
void in_case_of_backslash(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc, FA_Container &fa, SubExprCompiled& backPart) {
assert(readChar(ctx) == U'\\');
int32_t leader = peep(ctx); aux_ERROR_CHECK;
if (leader == U'b'){
@ -62,9 +63,9 @@ void in_case_of_backslash(REGEX_IS024_MeaningContext &ctx, const CommonCodesets&
return; // To avoid reading leader again (it gets read in the end)
}
readChar(ctx);
}
}
void repeat_stuff_with_check(REGEX_IS024_MeaningContext& ctx,
void repeat_stuff_with_check(REGEX_IS024_MeaningContext& ctx,
SubExprCompiled &patient, FA_Container& fa, size_t min_allowed, size_t max_allowed){
if (min_allowed > max_allowed)
aux_THROW("repeat operation: min > max");
@ -75,9 +76,9 @@ void repeat_stuff_with_check(REGEX_IS024_MeaningContext& ctx,
"выражение корректно и не вызвает бесконечного цикла, напишите об этом в жалобную книгу: "
"По ссылке: file:///dev/null Ваши предложения по улучшению libregexis024 обязательно будут рассмотрены.");
apply_repeat_to_subexpression(patient, fa, min_allowed, max_allowed);
}
}
void repeat_command_processing(REGEX_IS024_MeaningContext &ctx, FA_Container &fa, std::vector<SubExprCompiled>& parts,
void repeat_command_processing(REGEX_IS024_MeaningContext &ctx, FA_Container &fa, std::vector<SubExprCompiled>& parts,
const Command& cmd){
if (parts.empty())
aux_THROW("no subexpression before !repeat command");
@ -107,10 +108,10 @@ void repeat_command_processing(REGEX_IS024_MeaningContext &ctx, FA_Container &fa
aux_THROW("!repeat: min > max");
repeat_stuff_with_check(ctx, parts.back(), fa, min_allowed, max_allowed); aux_ERROR_CHECK;
}
}
}
chekushka Sequence_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx, ParsingContext &pctx, FA_Container &fa) {
chekushka Sequence_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx, ParsingContext &pctx, FA_Container &fa) {
while (true) {
int32_t fst = peep(ctx);
call_ERROR_CHECK;
@ -179,22 +180,22 @@ chekushka Sequence_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx, Parsing
readChar(ctx);
if (ctx.ktr.retrieval_info[id].stored_in_sa)
parts.emplace_back(subexpression_from_path(
fa.makeTrackArrayMovImm(regex024_opcodes::MOV_SELARR_IMM,
fa.makeTrackArrayMovImm(opcodes::MOV_SELARR_IMM,
ctx.ktr.retrieval_info[id].selarr_first, value)));
if (ctx.ktr.retrieval_info[id].stored_in_ca)
parts.emplace_back(subexpression_from_path(
fa.makeTrackArrayMovImm(regex024_opcodes::MOV_COLARR_IMM,
fa.makeTrackArrayMovImm(opcodes::MOV_COLARR_IMM,
ctx.ktr.retrieval_info[id].colarr_first, value)));
} else if (typeDet == U';'){
ensure_space_for_track_unit(ctx, name, tracking_var_types::dot_cur_pos); call_ERROR_CHECK;
readChar(ctx);
if (ctx.ktr.retrieval_info[id].stored_in_sa)
parts.emplace_back(subexpression_from_path(
fa.makeTrackArrayMovHalfinvariant(regex024_opcodes::MOV_SELARR_CHPOS,
fa.makeTrackArrayMovHalfinvariant(opcodes::MOV_SELARR_CHPOS,
ctx.ktr.retrieval_info[id].selarr_first)));
if (ctx.ktr.retrieval_info[id].stored_in_ca)
parts.emplace_back(subexpression_from_path(
fa.makeTrackArrayMovHalfinvariant(regex024_opcodes::MOV_COLARR_BTPOS,
fa.makeTrackArrayMovHalfinvariant(opcodes::MOV_COLARR_BTPOS,
ctx.ktr.retrieval_info[id].colarr_first)));
} else
call_THROW("Missing ; or ( in the beginning of tracking unit");
@ -214,9 +215,10 @@ chekushka Sequence_ParseCall::firstTime(REGEX_IS024_MeaningContext &ctx, Parsing
for (SubExprCompiled& part: parts)
result = join(result, part);
return NULL;
}
}
chekushka Sequence_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx, ParsingContext &pctx, FA_Container &fa) {
chekushka Sequence_ParseCall::afterReceive(REGEX_IS024_MeaningContext &ctx, ParsingContext &pctx, FA_Container &fa) {
// This is possible only if I received a bracket expression
return firstTime(ctx, pctx, fa);
}
}

33
src/libregexis024sol/expr_parse_functions/epf.h
View File

@ -10,7 +10,8 @@
#include <assert.h>
#include <libregexis024fa/selarr_priority_table.h>
struct ParsingContext{
namespace regexis024 {
struct ParsingContext{
/* Those subexpressions, that are tracket by s`a are forbidden from nesting inside themselves */
std::vector<bool> is_inside_of_these_sa_subexpressions;
bool select_cmd_encountered = false;
@ -27,24 +28,24 @@ struct ParsingContext{
explicit ParsingContext(const CommonCodesets& cc_): cc(cc_){}
};
typedef REGEX_IS024_MeaningContext ctx_t;
struct ParseCall;
typedef std::unique_ptr<ParseCall> chekushka;
struct ParseCall{
typedef REGEX_IS024_MeaningContext ctx_t;
struct ParseCall;
typedef std::unique_ptr<ParseCall> chekushka;
struct ParseCall{
SubExprCompiled& result;
explicit ParseCall(SubExprCompiled &result) : result(result) {}
virtual ~ParseCall() = default;
virtual chekushka afterReceive(ctx_t& ctx, ParsingContext& pctx, FA_Container& fa) { assert(false); }
virtual chekushka firstTime(ctx_t& ctx, ParsingContext& pctx, FA_Container& fa) { assert(false); }
};
};
struct TopLvl_ParseCall: public ParseCall{
struct TopLvl_ParseCall: public ParseCall{
explicit TopLvl_ParseCall(SubExprCompiled &result) : ParseCall(result) {}
chekushka afterReceive(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) override;
chekushka firstTime(ctx_t &ctx, ParsingContext &pctx, FA_Container &fa) override;
};
};
struct BracketLvl_ParseCall: public ParseCall{
struct BracketLvl_ParseCall: public ParseCall{
/* -1 if this is a normal bracket expression. Otherwise, it is an index in ctx.retrieval_info vector */
int64_t namedSubexpressionId;
SubExprCompiled tmp_ret_buff;
@ -52,23 +53,21 @@ struct BracketLvl_ParseCall: public ParseCall{
ParseCall(result), namedSubexpressionId(namedSubexpressionId) {}
chekushka afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) override;
chekushka firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa) override;
};
};
struct ForkLvl_ParseCall: public ParseCall{
struct ForkLvl_ParseCall: public ParseCall{
std::vector<SubExprCompiled> options;
explicit ForkLvl_ParseCall(SubExprCompiled &result) : ParseCall(result) {}
chekushka afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa);
chekushka firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa);
};
};
struct Sequence_ParseCall: public ParseCall{
struct Sequence_ParseCall: public ParseCall{
std::vector<SubExprCompiled> parts;
explicit Sequence_ParseCall(SubExprCompiled &result) :ParseCall(result) {}
chekushka afterReceive(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa);
chekushka firstTime(REGEX_IS024_MeaningContext& ctx, ParsingContext& pctx, FA_Container& fa);
};
/* Some auxilary functions */
};
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_EXPR_PARSE_FUNCTIONS_EPF_H

13
src/libregexis024sol/expr_parse_functions/tracking_units.cpp
View File

@ -4,20 +4,20 @@
#define aux_THROW(str) do { report(ctx, "regex: " str); return; } while (0)
#define aux_ERROR_CHECK do { if (ctx.error) { return; } } while (0)
void for_one_type(REGEX_IS024_MeaningContext &ctx, uint16_t& free_ARR_tai, int& ARR_first, int& ARR_second,
const std::string& ARR_NAME, tracking_var_type type){
namespace regexis024 {
void for_one_type(REGEX_IS024_MeaningContext &ctx, uint16_t& free_ARR_tai, int& ARR_first, int& ARR_second,
const std::string& ARR_NAME, tracking_var_type_t type){
#define check_is_available() if (free_ARR_tai == UINT16_MAX) { \
report(ctx, ("regex: " + ARR_NAME + ": key namespace overflow").c_str()); return;}
report(ctx, ("regex: " + ARR_NAME + ": key namespace overflow").c_str()); return;}
check_is_available()
ARR_first = free_ARR_tai++;
if (type == tracking_var_types::range){
check_is_available()
ARR_second = free_ARR_tai++;
}
}
}
void ensure_space_for_track_unit(REGEX_IS024_MeaningContext &ctx, const std::string& name, tracking_var_type type) {
void ensure_space_for_track_unit(REGEX_IS024_MeaningContext &ctx, const std::string& name, tracking_var_type_t type) {
size_t id = ctx.ktr.track_names[name];
/* Size of this verctor won't be changed. THis is a safe reference */
SubtrackingNameInfo& info = ctx.ktr.retrieval_info[id];
@ -35,4 +35,5 @@ void ensure_space_for_track_unit(REGEX_IS024_MeaningContext &ctx, const std::str
} else if (info.type != type){
aux_THROW("tracking tool unit type mismatch");
}
}
}

5
src/libregexis024sol/expr_parse_functions/tracking_units.h
View File

@ -4,7 +4,8 @@
#include <libregexis024sol/expr_compiler.h>
void ensure_space_for_track_unit(REGEX_IS024_MeaningContext &ctx, const std::string& name, tracking_var_type type);
namespace regexis024 {
void ensure_space_for_track_unit(REGEX_IS024_MeaningContext &ctx, const std::string& name, tracking_var_type_t type);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_TRACKING_UNITS_H

2
src/libregexis024sol/part_of_expr_that_tracks.cpp
View File

@ -1,2 +0,0 @@
// #include <libregexis024sol/part_of_expr_that_tracks.h>

13
src/libregexis024sol/part_of_expr_that_tracks.h
View File

@ -6,12 +6,13 @@
#include <string>
#include <libregexis024fa/tracking_variables.h>
struct SubtrackingNameInfo{
namespace regexis024 {
struct SubtrackingNameInfo{
bool stored_in_ca = true;
bool stored_in_sa = false;
bool discovered = false;
tracking_var_type type;
tracking_var_type_t type;
/* These fields will be -1 if unused */
int colarr_first = -1;
int colarr_second = -1;
@ -20,12 +21,12 @@ struct SubtrackingNameInfo{
bool minimizing = false;
int selarr_first = -1;
int selarr_second = -1;
};
};
struct KnownTrackingTools {
struct KnownTrackingTools {
std::map<std::string, int64_t> track_names;
std::vector<SubtrackingNameInfo> retrieval_info;
};
};
}
#endif //PART_OF_EXPR_THAT_TRACKS_H

30
src/libregexis024sol/sol_misc_base.cpp
View File

@ -1,19 +1,20 @@
#include <libregexis024sol/sol_misc_base.h>
#include <libregexis024vm/utils.h>
void report(REGEX_IS024_MeaningContext &ctx, const char *error) {
namespace regexis024 {
void report(REGEX_IS024_MeaningContext &ctx, const char *error) {
if (!ctx.error){
ctx.error = true;
ctx.error_msg = error;
}
}
}
bool isEnd(REGEX_IS024_MeaningContext &ctx) {
bool isEnd(REGEX_IS024_MeaningContext &ctx) {
return ctx.pos == ctx.input_size;
}
}
int32_t peep(REGEX_IS024_MeaningContext &ctx) {
// printf("pos = %lu\n", ctx.pos);
int32_t peep(REGEX_IS024_MeaningContext &ctx) {
// printf("pos = %lu\n", ctx.pos);
if (isEnd(ctx))
return -1; // This is probably the only place where getting negative return does not generate error
int32_t cp; size_t sz;
@ -21,10 +22,10 @@ int32_t peep(REGEX_IS024_MeaningContext &ctx) {
if (cp < 0)
report(ctx, "encoding error");
return cp;
}
}
int32_t readChar(REGEX_IS024_MeaningContext &ctx) {
// printf("READ pos = %lu\n", ctx.pos);
int32_t readChar(REGEX_IS024_MeaningContext &ctx) {
// printf("READ pos = %lu\n", ctx.pos);
int32_t cp; size_t sz;
utf8_string_iterat(cp, sz, ctx.pos, ctx.input, ctx.input_size);
if (cp >= 0)
@ -32,13 +33,13 @@ int32_t readChar(REGEX_IS024_MeaningContext &ctx) {
else
report(ctx, "bruh what?? How this even happened");
return cp;
}
}
bool is_REGEX024_nameConstituent(int32_t ch) {
bool is_REGEX024_nameConstituent(int32_t ch) {
return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z');
}
}
std::string tryRead_REGEX024_name(REGEX_IS024_MeaningContext &ctx) {
std::string tryRead_REGEX024_name(REGEX_IS024_MeaningContext &ctx) {
std::string res;
while (true){
int32_t ch = peep(ctx);
@ -50,6 +51,5 @@ std::string tryRead_REGEX024_name(REGEX_IS024_MeaningContext &ctx) {
}
}
return res;
}
}

17
src/libregexis024sol/sol_misc_base.h
View File

@ -5,16 +5,17 @@
#include <libregexis024sol/expr_compiler.h>
#include <string>
void report(REGEX_IS024_MeaningContext& ctx, const char* error);
namespace regexis024 {
void report(REGEX_IS024_MeaningContext& ctx, const char* error);
bool isEnd(REGEX_IS024_MeaningContext& ctx);
int32_t peep(REGEX_IS024_MeaningContext& ctx);
int32_t readChar(REGEX_IS024_MeaningContext& ctx);
bool isEnd(REGEX_IS024_MeaningContext& ctx);
int32_t peep(REGEX_IS024_MeaningContext& ctx);
int32_t readChar(REGEX_IS024_MeaningContext& ctx);
bool is_REGEX024_nameConstituent(int32_t ch);
/* Name in my library consists of [0-9a-zA-Z]. If the first peeped letter is not name constituent,
bool is_REGEX024_nameConstituent(int32_t ch);
/* Name in my library consists of [0-9a-zA-Z]. If the first peeped letter is not name constituent,
* empty string is returned */
std::string tryRead_REGEX024_name(REGEX_IS024_MeaningContext& ctx);
std::string tryRead_REGEX024_name(REGEX_IS024_MeaningContext& ctx);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_SOL_MISC_BASE_H

34
src/libregexis024sol/special_terminals.h
View File

@ -5,32 +5,34 @@
#include <libregexis024sol/expr_compiler.h>
#include <libregexis024sol/common_codesets.h>
/* This option of backslash usage should be checked last.
namespace regexis024 {
/* This option of backslash usage should be checked last.
* Function can generate error. Always check the error first */
void
backslash_expression_parsing_try_regular(REGEX_IS024_MeaningContext& ctx, const CommonCodesets& cc,
void
backslash_expression_parsing_try_regular(REGEX_IS024_MeaningContext& ctx, const CommonCodesets& cc,
bool& ret_is_multicode, codeset_t& ret_set);
struct CommandEntity;
struct Command;
struct CommandArgument;
struct CommandEntity;
struct Command;
struct CommandArgument;
struct CommandEntity{
struct CommandEntity{
std::string name;
std::vector<CommandArgument> arguments;
};
};
struct CommandArgument: CommandEntity{
struct CommandArgument: CommandEntity{
bool is_empty = true;
};
};
struct Command: CommandEntity{
struct Command: CommandEntity{
bool tilda = false;
};
};
/* Zlaya sobaka. Kidaet oshibki v context */
Command command_expr_parse(REGEX_IS024_MeaningContext& ctx);
bool is_command_for_charset(const Command& cmd);
void interpret_command_as_charset_giving(const CommonCodesets& cc, const Command& cmd, codeset_t& ret);
/* Zlaya sobaka. Kidaet oshibki v context */
Command command_expr_parse(REGEX_IS024_MeaningContext& ctx);
bool is_command_for_charset(const Command& cmd);
void interpret_command_as_charset_giving(const CommonCodesets& cc, const Command& cmd, codeset_t& ret);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_SPECIAL_TERMINALS_H

86
src/libregexis024sol/square_bracket_expression.cpp
View File

@ -6,82 +6,83 @@
#include <memory>
#include <assert.h>
/* Can allow backslash (later should check that backslash expression is not multicharar or empty */
bool soundsLikeCharOrRangeStart(int32_t peeped) {
namespace regexis024 {
/* Can allow backslash (later should check that backslash expression is not multicharar or empty */
bool soundsLikeCharOrRangeStart(int32_t peeped) {
return peeped >= 0 && (peeped != U'[' && peeped != U']' && peeped != U'!' && \
peeped != '^' && peeped != '&' && peeped != '-');
}
}
typedef REGEX_IS024_MeaningContext ctx_t;
typedef REGEX_IS024_MeaningContext ctx_t;
struct ParseCall;
typedef std::shared_ptr<ParseCall> chekushka;
struct ParseCall;
typedef std::shared_ptr<ParseCall> chekushka;
struct ParseCall{
struct ParseCall{
codeset_t& result;
explicit ParseCall(codeset_t &result) : result(result) {}
virtual ~ParseCall() = default;
virtual chekushka afterReceive(ctx_t& ctx, const CommonCodesets& cc) { assert(false); }
virtual chekushka firstTime(ctx_t& ctx, const CommonCodesets& cc) { assert(false); }
};
};
#define call_ERROR_CHECK do { if (ctx.error) { return NULL; } } while (0)
#define call_THROW(str) do { report(ctx, "square bracket expression: " str); return NULL; } while (0)
/* [...] */
struct ZeroLvl_ParseCall: public ParseCall{
/* [...] */
struct ZeroLvl_ParseCall: public ParseCall{
explicit ZeroLvl_ParseCall(codeset_t &result) : ParseCall(result) {}
chekushka afterReceive(ctx_t &ctx, const CommonCodesets& cc) override;
chekushka firstTime(ctx_t &ctx, const CommonCodesets& cc) override;
};
};
/* ...&...&... */
struct FirstLvl_ParseCall: public ParseCall{
/* ...&...&... */
struct FirstLvl_ParseCall: public ParseCall{
codeset_t ret_buf_for_new;
bool got_one = false;
explicit FirstLvl_ParseCall(codeset_t& result) : ParseCall(result) {}
chekushka afterReceive(ctx_t &ctx, const CommonCodesets& cc) override;
chekushka firstTime(ctx_t &ctx, const CommonCodesets& cc) override;
};
};
/* ab[]vgd[]eyo[]zhz */
struct SecondLvl_ParseCall: public ParseCall{
/* ab[]vgd[]eyo[]zhz */
struct SecondLvl_ParseCall: public ParseCall{
codeset_t ret_buf_for_new;
explicit SecondLvl_ParseCall(codeset_t& result) : ParseCall(result) {}
chekushka afterReceive(ctx_t &ctx, const CommonCodesets& cc) override;
chekushka firstTime(ctx_t &ctx, const CommonCodesets& cc) override;
};
};
/* ^... */
struct CircumflexLvl_ParseCall: public ParseCall{
/* ^... */
struct CircumflexLvl_ParseCall: public ParseCall{
codeset_t ret_buf_for_new;
explicit CircumflexLvl_ParseCall(codeset_t& result) : ParseCall(result) {}
chekushka afterReceive(ctx_t &ctx, const CommonCodesets& cc) override;
chekushka firstTime(ctx_t &ctx, const CommonCodesets& cc) override;
};
};
/* ********* ZeroLvl_ParseCall ********** */
/* ********* ZeroLvl_ParseCall ********** */
chekushka ZeroLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
chekushka ZeroLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
assert(readChar(ctx) == U'[');
return std::make_shared<FirstLvl_ParseCall>(result);
}
}
chekushka ZeroLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
chekushka ZeroLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
if (peep(ctx) != U']')
call_THROW("lvl 0: missing ]");
readChar(ctx);
return NULL;
}
}
/* ********* FirstLvl_ParseCall ********** */
/* ********* FirstLvl_ParseCall ********** */
chekushka FirstLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
chekushka FirstLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
return std::make_shared<SecondLvl_ParseCall>(result);
}
}
chekushka FirstLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
chekushka FirstLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
if (got_one)
result = intersect_sets(result, ret_buf_for_new);
else
@ -91,11 +92,11 @@ chekushka FirstLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc)
return std::make_shared<SecondLvl_ParseCall>(ret_buf_for_new);
}
return NULL;
}
}
/* ********* SecondLvl_ParseCall ********** */
/* ********* SecondLvl_ParseCall ********** */
chekushka SecondLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
chekushka SecondLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
repeat:
int32_t ch = peep(ctx); call_ERROR_CHECK;
if (ch == U'^'){
@ -147,28 +148,28 @@ chekushka SecondLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
goto repeat;
}
return NULL;
}
}
chekushka SecondLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
chekushka SecondLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
result = merge_sets(result, ret_buf_for_new);
return firstTime(ctx, cc);
}
}
/* ********* CircumflexLvl_ParseCall ********* */
/* ********* CircumflexLvl_ParseCall ********* */
chekushka CircumflexLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
chekushka CircumflexLvl_ParseCall::firstTime(ctx_t &ctx, const CommonCodesets& cc) {
assert(readChar(ctx) == U'^');
return std::make_shared<FirstLvl_ParseCall>(ret_buf_for_new);
}
}
chekushka CircumflexLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
chekushka CircumflexLvl_ParseCall::afterReceive(ctx_t &ctx, const CommonCodesets& cc) {
result = invert_set(ret_buf_for_new);
return NULL;
}
}
/* Aaaaaaaaand... The function we have all been waiting for so long! */
codeset_t sq_bracket_expr_parse(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc) {
/* Aaaaaaaaand... The function we have all been waiting for so long! */
codeset_t sq_bracket_expr_parse(REGEX_IS024_MeaningContext &ctx, const CommonCodesets& cc) {
std::vector<std::shared_ptr<ParseCall>> callStack;
codeset_t res;
callStack.push_back(std::make_shared<ZeroLvl_ParseCall>(res));
@ -186,4 +187,5 @@ codeset_t sq_bracket_expr_parse(REGEX_IS024_MeaningContext &ctx, const CommonCod
}
}
return res;
}
}

5
src/libregexis024sol/square_bracket_expression.h
View File

@ -5,6 +5,7 @@
#include <libregexis024sol/expr_compiler.h>
#include <libregexis024sol/common_codesets.h>
codeset_t sq_bracket_expr_parse(REGEX_IS024_MeaningContext& ctx, const CommonCodesets& cc);
namespace regexis024 {
codeset_t sq_bracket_expr_parse(REGEX_IS024_MeaningContext& ctx, const CommonCodesets& cc);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_SQUARE_BRACKET_EXPRESSION_H

32
src/libregexis024sol/subexpr_fa_transformed.cpp
View File

@ -3,11 +3,12 @@
#include <assert.h>
#include <stdio.h>
SubExprCompiled subexpr_charset_reading_filter(const codeset_t &codeset, FA_Container &fa) {
namespace regexis024 {
SubExprCompiled subexpr_charset_reading_filter(const codeset_t &codeset, FA_Container &fa) {
return subexpression_from_path(fa.makeOneCharRead(codeset, false));
}
}
SubExprCompiled join(const SubExprCompiled &A, const SubExprCompiled &B) {
SubExprCompiled join(const SubExprCompiled &A, const SubExprCompiled &B) {
if (!A.start)
return B;
if (!B.start)
@ -19,18 +20,18 @@ SubExprCompiled join(const SubExprCompiled &A, const SubExprCompiled &B) {
res.ends = B.ends;
res.can_be_empty = A.can_be_empty && B.can_be_empty;
return res;
}
}
SubExprCompiled subexpression_from_path(FA_NodePathPart *node) {
SubExprCompiled subexpression_from_path(FA_NodePathPart *node) {
SubExprCompiled res;
res.start = node;
res.ends.push_back(&(node->nxt_node));
/* There is only one char reading path node type */
res.can_be_empty = (node->type != one_char_read);
return res;
}
}
SubExprCompiled RobertAngier(const SubExprCompiled& source, FA_Container& fa) {
SubExprCompiled RobertAngier(const SubExprCompiled& source, FA_Container& fa) {
SubExprCompiled res;
if (!source.start)
return res;
@ -68,9 +69,9 @@ SubExprCompiled RobertAngier(const SubExprCompiled& source, FA_Container& fa) {
for (Marked& mrkd: searched)
mrkd.original->search_mark = -1;
return res;
}
}
void reattach_all_ends_to_one_node(SubExprCompiled& patient, FA_Node* node){
void reattach_all_ends_to_one_node(SubExprCompiled& patient, FA_Node* node){
assert(node);
assert(patient.start);
for (FA_Node** end: patient.ends){
@ -78,9 +79,9 @@ void reattach_all_ends_to_one_node(SubExprCompiled& patient, FA_Node* node){
printf("DEBUG %lu->->->->->%lu\n", patient.start->nodeId, node->nodeId);
reattach_fa_node_edge(end, node);
}
}
}
void apply_repeat_to_subexpression(SubExprCompiled &patient, FA_Container& fa, size_t min_allowed, size_t max_allowed) {
void apply_repeat_to_subexpression(SubExprCompiled &patient, FA_Container& fa, size_t min_allowed, size_t max_allowed) {
assert(min_allowed <= max_allowed && min_allowed <= REGEXIS024_MAX_REPEAT);
if (!patient.start)
return;
@ -144,9 +145,9 @@ void apply_repeat_to_subexpression(SubExprCompiled &patient, FA_Container& fa, s
}
if (min_allowed == 0)
patient.can_be_empty = true;
}
}
SubExprCompiled forkify(const std::vector<SubExprCompiled> &options, FA_Container& fa){
SubExprCompiled forkify(const std::vector<SubExprCompiled> &options, FA_Container& fa){
SubExprCompiled result;
size_t non_empty = 0;
result.can_be_empty = false;
@ -177,8 +178,9 @@ SubExprCompiled forkify(const std::vector<SubExprCompiled> &options, FA_Containe
}
}
return result;
}
}
void SubExprCompiled::assertDefault() {
void SubExprCompiled::assertDefault() {
assert(!start && ends.empty() && can_be_empty);
}
}

23
src/libregexis024sol/subexpr_fa_transformed.h
View File

@ -3,30 +3,31 @@
#include <libregexis024fa/finite_automaton.h>
struct SubExprCompiled{
namespace regexis024 {
struct SubExprCompiled{
FA_Node* start = NULL;
/* After putting there values from neighbour vectors in nodes, these vectors must not change size */
std::vector<FA_Node**> ends;
bool can_be_empty = true;
void assertDefault();
};
};
SubExprCompiled subexpr_charset_reading_filter(const codeset_t& codeset, FA_Container& fa);
SubExprCompiled subexpr_charset_reading_filter(const codeset_t& codeset, FA_Container& fa);
SubExprCompiled join(const SubExprCompiled& A, const SubExprCompiled& B);
SubExprCompiled join(const SubExprCompiled& A, const SubExprCompiled& B);
SubExprCompiled forkify(const std::vector<SubExprCompiled>& options, FA_Container& fa);
SubExprCompiled forkify(const std::vector<SubExprCompiled>& options, FA_Container& fa);
SubExprCompiled subexpression_from_path(FA_NodePathPart* node);
SubExprCompiled subexpression_from_path(FA_NodePathPart* node);
/* And then Robert Angier said `It's prestige time` and prestiged all over the place.
/* And then Robert Angier said `It's prestige time` and prestiged all over the place.
* If you still don't get it, this function copies section of NFA of regexp */
SubExprCompiled RobertAngier(const SubExprCompiled& source, FA_Container& fa);
SubExprCompiled RobertAngier(const SubExprCompiled& source, FA_Container& fa);
#define REGEXIS024_MAX_REPEAT 64
/* pass REGEXIS024_MAX_REPEAT + 1 as max_allowed to allow infinite repeat */
void apply_repeat_to_subexpression(SubExprCompiled& patient, FA_Container& fa, size_t min_allowed, size_t max_allowed);
/* pass REGEXIS024_MAX_REPEAT + 1 as max_allowed to allow infinite repeat */
void apply_repeat_to_subexpression(SubExprCompiled& patient, FA_Container& fa, size_t min_allowed, size_t max_allowed);
}
#endif //LIBREGEXIS024_SRC_LIBREGEXIS024SOL_SUBEXPR_FA_TRANSFORMED_H

8
src/libregexis024test/byte_code_assembler.h
View File

@ -11,15 +11,17 @@
#include <map>
#include <stdio.h>
using namespace regexis024;
struct assembler_context_bookmark{
regex_near_ptr_t pos_in_r024program;
near_ptr_t pos_in_r024program;
int LINE;
};
struct pending_bookmark{
/* Must fill this byte with pos of pos_in_r024program in assembler_context_bookmark
* In a sense, this is a pointer to a NULL pointer that is yet to become normal kinda pointer */
regex_near_ptr_t pos_in_r024program;
near_ptr_t pos_in_r024program;
const char* name;
/* LINE of the reference is needed in case of error */
int LINE;
@ -46,7 +48,7 @@ struct assembler_context{
}
/* pending bookmerk requests should be added only with beg_for_bookmark method,
* or else SEGFAULT will be your frequent guest */
*reinterpret_cast<regex_near_ptr_t *>(&result[br.pos_in_r024program]) = bookmarks[br.name].pos_in_r024program;
*reinterpret_cast<near_ptr_t *>(&result[br.pos_in_r024program]) = bookmarks[br.name].pos_in_r024program;
}
}

64
src/libregexis024test/byte_code_disassembler.h
View File

@ -11,8 +11,9 @@
#include <map>
#include <stdio.h>
#include <inttypes.h>
#include <stdexcept>
// TODO: apply here my new change in near pointer size
using namespace regexis024;
struct landing_place_resolvance{
size_t name_id;
@ -34,12 +35,14 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
};
uint64_t used_names = 0;
/* From program position -> to names[ind] & */
std::map<regex_near_ptr_t, landing_place_resolvance> bookmarks;
regex_near_ptr_t IP = 0;
std::map<near_ptr_t, landing_place_resolvance> bookmarks;
near_ptr_t IP = 0;
auto check_inboundness = [&](int region){
if (!vmprog_check_inboundness(prgSize, IP, region))
exitf("This program can't be decomposed into commands in a trivial way");
if (!vmprog_check_inboundness(prgSize, IP, region)) {
fprintf(stderr, "This program can't be decomposed into commands in a trivial way");
std::terminate();
}
};
auto extract_b = [&]() -> uint8_t{
check_inboundness(1);
@ -60,19 +63,19 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
auto extract_instruction = [&]() -> uint8_t{
return extract_b();
};
auto extract_sslot_id = [&]() -> regex_sslot_id_t{
auto extract_sslot_id = [&]() -> sslot_id_t{
return extract_dw();
};
auto extract_near_pointer = [&]() -> regex_near_ptr_t{
auto extract_near_pointer = [&]() -> near_ptr_t{
return extract_qw();
};
auto extract_track_array_index = [&]() -> regex_tai_t{
auto extract_track_array_index = [&]() -> tai_t{
return extract_w();
};
bool second_phase = false;
auto fph_register_landing = [&](regex_near_ptr_t pos){
auto fph_register_landing = [&](near_ptr_t pos){
if (!second_phase){
if (bookmarks.count(pos) == 0){
if (used_names == names.size())
@ -83,15 +86,17 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
}
};
auto get_bookmark_in_2phase = [&](regex_near_ptr_t pos) -> std::string {
if (bookmarks.count(pos) == 0)
exitf("bruh");
auto get_bookmark_in_2phase = [&](near_ptr_t pos) -> std::string {
if (bookmarks.count(pos) == 0) {
fprintf(stderr, "Bruh\n");
std::terminate();
}
return names[bookmarks[pos].name_id];
};
auto one_reading = [&](){
while (IP < prgSize) {
regex_near_ptr_t start_pos = IP;
near_ptr_t start_pos = IP;
if (second_phase){
if (bookmarks.count(IP) != 0){
printf("%s:\n", get_bookmark_in_2phase(IP).c_str());
@ -102,11 +107,11 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
switch (opcode) {
#define secPrint(fmt, ...) if (second_phase) {printf("% 3lu) " fmt, start_pos, __VA_ARGS__);} } break;
#define secPrintNoArg(str) if (second_phase) {printf("% 3lu) " str, start_pos);} } break;
#define instCase(oper_code) case regex024_opcodes::oper_code: {
#define instCase(oper_code) case opcodes::oper_code: {
#define jcMess(cond, sz_uppercase, x_t, extract_method, printf_sign) \
instCase(JC ## cond ## _ ## sz_uppercase) \
x_t x = extract_method(); \
regex_near_ptr_t dest = extract_near_pointer(); \
near_ptr_t dest = extract_near_pointer(); \
fph_register_landing(dest); \
secPrint("JC" #cond "_" #sz_uppercase " %" printf_sign " $%s\n", x, get_bookmark_in_2phase(dest).c_str())
#define jcCacaphony(cond) \
@ -131,22 +136,22 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
instCase(FORK)
uint32_t ssid = extract_sslot_id();
regex_near_ptr_t dest = extract_near_pointer();
near_ptr_t dest = extract_near_pointer();
fph_register_landing(dest);
secPrint("FORK %u $%s\n", ssid, get_bookmark_in_2phase(dest).c_str())
simpleDimple(MATCH)
simpleDimple(DIE)
instCase(PARAM_READ_SS_NUMBER)
regex_sslot_id_t ssid_max_plus_one = extract_sslot_id();
sslot_id_t ssid_max_plus_one = extract_sslot_id();
secPrint("PARAM_READ_SS_NUMBER %u\n", ssid_max_plus_one)
instCase(PARAM_FORK_SS_NUMBER)
regex_sslot_id_t ssid_max_plus_one = extract_sslot_id();
sslot_id_t ssid_max_plus_one = extract_sslot_id();
secPrint("PARAM_FORK_SS_NUMBER %u\n", ssid_max_plus_one)
instCase(PARAM_SELARR_LEN)
regex_tai_t tai_max_plus_one = extract_track_array_index();
tai_t tai_max_plus_one = extract_track_array_index();
secPrint("PARAM_SELARR_LEN %hu\n", tai_max_plus_one)
instCase(PARAM_COLSIFTFUNC_SET)
regex_near_ptr_t entry = extract_near_pointer();
near_ptr_t entry = extract_near_pointer();
fph_register_landing(entry);
secPrint("PARAM_COLSIFTFUNC_SET $%s\n", get_bookmark_in_2phase(entry).c_str())
simpleDimple(PARAM_COLSIFTFUNC_WIPE)
@ -156,36 +161,37 @@ void print_disassembly(size_t prgSize, uint8_t* prg){
instCase(MSG_FED_INPUT_EXTENDED)
uint8_t left = extract_b();
uint8_t right = extract_b();
regex_sslot_id_t part = extract_sslot_id();
sslot_id_t part = extract_sslot_id();
secPrint("MSG_FED_INPUT_EXTENDED %hhu %hhu %u\n", left, right, part)
instCase(DMOV_RABX_SELARR)
regex_tai_t i = extract_track_array_index();
tai_t i = extract_track_array_index();
secPrint("DMOV_RABX_SELARR %hu\n", i)
instCase(DDIST_RABX_SELARR)
regex_tai_t s = extract_track_array_index();
regex_tai_t e = extract_track_array_index();
tai_t s = extract_track_array_index();
tai_t e = extract_track_array_index();
secPrint("DDIST_RABX_SELARR %hu %hu\n", s, e);
simpleDimple(SIFTPRIOR_MIN_RABX)
simpleDimple(SIFTPRIOR_MAX_RABX)
simpleDimple(SIFT_DONE)
instCase(MOV_COLARR_IMM)
regex_tai_t tai = extract_track_array_index();
tai_t tai = extract_track_array_index();
uint64_t imm = extract_qw();
secPrint("MOV_COLARR_IMM %hu %lu\n", tai, imm);
instCase(MOV_COLARR_BTPOS)
regex_tai_t tai = extract_track_array_index();
tai_t tai = extract_track_array_index();
secPrint("MOV_COLARR_BTPOS %hu\n", tai);
instCase(MOV_SELARR_IMM)
regex_tai_t tai = extract_track_array_index();
tai_t tai = extract_track_array_index();
uint64_t imm = extract_qw();
secPrint("MOV_SELARR_IMM %hu %lu\n", tai, imm);
instCase(MOV_SELARR_CHPOS)
regex_tai_t tai = extract_track_array_index();
tai_t tai = extract_track_array_index();
secPrint("MOV_SELARR_CHPOS %hu\n", tai);
simpleDimple(INIT)
simpleDimple(THROW)
default:
exitf("Bad opcode\n");
fprintf(stderr, "Bad opcode\n");
std::terminate();
#undef secPrint
#undef secPrintNoArg
#undef instCase

10
src/libregexis024test/test0.cpp
View File

@ -2,12 +2,16 @@
#include <libregexis024vm/utils.h>
#include <stdio.h>
using namespace regexis024;
void test_ccs_fnc(const codeset_t &got, const codeset_t &expected){
static int id = 1;
if (got == expected)
if (got == expected) {
printf("Test %d passed\n", id++);
else
exitf("Test %d failed\n", id);
} else {
printf("Test %d failed\n", id);
std::terminate();
}
}
void invert_test(const codeset_t& A, const codeset_t& C){

4
src/libregexis024test/test1.cpp
View File

@ -10,8 +10,8 @@ static int test_id = 0;
void do_test(const std::vector<uint8_t>& prg, const std::string& str, const std::vector<bool>& prefix_matching){
assert(str.size() + 1 == prefix_matching.size());
REGEX_IS024_CONTEXT ctx{prg.size(), prg.data(), 0, 0, 1000, 1000, 1000000};
regex024_error_code ret;
VMContext ctx{prg.size(), prg.data(), 0, 0, 1000, 1000, 1000000};
error_code_t ret;
// todo
printf("TEST %d passed\n", test_id);
test_id++;

2
src/libregexis024test/test2.cpp
View File

@ -1,6 +1,8 @@
#include <libregexis024sol/expr_compiler.h>
#include <libregexis024test/byte_code_disassembler.h>
using namespace regexis024;
int main(){
std::string regular_expression = "\\>1*";
REGEX_IS024_MeaningContext regex(regular_expression.size(), regular_expression.c_str());

2
src/libregexis024test/test3.cpp
View File

@ -7,6 +7,8 @@
#include <stdexcept>
#include <random>
using namespace regexis024;
struct test_id_t {
int test_id;
int subtest_id;

43
src/libregexis024test/test4.cpp
View File

@ -21,19 +21,54 @@ void test(const string& input, const string& pattern, const MatchInfo& right_ans
}
int main() {
test("11aa", "^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo({}, {}));
test("aa11", "^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo({}, {}));
test("a111", "^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo());
test("aa11", "^!A;\\B!A;\\B!any;\\B!any;$", MatchInfo());
test("1a11", "^!A;\\B!A;\\B!any;\\B!any;$", MatchInfo());
test("11aa", "!dfa;^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo({}, {}));
test("aa11", "!dfa;^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo({}, {}));
test("a111", "!dfa;^!A;\\B!A;\\b!any;\\B!any;$", MatchInfo());
test("aa11", "!dfa;^!A;\\B!A;\\B!any;\\B!any;$", MatchInfo());
test("1a11", "!dfa;^!A;\\B!A;\\B!any;\\B!any;$", MatchInfo());
test("LINE\r\nFirst:Second\r\nThird:12\r\n\r\n",
"!dfa;!select{fieldname{ca}fieldbody{ca}}^^^LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n$$$",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}, {0, 20}, {1, 25}, {2, 26}, {3, 28}}, {20, 25, 26, 28}));
test("LINE\r\nFirst:Second\r\nThird:12\r\n\r\n",
"!dfa;!select{fieldname{ca}fieldbody{ca}}^LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+\\>):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}, {0, 20}, {1, 25}, {2, 26}, {3, 28}}, {20, 25, 26, 28}));
test("LINE\r\nFirst:Second\r\nThird:12\r\n\r\n",
"!dfa;!select{fieldname{ca}fieldbody{ca}}^LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}, {0, 20}, {1, 25}, {2, 26}, {3, 28}}, {20, 25, 26, 28}));
test("LINE\r\nFirst:Second\r\n\r\n",
"!select{fieldname{ca}}LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}}, {6, 11}));
test("LINE\r\nFirst:Second\r\n\r\n",
"!select{fieldname}LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 12}, {1, 18}}, {6, 11}));
test("LINE\r\nFirst:Second\r\nThird:12\r\n\r\n",
"!select{fieldname{ca}fieldbody{ca}}LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}, {0, 20}, {1, 25}, {2, 26}, {3, 28}}, {20, 25, 26, 28}));
test("абвгд", "абвгд", MatchInfo({}, {}));
test("абвввввввгд", "абв*г+д", MatchInfo({}, {}));
test("абвввввввд", "абв*г+д", MatchInfo());
test("LINE\r\nFirst:Second\r\nThird:12\r\n\r\n",
"!dfa;^LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}, {0, 20}, {1, 25}, {2, 26}, {3, 28}}, {}));
test("LINE\r\nFirst:Second\r\n\r\n",
"LINE\r\n(#fieldname([\\u0021-\\u007E&^:]+):#fieldbody([\\u0000-\\u007F&^\r\n]*)\r\n)*\r\n",
MatchInfo({{0, 6}, {1, 11}, {2, 12}, {3, 18}}, {}));
test("C111111111111", "C\\>1*", MatchInfo({}, {}));
// return 0;
test("GET / HTTP/1.1\r\nHost: bibura sosat\r\nLos-es-raus: a\rfaafafdf\r\n\r\n",
test("GET / HTTP/1.1\r\nHost: example.com\r\nAAAAA: a\rfaafafdf\r\n\r\n",
"!dfa;(GET|POST) / HTTP/(1.1|1.0|0.9)\r\n([\\u0021-\\u007E&^:]+:([\\u0000-\\u007F&^\r\n])*\r\n)*\r\n",
MatchInfo());
test("\r24234\r\n", "[\\u0000-\\u007F&^\r\n]*\r\n", MatchInfo());
test("\n3432\r\n", "[\\u0000-\\u007F&^\r\n]*\r\n", MatchInfo());
test("3:::;;432\r\n", "[\\u0000-\\u007F&^\r\n]*\r\n", MatchInfo({}, {}));
test("3:::;;432 \r\n", "[\\u0000-\\u007F&^\r\n]*\r\n", MatchInfo({}, {}));
test("GET / HTTP/0.9\r\nHost: bibura sosat\r\nLos-es-raus: afaafafdf\r\n\r\n",
test("GET / HTTP/0.9\r\nHost: bibur at\r\nContent-type: html\r\n\r\n",
"^(GET|POST\\>) / HTTP/(1.1|1.0|0.9)\r\n([\\u0021-\\u007E&^:]+:([\\u0000-\\u007F&^\r\n])*\r\n)*\r\n",
MatchInfo({}, {}));
// return 0;
test("b", "#boba(b)", MatchInfo({{0, 0}, {1, 1}}, {}));
test("abc", "!selarr{boba{ca}}^a#boba(b)c$", MatchInfo({{0, 1}, {1, 2}}, {1, 2}));
for (int i = 0; i < 64; i++) {

38
src/libregexis024tools/stringmatching.cpp
View File

@ -7,7 +7,8 @@
// using namespace regexis024;
void convert(regexis024::TrackingVariableInfo& to, const SubtrackingNameInfo& from) {
namespace regexis024 {
void convert(TrackingVariableInfo& to, const SubtrackingNameInfo& from) {
#define plagiat(field) to.field = from.field;
plagiat(type);
plagiat(colarr_first);
@ -17,11 +18,11 @@ void convert(regexis024::TrackingVariableInfo& to, const SubtrackingNameInfo& fr
plagiat(selarr_second);
plagiat(stored_in_sa);
#undef plagiat
}
}
int regexis024::matchStrToRegexp(const std::string& input, const std::string& pattern,
int matchStrToRegexp(const std::string& input, const std::string& pattern,
MatchInfo& retMatchInfo, track_var_list& retTrackVarList, std::string& retStatus)
{
{
retTrackVarList = {};
retMatchInfo = MatchInfo();
retStatus = "";
@ -34,14 +35,14 @@ int regexis024::matchStrToRegexp(const std::string& input, const std::string& pa
for (auto& iip: regexp.ktr.track_names) {
convert(retTrackVarList[iip.first], regexp.ktr.retrieval_info[iip.second]);
}
REGEX_IS024_VirtualMachine vm(regexp.compiled_program.size(), regexp.compiled_program.data(),
VirtualMachine vm(regexp.compiled_program.size(), regexp.compiled_program.data(),
UINT64_MAX, UINT16_MAX,
UINT32_MAX, UINT32_MAX, UINT64_MAX);
auto getVMErrString = [&]() -> std::string {
return std::string(regex024_error_code_tostr(vm.getErrno()));
return std::string(error_code_to_str(vm.getErrno()));
};
if (vm.initialize() != regex024_error_codes::stable) {
if (vm.initialize() != error_codes::stable) {
retStatus = "Virtual machine initialization. " + getVMErrString();
return -1;
}
@ -51,11 +52,11 @@ int regexis024::matchStrToRegexp(const std::string& input, const std::string& pa
retStatus = "Unnatural extended input request.";
return -1;
}
if (vm.addNewMatchingThread() != regex024_error_codes::stable) {
if (vm.addNewMatchingThread() != error_codes::stable) {
retStatus = "Virtual machine first kick. " + getVMErrString();
}
if (left_ext_feed) {
if (vm.extendedFeedCharacter('\n') != regex024_error_codes::stable) {
if (vm.extendedFeedCharacter('\n') != error_codes::stable) {
retStatus = "VM left extended input. " + getVMErrString();
return -1;
}
@ -63,19 +64,19 @@ int regexis024::matchStrToRegexp(const std::string& input, const std::string& pa
for (size_t cur_text_pos = 0;cur_text_pos < input.size();) {
int32_t inp_code;
size_t adj;
utf8_string_iterat(inp_code, adj, cur_text_pos, reinterpret_cast<const uint8_t*>(input.data()), input.size());
utf8_string_iterat(inp_code, adj, cur_text_pos, input.data(), input.size());
if (inp_code < 0) {
retStatus = "Input string encoding error.";
return -1;
}
if (vm.feedCharacter(static_cast<uint64_t>(inp_code), adj) != regex024_error_codes::stable) {
if (vm.feedCharacter(static_cast<uint64_t>(inp_code), adj) != error_codes::stable) {
retStatus = "VM input. " + getVMErrString();
return -1;
}
cur_text_pos += adj;
}
if (right_ext_feed) {
if (vm.extendedFeedCharacter('\n') != regex024_error_codes::stable) {
if (vm.extendedFeedCharacter('\n') != error_codes::stable) {
retStatus = "VM right extended input. " + getVMErrString();
return -1;
}
@ -91,18 +92,19 @@ int regexis024::matchStrToRegexp(const std::string& input, const std::string& pa
std::reverse(retMatchInfo.ca_history.begin(), retMatchInfo.ca_history.end());
}
return 0;
}
}
bool regexis024::MatchInfo::operator==(const MatchInfo &other) const {
bool MatchInfo::operator==(const MatchInfo &other) const {
if (!have_match && !other.have_match)
return true;
return (have_match == other.have_match) && (sa == other.sa) && (ca_history == other.ca_history);
}
}
bool regexis024::MatchInfo::operator!=(const MatchInfo &other) const {
bool MatchInfo::operator!=(const MatchInfo &other) const {
return !(*this == other);
}
}
regexis024::MatchInfo::MatchInfo(const std::vector<REGEX_IS024_CAEvent> &ca_history, const std::vector<uint64_t> &sa):
MatchInfo::MatchInfo(const std::vector<CAEvent> &ca_history, const std::vector<uint64_t> &sa):
ca_history(ca_history), sa(sa), have_match(true) {
}
}

6
src/libregexis024tools/stringmatching.h
View File

@ -11,7 +11,7 @@ namespace regexis024 {
bool stored_in_ca = true;
bool stored_in_sa = false;
tracking_var_type type;
tracking_var_type_t type;
/* These fields will be -1 if unused */
int colarr_first = -1;
int colarr_second = -1;
@ -24,7 +24,7 @@ namespace regexis024 {
struct MatchInfo {
bool have_match = false;
std::vector<REGEX_IS024_CAEvent> ca_history;
std::vector<CAEvent> ca_history;
std::vector<uint64_t> sa;
bool operator==(const MatchInfo& other) const ;
@ -32,7 +32,7 @@ namespace regexis024 {
MatchInfo() = default;
MatchInfo(const std::vector<REGEX_IS024_CAEvent> &ca_history, const std::vector<uint64_t> &sa);
MatchInfo(const std::vector<CAEvent> &ca_history, const std::vector<uint64_t> &sa);
};
int matchStrToRegexp(const std::string& input, const std::string& pattern,

311
src/libregexis024vm/instruction_implementation.cpp
View File

@ -1,21 +1,22 @@
#include <libregexis024vm/instruction_implementation.h>
#include <stdexcept>
void swap_old_settled_and_new_active(REGEX_IS024_CONTEXT &ctx, REGEX_IS024_Thread& old_settled){
namespace regexis024 {
void swap_old_settled_and_new_active(VMContext &ctx, Thread& old_settled){
ctx_print_debug(ctx);
assert(old_settled.slot_occupation_status == SLOT_OCCUPIED_val);
REGEX_IS024_Thread temp = old_settled;
Thread temp = old_settled;
old_settled = ctx.active_thread;
old_settled.slot_occupation_status = SLOT_NEW_val;
ctx.active_thread = temp;
// slot_occupation_status & SLOT_OCCUPIED of actie thread is true, because it was retrieved from old_settled
}
// slot_occupation_status & SLOT_OCCUPIED of active thread is true, because it was retrieved from old_settled
}
void start_noncloning_conflict(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Thread& other){
void start_noncloning_conflict(VMContext& ctx, Thread& other){
ctx_print_debug(ctx);
if (ctx.have_sift_function){
ctx.sifting_with = &other;
ctx.who_started_sift = regex024_opcode::READ;
ctx.who_started_sift = opcode_t::READ;
ctx.intruder_IP = ctx.active_thread.IP;
ctx.active_thread.IP = ctx.sift_function;
ctx.RAX = ctx.RBX = 0;
@ -23,14 +24,14 @@ void start_noncloning_conflict(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Thread& oth
ctx.active_thread.delete_thread();
ctx.try_to_continue_scheduled();
}
}
}
/* The one that drops as an intruder here is current active.thread.IP */
void start_cloning_conflict(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Thread& other, regex_near_ptr_t clone_IP){
/* The one that drops as an intruder here is current active.thread.IP */
void start_cloning_conflict(VMContext& ctx, Thread& other, near_ptr_t clone_IP){
ctx_print_debug(ctx);
if (ctx.have_sift_function){
ctx.sifting_with = &other;
ctx.who_started_sift = regex024_opcode::FORK;
ctx.who_started_sift = opcode_t::FORK;
ctx.intruder_IP = ctx.active_thread.IP;
ctx.child_ret_IP = clone_IP;
ctx.active_thread.IP = ctx.sift_function;
@ -38,32 +39,32 @@ void start_cloning_conflict(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Thread& other,
} else {
ctx.active_thread.IP = clone_IP;
}
}
}
#define initialization_phase_check() if (ctx.initialized){ \
ctx.error = regex024_error_codes::too_late; return; }
ctx.error = error_codes::too_late; return; }
#define general_matching_mode_check() if (!ctx.initialized){ \
ctx.error = regex024_error_codes::too_early; return; } if(ctx.sifting_with){ \
ctx.error = regex024_error_codes::instruction_not_for_collision_thread; return; }
ctx.error = error_codes::too_early; return; } if(ctx.sifting_with){ \
ctx.error = error_codes::instruction_not_for_collision_thread; return; }
#define sift_mode_check() if (!ctx.sifting_with){ \
ctx.error = regex024_error_codes::instruction_not_for_collision_thread; return; }
ctx.error = error_codes::instruction_not_for_collision_thread; return; }
/* Can append to both read_halted+new stacks of context */
void read_halted_new_type_stacks_append(REGEX_IS024_CONTEXT &ctx, regex_sslot_id_t ssid){
/* Can append to both read_halted+new stacks of context */
void read_halted_new_type_stacks_append(VMContext &ctx, sslot_id_t ssid){
ctx_print_debug(ctx);
if (ssid < ctx.portion_of_FIRST_read_halt_ns){
ctx.READ_halted_stack_new_first.append(ssid);
} else {
ctx.READ_halted_stack_new_second.append(ssid);
}
}
}
void do_i_read(REGEX_IS024_CONTEXT &ctx, regex_sslot_id_t ssid) {
void do_i_read(VMContext &ctx, sslot_id_t ssid) {
ctx_print_debug(ctx);
general_matching_mode_check()
if (ssid >= ctx.read_slots_number)
smitsya(read_sslot_out_of_range);
REGEX_IS024_Thread& other = ctx.READ_halted_slots[ssid];
Thread& other = ctx.READ_halted_slots[ssid];
if (other.slot_occupation_status & SLOT_OCCUPIED){
if (other.slot_occupation_status & SLOT_NEW){
start_noncloning_conflict(ctx, other);
@ -79,60 +80,60 @@ void do_i_read(REGEX_IS024_CONTEXT &ctx, regex_sslot_id_t ssid) {
read_halted_new_type_stacks_append(ctx, ssid);
ctx.try_to_continue_scheduled();
}
}
}
void i_READ(REGEX_IS024_CONTEXT &ctx) {
void i_READ(VMContext &ctx) {
ctx_print_debug(ctx);
check_available_prg(REGEX024_BYTECODE_SSLOT_ID_SZ)
regex_sslot_id_t ssid = ctx.extract_sslot_id();
check_available_prg(BYTECODE_SSLOT_ID_SZ)
sslot_id_t ssid = ctx.extract_sslot_id();
do_i_read(ctx, ssid);
}
}
void i_READZ(REGEX_IS024_CONTEXT &ctx) {
void i_READZ(VMContext &ctx) {
ctx_print_debug(ctx);
do_i_read(ctx, 0);
}
}
void i_JUMP(REGEX_IS024_CONTEXT& ctx){
void i_JUMP(VMContext& ctx){
ctx_print_debug(ctx);
check_available_prg(REGEX024_BYTECODE_NEAR_POINTER_SZ)
check_available_prg(BYTECODE_NEAR_POINTER_SZ)
ctx.active_thread.IP = ctx.extract_near_pointer();
}
}
template<typename conditionT, typename immArgSzT>
void i_JC(REGEX_IS024_CONTEXT& ctx)
{
template<typename conditionT, typename immArgSzT>
void i_JC(VMContext& ctx)
{
ctx_print_debug(ctx);
check_available_prg(immArgSzT::byte_sz + REGEX024_BYTECODE_NEAR_POINTER_SZ);
check_available_prg(immArgSzT::byte_sz + BYTECODE_NEAR_POINTER_SZ);
uint64_t imm_val_B = immArgSzT::extract(ctx);
regex_near_ptr_t dest = ctx.extract_near_pointer();
near_ptr_t dest = ctx.extract_near_pointer();
uint64_t imm_val_A = ctx.INP;
if (conditionT::call(imm_val_A, imm_val_B))
ctx.active_thread.IP = dest;
}
}
struct condEqual{static bool call(uint64_t A, uint64_t B){return A == B;}};
struct condLess{static bool call(uint64_t A, uint64_t B){return A < B;}};
struct condGrtr{static bool call(uint64_t A, uint64_t B){return A > B;}};
struct condEqual{static bool call(uint64_t A, uint64_t B){return A == B;}};
struct condLess{static bool call(uint64_t A, uint64_t B){return A < B;}};
struct condGrtr{static bool call(uint64_t A, uint64_t B){return A > B;}};
struct immArgByte{
struct immArgByte{
static constexpr int byte_sz = 1;
static uint64_t extract(REGEX_IS024_CONTEXT& ctx){return ctx.extract_b();}
};
struct immArgWord{
static uint64_t extract(VMContext& ctx){return ctx.extract_b();}
};
struct immArgWord{
static constexpr int byte_sz = 2;
static uint64_t extract(REGEX_IS024_CONTEXT& ctx){return ctx.extract_w();}
};
struct immArgDoubleWord{
static uint64_t extract(VMContext& ctx){return ctx.extract_w();}
};
struct immArgDoubleWord{
static constexpr int byte_sz = 4;
static uint64_t extract(REGEX_IS024_CONTEXT& ctx){return ctx.extract_dw();}
};
struct immArgQuadWord{
static uint64_t extract(VMContext& ctx){return ctx.extract_dw();}
};
struct immArgQuadWord{
static constexpr int byte_sz = 8;
static uint64_t extract(REGEX_IS024_CONTEXT& ctx){return ctx.extract_qw();}
};
static uint64_t extract(VMContext& ctx){return ctx.extract_qw();}
};
void clone_thread_into_slot(REGEX_IS024_Thread& source, REGEX_IS024_Thread& vessel){
void clone_thread_into_slot(Thread& source, Thread& vessel){
thread_print_debug(source);
my_assert(!(vessel.slot_occupation_status & SLOT_OCCUPIED));
my_assert((source.slot_occupation_status & SLOT_OCCUPIED));
@ -143,18 +144,18 @@ void clone_thread_into_slot(REGEX_IS024_Thread& source, REGEX_IS024_Thread& vess
if (vessel.SAptr){
vessel.SAptr[0]++;
}
}
}
/* One FORK-slot governs the one single unique position in program: the next one after the fork */
void i_FORK(REGEX_IS024_CONTEXT& ctx){
/* One FORK-slot governs the one single unique position in program: the next one after the fork */
void i_FORK(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
check_available_prg(REGEX024_BYTECODE_SSLOT_ID_SZ + REGEX024_BYTECODE_NEAR_POINTER_SZ);
regex_sslot_id_t ssid = ctx.extract_sslot_id();
regex_near_ptr_t dest = ctx.extract_near_pointer();
check_available_prg(BYTECODE_SSLOT_ID_SZ + BYTECODE_NEAR_POINTER_SZ);
sslot_id_t ssid = ctx.extract_sslot_id();
near_ptr_t dest = ctx.extract_near_pointer();
if (ssid >= ctx.fork_slots_number)
smitsya(fork_sslot_out_of_range);
REGEX_IS024_Thread& other = ctx.FORK_halted_slots[ssid];
Thread& other = ctx.FORK_halted_slots[ssid];
if (other.slot_occupation_status & SLOT_OCCUPIED){
start_cloning_conflict(ctx, other, dest);
} else {
@ -162,9 +163,9 @@ void i_FORK(REGEX_IS024_CONTEXT& ctx){
ctx.active_thread.IP = dest;
ctx.FORK_halted_stack.append(ssid);
}
}
}
void i_MATCH(REGEX_IS024_CONTEXT& ctx){
void i_MATCH(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
if (ctx.matched_thread.slot_occupation_status & SLOT_OCCUPIED){
@ -172,108 +173,108 @@ void i_MATCH(REGEX_IS024_CONTEXT& ctx){
} else {
clone_thread_into_slot(ctx.active_thread, ctx.matched_thread);
}
}
}
void i_DIE(REGEX_IS024_CONTEXT& ctx){
void i_DIE(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
ctx.active_thread.delete_thread();
ctx.try_to_continue_scheduled();
}
}
void i_PARAM_READ_SS_NUMBER(REGEX_IS024_CONTEXT& ctx){
void i_PARAM_READ_SS_NUMBER(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(REGEX024_BYTECODE_SSLOT_ID_SZ)
regex_sslot_id_t read_slots_number = ctx.extract_sslot_id();
check_available_prg(BYTECODE_SSLOT_ID_SZ)
sslot_id_t read_slots_number = ctx.extract_sslot_id();
ctx.read_slots_number = read_slots_number;
}
}
void i_PARAM_FORK_SS_NUMBER(REGEX_IS024_CONTEXT& ctx){
void i_PARAM_FORK_SS_NUMBER(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(REGEX024_BYTECODE_SSLOT_ID_SZ)
regex_sslot_id_t fork_slots_number = ctx.extract_sslot_id();
check_available_prg(BYTECODE_SSLOT_ID_SZ)
sslot_id_t fork_slots_number = ctx.extract_sslot_id();
ctx.fork_slots_number = fork_slots_number;
}
}
void i_PARAM_SELARR_LEN(REGEX_IS024_CONTEXT& ctx){
void i_PARAM_SELARR_LEN(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
regex_tai_t selection_array_len = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
tai_t selection_array_len = ctx.extract_track_array_index();
ctx.selection_array_len = selection_array_len;
}
}
void i_PARAM_COLSIFTFUNC_SET(REGEX_IS024_CONTEXT& ctx){
void i_PARAM_COLSIFTFUNC_SET(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(REGEX024_BYTECODE_NEAR_POINTER_SZ)
regex_near_ptr_t sift_function = ctx.extract_near_pointer();
check_available_prg(BYTECODE_NEAR_POINTER_SZ)
near_ptr_t sift_function = ctx.extract_near_pointer();
ctx.have_sift_function = true;
ctx.sift_function = sift_function;
}
}
void i_PARAM_COLSIFTFUNC_WIPE(REGEX_IS024_CONTEXT& ctx){
void i_PARAM_COLSIFTFUNC_WIPE(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
ctx.have_sift_function = false;
}
}
void i_MSG_MULTISTART_ALLOWED(REGEX_IS024_CONTEXT& ctx){
void i_MSG_MULTISTART_ALLOWED(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(1)
ctx.allows_multistart = (bool)ctx.extract_b();
}
}
void i_MSG_FED_INPUT_EXTENDED(REGEX_IS024_CONTEXT& ctx){
void i_MSG_FED_INPUT_EXTENDED(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
check_available_prg(1 + 1 + REGEX024_BYTECODE_SSLOT_ID_SZ)
check_available_prg(1 + 1 + BYTECODE_SSLOT_ID_SZ)
ctx.fed_input_extends_left = ctx.extract_b();
ctx.fed_input_extends_right = ctx.extract_b();
ctx.portion_of_second_read_halt_ns = ctx.extract_sslot_id();
}
}
uint64_t get_el_from_selarr(uint64_t* sa, regex_near_ptr_t ind){
uint64_t get_el_from_selarr(uint64_t* sa, near_ptr_t ind){
return sa ? sa[1UL + ind] : 0;
}
}
void i_DMOV_RABX_SELARR(REGEX_IS024_CONTEXT& ctx){
void i_DMOV_RABX_SELARR(VMContext& ctx){
ctx_print_debug(ctx);
sift_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
regex_tai_t i1 = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
tai_t i1 = ctx.extract_track_array_index();
if (i1 >= ctx.selection_array_len)
smitsya(selection_arr_out_of_range);
ctx.RAX = get_el_from_selarr(ctx.active_thread.SAptr, i1);
ctx.RBX = get_el_from_selarr(ctx.sifting_with->SAptr, i1);
}
}
uint64_t get_selarr_el_dist(uint64_t* sa, uint16_t start, uint16_t end){
uint64_t get_selarr_el_dist(uint64_t* sa, uint16_t start, uint16_t end){
uint64_t v_start = get_el_from_selarr(sa, start);
uint64_t v_end = get_el_from_selarr(sa, end);
return v_end > v_start ? v_end - v_start : 0;
}
}
void i_DDIST_RABX_SELARR(REGEX_IS024_CONTEXT& ctx){
void i_DDIST_RABX_SELARR(VMContext& ctx){
ctx_print_debug(ctx);
sift_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ * 2)
regex_tai_t i_start = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ * 2)
tai_t i_start = ctx.extract_track_array_index();
if (i_start >= ctx.selection_array_len)
smitsya(selection_arr_out_of_range);
regex_tai_t i_end = ctx.extract_track_array_index();
tai_t i_end = ctx.extract_track_array_index();
if (i_end >= ctx.selection_array_len)
smitsya(selection_arr_out_of_range);
ctx.RAX = get_selarr_el_dist(ctx.active_thread.SAptr, i_start, i_end);
ctx.RBX = get_selarr_el_dist(ctx.sifting_with->SAptr, i_start, i_end);
}
}
void finish_conflict_homesteader_wins(REGEX_IS024_CONTEXT& ctx){
void finish_conflict_homesteader_wins(VMContext& ctx){
ctx_print_debug(ctx);
if (ctx.who_started_sift == regex024_opcodes::READ){
if (ctx.who_started_sift == opcodes::READ){
ctx.active_thread.delete_thread();
ctx.try_to_continue_scheduled();
} else {
@ -282,13 +283,13 @@ void finish_conflict_homesteader_wins(REGEX_IS024_CONTEXT& ctx){
ctx.active_thread.IP = ctx.child_ret_IP;
}
ctx.sifting_with = NULL;
}
}
void finish_conflict_intruder_wins(REGEX_IS024_CONTEXT& ctx){
void finish_conflict_intruder_wins(VMContext& ctx){
ctx_print_debug(ctx);
ctx.sifting_with->delete_thread();
ctx.active_thread.IP = ctx.intruder_IP;
if (ctx.who_started_sift == regex024_opcodes::READ){
if (ctx.who_started_sift == opcodes::READ){
/* noncloning conflict won by intruder+ */
*ctx.sifting_with = ctx.active_thread;
ctx.active_thread.slot_occupation_status = SLOT_EMPTY_val;
@ -299,9 +300,9 @@ void finish_conflict_intruder_wins(REGEX_IS024_CONTEXT& ctx){
ctx.active_thread.IP = ctx.child_ret_IP;
}
ctx.sifting_with = NULL;
}
}
void i_SIFTPRIOR_MIN_RABX(REGEX_IS024_CONTEXT& ctx){
void i_SIFTPRIOR_MIN_RABX(VMContext& ctx){
ctx_print_debug(ctx);
sift_mode_check()
if (ctx.RAX < ctx.RBX){
@ -309,9 +310,9 @@ void i_SIFTPRIOR_MIN_RABX(REGEX_IS024_CONTEXT& ctx){
} else if (ctx.RAX > ctx.RBX){
finish_conflict_homesteader_wins(ctx);
}
}
}
void i_SIFTPRIOR_MAX_RABX(REGEX_IS024_CONTEXT& ctx){
void i_SIFTPRIOR_MAX_RABX(VMContext& ctx){
ctx_print_debug(ctx);
sift_mode_check()
if (ctx.RAX > ctx.RBX){
@ -319,45 +320,45 @@ void i_SIFTPRIOR_MAX_RABX(REGEX_IS024_CONTEXT& ctx){
} else if (ctx.RAX < ctx.RBX){
finish_conflict_homesteader_wins(ctx);
}
}
}
void i_SIFT_DONE(REGEX_IS024_CONTEXT& ctx){
void i_SIFT_DONE(VMContext& ctx){
ctx_print_debug(ctx);
sift_mode_check()
finish_conflict_homesteader_wins(ctx);
}
}
/* Can give errors */
void ca_branch_new_node(REGEX_IS024_CONTEXT& ctx, regex_tai_t key, uint64_t val){
/* Can give errors */
void ca_branch_new_node(VMContext& ctx, tai_t key, uint64_t val){
ctx_print_debug(ctx);
if (ctx.CAN_total >= ctx.CA_TREE_LIMIT)
smitsya(ca_tree_limit_violation);
REGEX024_CollectionArrayNode* node = new REGEX024_CollectionArrayNode{key, val, ctx.active_thread.CAHptr, 1};
CollectionArrayNode* node = new CollectionArrayNode{key, val, ctx.active_thread.CAHptr, 1};
// if (ctx.active_thread.CAHptr)
// (ctx.active_thread.CAHptr->refs)++;
ctx.active_thread.CAHptr = node;
ctx.CAN_total++;
}
}
void i_MOV_COLARR_IMM(REGEX_IS024_CONTEXT& ctx){
void i_MOV_COLARR_IMM(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ + 8)
regex_tai_t ca_ind = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ + 8)
tai_t ca_ind = ctx.extract_track_array_index();
uint64_t imm = ctx.extract_qw();
ca_branch_new_node(ctx, ca_ind, imm);
}
}
void i_MOV_COLARR_BTPOS(REGEX_IS024_CONTEXT& ctx){
void i_MOV_COLARR_BTPOS(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
regex_tai_t ca_ind = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
tai_t ca_ind = ctx.extract_track_array_index();
ca_branch_new_node(ctx, ca_ind, ctx.passed_bytes);
}
}
/* Can throw error, should be placed at the end. Call ONLY in general matching mode */
void edit_selection_array(REGEX_IS024_CONTEXT& ctx, uint64_t key, uint64_t val){
/* Can throw error, should be placed at the end. Call ONLY in general matching mode */
void edit_selection_array(VMContext& ctx, uint64_t key, uint64_t val){
ctx_print_debug(ctx);
uint64_t N = ctx.selection_array_len;
if (key >= N)
@ -382,41 +383,42 @@ void edit_selection_array(REGEX_IS024_CONTEXT& ctx, uint64_t key, uint64_t val){
ctx.active_thread.SAptr[0]--;
ctx.active_thread.SAptr = sa_instance;
}
}
}
void i_MOV_SELARR_IMM(REGEX_IS024_CONTEXT& ctx){
void i_MOV_SELARR_IMM(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ + 8)
regex_tai_t sa_ind = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ + 8)
tai_t sa_ind = ctx.extract_track_array_index();
uint64_t imm = ctx.extract_qw();
edit_selection_array(ctx, sa_ind, imm);
}
}
void i_MOV_SELARR_CHPOS(REGEX_IS024_CONTEXT& ctx){
void i_MOV_SELARR_CHPOS(VMContext& ctx){
ctx_print_debug(ctx);
general_matching_mode_check()
check_available_prg(REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
regex_tai_t sa_ind = ctx.extract_track_array_index();
check_available_prg(BYTECODE_TRACK_ARRAY_INDEX_ID_SZ)
tai_t sa_ind = ctx.extract_track_array_index();
edit_selection_array(ctx, sa_ind, ctx.passed_chars);
}
}
void calloc_stack_slots(REGEX_IS024_Stack& stack, regex_sslot_id_t nmemb) {
assert(stack.sz == 0 && !stack.slots);
regex_sslot_id_t* storage = static_cast<regex_sslot_id_t *>(calloc(nmemb, sizeof(regex_sslot_id_t)));
void calloc_stack_slots(SSID_Stack& stack, sslot_id_t nmemb) {
assert(stack.max_size == 0 && stack.sz == 0 && !stack.slots);
sslot_id_t* storage = static_cast<sslot_id_t *>(calloc(nmemb, sizeof(sslot_id_t)));
if (!storage)
throw std::bad_alloc();
stack.slots = storage;
}
stack.max_size = nmemb;
}
REGEX_IS024_Thread* calloc_slots_array(regex_sslot_id_t nmemb) {
REGEX_IS024_Thread* ptr = static_cast<REGEX_IS024_Thread *>(calloc(nmemb, sizeof(REGEX_IS024_Thread)));
Thread* calloc_slots_array(sslot_id_t nmemb) {
Thread* ptr = static_cast<Thread *>(calloc(nmemb, sizeof(Thread)));
if (!ptr)
throw std::bad_alloc();
return ptr;
}
}
void i_INIT(REGEX_IS024_CONTEXT& ctx){
void i_INIT(VMContext& ctx){
ctx_print_debug(ctx);
initialization_phase_check()
if (ctx.selection_array_len > ctx.SA_LEN_LIMIT)
@ -440,21 +442,21 @@ void i_INIT(REGEX_IS024_CONTEXT& ctx){
ctx.initialized = true;
ctx.unnatural_started_thread_IP = ctx.active_thread.IP;
ctx.active_thread.delete_thread();
}
}
void i_THROW(REGEX_IS024_CONTEXT& ctx){
ctx.error = regex024_error_codes::program_throw;
}
void i_THROW(VMContext& ctx){
ctx.error = error_codes::program_throw;
}
void instruction_table(REGEX_IS024_CONTEXT &ctx) {
void instruction_table(VMContext &ctx) {
ctx_print_debug(ctx);
uint8_t opcode = ctx.extract_instruction();
#define rcase(inst) case regex024_opcodes::inst: return i_ ## inst (ctx);
#define jumpC(UN, st) case regex024_opcodes::JC ## UN ## _B: return i_JC<st, immArgByte>(ctx); \
case regex024_opcodes::JC ## UN ## _W: return i_JC<st, immArgWord>(ctx); \
case regex024_opcodes::JC ## UN ## _DW: return i_JC<st, immArgDoubleWord>(ctx); \
case regex024_opcodes::JC ## UN ## _QW: return i_JC<st, immArgQuadWord>(ctx);
#define rcase(inst) case opcodes::inst: return i_ ## inst (ctx);
#define jumpC(UN, st) case opcodes::JC ## UN ## _B: return i_JC<st, immArgByte>(ctx); \
case opcodes::JC ## UN ## _W: return i_JC<st, immArgWord>(ctx); \
case opcodes::JC ## UN ## _DW: return i_JC<st, immArgDoubleWord>(ctx); \
case opcodes::JC ## UN ## _QW: return i_JC<st, immArgQuadWord>(ctx);
switch (opcode) {
rcase(READ)
rcase(READZ)
@ -486,6 +488,7 @@ void instruction_table(REGEX_IS024_CONTEXT &ctx) {
rcase(INIT)
rcase(THROW)
default:
ctx.error = regex024_error_codes::invalid_opcode;
ctx.error = error_codes::invalid_opcode;
}
}
}

8
src/libregexis024vm/instruction_implementation.h
View File

@ -7,7 +7,7 @@
#include <libregexis024vm/vm_opcodes.h>
#include <assert.h>
#define smitsya(error_type) do {ctx.error = regex024_error_codes::error_type; return; } while (0)
#define smitsya(error_type) do {ctx.error = error_codes::error_type; return; } while (0)
#define SLOT_EMPTY_val 0
#define SLOT_OCCUPIED 1
@ -16,7 +16,7 @@
#define SLOT_NEW_val (SLOT_OCCUPIED | SLOT_NEW)
#define check_available_prg(regionSz) if (!ctx.check_inboundness(regionSz)){ \
ctx.error = regex024_error_codes::improper_finish; return; }
ctx.error = error_codes::improper_finish; return; }
#if defined(LIBREGEXIS024_DEBUG) && defined(LIBREGEXIS024_ALLOW_LOUD)
@ -30,6 +30,8 @@
#define thread_print_debug(thread)
#endif
void instruction_table(REGEX_IS024_CONTEXT& ctx);
namespace regexis024 {
void instruction_table(VMContext& ctx);
}
#endif //LIBREGEXIS024_INSTRUCTION_IMPLEMENTATION_H

7
src/libregexis024vm/libregex024opcodes_stringification.cpp
View File

@ -1,10 +1,10 @@
#include <libregexis024vm/vm_opcodes.h>
#include <libregexis024vm/utils.h>
#define rcase(name) case regex024_opcodes::name: return #name;
const char *regex024_opcode_tostr(regex024_opcode x) {
namespace regexis024 {
const char *opcode_to_str(opcode_t x) {
switch (x) {
#define rcase(name) case opcodes::name: return #name;
rcase(READ)
rcase(READZ)
rcase(JUMP)
@ -44,4 +44,5 @@ const char *regex024_opcode_tostr(regex024_opcode x) {
default:
return "Invalid opcode";
}
}
}

117
src/libregexis024vm/libregexis024vm.h
View File

@ -2,13 +2,13 @@
#define LIBREGEXIS024_LIBREGEXIS024VM_H
/* This thing is bloated. And slow (Because I designed it imperfectly and because it is bloated).
* I could have halven the amount of bloat, but that would require me writing code in headers.
* I am gonna use it for KM, even more bloated project. So I thought that this design is on the spot.
* C++ is such a funny language. Code is divided into .cpp and .h files. But it only makes problems.
* All of my work on this C++ project was not serious from the beginning. It's all funny stuff. */
* I could have halven the amount of bloat, but that would require me writing code in headers.
* I am gonna use it for KM, even more bloated project. So I thought that this design is on the spot.
* C++ is such a funny language. Code is divided into .cpp and .h files. But it only makes problems.
* All of my work on this C++ project was not serious from the beginning. It's all funny stuff. */
/* Also, please, consider using libregexis024vm/libregexis024vm_interface.h
* Naming in this project is super inconsistent. I don't want it to trash your namespace */
* Naming in this project is super inconsistent. I don't want it to trash your namespace */
#include <libregexis024vm/vm_errno.h>
#include <libregexis024vm/utils.h>
@ -16,37 +16,38 @@
#include <stdlib.h>
#include <stdint.h>
struct REGEX_IS024_Stack{
regex_sslot_id_t* slots = NULL;
regex_sslot_id_t sz = 0;
namespace regexis024 {
struct SSID_Stack{
sslot_id_t* slots = NULL;
sslot_id_t max_size = 0;
sslot_id_t sz = 0;
regex_sslot_id_t pop();
void append(regex_sslot_id_t x);
sslot_id_t pop();
void append(sslot_id_t x);
bool empty() const;
bool non_empty() const;
REGEX_IS024_Stack(const REGEX_IS024_Stack&) = delete;
REGEX_IS024_Stack& operator=(const REGEX_IS024_Stack&) = delete;
REGEX_IS024_Stack() = default;
SSID_Stack(const SSID_Stack&) = delete;
SSID_Stack& operator=(const SSID_Stack&) = delete;
SSID_Stack() = default;
~REGEX_IS024_Stack();
};
~SSID_Stack();
};
struct REGEX024_CollectionArrayNode{
struct CollectionArrayNode{
/* Key is small for historical reasons I do not rememeber. Who cares anyway */
regex_tai_t key;
tai_t key;
uint64_t value;
/* NULL at the beginning */
REGEX024_CollectionArrayNode* prev;
CollectionArrayNode* prev;
/* Reference counting */
uint64_t refs = 0;
};
};
struct REGEX_IS024_Thread{
struct Thread{
/* First byte field is used only when thread is located in slot */
uint8_t slot_occupation_status = 0;
regex_near_ptr_t IP = 0;
REGEX024_CollectionArrayNode* CAHptr = NULL;
near_ptr_t IP = 0;
CollectionArrayNode* CAHptr = NULL;
/* Pointer to the seletion array. SA's are reference counted. Because of that every SA
* is elongated by one meta element in the beginning - reference counter. So the actual elements
* are enumerated starting from one. */
@ -54,20 +55,20 @@ struct REGEX_IS024_Thread{
void delete_thread() noexcept;
void debug_print(const char* place);
};
};
struct REGEX_IS024_CONTEXT{
REGEX_IS024_CONTEXT(size_t programSize, const uint8_t *data, uint64_t caTreeLimit, regex_tai_t saLenLimit,
regex_sslot_id_t readSsLimit, regex_sslot_id_t forkSsLimit, uint64_t timeTickLimit);
struct VMContext{
VMContext(size_t programSize, const uint8_t *data, uint64_t caTreeLimit, tai_t saLenLimit,
sslot_id_t readSsLimit, sslot_id_t forkSsLimit, uint64_t timeTickLimit);
regex024_error_code feedSOF();
error_code_t feedSOF();
/* You can safely pile up calls to this command, nothing bad will happen */
regex024_error_code startThread();
regex024_error_code extendedFeedCharacter(uint64_t input);
regex024_error_code feedCharacter(uint64_t INP, uint64_t corresponding_byte_amount);
error_code_t startThread();
error_code_t extendedFeedCharacter(uint64_t input);
error_code_t feedCharacter(uint64_t INP, uint64_t corresponding_byte_amount);
~REGEX_IS024_CONTEXT();
~VMContext();
/* Program size larger than 2^62 is forbidden */
size_t program_size = 0;
@ -78,9 +79,9 @@ struct REGEX_IS024_CONTEXT{
/* CA = Collecton array. */
uint64_t CA_TREE_LIMIT;
/* SA = Selection array */
regex_tai_t SA_LEN_LIMIT;
regex_sslot_id_t READ_SS_LIMIT;
regex_sslot_id_t FORK_SS_LIMIT;
tai_t SA_LEN_LIMIT;
sslot_id_t READ_SS_LIMIT;
sslot_id_t FORK_SS_LIMIT;
/* If time_tick_limit is non-zero, regex virtual machine will stop with error
* after this many ticks. This parameter set's the timeout.*/
@ -93,38 +94,38 @@ struct REGEX_IS024_CONTEXT{
uint64_t CAN_total = 0;
/* Program selects it */
regex_tai_t selection_array_len = 0;
regex_sslot_id_t read_slots_number = 0;
regex_sslot_id_t fork_slots_number = 0;
tai_t selection_array_len = 0;
sslot_id_t read_slots_number = 0;
sslot_id_t fork_slots_number = 0;
bool have_sift_function = false;
regex_near_ptr_t sift_function;
near_ptr_t sift_function;
bool allows_multistart = false;
uint8_t fed_input_extends_left = 0, fed_input_extends_right = 0;
regex_sslot_id_t portion_of_second_read_halt_ns = 0, portion_of_FIRST_read_halt_ns = 0;
sslot_id_t portion_of_second_read_halt_ns = 0, portion_of_FIRST_read_halt_ns = 0;
bool initialized = false;
regex_near_ptr_t unnatural_started_thread_IP = 1337;
regex024_error_code error = regex024_error_codes::stable;
near_ptr_t unnatural_started_thread_IP = 1337;
error_code_t error = error_codes::stable;
REGEX_IS024_Thread* READ_halted_slots;
REGEX_IS024_Stack READ_halted_stack_old;
REGEX_IS024_Stack READ_halted_stack_new_first;
REGEX_IS024_Stack READ_halted_stack_new_second;
REGEX_IS024_Thread* FORK_halted_slots;
REGEX_IS024_Stack FORK_halted_stack;
Thread* READ_halted_slots;
SSID_Stack READ_halted_stack_old;
SSID_Stack READ_halted_stack_new_first;
SSID_Stack READ_halted_stack_new_second;
Thread* FORK_halted_slots;
SSID_Stack FORK_halted_stack;
REGEX_IS024_Thread active_thread;
Thread active_thread;
/* Environment for sifting stuff */
REGEX_IS024_Thread* sifting_with = NULL;
Thread* sifting_with = NULL;
/* specifies the type of operation vm should do after shift (there are only two distinct options) */
uint8_t who_started_sift;
/* Sifting process uses IP field of active thread. Other data of thread is not modified or used during collision
* procudure. Old IP is stored there, if needed */
regex_near_ptr_t child_ret_IP;
regex_near_ptr_t intruder_IP;
near_ptr_t child_ret_IP;
near_ptr_t intruder_IP;
/* RAX corresponds to intruder. Its data is stored in active thread field*/
uint64_t RAX;
/* RBX corresponds to homesteader. Its data is accessible by `REGEX_IS024_Thread* sifting_with` pointer*/
@ -132,7 +133,7 @@ struct REGEX_IS024_CONTEXT{
/* Will be unoccupied if no threads matched. After each feed of character this field will be wiped
* User should take care of intermediate success himself */
REGEX_IS024_Thread matched_thread;
Thread matched_thread;
uint64_t INP = 0;
uint64_t passed_chars = 0;
@ -148,11 +149,11 @@ struct REGEX_IS024_CONTEXT{
uint64_t extract_qw();
uint8_t extract_instruction();
regex_sslot_id_t extract_sslot_id();
regex_near_ptr_t extract_near_pointer();
regex_tai_t extract_track_array_index();
sslot_id_t extract_sslot_id();
near_ptr_t extract_near_pointer();
tai_t extract_track_array_index();
void debug_print(const char* place);
};
};
}
#endif //LIBREGEXIS024_LIBREGEXIS024VM_H

124
src/libregexis024vm/libregexis024vm_context.cpp
View File

@ -1,54 +1,54 @@
#include <stdexcept>
#include <libregexis024vm/libregexis024vm.h>
#include <libregexis024vm/instruction_implementation.h>
#include <utility>
regex_sslot_id_t REGEX_IS024_Stack::pop() {
namespace regexis024 {
sslot_id_t SSID_Stack::pop() {
assert(sz != 0);
return slots[--sz];
}
}
void REGEX_IS024_Stack::append(regex_sslot_id_t x) {
void SSID_Stack::append(sslot_id_t x) {
assert(max_size > 0);
assert(slots);
assert(sz < max_size);
slots[sz] = x;
sz++;
}
}
bool REGEX_IS024_Stack::empty() const {
return !non_empty();
}
bool SSID_Stack::empty() const {
return sz == 0;
}
bool REGEX_IS024_Stack::non_empty() const {
return sz;
}
REGEX_IS024_Stack::~REGEX_IS024_Stack() {
SSID_Stack::~SSID_Stack() {
assert(empty());
free(slots);
}
}
REGEX_IS024_CONTEXT::REGEX_IS024_CONTEXT(size_t programSize, const uint8_t *data,
uint64_t caTreeLimit, regex_tai_t saLenLimit,
regex_sslot_id_t readSsLimit, regex_sslot_id_t forkSsLimit,
VMContext::VMContext(size_t programSize, const uint8_t *data,
uint64_t caTreeLimit, tai_t saLenLimit,
sslot_id_t readSsLimit, sslot_id_t forkSsLimit,
uint64_t timeTickLimit) :
program_size(programSize), prg(data), CA_TREE_LIMIT(caTreeLimit), SA_LEN_LIMIT(saLenLimit),
READ_SS_LIMIT(readSsLimit), FORK_SS_LIMIT(forkSsLimit), time_tick_limit(timeTickLimit)
{
{
if (program_size > (1UL << 62))
exitf("Program is too huge\n");
throw std::runtime_error("Program is too big");
active_thread.slot_occupation_status = SLOT_OCCUPIED;
}
}
/* No only will it launch a wave of deallocation in CA tree, but as a nice bonus it's
/* No only will it launch a wave of deallocation in CA tree, but as a nice bonus it's
* gonna deoccupy slot_occupation_status*/
void REGEX_IS024_Thread::delete_thread() noexcept {
void Thread::delete_thread() noexcept {
thread_print_debug(*this);
my_assert(slot_occupation_status & SLOT_OCCUPIED);
slot_occupation_status = SLOT_EMPTY_val;
REGEX024_CollectionArrayNode* cur_CAptr = CAHptr;
CollectionArrayNode* cur_CAptr = CAHptr;
while (cur_CAptr){
assert(cur_CAptr->refs > 0);
if (--(cur_CAptr->refs) == 0){
REGEX024_CollectionArrayNode* next_CAptr = cur_CAptr->prev;
CollectionArrayNode* next_CAptr = cur_CAptr->prev;
delete cur_CAptr;
cur_CAptr = next_CAptr;
} else
@ -58,33 +58,33 @@ void REGEX_IS024_Thread::delete_thread() noexcept {
if (--(SAptr[0]) == 0)
free(SAptr);
}
}
}
void emptify_one_of_new_read_halted_stacks(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Stack& type_new_stack){
while (type_new_stack.non_empty()){
REGEX_IS024_Thread& thread = ctx.READ_halted_slots[type_new_stack.pop()];
void emptify_one_of_new_read_halted_stacks(VMContext& ctx, SSID_Stack& type_new_stack){
while (!type_new_stack.empty()){
Thread& thread = ctx.READ_halted_slots[type_new_stack.pop()];
assert(thread.slot_occupation_status & SLOT_OCCUPIED);
thread.delete_thread();
}
}
}
/* First it will try to pop pending thread from FORK_halted_stack
/* First it will try to pop pending thread from FORK_halted_stack
* Then it will try popping thread from READ_halted_stack_old (checking if top
* thread here is not actually SLOT_NEW). If something succeded, corresponding slot will be deoccupied, and
* active slot will be occupied with it.
*
* try_to_continue_scheduled() assumes that active thread is unoccupied.*/
void REGEX_IS024_CONTEXT::try_to_continue_scheduled(){
void VMContext::try_to_continue_scheduled(){
ctx_print_debug(*this);
my_assert(!(active_thread.slot_occupation_status & SLOT_OCCUPIED));
if (FORK_halted_stack.sz){
regex_sslot_id_t ssid = FORK_halted_stack.pop();
sslot_id_t ssid = FORK_halted_stack.pop();
active_thread = FORK_halted_slots[ssid];
FORK_halted_slots[ssid].slot_occupation_status = SLOT_EMPTY_val;
return;
}
while (READ_halted_stack_old.sz){
regex_sslot_id_t ssid = READ_halted_stack_old.pop();
sslot_id_t ssid = READ_halted_stack_old.pop();
if (READ_halted_slots[ssid].slot_occupation_status & SLOT_NEW){
/* This is the case when old thread was silently replaced by settled new thread */
continue;
@ -94,30 +94,30 @@ void REGEX_IS024_CONTEXT::try_to_continue_scheduled(){
return;
}
/* Failure here will be detected. We started with unoccupied active thread. iterator inside kick will see it */
}
}
void kick(REGEX_IS024_CONTEXT& ctx) {
void kick(VMContext& ctx) {
ctx_print_debug(ctx);
while ((ctx.active_thread.slot_occupation_status & SLOT_OCCUPIED)
&& ctx.error == regex024_error_codes::stable){
&& ctx.error == error_codes::stable){
if (ctx.timer >= ctx.time_tick_limit)
smitsya(timeout);
ctx.timer++;
check_available_prg(REGEX024_BYTECODE_INSTRUCTION_SZ) // May return from kick(ctx)
check_available_prg(BYTECODE_INSTRUCTION_SZ) // May return from kick(ctx)
// smivanie from those instructions will be immediately detected. Everything is OK
instruction_table(ctx);
}
}
}
regex024_error_code REGEX_IS024_CONTEXT::feedSOF() {
error_code_t VMContext::feedSOF() {
ctx_print_debug(*this);
kick(*this);
return error;
}
}
regex024_error_code REGEX_IS024_CONTEXT::startThread() {
error_code_t VMContext::startThread() {
ctx_print_debug(*this);
active_thread.slot_occupation_status = SLOT_OCCUPIED;
active_thread.IP = unnatural_started_thread_IP;
@ -125,31 +125,22 @@ regex024_error_code REGEX_IS024_CONTEXT::startThread() {
active_thread.CAHptr = NULL;
kick(*this);
return error;
}
}
/* I hate C++ (aka antichrist), won't use move sementic (aka drink cornsyrup) */
void swap_stacks(REGEX_IS024_Stack& A, REGEX_IS024_Stack& B) {
std::swap(A.sz, B.sz);
std::swap(A.slots, B.slots);
}
void fill_empty_old_read_halted_stack(REGEX_IS024_CONTEXT& ctx, REGEX_IS024_Stack& read_halted_stack_new){
void fill_empty_old_read_halted_stack(VMContext& ctx, SSID_Stack& read_halted_stack_new){
ctx_print_debug(ctx);
my_assert(!ctx.READ_halted_stack_old.non_empty());
// Actually, READ_halted_stack_old is always empty in this case
assert(ctx.READ_halted_stack_old.empty());
swap_stacks(ctx.READ_halted_stack_old, read_halted_stack_new);
for (uint32_t i = 0; i < ctx.READ_halted_stack_old.sz; i++){
REGEX_IS024_Thread& slot = ctx.READ_halted_slots[ctx.READ_halted_stack_old.slots[i]];
/* Should get rid of 'NEW' qualifier */
assert(slot.slot_occupation_status & SLOT_OCCUPIED);
if (slot.slot_occupation_status & SLOT_OCCUPIED)
slot.slot_occupation_status = SLOT_OCCUPIED;
while (!read_halted_stack_new.empty()) {
sslot_id_t sr = read_halted_stack_new.pop();
Thread& slot = ctx.READ_halted_slots[sr];
assert(slot.slot_occupation_status & SLOT_NEW_val);
slot.slot_occupation_status = SLOT_OCCUPIED_val;
ctx.READ_halted_stack_old.append(sr);
}
}
}
regex024_error_code REGEX_IS024_CONTEXT::feedCharacter(uint64_t input, uint64_t corresponding_byte_amount) {
error_code_t VMContext::feedCharacter(uint64_t input, uint64_t corresponding_byte_amount) {
ctx_print_debug(*this);
if (matched_thread.slot_occupation_status & SLOT_OCCUPIED)
matched_thread.delete_thread();
@ -161,9 +152,9 @@ regex024_error_code REGEX_IS024_CONTEXT::feedCharacter(uint64_t input, uint64_t
try_to_continue_scheduled();
kick(*this);
return error;
}
}
regex024_error_code REGEX_IS024_CONTEXT::extendedFeedCharacter(uint64_t input) {
error_code_t VMContext::extendedFeedCharacter(uint64_t input) {
ctx_print_debug(*this);
if (matched_thread.slot_occupation_status & SLOT_OCCUPIED)
matched_thread.delete_thread();
@ -172,21 +163,21 @@ regex024_error_code REGEX_IS024_CONTEXT::extendedFeedCharacter(uint64_t input) {
try_to_continue_scheduled();
kick(*this);
return error;
}
}
REGEX_IS024_CONTEXT::~REGEX_IS024_CONTEXT() {
VMContext::~VMContext() {
ctx_print_debug(*this);
if (initialized){
emptify_one_of_new_read_halted_stacks(*this, READ_halted_stack_new_first);
emptify_one_of_new_read_halted_stacks(*this, READ_halted_stack_new_second);
while (READ_halted_stack_old.non_empty()){
REGEX_IS024_Thread& thread = READ_halted_slots[READ_halted_stack_old.pop()];
while (!READ_halted_stack_old.empty()){
Thread& thread = READ_halted_slots[READ_halted_stack_old.pop()];
assert(thread.slot_occupation_status & SLOT_OCCUPIED);
if (!(thread.slot_occupation_status & SLOT_NEW))
thread.delete_thread();
}
free(READ_halted_slots);
while (FORK_halted_stack.non_empty())
while (!FORK_halted_stack.empty())
FORK_halted_slots[FORK_halted_stack.pop()].delete_thread();
free(FORK_halted_slots);
@ -194,4 +185,5 @@ REGEX_IS024_CONTEXT::~REGEX_IS024_CONTEXT() {
matched_thread.delete_thread();
}
}
}
}

36
src/libregexis024vm/libregexis024vm_disassembly.cpp
View File

@ -1,38 +1,40 @@
#include <libregexis024vm/libregexis024vm.h>
#include <libregexis024vm/vm_opcodes.h>
bool REGEX_IS024_CONTEXT::check_inboundness(int region){
namespace regexis024 {
bool VMContext::check_inboundness(int region){
return vmprog_check_inboundness(program_size, active_thread.IP, region);
}
}
uint8_t REGEX_IS024_CONTEXT::extract_b() {
uint8_t VMContext::extract_b() {
return vmprog_extract_b(&active_thread.IP, prg);
}
}
uint16_t REGEX_IS024_CONTEXT::extract_w() {
uint16_t VMContext::extract_w() {
return vmprog_extract_w(&active_thread.IP, prg);
}
}
uint32_t REGEX_IS024_CONTEXT::extract_dw() {
uint32_t VMContext::extract_dw() {
return vmprog_extract_dw(&active_thread.IP, prg);
}
}
uint64_t REGEX_IS024_CONTEXT::extract_qw() {
uint64_t VMContext::extract_qw() {
return vmprog_extract_qw(&active_thread.IP, prg);
}
}
uint8_t REGEX_IS024_CONTEXT::extract_instruction() {
uint8_t VMContext::extract_instruction() {
return extract_b();
}
}
regex_sslot_id_t REGEX_IS024_CONTEXT::extract_sslot_id() {
sslot_id_t VMContext::extract_sslot_id() {
return extract_dw();
}
}
regex_near_ptr_t REGEX_IS024_CONTEXT::extract_near_pointer() {
near_ptr_t VMContext::extract_near_pointer() {
return extract_qw();
}
}
regex_tai_t REGEX_IS024_CONTEXT::extract_track_array_index() {
tai_t VMContext::extract_track_array_index() {
return extract_w();
}
}

101
src/libregexis024vm/libregexis024vm_interface.cpp
View File

@ -1,105 +1,106 @@
#include <stdexcept>
#include <libregexis024vm/libregexis024vm_interface.h>
#include <libregexis024vm/libregexis024vm.h>
#include <libregexis024vm/instruction_implementation.h>
bool REGEX_IS024_CAEvent::operator==(const REGEX_IS024_CAEvent &other) const {
namespace regexis024 {
bool CAEvent::operator==(const CAEvent &other) const {
return (key == other.key) && (value == other.value);
}
}
#define reveal ((REGEX_IS024_CONTEXT*)opaque)
#define reveal ((VMContext*)opaque)
REGEX_IS024_VirtualMachine::REGEX_IS024_VirtualMachine(size_t programSize, const uint8_t *data,
uint64_t caTreeLimit, regex_tai_t saLenLimit,
regex_sslot_id_t readSsLimit, regex_sslot_id_t forkSsLimit,
VirtualMachine::VirtualMachine(size_t programSize, const uint8_t *data,
uint64_t caTreeLimit, tai_t saLenLimit,
sslot_id_t readSsLimit, sslot_id_t forkSsLimit,
uint64_t timeTickLimit) {
opaque = new REGEX_IS024_CONTEXT(programSize, data, caTreeLimit, saLenLimit,
opaque = new VMContext(programSize, data, caTreeLimit, saLenLimit,
readSsLimit, forkSsLimit, timeTickLimit);
}
}
regex024_error_code REGEX_IS024_VirtualMachine::initialize() {
error_code_t VirtualMachine::initialize() {
if (gave_SOF)
exitf("double feedSOF\n");
throw std::runtime_error("double feedSOF\n");
gave_SOF = true;
return reveal->feedSOF();
}
}
bool REGEX_IS024_VirtualMachine::isInitialized() {
bool VirtualMachine::isInitialized() {
return reveal->initialized;
}
}
bool REGEX_IS024_VirtualMachine::isUsable() {
return isInitialized() && reveal->error == regex024_error_codes::stable;
}
bool VirtualMachine::isUsable() {
return isInitialized() && reveal->error == error_codes::stable;
}
REGEX_IS024_VirtualMachine::~REGEX_IS024_VirtualMachine() {
VirtualMachine::~VirtualMachine() {
delete reveal;
}
}
regex_tai_t REGEX_IS024_VirtualMachine::getSelectionArrayLength() {
tai_t VirtualMachine::getSelectionArrayLength() {
return isUsable() ? reveal->selection_array_len : 0;
}
}
bool REGEX_IS024_VirtualMachine::isAllowMultistart() {
bool VirtualMachine::isAllowMultistart() {
return isUsable() ? reveal->allows_multistart : false;
}
}
uint8_t REGEX_IS024_VirtualMachine::getInputLeftExtensionSize() {
uint8_t VirtualMachine::getInputLeftExtensionSize() {
return isUsable() ? reveal->fed_input_extends_left : 0;
}
}
uint8_t REGEX_IS024_VirtualMachine::getInputRightExtensionSize() {
uint8_t VirtualMachine::getInputRightExtensionSize() {
return isUsable() ? reveal->fed_input_extends_right : 0;
}
}
regex024_error_code REGEX_IS024_VirtualMachine::getErrno() {
error_code_t VirtualMachine::getErrno() {
return reveal->error;
}
}
/* Stupid kinda function. Checks if somebody is ready to continue reading the actual string */
bool REGEX_IS024_VirtualMachine::haveSurvivors() {
return isUsable() && (reveal->READ_halted_stack_new_first.non_empty());
}
/* Stupid kinda function. Checks if somebody is ready to continue reading the actual string or extended l-r input */
bool VirtualMachine::haveSurvivors() {
return isUsable() && (!reveal->READ_halted_stack_new_first.empty() || !reveal->READ_halted_stack_new_second.empty());
}
bool REGEX_IS024_VirtualMachine::isMatched() {
bool VirtualMachine::isMatched() {
return isUsable() && static_cast<bool>((reveal->matched_thread.slot_occupation_status & SLOT_OCCUPIED));
}
}
std::vector<REGEX_IS024_CAEvent> REGEX_IS024_VirtualMachine::getMatchedThreadCABranchReverse() {
std::vector<CAEvent> VirtualMachine::getMatchedThreadCABranchReverse() {
if (!isMatched())
return {};
std::vector<REGEX_IS024_CAEvent> res;
REGEX024_CollectionArrayNode* cur = reveal->matched_thread.CAHptr;
std::vector<CAEvent> res;
CollectionArrayNode* cur = reveal->matched_thread.CAHptr;
while (cur != NULL){
res.push_back({cur->key, cur->value});
cur = cur->prev;
}
return res;
}
}
uint64_t REGEX_IS024_VirtualMachine::getMatchedThreadSAValue(uint16_t key) {
uint64_t VirtualMachine::getMatchedThreadSAValue(uint16_t key) {
if (key >= getSelectionArrayLength())
return 0;
if (!isMatched())
return 0;
return reveal->matched_thread.SAptr ? reveal->matched_thread.SAptr[key + 1] : 0;
}
}
regex024_error_code REGEX_IS024_VirtualMachine::addNewMatchingThread() {
error_code_t VirtualMachine::addNewMatchingThread() {
if (!isUsable())
exitf("unusable\n");
// if (started_first_thread && !isAllowMultistart())
// exitf("Multistart is forbidden, bad usage of program\n");
throw std::runtime_error("unusable");
return reveal->startThread();
}
}
regex024_error_code REGEX_IS024_VirtualMachine::extendedFeedCharacter(uint64_t input) {
error_code_t VirtualMachine::extendedFeedCharacter(uint64_t input) {
if (!isUsable())
exitf("unusable\n");
throw std::runtime_error("unusable\n");
return reveal->extendedFeedCharacter(input);
}
}
regex024_error_code REGEX_IS024_VirtualMachine::feedCharacter(uint64_t input, uint64_t bytesResembled) {
error_code_t VirtualMachine::feedCharacter(uint64_t input, uint64_t bytesResembled) {
if (!isUsable())
exitf("unusable\n");
throw std::runtime_error("unusable\n");
return reveal->feedCharacter(input, bytesResembled);
}
}

39
src/libregexis024vm/libregexis024vm_interface.h
View File

@ -6,41 +6,42 @@
#include <libregexis024vm/vm_errno.h>
#include <libregexis024vm/vm_opcodes_types.h>
struct REGEX_IS024_CAEvent{
regex_tai_t key;
namespace regexis024 {
struct CAEvent{
tai_t key;
uint64_t value;
bool operator==(const REGEX_IS024_CAEvent& other) const;
};
bool operator==(const CAEvent& other) const;
};
class REGEX_IS024_VirtualMachine{
public:
REGEX_IS024_VirtualMachine(size_t programSize, const uint8_t *data, uint64_t caTreeLimit, uint16_t saLenLimit,
struct VirtualMachine{
VirtualMachine(size_t programSize, const uint8_t *data, uint64_t caTreeLimit, uint16_t saLenLimit,
uint32_t readSsLimit, uint32_t forkSsLimit, uint64_t timeTickLimit);
REGEX_IS024_VirtualMachine(const REGEX_IS024_VirtualMachine& ) = delete;
REGEX_IS024_VirtualMachine& operator=(const REGEX_IS024_VirtualMachine&) = delete;
VirtualMachine(const VirtualMachine& ) = delete;
VirtualMachine& operator=(const VirtualMachine&) = delete;
regex024_error_code initialize();
error_code_t initialize();
bool isInitialized();
bool isUsable();
virtual ~REGEX_IS024_VirtualMachine();
regex_tai_t getSelectionArrayLength();
virtual ~VirtualMachine();
tai_t getSelectionArrayLength();
bool isAllowMultistart();
uint8_t getInputLeftExtensionSize();
uint8_t getInputRightExtensionSize();
regex024_error_code getErrno();
error_code_t getErrno();
bool haveSurvivors();
bool isMatched();
std::vector<REGEX_IS024_CAEvent> getMatchedThreadCABranchReverse();
std::vector<CAEvent> getMatchedThreadCABranchReverse();
uint64_t getMatchedThreadSAValue(uint16_t key);
regex024_error_code addNewMatchingThread();
regex024_error_code extendedFeedCharacter(uint64_t input);
regex024_error_code feedCharacter(uint64_t input, uint64_t bytesResembled);
error_code_t addNewMatchingThread();
error_code_t extendedFeedCharacter(uint64_t input);
error_code_t feedCharacter(uint64_t input, uint64_t bytesResembled);
private:
private:
bool gave_SOF = false;
void* opaque;
};
};
}
#endif //LIBREGEXIS024_LIBREGEXIS024VM_INTERFACE_H

42
src/libregexis024vm/utils.cpp
View File

@ -10,35 +10,28 @@
#error "Big endian is currently unsupported"
#endif
void exitf(const char *fmt, ...) {
va_list va;
va_start(va, fmt);
vfprintf(stderr, fmt, va);
va_end(va);
exit(1);
}
int utf8_retrieve_size(uint8_t firstByte) {
if (!(firstByte & 0b10000000))
namespace regexis024 {
int utf8_retrieve_size(char firstByte) {
if (!((uint8_t)firstByte & 0b10000000))
return 1;
uint8_t a = 0b11000000;
uint8_t b = 0b00100000;
for (int i = 2; i <= 4; i++){
if ((firstByte & (a | b)) == a)
if (((uint8_t)firstByte & (a | b)) == a)
return i;
a |= b;
b >>= 1;
}
return -1;
}
}
int32_t utf8_retrieve_character(int sz, size_t pos, const uint8_t *string) {
int32_t utf8_retrieve_character(int sz, size_t pos, const char *string) {
if (sz == 1)
return string[pos];
uint32_t v = string[pos] & (0b01111111 >> sz);
return (uint8_t)string[pos];
uint32_t v = (uint8_t)string[pos] & (0b01111111 >> sz);
pos++;
for (int i = 1; i < sz; i++){
uint32_t th = string[pos];
uint32_t th = (uint8_t)string[pos];
if ((th & 0b11000000) != 0b10000000)
return -1;
v <<= 6;
@ -47,18 +40,16 @@ int32_t utf8_retrieve_character(int sz, size_t pos, const uint8_t *string) {
}
assert(v <= INT32_MAX);
return static_cast<int32_t>(v);
}
}
#define AAAAAA {cp = -1; return;}
void utf8_string_iterat(int32_t &cp, size_t &adj, size_t pos, const uint8_t *string, size_t string_size) {
if (pos >= string_size) AAAAAA
void utf8_string_iterat(int32_t &cp, size_t &adj, size_t pos, const char *string, size_t string_size) {
if (pos >= string_size) {cp = -1; return;}
adj = utf8_retrieve_size(string[pos]);
if (adj < 0 || pos + adj > string_size) AAAAAA
if ((cp = utf8_retrieve_character(adj, pos, string)) < 0) AAAAAA
}
if (adj < 0 || pos + adj > string_size) {cp = -1; return;}
if ((cp = utf8_retrieve_character(adj, pos, string)) < 0) {cp = -1;}
}
bool is_string_in_stringset(const char *strSample, const char **strSet) {
bool is_string_in_stringset(const char *strSample, const char **strSet) {
const char** cmpSubject = strSet;
while ((*cmpSubject) != NULL){
if (strcmp(strSample, *cmpSubject) == 0)
@ -66,4 +57,5 @@ bool is_string_in_stringset(const char *strSample, const char **strSet) {
cmpSubject++; // += 8 bytes
}
return false;
}
}

19
src/libregexis024vm/utils.h
View File

@ -4,18 +4,19 @@
#include <stdint.h>
#include <stdlib.h>
void exitf(const char* fmt, ...);
// todo: move this file out from my eyes.
namespace regexis024 {
/* 1, 2, 3, 4 on success; -1 on error */
int utf8_retrieve_size(char firstByte);
/* 1, 2, 3, 4 on success; -1 on error */
int utf8_retrieve_size(uint8_t firstByte);
/* sz is a positive value returned by utf8_retrieve_size. Returns negative on error */
int32_t utf8_retrieve_character(int sz, size_t pos, const char* string);
/* sz is a positive value returned by utf8_retrieve_size. Returns negative on error */
int32_t utf8_retrieve_character(int sz, size_t pos, const uint8_t* string);
/* cp is negative on error. adj is the size of letter in bytes. Can be used to adjust pos.
/* cp is negative on error. adj is the size of letter in bytes. Can be used to adjust pos.
* All safety checks will be performed */
void utf8_string_iterat(int32_t& cp, size_t& adj, size_t pos, const uint8_t* string, size_t string_size);
void utf8_string_iterat(int32_t& cp, size_t& adj, size_t pos, const char* string, size_t string_size);
bool is_string_in_stringset(const char* strSample, const char* strSet[]);
bool is_string_in_stringset(const char* strSample, const char* strSet[]);
}
#endif //LIBREGEXIS024_UTILS_H

6
src/libregexis024vm/vm_errno.cpp
View File

@ -1,7 +1,8 @@
#include <libregexis024vm/vm_errno.h>
const char *regex024_error_code_tostr(regex024_error_code x) {
#define rcase(name) case regex024_error_codes::name: return #name;
namespace regexis024 {
const char *error_code_to_str(error_code_t x) {
#define rcase(name) case error_codes::name: return #name;
switch (x) {
rcase(stable)
rcase(ca_tree_limit_violation)
@ -23,4 +24,5 @@ const char *regex024_error_code_tostr(regex024_error_code x) {
default:
return "unknown_error_code";
}
}
}

12
src/libregexis024vm/vm_errno.h
View File

@ -3,7 +3,8 @@
#include <stdint.h>
namespace regex024_error_codes {
namespace regexis024 {
namespace error_codes {
enum regex024_error_code_I: int {
stable = 0,
ca_tree_limit_violation = -1,
@ -36,10 +37,11 @@ namespace regex024_error_codes {
/* O_o */
bad_alloc = -17,
};
}
typedef error_codes::regex024_error_code_I error_code_t;
const char* error_code_to_str(error_code_t x);
}
typedef regex024_error_codes::regex024_error_code_I regex024_error_code;
const char* regex024_error_code_tostr(regex024_error_code x);
#endif //LIBREGEXIS024_VM_ERRNO_H

48
src/libregexis024vm/vm_opcodes.h
View File

@ -3,7 +3,8 @@
#include <libregexis024vm/vm_opcodes_types.h>
namespace regex024_opcodes {
namespace regexis024 {
namespace opcodes {
enum regex024_opcode_I: uint8_t{
/* READ <Settlement ID> */
READ = 0,
@ -72,28 +73,27 @@ namespace regex024_opcodes {
THROW = 35,
regex024_opcode_greaterMax = 36
};
}
typedef opcodes::regex024_opcode_I opcode_t;
const char* opcode_to_str(opcode_t x);
constexpr uint64_t BYTECODE_INSTRUCTION_SZ = 1;
constexpr uint64_t BYTECODE_SSLOT_ID_SZ = 4;
constexpr uint64_t BYTECODE_TRACK_ARRAY_INDEX_ID_SZ = 2;
constexpr uint64_t BYTECODE_NEAR_POINTER_SZ = 8;
bool vmprog_check_inboundness(near_ptr_t prgSize, near_ptr_t IP, near_ptr_t region);
uint8_t vmprog_extract_b(near_ptr_t* IPptr, const uint8_t* prg);
uint16_t vmprog_extract_w(near_ptr_t* IPptr, const uint8_t* prg);
uint32_t vmprog_extract_dw(near_ptr_t* IPptr, const uint8_t* prg);
uint64_t vmprog_extract_qw(near_ptr_t* IPptr, const uint8_t* prg);
uint8_t vmprog_extract_instruction(near_ptr_t* IPptr, const uint8_t* prg);
sslot_id_t vmprog_extract_sslot_id(near_ptr_t* IPptr, const uint8_t* prg);
near_ptr_t vmprog_extract_near_pointer(near_ptr_t* IPptr, const uint8_t* prg);
tai_t vmprog_extrack_track_array_index(near_ptr_t* IPptr, const uint8_t* prg);
}
typedef regex024_opcodes::regex024_opcode_I regex024_opcode;
const char* regex024_opcode_tostr(regex024_opcode x);
constexpr uint64_t REGEX024_BYTECODE_INSTRUCTION_SZ = 1;
constexpr uint64_t REGEX024_BYTECODE_SSLOT_ID_SZ = 4;
constexpr uint64_t REGEX024_BYTECODE_TRACK_ARRAY_INDEX_ID_SZ = 2;
constexpr uint64_t REGEX024_BYTECODE_NEAR_POINTER_SZ = 8;
bool vmprog_check_inboundness(regex_near_ptr_t prgSize, regex_near_ptr_t IP, regex_near_ptr_t region);
uint8_t vmprog_extract_b(regex_near_ptr_t* IPptr, const uint8_t* prg);
uint16_t vmprog_extract_w(regex_near_ptr_t* IPptr, const uint8_t* prg);
uint32_t vmprog_extract_dw(regex_near_ptr_t* IPptr, const uint8_t* prg);
uint64_t vmprog_extract_qw(regex_near_ptr_t* IPptr, const uint8_t* prg);
uint8_t vmprog_extract_instruction(regex_near_ptr_t* IPptr, const uint8_t* prg);
regex_sslot_id_t vmprog_extract_sslot_id(regex_near_ptr_t* IPptr, const uint8_t* prg);
regex_near_ptr_t vmprog_extract_near_pointer(regex_near_ptr_t* IPptr, const uint8_t* prg);
regex_tai_t vmprog_extrack_track_array_index(regex_near_ptr_t* IPptr, const uint8_t* prg);
#endif //LIBREGEXIS024_VM_OPCODES_H

61
src/libregexis024vm/vm_opcodes_disassembly.cpp
View File

@ -1,47 +1,54 @@
#include <libregexis024vm/vm_opcodes.h>
#ifndef __ORDER_LITTLE_ENDIAN__
#error "Big endian is currently unsupported"
#endif
bool vmprog_check_inboundness(regex_near_ptr_t prgSz, regex_near_ptr_t IP, regex_near_ptr_t region) {
namespace regexis024 {
bool vmprog_check_inboundness(near_ptr_t prgSz, near_ptr_t IP, near_ptr_t region) {
return IP + region <= prgSz;
}
}
uint8_t vmprog_extract_b(regex_near_ptr_t *IPptr, const uint8_t *prg) {
uint8_t vmprog_extract_b(near_ptr_t *IPptr, const uint8_t *prg) {
return prg[(*IPptr)++];
}
}
uint16_t vmprog_extract_w(regex_near_ptr_t *IPptr, const uint8_t *prg) {
uint16_t answer = *(uint16_t*)(&prg[*IPptr]);
*IPptr += 2;
uint16_t vmprog_extract_w(near_ptr_t *IPptr, const uint8_t *prg) {
uint16_t answer = 0;
(*IPptr) += 2;
for (int i = 1; i < 3; i++) {
answer <<= 8; answer |= prg[(*IPptr) - i];
}
return answer;
}
}
uint32_t vmprog_extract_dw(regex_near_ptr_t *IPptr, const uint8_t *prg) {
uint32_t answer = *(uint32_t *)(&prg[*IPptr]);
*IPptr += 4;
uint32_t vmprog_extract_dw(near_ptr_t *IPptr, const uint8_t *prg) {
uint32_t answer = 0;
(*IPptr) += 4;
for (int i = 1; i < 5; i++) {
answer <<= 8; answer |= prg[(*IPptr) - i];
}
return answer;
}
}
uint64_t vmprog_extract_qw(regex_near_ptr_t *IPptr, const uint8_t *prg) {
uint64_t answer = *(uint64_t *)(&prg[*IPptr]);
*IPptr += 8;
uint64_t vmprog_extract_qw(near_ptr_t *IPptr, const uint8_t *prg) {
uint64_t answer = 0;
(*IPptr) += 8;
for (int i = 1; i < 9; i++) {
answer <<= 8; answer |= prg[(*IPptr) - i];
}
return answer;
}
}
uint8_t vmprog_extract_instruction(regex_near_ptr_t *IPptr, const uint8_t *prg) {
uint8_t vmprog_extract_instruction(near_ptr_t *IPptr, const uint8_t *prg) {
return vmprog_extract_b(IPptr, prg);
}
}
regex_sslot_id_t vmprog_extract_sslot_id(regex_near_ptr_t *IPptr, const uint8_t *prg) {
sslot_id_t vmprog_extract_sslot_id(near_ptr_t *IPptr, const uint8_t *prg) {
return vmprog_extract_dw(IPptr, prg);
}
}
regex_near_ptr_t vmprog_extract_near_pointer(regex_near_ptr_t *IPptr, const uint8_t *prg) {
near_ptr_t vmprog_extract_near_pointer(near_ptr_t *IPptr, const uint8_t *prg) {
return vmprog_extract_qw(IPptr, prg);
}
}
regex_tai_t vmprog_extrack_track_array_index(regex_near_ptr_t *IPptr, const uint8_t *prg) {
tai_t vmprog_extrack_track_array_index(near_ptr_t *IPptr, const uint8_t *prg) {
return vmprog_extract_w(IPptr, prg);
}
}

9
src/libregexis024vm/vm_opcodes_types.h
View File

@ -3,9 +3,10 @@
#include <stdint.h>
typedef uint32_t regex_sslot_id_t;
typedef uint64_t regex_near_ptr_t;
typedef uint16_t regex_tai_t;
namespace regexis024 {
typedef uint32_t sslot_id_t;
typedef uint64_t near_ptr_t;
typedef uint16_t tai_t;
}
#endif //VM_OPCODES_TYPES_H