mirror of
https://github.com/mirkobrombin/raven.git
synced 2026-11-03 21:46:32 +00:00
539 lines
22 KiB
C++
539 lines
22 KiB
C++
#include "windows.h"
|
|
#include "nt/nls.h"
|
|
#include "nt/text.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <stdexcept>
|
|
#include <sys/mman.h>
|
|
|
|
namespace raven {
|
|
|
|
namespace {
|
|
|
|
uint64_t read_le(std::span<const uint8_t> bytes, size_t at, size_t width)
|
|
{
|
|
uint64_t value = 0;
|
|
for (size_t byte = 0; byte < width; ++byte)
|
|
value |= uint64_t(bytes[at + byte]) << (byte * 8);
|
|
return value;
|
|
}
|
|
|
|
void write_le(std::span<uint8_t> bytes, size_t at, uint64_t value, size_t width)
|
|
{
|
|
for (size_t byte = 0; byte < width; ++byte)
|
|
bytes[at + byte] = uint8_t(value >> (byte * 8));
|
|
}
|
|
|
|
// One printf-style conversion of Win32 wsprintf: flags, width, precision, size prefix and type.
|
|
struct Conversion {
|
|
bool left = false, zero = false, plus = false, space = false, alternate = false;
|
|
int64_t width = 0, precision = -1;
|
|
bool wide_size = false, narrow_size = false;
|
|
char type = 0;
|
|
bool width_argument = false, precision_argument = false;
|
|
};
|
|
|
|
std::optional<Conversion> parse_conversion(std::u16string_view format, size_t &at)
|
|
{
|
|
Conversion item;
|
|
for (; at < format.size(); ++at) {
|
|
const auto c = format[at];
|
|
if (c == u'-') item.left = true;
|
|
else if (c == u'0') item.zero = true;
|
|
else if (c == u'+') item.plus = true;
|
|
else if (c == u' ') item.space = true;
|
|
else if (c == u'#') item.alternate = true;
|
|
else break;
|
|
}
|
|
if (at < format.size() && format[at] == u'*') {
|
|
item.width_argument = true;
|
|
++at;
|
|
} else {
|
|
for (; at < format.size() && format[at] >= u'0' && format[at] <= u'9'; ++at)
|
|
item.width = std::min<int64_t>(item.width * 10 + (format[at] - u'0'), 1024);
|
|
}
|
|
if (at < format.size() && format[at] == u'.') {
|
|
++at;
|
|
item.precision = 0;
|
|
if (at < format.size() && format[at] == u'*') {
|
|
item.precision_argument = true;
|
|
++at;
|
|
} else {
|
|
for (; at < format.size() && format[at] >= u'0' && format[at] <= u'9'; ++at)
|
|
item.precision = std::min<int64_t>(item.precision * 10 + (format[at] - u'0'), 1024);
|
|
}
|
|
}
|
|
for (; at < format.size(); ++at) {
|
|
if (format[at] == u'l') item.wide_size = true;
|
|
else if (format[at] == u'h') item.narrow_size = true;
|
|
else break;
|
|
}
|
|
if (at >= format.size())
|
|
return std::nullopt;
|
|
const auto type = format[at++];
|
|
if (type > 127 || std::string_view("cCdiuxXsS").find(char(type)) == std::string_view::npos)
|
|
return std::nullopt;
|
|
item.type = char(type);
|
|
return item;
|
|
}
|
|
|
|
}
|
|
|
|
uint64_t NativeWindows::desktop_window()
|
|
{
|
|
if (desktop && objects.window(desktop))
|
|
return desktop;
|
|
// The class needs a non-zero procedure to register; the window itself carries none and is answered by the system.
|
|
DesktopClass definition{"#32769", 0, 1};
|
|
const auto id = objects.register_class(std::move(definition));
|
|
if (!id)
|
|
throw uint32_t(8);
|
|
const auto &screen = objects.nonclient_metrics();
|
|
DesktopWindow record{id, 0, {}, 0, 0, screen.screen_x, screen.screen_y};
|
|
record.style = 0x96000000;
|
|
record.visible = true;
|
|
desktop = objects.add(std::move(record));
|
|
if (!desktop)
|
|
throw uint32_t(8);
|
|
return desktop;
|
|
}
|
|
|
|
// Re-runs WM_NCCALCSIZE for the current outer rectangle and adopts the client rectangle it answers.
|
|
void NativeWindows::recalculate_client(uint64_t handle,int32_t previous_width,int32_t previous_height,std::optional<std::pair<int32_t,int32_t>> origin)
|
|
{
|
|
auto *window = objects.window(handle);
|
|
if (!window)
|
|
throw uint32_t(1400);
|
|
const auto laid_out = origin ? *origin : std::pair<int32_t,int32_t>{window->x, window->y};
|
|
const auto scratch = process.map_memory(4096, PROT_READ | PROT_WRITE);
|
|
DesktopRect client{};
|
|
bool resized = false;
|
|
int32_t old_width = previous_width >= 0 ? previous_width : window->width, old_height = previous_height >= 0 ? previous_height : window->height;
|
|
try {
|
|
// The extended form Windows sends after creation: NCCALCSIZE_PARAMS holds the new window rectangle, the old one and the old client
|
|
// rectangle, then a pointer to the WINDOWPOS that follows it. A program that draws its own frame answers only this form.
|
|
const bool narrow = process.mode() == NativeMode::x86;
|
|
const size_t pointer = narrow ? 4 : 8, position = 48 + pointer;
|
|
std::vector<uint8_t> bytes(position + (narrow ? 28 : 40));
|
|
const int32_t values[12] = {window->outer.left, window->outer.top, window->outer.right, window->outer.bottom,
|
|
window->outer.left, window->outer.top, window->outer.right, window->outer.bottom,
|
|
window->x, window->y, window->x + window->width, window->y + window->height};
|
|
for (size_t index = 0; index < 12; ++index)
|
|
write_le(std::span<uint8_t>(bytes), index * 4, uint32_t(values[index]), 4);
|
|
write_le(std::span<uint8_t>(bytes), 48, scratch + position, pointer);
|
|
write_le(std::span<uint8_t>(bytes), position, handle, pointer);
|
|
const int32_t place[4] = {window->outer.left, window->outer.top, window->outer.right - window->outer.left, window->outer.bottom - window->outer.top};
|
|
for (size_t index = 0; index < 4; ++index)
|
|
write_le(std::span<uint8_t>(bytes), position + pointer * 2 + index * 4, uint32_t(place[index]), 4);
|
|
write_le(std::span<uint8_t>(bytes), position + pointer * 2 + 16, 0x20 | 0x4 | 0x10, 4);
|
|
process.write_memory(scratch, bytes);
|
|
send(handle, 0x83, 1, scratch);
|
|
window = objects.window(handle);
|
|
if (!window)
|
|
throw std::runtime_error("window was destroyed during frame calculation");
|
|
const auto answer = process.read_memory(scratch, 16);
|
|
client = {int32_t(read_le(answer, 0, 4)), int32_t(read_le(answer, 4, 4)), int32_t(read_le(answer, 8, 4)), int32_t(read_le(answer, 12, 4))};
|
|
if (std::getenv("RAVEN_TRACE_NC")) fprintf(stderr, "nc %llx outer %d,%d,%d,%d -> %d,%d,%d,%d\n", (unsigned long long)handle, values[0], values[1], values[2], values[3], client.left, client.top, client.right, client.bottom);
|
|
} catch (...) {
|
|
process.unmap_memory(scratch);
|
|
throw;
|
|
}
|
|
process.unmap_memory(scratch);
|
|
// A window too small for its frame has an empty client area, never a negative one.
|
|
client.right = std::max(client.right, client.left);
|
|
client.bottom = std::max(client.bottom, client.top);
|
|
window->x = client.left;
|
|
window->y = client.top;
|
|
window->width = client.right - client.left;
|
|
window->height = client.bottom - client.top;
|
|
if (client.left != laid_out.first || client.top != laid_out.second)
|
|
for (const auto child : objects.child_windows(handle))
|
|
shift_window(child, client.left - laid_out.first, client.top - laid_out.second);
|
|
resized = window->width != old_width || window->height != old_height;
|
|
objects.update_window_dcs(handle);
|
|
if (resized)
|
|
publish_window(handle, uint32_t(std::max(window->width, 0)), uint32_t(std::max(window->height, 0)));
|
|
if (resized)
|
|
send(handle, 5, 0, uint16_t(window->width) | (uint64_t(uint16_t(window->height)) << 16));
|
|
if (objects.window(handle) && objects.window_visible(handle)) {
|
|
window = objects.window(handle);
|
|
objects.invalidate(handle, {0, 0, window->width, window->height}, true);
|
|
present(handle);
|
|
}
|
|
}
|
|
|
|
void NativeWindows::reshape(uint64_t handle, DesktopRect outer)
|
|
{
|
|
auto *window = objects.window(handle);
|
|
const bool moved = window->outer.left != outer.left || window->outer.top != outer.top;
|
|
const bool resized = window->outer.right - window->outer.left != outer.right - outer.left ||
|
|
window->outer.bottom - window->outer.top != outer.bottom - outer.top;
|
|
const int32_t client_width = window->width, client_height = window->height;
|
|
// Where the children were laid out: the client origin before the change, which they follow wherever the client area goes.
|
|
const std::pair<int32_t, int32_t> laid_out{window->x, window->y};
|
|
if (resized && window->bitmap) {
|
|
// The surface is outer-sized, so a new size needs a new surface. A window that carries a graphics driver's surface keeps its host
|
|
// window, because that surface stays attached to it; any other gets a new host window, which the compositor places afresh.
|
|
const bool visible = window->visible;
|
|
const bool kept = keep_host_window;
|
|
keep_host_window = keep_host_window || hosting_surface.contains(handle);
|
|
resizing = true;
|
|
try { release_surface(handle); } catch (...) { keep_host_window = kept; resizing = false; throw; }
|
|
keep_host_window = kept;
|
|
resizing = false;
|
|
window = objects.window(handle);
|
|
window->bitmap = 0;
|
|
window->dc = 0;
|
|
window->outer = outer;
|
|
window->x = outer.left;
|
|
window->y = outer.top;
|
|
window->width = outer.right - outer.left;
|
|
window->height = outer.bottom - outer.top;
|
|
recalculate_client(handle, client_width, client_height, laid_out);
|
|
(void)visible;
|
|
} else {
|
|
window->outer = outer;
|
|
window->x = outer.left;
|
|
window->y = outer.top;
|
|
window->width = outer.right - outer.left;
|
|
window->height = outer.bottom - outer.top;
|
|
recalculate_client(handle, client_width, client_height, laid_out);
|
|
}
|
|
window = objects.window(handle);
|
|
if (window && moved)
|
|
send(handle, 3, 0, uint16_t(window->x) | (uint64_t(uint16_t(window->y)) << 16));
|
|
}
|
|
|
|
// Queues WM_TIMER for every expired timer; messages already waiting for the same timer are not duplicated.
|
|
void NativeWindows::post_due_timers()
|
|
{
|
|
const auto now = std::chrono::steady_clock::now();
|
|
for (auto &timer : timers) {
|
|
if (timer.due > now)
|
|
continue;
|
|
const uint32_t kind = timer.system ? 0x118 : 0x113;
|
|
const bool pending = std::any_of(messages.begin(), messages.end(), [&](const Message &message) {
|
|
return message.message == kind && message.window == timer.window && message.wparam == timer.id;
|
|
});
|
|
if (!pending && messages.size() < 10000)
|
|
queue({timer.window, timer.id, timer.procedure, kind, uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count()), cursor_x, cursor_y, 0, timer.window ? 0 : timer.thread},0x10);
|
|
timer.due = now + std::chrono::milliseconds(timer.interval);
|
|
}
|
|
}
|
|
|
|
bool NativeWindows::system_dispatch(std::string_view name)
|
|
{
|
|
const bool ansi = name == "wsprintfA" || name == "wnsprintfA" || name == "wvsprintfA" || name == "wvnsprintfA";
|
|
// wnsprintf takes the buffer's size in characters before the format and never writes past it; the wv forms take their arguments
|
|
// from a va_list, a pointer to them in memory.
|
|
const bool bounded = name == "wnsprintfA" || name == "wnsprintfW" || name == "wvnsprintfA" || name == "wvnsprintfW";
|
|
const bool listed = name.starts_with("wv");
|
|
const bool format = name == "wsprintfW" || name == "wsprintfA" || name == "wvsprintfW" || name == "wvsprintfA" || bounded;
|
|
if (name != "GetDesktopWindow" && name != "PtInRect" && name != "SetRect" && name != "TranslateAcceleratorW" && name != "SetMenu" &&
|
|
name != "GetMenuItemRect" && name != "CheckMenuItem" && name != "SetCapture" &&
|
|
name != "ReleaseCapture" && name != "SetTimer" && name != "SetCoalescableTimer" && name != "KillTimer" && !format)
|
|
return false;
|
|
uint64_t result = 0;
|
|
try {
|
|
if (name == "GetDesktopWindow") {
|
|
process.api_arguments(0);
|
|
result = desktop_window();
|
|
} else if (name == "PtInRect") {
|
|
const auto args = process.api_arguments(3);
|
|
const auto bytes = process.read_memory(args[0], 16);
|
|
const auto left = int32_t(read_le(bytes, 0, 4)), top = int32_t(read_le(bytes, 4, 4));
|
|
const auto right = int32_t(read_le(bytes, 8, 4)), bottom = int32_t(read_le(bytes, 12, 4));
|
|
// A 32-bit caller pushes the two coordinates; a 64-bit caller passes the POINT packed in one register.
|
|
const bool packed = process.mode() != NativeMode::x86;
|
|
const auto x = int32_t(uint32_t(args[1])), y = packed ? int32_t(uint32_t(args[1] >> 32)) : int32_t(uint32_t(args[2]));
|
|
result = x >= left && x < right && y >= top && y < bottom;
|
|
} else if (name == "TranslateAcceleratorW") {
|
|
const auto args = process.api_arguments(3);
|
|
const auto *table = objects.accelerators(args[1]);
|
|
if (!table || !objects.window(args[0]))
|
|
throw uint32_t(1400);
|
|
const bool narrow = process.mode() == NativeMode::x86;
|
|
const auto bytes = process.read_memory(args[2], narrow ? 28 : 48);
|
|
const auto message = uint32_t(read_le(bytes, narrow ? 4 : 8, 4));
|
|
const auto wparam = read_le(bytes, narrow ? 8 : 16, narrow ? 4 : 8);
|
|
const auto state = modifier_state();
|
|
for (const auto &entry : *table) {
|
|
const bool virtual_key = entry.flags & 1;
|
|
bool match = false;
|
|
if (virtual_key && (message == 0x100 || message == 0x104))
|
|
match = wparam == entry.key && bool(entry.flags & 4) == state.shift && bool(entry.flags & 8) == state.control &&
|
|
bool(entry.flags & 0x10) == state.alt;
|
|
else if (!virtual_key && message == 0x102 && !state.alt)
|
|
match = wparam == entry.key;
|
|
if (match) {
|
|
send(args[0], 0x111, uint64_t(entry.command) | (uint64_t(1) << 16), 0);
|
|
result = 1;
|
|
break;
|
|
}
|
|
}
|
|
} else if (name == "SetMenu") {
|
|
const auto args = process.api_arguments(2);
|
|
auto *window = objects.window(args[0]);
|
|
if (!window)
|
|
throw uint32_t(1400);
|
|
if (window->parent || (args[1] && !objects.menu(args[1])))
|
|
throw uint32_t(args[1] && !objects.menu(args[1]) ? 1401 : 120);
|
|
window->menu = args[1];
|
|
recalculate_client(args[0]);
|
|
result = 1;
|
|
} else if (name == "GetMenuItemRect") {
|
|
const auto args = process.api_arguments(4);
|
|
const auto *window = objects.window(args[0]);
|
|
if (!window)
|
|
throw uint32_t(1400);
|
|
// Only the menu bar of its own window has a layout; popup menus are not laid out yet.
|
|
if (args[1] != window->menu || !window->menu)
|
|
throw uint32_t(120);
|
|
const auto rects = menu_bar_items(*window);
|
|
if (uint32_t(args[2]) >= rects.size())
|
|
throw uint32_t(87);
|
|
const auto &rect = rects[uint32_t(args[2])];
|
|
std::array<uint8_t, 16> bytes{};
|
|
const int32_t values[4] = {window->outer.left + rect.left, window->outer.top + rect.top, window->outer.left + rect.right,
|
|
window->outer.top + rect.bottom};
|
|
for (size_t index = 0; index < 4; ++index)
|
|
write_le(bytes, index * 4, uint32_t(values[index]), 4);
|
|
process.write_memory(args[3], bytes);
|
|
result = 1;
|
|
} else if (name == "CheckMenuItem") {
|
|
const auto args = process.api_arguments(3);
|
|
auto *menu = objects.edit_menu(args[0]);
|
|
if (!menu)
|
|
throw uint32_t(1401);
|
|
const bool by_position = uint32_t(args[2]) & 0x400;
|
|
DesktopMenuItem *found = nullptr;
|
|
const auto search = [&](auto &&self, DesktopMenu &level) -> void {
|
|
if (by_position) {
|
|
if (!found && uint32_t(args[1]) < level.items.size())
|
|
found = &level.items[uint32_t(args[1])];
|
|
return;
|
|
}
|
|
for (auto &item : level.items) {
|
|
if (!item.submenu && item.id == uint32_t(args[1])) {
|
|
found = &item;
|
|
return;
|
|
}
|
|
if (item.submenu)
|
|
if (auto *child = objects.edit_menu(item.submenu)) {
|
|
self(self, *child);
|
|
if (found)
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
search(search, *menu);
|
|
if (!found) {
|
|
result = UINT32_MAX;
|
|
} else {
|
|
result = (found->state & 8) ? 8 : 0;
|
|
found->state = (found->state & ~8U) | ((uint32_t(args[2]) & 8) ? 8U : 0U);
|
|
}
|
|
} else if (name == "SetCapture") {
|
|
const auto args = process.api_arguments(1);
|
|
if (!objects.window(args[0]))
|
|
throw uint32_t(1400);
|
|
result = capture;
|
|
capture = args[0];
|
|
if (result && result != args[0] && objects.window(result))
|
|
send(result, 0x215, 0, args[0]);
|
|
else if (result && !objects.window(result))
|
|
result = 0;
|
|
} else if (name == "ReleaseCapture") {
|
|
process.api_arguments(0);
|
|
if (capture) {
|
|
const auto previous = capture;
|
|
capture = 0;
|
|
if (objects.window(previous))
|
|
send(previous, 0x215, 0, 0);
|
|
}
|
|
result = 1;
|
|
} else if (name == "SetTimer" || name == "SetCoalescableTimer") {
|
|
// The coalescing tolerance is only a hint, so both entry points share one timer.
|
|
const auto args = process.api_arguments(name == "SetTimer" ? 4 : 5);
|
|
const auto interval = std::clamp<uint32_t>(uint32_t(args[2]), 10, 0x7fffffff);
|
|
if (args[0] && !objects.window(args[0]))
|
|
throw uint32_t(1400);
|
|
uint64_t id = args[1];
|
|
if (!args[0]) {
|
|
// A thread timer without a window gets a fresh system identifier.
|
|
id = next_timer_id++;
|
|
} else if (!id) {
|
|
throw uint32_t(87);
|
|
}
|
|
if (timers.size() >= 1024)
|
|
throw uint32_t(8);
|
|
std::erase_if(timers, [&](const Timer &timer) { return timer.window == args[0] && timer.id == id; });
|
|
timers.push_back({args[0], id, args[3], interval, std::chrono::steady_clock::now() + std::chrono::milliseconds(interval), false, environment.thread_id()});
|
|
result = id;
|
|
} else if (name == "KillTimer") {
|
|
const auto args = process.api_arguments(2);
|
|
const auto before = timers.size();
|
|
std::erase_if(timers, [&](const Timer &timer) { return timer.window == args[0] && timer.id == args[1]; });
|
|
if (before == timers.size())
|
|
throw uint32_t(1814);
|
|
result = 1;
|
|
} else if (name == "SetRect") {
|
|
const auto args = process.api_arguments(5);
|
|
std::array<uint8_t, 16> bytes{};
|
|
for (size_t index = 0; index < 4; ++index)
|
|
write_le(bytes, index * 4, uint32_t(args[1 + index]), 4);
|
|
process.write_memory(args[0], bytes);
|
|
result = 1;
|
|
} else {
|
|
// cdecl variadic: count the consumed words from the format string before reading them off the stack.
|
|
const size_t first = bounded ? 2 : 1;
|
|
const auto head = process.api_arguments(first + 1);
|
|
std::u16string pattern;
|
|
if (ansi) {
|
|
std::string narrow;
|
|
for (size_t index = 0; index < 4096; ++index) {
|
|
const auto byte = process.read_memory(head[first] + index, 1)[0];
|
|
if (!byte)
|
|
break;
|
|
narrow.push_back(char(byte));
|
|
}
|
|
pattern = from_ansi(narrow, 1252);
|
|
} else {
|
|
pattern = window_text(head[first]);
|
|
}
|
|
size_t words = 0;
|
|
for (size_t at = 0; at < pattern.size();) {
|
|
if (pattern[at++] != u'%')
|
|
continue;
|
|
if (at < pattern.size() && pattern[at] == u'%') {
|
|
++at;
|
|
continue;
|
|
}
|
|
const auto item = parse_conversion(pattern, at);
|
|
if (!item)
|
|
break;
|
|
words += 1 + item->width_argument + item->precision_argument;
|
|
}
|
|
if (words > 64)
|
|
throw uint32_t(87);
|
|
const auto args = process.api_arguments(first + 1 + (listed ? 1 : words));
|
|
size_t next = first + 1;
|
|
const size_t slot = process.mode() == NativeMode::x86 ? 4 : 8;
|
|
const auto take = [&]() -> uint64_t {
|
|
if (!listed)
|
|
return args[next++];
|
|
const auto bytes = process.read_memory(args[first + 1] + (next++ - first - 1) * slot, slot);
|
|
return read_le(bytes, 0, slot);
|
|
};
|
|
std::u16string output;
|
|
for (size_t at = 0; at < pattern.size();) {
|
|
const auto c = pattern[at++];
|
|
if (c != u'%') {
|
|
output.push_back(c);
|
|
continue;
|
|
}
|
|
if (at < pattern.size() && pattern[at] == u'%') {
|
|
output.push_back(u'%');
|
|
++at;
|
|
continue;
|
|
}
|
|
auto item = parse_conversion(pattern, at);
|
|
if (!item)
|
|
break;
|
|
if (item->width_argument) {
|
|
const auto value = int32_t(uint32_t(take()));
|
|
item->left |= value < 0;
|
|
item->width = std::min<int64_t>(std::abs(int64_t(value)), 1024);
|
|
}
|
|
if (item->precision_argument) {
|
|
const auto value = int32_t(uint32_t(take()));
|
|
item->precision = value < 0 ? -1 : std::min<int64_t>(value, 1024);
|
|
}
|
|
const auto value = take();
|
|
std::u16string body;
|
|
if (item->type == 'c' || item->type == 'C') {
|
|
if (ansi && item->type == 'c')
|
|
body = from_ansi(std::string(1, char(uint8_t(value))), 1252);
|
|
else
|
|
body.push_back(char16_t(uint16_t(value)));
|
|
} else if (item->type == 's' || item->type == 'S') {
|
|
// %s takes the string width of the function (UTF-16); %S, %hs and %ls swap it.
|
|
bool wide = (item->type == 's') != ansi;
|
|
if (item->narrow_size) wide = false;
|
|
if (item->wide_size) wide = true;
|
|
if (!value) {
|
|
body = u"(null)";
|
|
} else {
|
|
for (size_t index = 0; index < 4096; ++index) {
|
|
const auto bytes = process.read_memory(value + index * (wide ? 2 : 1), wide ? 2 : 1);
|
|
const char16_t character = wide ? char16_t(bytes[0] | bytes[1] << 8) : char16_t(bytes[0]);
|
|
if (!character || (item->precision >= 0 && int64_t(index) >= item->precision))
|
|
break;
|
|
body.push_back(character);
|
|
}
|
|
}
|
|
} else {
|
|
const bool signed_type = item->type == 'd' || item->type == 'i';
|
|
uint32_t raw = uint32_t(value);
|
|
if (item->narrow_size)
|
|
raw = signed_type ? uint32_t(int32_t(int16_t(raw))) : uint32_t(uint16_t(raw));
|
|
const bool negative = signed_type && int32_t(raw) < 0;
|
|
uint64_t magnitude = signed_type ? (negative ? uint64_t(-int64_t(int32_t(raw))) : raw) : raw;
|
|
std::string digits;
|
|
const bool hexadecimal = item->type == 'x' || item->type == 'X';
|
|
do {
|
|
const auto digit = unsigned(magnitude % (hexadecimal ? 16 : 10));
|
|
digits.push_back(char((digit < 10 ? '0' : (item->type == 'X' ? 'A' : 'a') - 10) + digit));
|
|
magnitude /= hexadecimal ? 16 : 10;
|
|
} while (magnitude);
|
|
while (item->precision >= 0 && int64_t(digits.size()) < item->precision)
|
|
digits.push_back('0');
|
|
std::string prefix;
|
|
if (negative) prefix = "-";
|
|
else if (signed_type && item->plus) prefix = "+";
|
|
else if (signed_type && item->space) prefix = " ";
|
|
if (hexadecimal && item->alternate && raw) prefix = item->type == 'X' ? "0X" : "0x";
|
|
if (item->zero && !item->left && item->precision < 0)
|
|
while (int64_t(prefix.size() + digits.size()) < item->width)
|
|
digits.push_back('0');
|
|
std::reverse(digits.begin(), digits.end());
|
|
for (const char character : prefix + digits)
|
|
body.push_back(char16_t(character));
|
|
}
|
|
while (int64_t(body.size()) < item->width)
|
|
body.insert(item->left ? body.end() : body.begin(), u' ');
|
|
output += body;
|
|
}
|
|
const int64_t capacity = bounded ? int64_t(int32_t(uint32_t(head[1]))) : 1024;
|
|
if (capacity <= 0)
|
|
throw uint32_t(87);
|
|
if (int64_t(output.size()) > capacity - 1)
|
|
output.resize(size_t(capacity - 1));
|
|
std::vector<uint8_t> bytes;
|
|
if (ansi) {
|
|
const auto narrow = to_ansi(output, 1252);
|
|
bytes.assign(narrow.begin(), narrow.end());
|
|
bytes.push_back(0);
|
|
result = narrow.size();
|
|
} else {
|
|
bytes.resize((output.size() + 1) * 2);
|
|
for (size_t index = 0; index < output.size(); ++index)
|
|
write_le(bytes, index * 2, output[index], 2);
|
|
result = output.size();
|
|
}
|
|
process.write_memory(head[0], bytes);
|
|
}
|
|
} catch (uint32_t error) { environment.set_last_error(error); }
|
|
catch (const std::runtime_error &failure) {
|
|
const std::string_view message = failure.what();
|
|
if (message.find("readable") == message.npos && message.find("writable") == message.npos) throw;
|
|
environment.set_last_error(998);
|
|
result = 0;
|
|
}
|
|
process.return_api(result);
|
|
return true;
|
|
}
|
|
|
|
}
|