{

using namespace std;

ios::fmtflags state{out.flags()};

out << "0x" << hex << setfill('0') << setw(8) << static_cast<uint32_t>(value);

out.flags(state);

{

using header = ink::internal::header;

// Sanity

inkAssert(_ptr + sizeof(T) <= _story->end(), "Unexpected EOF in Ink execution");

// Read memory

T val = *( const T* ) _ptr;

if (_story->get_header().endien == header::endian_types::differ) {

val = header::swap_bytes(val);

}

// Advance ip

_ptr += sizeof(T);

// Return

return val;

{

// TODO: Garbage collection? ? which garbage ?

_fallback_choice = nullopt;

_choices.clear();

{

inkAssert(dst < src, "Only support copieng to higher state!");

size_t old_size = _tags.size();

size_t idx = _tags_begin[static_cast<int>(src)];

size_t n = _tags_begin[static_cast<int>(src) + 1] - idx;

size_t idy = _tags_begin[static_cast<int>(dst) + 1];

for (size_t i = 0; i < n; ++i) {

_tags.insert(idy + n) = _tags[idx + i * 2];

}

for (size_t i = static_cast<int>(dst) + 1; i < _tags_begin.capacity(); ++i) {

_tags_begin.set(i, _tags_begin[i] + n);

}

inkAssert(_tags.size() == old_size + n, "Expected n new elements");

{

size_t old_size = _tags.size();

size_t idy = _tags_begin[static_cast<int>(tags_level::UNKNOWN)];

size_t end = _tags_begin[static_cast<int>(tags_level::UNKNOWN) + 1];

size_t n = end - idy;

if (n == 0) {

return;

}

for (const tags_level& where : wheres) {

size_t idx = _tags_begin[static_cast<int>(where) + 1];

idy = _tags_begin[static_cast<int>(tags_level::UNKNOWN)];

end = _tags_begin[static_cast<int>(tags_level::UNKNOWN) + 1];

inkAssert(n == end - idy, "Same size in each iteration");

for (size_t i = 0; i < n; ++i) {

const char* tag = _tags[idy + i * 2];

_tags.insert(idx + i) = tag;

}

for (size_t i = static_cast<int>(where) + 1; i < _tags_begin.capacity(); ++i) {

_tags_begin.set(i, _tags_begin[i] + n);

}

}

_tags_begin.set(

static_cast<int>(tags_level::UNKNOWN) + 1, _tags_begin[static_cast<int>(tags_level::UNKNOWN)]

);

_tags.resize(_tags_begin[static_cast<int>(tags_level::UNKNOWN)]);

inkAssert(_tags.size() == old_size + (wheres.size() - 1) * n, "Expected to preserve size!");

{

// clear all tags begin which we do not want to keep

//

// resize to first other field which begins which should not be cleared

switch (which) {

case tags_clear_level::KEEP_NONE:

_tags.clear();

for (size_t i = 0; i < _tags_begin.capacity(); ++i) {

_tags_begin.set(i, 0);

}

break;

case tags_clear_level::KEEP_GLOBAL_AND_UNKNOWN:

_tags.remove(

_tags_begin[static_cast<int>(tags_level::KNOT)],

_tags_begin[static_cast<int>(tags_level::UNKNOWN)]

);

for (size_t i = static_cast<int>(tags_level::KNOT); i < _tags_begin.capacity(); ++i) {

_tags_begin.set(i, _tags_begin[static_cast<int>(tags_level::KNOT)]);

}

_tags_begin.set(static_cast<int>(tags_level::UNKNOWN) + 1, _tags.size());

break;

case tags_clear_level::KEEP_KNOT:

_tags.resize(_tags_begin[static_cast<int>(tags_level::KNOT) + 1]);

for (size_t i = static_cast<int>(tags_level::KNOT) + 2; i < _tags_begin.capacity(); ++i) {

_tags_begin.set(i, _tags_begin[static_cast<int>(tags_level::KNOT) + 1]);

}

break;

default: inkAssert(false, "Unhandeld clear type %d for tags.", static_cast<int>(which));

}

{

// Optimization: if we are _is_falling, then we can

// _should be_ able to safely assume that there is nothing to do here. A falling

// divert should only be taking us from a container to that same container's end point

// without entering any other containers

// OR IF is target is same position do nothing

// could happened if jumping to and of an unnamed container

if (dest == _ptr) {

_ptr = dest;

return;

}

const uint32_t* iter = nullptr;

container_t id;

ip_t offset = nullptr;

bool reversed = _ptr > dest;

// number of container which were already on the stack at current position

size_t comm_end = _container.size();

iter = nullptr;

while (_story->iterate_containers(iter, id, offset)) {

if (offset >= _ptr) {

break;

}

}

if (! reversed) {

_story->iterate_containers(iter, id, offset, true);

}

optional<ContainerData> last_pop = nullopt;

while (_story->iterate_containers(iter, id, offset, reversed)) {

if ((! reversed && offset >= dest) || (reversed && offset < dest)) {

break;

}

if (_container.empty() || _container.top().id != id) {

const uint32_t* iter2 = nullptr;

container_t id2;

ip_t offset2;

while (_story->iterate_containers(iter2, id2, offset2) && id2 != id) {}

_container.push({id, offset2 - _story->instructions()});

} else {

if (_container.size() == comm_end) {

last_pop = _container.pop();

comm_end -= 1;

} else {

_container.pop();

}

}

}

iter = nullptr;

while (_story->iterate_containers(iter, id, offset)) {

if (offset >= dest) {

break;

}

}

// if we jump directly to a named container start, go inside, if it's a ONLY_FIRST container

// it will get visited in the next step

// todo: check if a while is needed

if (offset == dest && static_cast<Command>(offset[0]) == Command::START_CONTAINER_MARKER) {

if (track_knot_visit

&& static_cast<CommandFlag>(offset[1]) & CommandFlag::CONTAINER_MARKER_IS_KNOT) {

_current_knot_id = id;

_entered_knot = true;

}

dest += 6;

_container.push({id, offset - _story->instructions()});

// if we entered a knot we just left, do not recount enter

if (reversed && comm_end == _container.size() - 1 && last_pop.has_value()

&& last_pop.value().id == id) {

comm_end += 1;

}

}

_ptr = dest;

// iff all container (until now) are entered at first position

bool allEnteredAtStart = true;

ip_t child_position = dest;

if (record_visits) {

const ContainerData* iData = nullptr;

size_t level = _container.size();

while (_container.iter(iData)) {

if (level > comm_end

|| _story->container_flag(iData->offset + _story->instructions())

& CommandFlag::CONTAINER_MARKER_ONLY_FIRST) {

auto parrent_offset = _story->instructions() + iData->offset;

inkAssert(child_position >= parrent_offset, "Container stack order is broken");

// 6 == len of START_CONTAINER_SIGNAL, if its 6 bytes behind the container it is a

// unnnamed subcontainers first child check if child_positino is the first child of

// current container

allEnteredAtStart = allEnteredAtStart && ((child_position - parrent_offset) <= 6);

child_position = parrent_offset;

_globals->visit(iData->id, allEnteredAtStart);

}

level -= 1;

}

}

{

if constexpr (type == frame_type::function) {

// add a function start marker

_output << values::func_start;

}

// Push next address onto the callstack

{

offset_t address = static_cast<offset_t>(_ptr - _story->instructions());

_stack.push_frame<type>(address, _evaluation_mode);

_ref_stack.push_frame<type>(address, _evaluation_mode);

}

_evaluation_mode = false; // unset eval mode when enter function or tunnel

// Do the jump

inkAssert(_story->instructions() + target < _story->end(), "Diverting past end of story data!");

jump(_story->instructions() + target, true, false);

{

// Pop the callstack

_ref_stack.fetch_values(_stack);

frame_type type;

offset_t offset = _stack.pop_frame(&type, _evaluation_mode);

_ref_stack.push_values(_stack);

{

frame_type t;

bool eval;

// TODO: write all refs to new frame

offset_t o = _ref_stack.pop_frame(&t, eval);

inkAssert(

o == offset && t == type && eval == _evaluation_mode,

"_ref_stack and _stack should be in frame sync!"

);

}

// SPECIAL: On function, do a trim

if (type == frame_type::function) {

_output << values::func_end;

} else if (type == frame_type::tunnel) {

// if we return but there is a divert target on top of

// the evaluation stack, we should follow this instead

// inkproof: I060

if (! _eval.is_empty() && _eval.top().type() == value_type::divert) {

start_frame<frame_type::tunnel>(_eval.pop().get<value_type::divert>());

return type;

}

}

// Jump to the old offset

inkAssert(

_story->instructions() + offset < _story->end(),

"Callstack return is outside bounds of story!"

);

jump(_story->instructions() + offset, false, false);

// Return frame type

return type;

: _story(data)

, _globals(global.cast<globals_impl>())

, _operations(

global.cast<globals_impl>()->strings(), global.cast<globals_impl>()->lists(), _rng,

*global.cast<globals_impl>(), *data, static_cast<const runner_interface&>(*this)

)

, _ptr(_story->instructions())

, _backup(nullptr)

, _done(nullptr)

, _evaluation_mode{false}

, _choices()

, _tags_begin(0, ~0)

, _container(ContainerData{})

#ifdef INK_ENABLE_CSTD

, _rng(static_cast<uint32_t>(time(NULL)))

#else

, _rng()

#endif

{

// register with globals

_globals->add_runner(this);

if (_globals->lists()) {

_output.set_list_meta(_globals->lists());

}

// initialize globals if necessary

if (! _globals->are_globals_initialized()) {

_globals->initialize_globals(this);

// Set us back to the beginning of the story

reset();

_ptr = _story->instructions();

}

{

// Advance interpreter one line and write to output

advance_line();

# ifdef INK_ENABLE_STL

line_type result{_output.get()};

# elif defined(INK_ENABLE_UNREAL)

line_type result{ANSI_TO_TCHAR(_output.get_alloc(_globals->strings(), _globals->lists()))};

# else

# error unsupported constraints for getline

# endif

// Fall through the fallback choice, if available

if (! has_choices() && _fallback_choice) {

choose(~0U);

}

inkAssert(_output.is_empty(), "Output should be empty after getline!");

return result;

{

# ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

_debug_stream->clear();

}

# endif

line_type result{};

while (can_continue()) {

result += getline();

}

inkAssert(_output.is_empty(), "Output should be empty after getall!");

return result;

{

// Advance interpreter and write lines to output

while (can_continue()) {

out << getline();

}

inkAssert(_output.is_empty(), "Output should be empty after getall!");

{

clear_tags(tags_clear_level::KEEP_KNOT);

// Step while we still have instructions to execute

while (_ptr != nullptr) {

// Stop if we hit a new line

if (line_step()) {

break;

}

}

// can be in save state becaues of choice

// Garbage collection TODO: How often do we want to do this?

if (_saved) {

restore();

}

_globals->gc();

if (_output.saved()) {

_output.restore();

}

{

if (has_choices()) {

inkAssert(index < _choices.size(), "Choice index out of range");

} else if (! _fallback_choice) {

inkAssert(false, "No choice and no Fallbackchoice!! can not choose");

}

_globals->turn();

// Get the choice

const auto& c = has_choices() ? _choices[index] : _fallback_choice.value();

// Get its thread

thread_t choiceThread = c._thread;

// Figure out where our previous pointer was for that thread

ip_t prev = nullptr;

if (choiceThread == ~0U) {

prev = _done;

} else {

prev = _threads.get(choiceThread);

}

// Make sure we have a previous pointer

inkAssert(prev != nullptr, "No 'done' point recorded before finishing choice output");

// Move to the previous pointer so we track our movements correctly

jump(prev, false, false);

_done = nullptr;

// Collapse callstacks to the correct thread

_stack.collapse_to_thread(choiceThread);

_ref_stack.collapse_to_thread(choiceThread);

_threads.clear();

_eval.clear();

// Jump to destination and clear choice list

jump(_story->instructions() + c.path(), true, false);

clear_choices();

_entered_knot = false;

{

// advance and clear output stream

advance_line();

_output.clear();

{

unsigned char* ptr = data;

bool should_write = data != nullptr;

std::uintptr_t offset = _ptr != nullptr ? _ptr - _story->instructions() : 0;

ptr = snap_write(ptr, offset, should_write);

offset = _backup - _story->instructions();

ptr = snap_write(ptr, offset, should_write);

offset = _done - _story->instructions();

ptr = snap_write(ptr, offset, should_write);

ptr = snap_write(ptr, _rng.get_state(), should_write);

ptr = snap_write(ptr, _evaluation_mode, should_write);

ptr = snap_write(ptr, _string_mode, should_write);

ptr = snap_write(ptr, _saved_evaluation_mode, should_write);

ptr = snap_write(ptr, _saved, should_write);

ptr = snap_write(ptr, _is_falling, should_write);

ptr += _output.snap(data ? ptr : nullptr, snapper);

ptr += _stack.snap(data ? ptr : nullptr, snapper);

ptr += _ref_stack.snap(data ? ptr : nullptr, snapper);

ptr += _eval.snap(data ? ptr : nullptr, snapper);

ptr += _tags_begin.snap(data ? ptr : nullptr, snapper);

ptr += _tags.snap(data ? ptr : nullptr, snapper);

snapper.runner_tags = _tags.data();

ptr = snap_write(ptr, _entered_global, should_write);

ptr = snap_write(ptr, _entered_knot, should_write);

ptr = snap_write(ptr, _current_knot_id, should_write);

ptr = snap_write(ptr, _current_knot_id_backup, should_write);

ptr += _container.snap(data ? ptr : nullptr, snapper);

ptr += _threads.snap(data ? ptr : nullptr, snapper);

ptr = snap_write(ptr, _fallback_choice.has_value(), should_write);

if (_fallback_choice) {

ptr += _fallback_choice.value().snap(data ? ptr : nullptr, snapper);

}

ptr += _choices.snap(data ? ptr : nullptr, snapper);

return static_cast<size_t>(ptr - data);

{

// find the path

ip_t destination = _story->find_offset_for(path);

if (destination == nullptr) {

// TODO: Error state?

return false;

}

// Clear state and move to destination

reset();

_ptr = _story->instructions();

jump(destination, false, true);

return true;

{

inkAssert(_output.saved(), "Cannot detect changes in non-saved stream.");

// Check if the old newline is still present (hasn't been glu'd) and

// if there is new text (non-whitespace) in the stream since saving

bool stillHasNewline = _output.ends_with(value_type::newline, _output.save_offset());

bool hasAddedNewText = _output.text_past_save() || _tags.last_size() < _tags.size();

// Newline is still there and there's no new text

if (stillHasNewline && ! hasAddedNewText) {

return change_type::no_change;

}

// If the newline is gone, we got glue'd. Continue as if we never had that newline

if (! stillHasNewline) {

return change_type::newline_removed;

}

// If there's new text content, we went too far

if (hasAddedNewText) {

return change_type::extended_past_newline;

}

inkFail("Invalid change detction. Never should be here!");

return change_type::no_change;

{

// Track if added tags are global ones

if (_ptr == _story->instructions()) {

// Step the interpreter until we've parsed all tags for the line

_entered_global = true;

_current_knot_id = ~0U;

_entered_knot = false;

}

// Step the interpreter

// Copy global tags to the first line

size_t o_size = _output.filled();

step();

if ((o_size < _output.filled() && _output.find_first_of(value_type::marker) == _output.npos

&& ! _evaluation_mode && ! _saved)

|| (_entered_knot && _entered_global)) {

if (_entered_global) {

assign_tags({tags_level::LINE, tags_level::GLOBAL});

_entered_global = false;

} else if (_entered_knot) {

if (has_knot_tags()) {

clear_tags(tags_clear_level::KEEP_GLOBAL_AND_UNKNOWN

); // clear knot tags since whe are entering another knot

}

// Next tags are always added to the line

assign_tags({tags_level::LINE, tags_level::KNOT});

// Unless we are out of content, we are going to try

// to continue a little further. This is to check for

// glue (which means there is potentially more content

// in this line) OR for non-text content such as choices.

// Save a snapshot

_entered_knot = false;

}

}

// If we're not within string evaluation

if (_output.find_first_of(value_type::marker) == _output.npos) {

// Haven't added more text

// If we have a saved state after a previous newline

// don't do this if we behind choice

if (_saved && ! has_choices() && ! _fallback_choice) {

// Check for changes in the output stream

switch (detect_change()) {

case change_type::extended_past_newline:

// We've gone too far. Restore to before we moved past the newline and return that we are

// done

restore();

assign_tags({tags_level::LINE});

return true;

case change_type::newline_removed:

// Newline was removed. Proceed as if we never hit it

forget();

break;

case change_type::no_change: break;

}

}

// If we're on a newline

if (_output.ends_with(value_type::newline)) {

// Unless we are out of content, we are going to try

// to continue a little further. This is to check for

// glue (which means there is potentially more content

// in this line) OR for non-text content such as choices.

if (_ptr != nullptr) {

// Save a snapshot of the current runtime state so we

// can return here if we end up hitting a new line

if (! _saved) {

assign_tags({tags_level::LINE});

save();

}

}

// Otherwise, make sure we don't have any snapshots hanging around

// expect we are in choice handleing

else if (! has_choices() && ! _fallback_choice) {

forget();

} else {

_output.forget();

}

}

}

return false;

{

#ifdef INK_ENABLE_EXCEPTIONS

try

#endif

{

inkAssert(_ptr != nullptr, "Can not step! Do not have a valid pointer");

// Load current command

Command cmd = read<Command>();

CommandFlag flag = read<CommandFlag>();

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "cmd " << cmd << " flags " << flag << " ";

}

#endif

// If we're falling and we hit a non-fallthrough command, stop the fall.

if (_is_falling

&& ! (

(cmd == Command::DIVERT && flag & CommandFlag::DIVERT_IS_FALLTHROUGH)

|| cmd == Command::END_CONTAINER_MARKER

)) {

_is_falling = false;

set_done_ptr(nullptr);

}

if (cmd >= Command::OP_BEGIN && cmd < Command::OP_END) {

_operations(cmd, _eval);

} else {

switch (cmd) {

// == Value Commands ==

case Command::STR: {

const char* str = read<const char*>();

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "str \"" << str << "\"";

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::string>(str));

} else {

_output << value{}.set<value_type::string>(str);

}

} break;

case Command::INT: {

int val = read<int>();

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "int " << val;

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::int32>(static_cast<int32_t>(val)));

}

// TEST-CASE B006 don't print integers

} break;

case Command::BOOL: {

bool val = read<int>() ? true : false;

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "bool " << (val ? "true" : "false");

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::boolean>(val));

} else {

_output << value{}.set<value_type::boolean>(val);

}

} break;

case Command::FLOAT: {

float val = read<float>();

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "float " << val;

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::float32>(val));

}

// TEST-CASE B006 don't print floats

} break;

case Command::VALUE_POINTER: {

hash_t val = read<hash_t>();

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "value_pointer ";

write_hash(*_debug_stream, val);

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::value_pointer>(val, static_cast<char>(flag) - 1));

} else {

inkFail("never conciderd what should happend here! (value pointer print)");

}

} break;

case Command::LIST: {

list_table::list list(read<int>());

#ifdef INK_ENABLE_STL

if (_debug_stream != nullptr) {

*_debug_stream << "list " << list.lid;

}

#endif

if (_evaluation_mode) {

_eval.push(value{}.set<value_type::list>(list));

} else {

char* str = _globals->strings().create(_globals->lists().stringLen(list) + 1);

_globals->lists().toString(str, list)[0] = 0;

_output << value{}.set<value_type::string>(str);

}

} break;

case Command::DIVERT_VAL: {

inkAssert(_evaluation_mode, "Can not push divert value into the output stream!");

// Push the divert target onto the stack

uint32_t target = read<uint32_t>();

_eval.push(value{}.set<value_type::divert>(target));

} break;

case Command::NEWLINE: {

if (_evaluation_mode) {

_eval.push(values::newline);