#include "builtins.h"

#include "extensions.h"

#include "interpreter.h"

#include "lexer.h"

#include "ns_buffer.h"

#include "parser.h"

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <math.h>

#include <stdarg.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <time.h>

#ifndef _WIN32

#include <sys/wait.h>

#endif

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-parameter"

#pragma clang diagnostic ignored "-Wmissing-field-initializers"

#endif

// Forward declarations for interpreter functions we need

static int module_export_bindings(Interpreter *interp, Env *caller_env, Env *mod_env, const char *alias, int line,

int col, const char *fail_msg);

// Helper macros

#define RUNTIME_ERROR(interp, msg, line, col) \

do { \

(interp)->error = strdup(msg); \

(interp)->error_line = line; \

(interp)->error_col = col; \

return value_null(); \

} while (0)

#define EXPECT_INT(v, name, interp, line, col) \

do { \

if ((v).type != VAL_INT) { \

char buf[128]; \

snprintf(buf, sizeof(buf), "%s expects int argument", name); \

RUNTIME_ERROR(interp, buf, line, col); \

} \

} while (0)

#define EXPECT_FLOAT(v, name, interp, line, col) \

do { \

if ((v).type != VAL_FLOAT) { \

char buf[128]; \

snprintf(buf, sizeof(buf), "%s expects float argument", name); \

RUNTIME_ERROR(interp, buf, line, col); \

} \

} while (0)

#define EXPECT_STR(v, name, interp, line, col) \

do { \

if ((v).type != VAL_STR) { \

char buf[128]; \

snprintf(buf, sizeof(buf), "%s expects str argument", name); \

RUNTIME_ERROR(interp, buf, line, col); \

} \

} while (0)

#define EXPECT_NUM(v, name, interp, line, col) \

do { \

if ((v).type != VAL_INT && (v).type != VAL_FLOAT) { \

char buf[128]; \

snprintf(buf, sizeof(buf), "%s expects int or float argument", name); \

RUNTIME_ERROR(interp, buf, line, col); \

} \

} while (0)

static bool writeback_ptr_name(Interpreter *interp, const char *name, Env *env, Value result, const char *rule,

int line, int col) {

if (!name) {

interp->error = strdup("Invalid pointer target");

interp->error_line = line;

interp->error_col = col;

return false;

}

if (interp && interp->isolate_env_writes && env && env->parent) {

bool local_found = false;

if (env->entries) {

for (size_t _i = 0; _i < env->count; _i++) {

EnvEntry *_e = &env->entries[_i];

if (_e->name && strcmp(_e->name, name) == 0) {

local_found = true;

break;

}

}

}

if (!local_found) {

if (!env_define(env, name, TYPE_UNKNOWN, 0, value_null())) {

char buf[128];

snprintf(buf, sizeof(buf), "%s writeback failed", rule);

interp->error = strdup(buf);

interp->error_line = line;

interp->error_col = col;

return false;

}

}

}

if (!env_assign(env, name, result, TYPE_UNKNOWN, 0, false)) {

char buf[128];

snprintf(buf, sizeof(buf), "%s writeback failed", rule);

interp->error = strdup(buf);

interp->error_line = line;

interp->error_col = col;

return false;

}

return true;

}

static bool writeback_first_ptr(Interpreter *interp, Expr **arg_nodes, Env *env, Value result, const char *rule,

int line, int col) {

if (!arg_nodes || !arg_nodes[0]) {

return true;

}

if (arg_nodes[0]->type != EXPR_PTR) {

return true;

}

return writeback_ptr_name(interp, arg_nodes[0]->as.ptr_name, env, result, rule, line, col);

}

static bool writeback_ptr_node(Interpreter *interp, Expr *node, Env *env, Value result, const char *rule, int line,

int col) {

if (!node || node->type != EXPR_PTR) {

return true;

}

return writeback_ptr_name(interp, node->as.ptr_name, env, result, rule, line, col);

}

static bool writeback_ptr_range(Interpreter *interp, Expr **arg_nodes, Env *env, int start_index, int end_index,

Value result, const char *rule, int line, int col) {

if (!arg_nodes) {

return true;

}

for (int i = start_index; i < end_index; ++i) {

if (!writeback_ptr_node(interp, arg_nodes[i], env, result, rule, line, col)) {

return false;

}

}

return true;

}

// Checked float -> int coercion helper.

// Returns true and sets *out on success. On failure, sets interp->error

// and returns false (caller should return value_null()).

