106 lines
3.6 KiB
C++
106 lines
3.6 KiB
C++
#include <stdexcept>
|
|
#include <libregexis024vm/libregexis024vm_interface.h>
|
|
#include <libregexis024vm/libregexis024vm.h>
|
|
#include <libregexis024vm/instruction_implementation.h>
|
|
|
|
namespace regexis024 {
|
|
bool CAEvent::operator==(const CAEvent &other) const {
|
|
return (key == other.key) && (value == other.value);
|
|
}
|
|
|
|
#define reveal ((VMContext*)opaque)
|
|
|
|
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 VMContext(programSize, data, caTreeLimit, saLenLimit,
|
|
readSsLimit, forkSsLimit, timeTickLimit);
|
|
}
|
|
|
|
error_code_t VirtualMachine::initialize() {
|
|
if (gave_SOF)
|
|
throw std::runtime_error("double feedSOF\n");
|
|
gave_SOF = true;
|
|
return reveal->feedSOF();
|
|
}
|
|
|
|
bool VirtualMachine::isInitialized() {
|
|
return reveal->initialized;
|
|
}
|
|
|
|
bool VirtualMachine::isUsable() {
|
|
return isInitialized() && reveal->error == error_codes::stable;
|
|
}
|
|
|
|
VirtualMachine::~VirtualMachine() {
|
|
delete reveal;
|
|
}
|
|
|
|
tai_t VirtualMachine::getSelectionArrayLength() {
|
|
return isUsable() ? reveal->selection_array_len : 0;
|
|
}
|
|
|
|
bool VirtualMachine::isAllowMultistart() {
|
|
return isUsable() ? reveal->allows_multistart : false;
|
|
}
|
|
|
|
uint8_t VirtualMachine::getInputLeftExtensionSize() {
|
|
return isUsable() ? reveal->fed_input_extends_left : 0;
|
|
}
|
|
|
|
uint8_t VirtualMachine::getInputRightExtensionSize() {
|
|
return isUsable() ? reveal->fed_input_extends_right : 0;
|
|
}
|
|
|
|
error_code_t VirtualMachine::getErrno() {
|
|
return reveal->error;
|
|
}
|
|
|
|
/* 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 VirtualMachine::isMatched() {
|
|
return isUsable() && static_cast<bool>((reveal->matched_thread.slot_occupation_status & SLOT_OCCUPIED));
|
|
}
|
|
|
|
std::vector<CAEvent> VirtualMachine::getMatchedThreadCABranchReverse() {
|
|
if (!isMatched())
|
|
return {};
|
|
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 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;
|
|
}
|
|
|
|
error_code_t VirtualMachine::addNewMatchingThread() {
|
|
if (!isUsable())
|
|
throw std::runtime_error("unusable");
|
|
return reveal->startThread();
|
|
}
|
|
|
|
error_code_t VirtualMachine::extendedFeedCharacter(uint64_t input) {
|
|
if (!isUsable())
|
|
throw std::runtime_error("unusable\n");
|
|
return reveal->extendedFeedCharacter(input);
|
|
}
|
|
|
|
error_code_t VirtualMachine::feedCharacter(uint64_t input, uint64_t bytesResembled) {
|
|
if (!isUsable())
|
|
throw std::runtime_error("unusable\n");
|
|
return reveal->feedCharacter(input, bytesResembled);
|
|
}
|
|
} |