static bool coerce_flt_to_int_checked(Interpreter *interp, double f, int64_t *out, const char *opname, int line,

int col) {

if (isnan(f) || isinf(f)) {

char buf[128];

snprintf(buf, sizeof(buf), "%s cannot coerce float to int", opname);

interp->error = strdup(buf);

interp->error_line = line;

interp->error_col = col;

return false;

}

if (f > (double)INT64_MAX || f < (double)INT64_MIN) {

char buf[128];

snprintf(buf, sizeof(buf), "%s cannot coerce float to int (out of range)", opname);

interp->error = strdup(buf);

interp->error_line = line;

interp->error_col = col;

return false;

}

*out = (int64_t)f;

return true;

}

// --- Encoding helpers ---

#ifndef _WIN32

static char *dec_latin1_to_utf8(const unsigned char *buf, size_t sz) {

size_t outcap = sz * 2 + 1;

char *out = malloc(outcap);

if (!out)

return NULL;

size_t op = 0;

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

unsigned char b = buf[i];

if (b < 0x80) {

out[op++] = (unsigned char)b;

} else {

if (op + 2 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xC0 | (b >> 6));

out[op++] = (unsigned char)(0x80 | (b & 0x3F));

}

}

out[op] = '\0';

return out;

}

#endif

static const uint32_t cp1252_map[32] = {0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,

0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,

0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,

0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178};

#ifdef _WIN32

static char *dec_cp1252_to_utf8(const unsigned char *buf, size_t sz) {

size_t outcap = (sz * 2) + 16;

char *out = malloc(outcap);

if (!out) {

return NULL;

}

size_t op = 0;

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

uint32_t cp;

unsigned char b = buf[i];

if (b < 0x80) {

cp = b;

} else if (b >= 0xA0) {

cp = b;

} else {

cp = cp1252_map[b - 0x80];

}

if (cp <= 0x7F) {

out[op++] = (unsigned char)cp;

} else if (cp <= 0x7FF) {

if (op + 2 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xC0 | (cp >> 6));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

} else if (cp <= 0xFFFF) {

if (op + 3 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xE0 | (cp >> 12));

out[op++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

} else {

if (op + 4 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xF0 | (cp >> 18));

out[op++] = (unsigned char)(0x80 | ((cp >> 12) & 0x3F));

out[op++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

}

}

out[op] = '\0';

return out;

}

#endif

static char *dec_utf16_to_utf8(const unsigned char *buf, size_t sz, int little_endian) {

size_t outcap = (sz * 3) + 16;

char *out = malloc(outcap);

if (!out) {

return NULL;

}

size_t op = 0;

size_t i = 0;

while (i + 1 < sz) {

uint16_t cu;

if (little_endian) {

cu = (uint16_t)(buf[i] | (buf[i + 1] << 8));

} else {

cu = (uint16_t)((buf[i] << 8) | buf[i + 1]);

}

i += 2;

uint32_t cp;

if (cu >= 0xD800 && cu <= 0xDBFF) {

if (i + 1 < sz) {

uint16_t cu2;

if (little_endian) {

cu2 = (uint16_t)(buf[i] | (buf[i + 1] << 8));

} else {

cu2 = (uint16_t)((buf[i] << 8) | buf[i + 1]);

}

if (cu2 >= 0xDC00 && cu2 <= 0xDFFF) {

i += 2;

cp = 0x10000 + (((uint32_t)cu - 0xD800) << 10) + ((uint32_t)cu2 - 0xDC00);

} else {

cp = 0xFFFD;

}

} else {

cp = 0xFFFD;

}

} else if (cu >= 0xDC00 && cu <= 0xDFFF) {

cp = 0xFFFD;

} else {

cp = cu;

}

if (cp <= 0x7F) {

out[op++] = (unsigned char)cp;

} else if (cp <= 0x7FF) {

if (op + 2 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xC0 | (cp >> 6));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

} else if (cp <= 0xFFFF) {

if (op + 3 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xE0 | (cp >> 12));

out[op++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

} else {

if (op + 4 + 1 > outcap) {

outcap *= 2;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)(0xF0 | (cp >> 18));

out[op++] = (unsigned char)(0x80 | ((cp >> 12) & 0x3F));

out[op++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));

out[op++] = (unsigned char)(0x80 | (cp & 0x3F));

}

}

if (i < sz) {

// trailing byte -> replacement

if (op + 3 + 1 > outcap) {

outcap += 16;

char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = (unsigned char)0xEF;

out[op++] = (unsigned char)0xBF;

out[op++] = (unsigned char)0xBD;

}

out[op] = '\0';

return out;

}

static unsigned char *enc_utf8_to_utf16(const char *s, size_t *out_sz, int little_endian) {

size_t slen = s ? strlen(s) : 0;

size_t outcap = ((slen + 1) * 4) + 4;

unsigned char *out = malloc(outcap);

if (!out) {

return NULL;

}

size_t op = 0;

size_t i = 0;

while (i < slen) {

unsigned char c = (unsigned char)s[i];

uint32_t cp = 0;

if (c < 0x80) {

cp = c;

i += 1;

} else if ((c & 0xE0) == 0xC0) {

if (i + 1 >= slen) {

cp = 0xFFFD;

i += 1;

} else {

cp = ((c & 0x1F) << 6) | ((unsigned char)s[i + 1] & 0x3F);

i += 2;

}

} else if ((c & 0xF0) == 0xE0) {

if (i + 2 >= slen) {

cp = 0xFFFD;

i += 1;

} else {

cp = ((c & 0x0F) << 12) | (((unsigned char)s[i + 1] & 0x3F) << 6) | ((unsigned char)s[i + 2] & 0x3F);

i += 3;

}

} else if ((c & 0xF8) == 0xF0) {

if (i + 3 >= slen) {

cp = 0xFFFD;

i += 1;

} else {

cp = ((c & 0x07) << 18) | (((unsigned char)s[i + 1] & 0x3F) << 12) |

(((unsigned char)s[i + 2] & 0x3F) << 6) | ((unsigned char)s[i + 3] & 0x3F);

i += 4;

}

} else {

cp = 0xFFFD;

i += 1;

}

if (cp <= 0xFFFF) {

uint16_t cu = (uint16_t)cp;

if (op + 2 + 2 > outcap) {

outcap *= 2;

unsigned char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

if (little_endian) {

out[op++] = (unsigned char)(cu & 0xFF);

out[op++] = (unsigned char)((cu >> 8) & 0xFF);

} else {

out[op++] = (unsigned char)((cu >> 8) & 0xFF);

out[op++] = (unsigned char)(cu & 0xFF);

}

} else {

// encode surrogate pair

uint32_t v = cp - 0x10000;

uint16_t hi = 0xD800 | (uint16_t)((v >> 10) & 0x3FF);

uint16_t lo = 0xDC00 | (uint16_t)(v & 0x3FF);

if (op + 4 + 2 > outcap) {

outcap *= 2;

unsigned char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

if (little_endian) {

out[op++] = (unsigned char)(hi & 0xFF);

out[op++] = (unsigned char)((hi >> 8) & 0xFF);

out[op++] = (unsigned char)(lo & 0xFF);

out[op++] = (unsigned char)((lo >> 8) & 0xFF);

} else {

out[op++] = (unsigned char)((hi >> 8) & 0xFF);

out[op++] = (unsigned char)(hi & 0xFF);

out[op++] = (unsigned char)((lo >> 8) & 0xFF);

out[op++] = (unsigned char)(lo & 0xFF);

}

}

}

*out_sz = op;

return out;

}

/* Count Unicode code points in a UTF-8 string. Returns the number of

* Unicode code points (characters) represented by the UTF-8 sequence.

* Invalid sequences are treated as a single replacement character.

*/

static size_t utf8_codepoint_count(const char *s) {

if (!s) {

return 0;

}

const unsigned char *p = (const unsigned char *)s;

size_t count = 0;

while (*p) {

unsigned char c = *p;

uint32_t codepoint = 0;

size_t seq_len = 0;

if (c < 0x80) {

codepoint = c;

seq_len = 1;

} else if ((c & 0xE0) == 0xC0) {

if (p[1] != '\0' && (p[1] & 0xC0) == 0x80) {

codepoint = ((uint32_t)(c & 0x1F) << 6) | (uint32_t)(p[1] & 0x3F);

seq_len = 2;

if (codepoint < 0x80) {

seq_len = 0; /* overlong */

}

}

} else if ((c & 0xF0) == 0xE0) {

if (p[1] != '\0' && p[2] != '\0' && (p[1] & 0xC0) == 0x80 && (p[2] & 0xC0) == 0x80) {

codepoint = ((uint32_t)(c & 0x0F) << 12) | ((uint32_t)(p[1] & 0x3F) << 6) | (uint32_t)(p[2] & 0x3F);

seq_len = 3;

if (codepoint < 0x800) {

seq_len = 0; /* overlong */

}

}

} else if ((c & 0xF8) == 0xF0) {

if (p[1] != '\0' && p[2] != '\0' && p[3] != '\0' && (p[1] & 0xC0) == 0x80 && (p[2] & 0xC0) == 0x80 &&

(p[3] & 0xC0) == 0x80) {

codepoint = ((uint32_t)(c & 0x07) << 18) | ((uint32_t)(p[1] & 0x3F) << 12) |

((uint32_t)(p[2] & 0x3F) << 6) | (uint32_t)(p[3] & 0x3F);

seq_len = 4;

if (codepoint < 0x10000 || codepoint > 0x10FFFF) {

seq_len = 0; /* overlong or out of range */

}

}

}

if (seq_len == 0) {

/* invalid sequence -> advance one byte (counts as one character) */

p++;

} else {

/* reject surrogate halves as invalid */

if (codepoint >= 0xD800 && codepoint <= 0xDFFF) {

p++;

} else {

p += seq_len;

}

}

count++;

}

return count;

}

static unsigned char *enc_utf8_to_cp1252(const char *s, size_t *out_sz, int is_windows) {

size_t slen = s ? strlen(s) : 0;

size_t outcap = slen + 16;

unsigned char *out = malloc(outcap);

if (!out) {

return NULL;

}

size_t op = 0;

size_t i = 0;

while (i < slen) {

unsigned char c = (unsigned char)s[i];

uint32_t cp = 0;

if (c < 0x80) {

cp = c;

i++;

} else if ((c & 0xE0) == 0xC0) {

if (i + 1 >= slen) {

cp = 0xFFFD;

i++;

} else {

cp = ((c & 0x1F) << 6) | ((unsigned char)s[i + 1] & 0x3F);

i += 2;

}

} else if ((c & 0xF0) == 0xE0) {

if (i + 2 >= slen) {

cp = 0xFFFD;

i++;

} else {

cp = ((c & 0x0F) << 12) | (((unsigned char)s[i + 1] & 0x3F) << 6) | ((unsigned char)s[i + 2] & 0x3F);

i += 3;

}

} else if ((c & 0xF8) == 0xF0) {

if (i + 3 >= slen) {

cp = 0xFFFD;

i++;

} else {

cp = ((c & 0x07) << 18) | (((unsigned char)s[i + 1] & 0x3F) << 12) |

(((unsigned char)s[i + 2] & 0x3F) << 6) | ((unsigned char)s[i + 3] & 0x3F);

i += 4;

}

} else {

cp = 0xFFFD;

i++;

}

unsigned char outb = 0;

if (cp <= 0x7F) {

{

outb = (unsigned char)cp;

}

} else if (cp >= 0x00A0 && cp <= 0x00FF) {

{

outb = (unsigned char)cp;

}

} else {

int found = -1;

for (int j = 0; j < 32; j++) {

if (cp1252_map[j] == cp) {

found = 0x80 + j;

break;

}

}

if (found >= 0) {

{

outb = (unsigned char)found;

}

} else {

free(out);

return NULL;

}

}

if (op + 1 > outcap) {

outcap *= 2;

unsigned char *n = realloc(out, outcap);

if (!n) {

free(out);

return NULL;

}

out = n;

}

out[op++] = outb;

}

*out_sz = op;

return out;

}

static char *module_source_dir_dup(Env *env) {

if (!env) {

return NULL;

}

EnvEntry *src_entry = env_get_entry(env, "__MODULE_SOURCE__");

if (!src_entry || !src_entry->initialized || src_entry->value.type != VAL_STR || !src_entry->value.as.s) {

return NULL;

}

const char *src = src_entry->value.as.s;

if (src[0] == '\0' || strcmp(src, "<string>") == 0 || strcmp(src, "<repl>") == 0) {

return NULL;

}

char *dir = strdup(src);

if (!dir) {

return NULL;

}

char *last_sep = NULL;

for (char *p = dir; *p; p++) {

if (*p == '/' || *p == '\\') {

last_sep = p;

}

}

if (last_sep) {

*last_sep = '\0';

} else {

strcpy(dir, ".");

}

return dir;

}

static const char *module_scope_name(Env *env) {

if (!env) {

return NULL;

}

EnvEntry *scope_entry = env_get_entry(env, "__MODULE_SCOPE__");

if (!scope_entry || !scope_entry->initialized || scope_entry->value.type != VAL_STR || !scope_entry->value.as.s) {

return NULL;

}

return scope_entry->value.as.s[0] != '\0' ? scope_entry->value.as.s : NULL;

}

// Global argv storage (set by main via builtins_set_argv)

static int g_argc = 0;

static char **g_argv = NULL;

static const char *k_digits64 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+_";

static const char *k_digits58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

static int is_valid_numeric_base(int base) { return base >= 2 && base <= 64; }

static const char *base_prefix_str(int base, char *buf, size_t buflen) {

switch (base) {

case 2:

return "0b";

case 8:

return "0o";

case 10:

return "0d";

case 16:

return "0x";

case 32:

return "0t";

case 58:

return "0c";

case 64:

return "0s";

default:

snprintf(buf, buflen, "0r%02d", base);

return buf;

}

}

static int numeric_base_of(Value v) {

if (v.type != VAL_INT && v.type != VAL_FLOAT) {

return 2;

}

if (v.type == VAL_FLOAT && v.num_base_nan) {

return 0;

}

return is_valid_numeric_base(v.num_base) ? v.num_base : 2;

}

static int result_base_from_values(Value a, Value b) {

int ba = numeric_base_of(a);

int bb = numeric_base_of(b);

if (ba <= 0) {

return bb > 0 ? bb : 2;

}

if (bb <= 0) {

return ba > 0 ? ba : 2;

}

return ba > bb ? ba : bb;

}

static char *int_to_base_prefixed_str(int64_t val, int base) {

if (!is_valid_numeric_base(base)) {

base = 2;

}

const char *alphabet = (base == 58) ? k_digits58 : k_digits64;

int is_negative = val < 0;

uint64_t uval = is_negative ? (uint64_t)(-val) : (uint64_t)val;

char digits_buf[160];

int dpos = (int)sizeof(digits_buf) - 1;

digits_buf[dpos--] = '\0';

if (uval == 0) {

digits_buf[dpos--] = '0';

} else {

while (uval > 0 && dpos >= 0) {

int d = (int)(uval % (uint64_t)base);

digits_buf[dpos--] = alphabet[d];

uval /= (uint64_t)base;

}

}

char pbuf[8];

const char *pref = base_prefix_str(base, pbuf, sizeof(pbuf));

size_t pref_len = strlen(pref);

const char *digs = &digits_buf[dpos + 1];

size_t digs_len = strlen(digs);

size_t out_len = (is_negative ? 1 : 0) + pref_len + digs_len;

char *out = malloc(out_len + 1);

if (!out) {

fprintf(stderr, "Out of memory\n");

exit(1);

}

size_t w = 0;

if (is_negative) {

out[w++] = '-';

}

memcpy(out + w, pref, pref_len);

w += pref_len;

memcpy(out + w, digs, digs_len);

w += digs_len;

out[w] = '\0';

return out;

}

static char *float_to_base_prefixed_str(double val, int base, int base_is_nan) {

if (isinf(val)) {

return strdup(signbit(val) ? "-INF" : "INF");

}

if (base_is_nan || isnan(val)) {

return strdup("NaN");

}

if (!is_valid_numeric_base(base)) {

base = 2;

}

const char *alphabet = (base == 58) ? k_digits58 : k_digits64;

int is_negative = signbit(val) ? 1 : 0;

double aval = is_negative ? -val : val;

uint64_t int_part = (uint64_t)floor(aval);

double frac_part = aval - (double)int_part;

char int_digits[160];

int ipos = (int)sizeof(int_digits) - 1;

int_digits[ipos--] = '\0';

if (int_part == 0) {

int_digits[ipos--] = '0';

} else {

uint64_t x = int_part;

while (x > 0 && ipos >= 0) {

int d = (int)(x % (uint64_t)base);

int_digits[ipos--] = alphabet[d];

x /= (uint64_t)base;

}

}

char frac_digits[96];

int fpos = 0;

for (int i = 0; i < 32 && frac_part > 0.0; i++) {

frac_part *= (double)base;

int d = (int)floor(frac_part + 1e-15);

if (d < 0) {

d = 0;

}

if (d >= base) {

d = base - 1;

}

frac_digits[fpos++] = alphabet[d];

frac_part -= (double)d;

if (frac_part < 0.0) {

frac_part = 0.0;

}

}

while (fpos > 0 && frac_digits[fpos - 1] == '0') {

fpos--;

}

frac_digits[fpos] = '\0';

char pbuf[8];

const char *pref = base_prefix_str(base, pbuf, sizeof(pbuf));

const char *ints = &int_digits[ipos + 1];

size_t out_len = (is_negative ? 1 : 0) + strlen(pref) + strlen(ints) + 2 + (fpos > 0 ? (size_t)fpos : 1);

char *out = malloc(out_len + 1);

if (!out) {

fprintf(stderr, "Out of memory\n");

exit(1);

}

if (fpos == 0) {

snprintf(out, out_len + 1, "%s%s%s.0", is_negative ? "-" : "", pref, ints);

} else {

snprintf(out, out_len + 1, "%s%s%s.%s", is_negative ? "-" : "", pref, ints, frac_digits);

}

return out;

}

static int parse_numeric_prefix(const char *s, int *out_base, const char **out_digits) {

if (!s || s[0] != '0') {

return 0;

}

int base = -1;

int plen = 2;

switch (s[1]) {

case 'b':

base = 2;

break;

case 'o':

base = 8;

break;

case 'd':

base = 10;

break;

case 'x':

base = 16;

break;

case 't':

base = 32;

break;

case 'c':

base = 58;

break;

case 's':

base = 64;

break;

case 'r':

if (!isdigit((unsigned char)s[2]) || !isdigit((unsigned char)s[3])) {

return 0;

}

base = ((s[2] - '0') * 10) + (s[3] - '0');

plen = 4;

break;

default:

return 0;

}

if (!is_valid_numeric_base(base)) {

return 0;

}

if (out_base) {

*out_base = base;

}

if (out_digits) {

*out_digits = s + plen;

}

return 1;

}

static int parse_prefixed_int_string(const char *text, int64_t *out_val, int *out_base) {

if (!text || !out_val || !out_base) {

return 0;

}

int neg = 0;

const char *s = text;

if (*s == '-') {

neg = 1;

s++;

}

int base = 2;

const char *digits = NULL;

if (!parse_numeric_prefix(s, &base, &digits) || !digits || !*digits) {

return 0;

}

if (strchr(digits, '.')) {

return 0;

}

int64_t acc = 0;

for (const char *p = digits; *p; p++) {

int dv = digit_value_for_base(base, *p);

if (dv < 0 || dv >= base) {

return 0;

}

if (acc > (INT64_MAX - dv) / base) {

return 0;

}

acc = (acc * base) + dv;

}

*out_val = neg ? -acc : acc;

*out_base = base;

return 1;

}

static int parse_prefixed_flt_string(const char *text, double *out_val, int *out_base, int *out_base_is_nan) {

if (!text || !out_val || !out_base || !out_base_is_nan) {

return 0;

}

if (strcmp(text, "INF") == 0) {

*out_val = INFINITY;

*out_base = 0;

*out_base_is_nan = 1;

return 1;

}

if (strcmp(text, "-INF") == 0) {

*out_val = -INFINITY;

*out_base = 0;

*out_base_is_nan = 1;

return 1;

}

if (strcmp(text, "NaN") == 0) {

*out_val = NAN;

*out_base = 0;

*out_base_is_nan = 1;

return 1;

}

int neg = 0;

const char *s = text;

if (*s == '-') {

neg = 1;

s++;

}

int base = 2;

const char *digits = NULL;

if (!parse_numeric_prefix(s, &base, &digits) || !digits || !*digits) {

return 0;

}

const char *dot = strchr(digits, '.');

if (!dot || dot == digits || *(dot + 1) == '\0') {

return 0;

}

double int_part = 0.0;

for (const char *p = digits; p < dot; p++) {

int dv = digit_value_for_base(base, *p);

if (dv < 0 || dv >= base) {

return 0;

}

int_part = (int_part * (double)base) + (double)dv;

}

double frac_part = 0.0;

double weight = 1.0 / (double)base;

for (const char *p = dot + 1; *p; p++) {

int dv = digit_value_for_base(base, *p);

if (dv < 0 || dv >= base) {

return 0;

}

frac_part += (double)dv * weight;

weight /= (double)base;

}

*out_val = neg ? -(int_part + frac_part) : (int_part + frac_part);

*out_base = base;

*out_base_is_nan = 0;

return 1;

}

// Helper: convert integer to binary string

static char *int_to_binary_str(int64_t val) {

if (val == 0) {

return strdup("0");

}

int is_negative = val < 0;

uint64_t uval = is_negative ? (uint64_t)(-val) : (uint64_t)val;

char buf[128];

int pos = 127;

buf[pos--] = '\0';

while (uval > 0 && pos >= 0) {