MVMString * MVM_coerce_n_s(MVMThreadContext *tc, MVMnum64 n) {
if (n == MVM_num_posinf(tc)) {
return MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "Inf");
}
else if (n == MVM_num_neginf(tc)) {
return MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "-Inf");
}
else if (n != n) {
return MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "NaN");
}
else {
char buf[64];
int i;
if (snprintf(buf, 64, "%.15g", n) < 0)
MVM_exception_throw_adhoc(tc, "Could not stringify number");
if (strstr(buf, ".")) {
MVMint64 is_not_scientific = !strstr(buf, "e");
i = strlen(buf);
while (i > 1 && ((buf[--i] == '0' && is_not_scientific) || buf[i] == ' '))
buf[i] = '\0';
if (buf[i] == '.')
buf[i] = '\0';
}
return MVM_string_ascii_decode(tc, tc->instance->VMString, buf, strlen(buf));
}
}
MVMString * MVM_coerce_n_s(MVMThreadContext *tc, MVMnum64 n) {
char buf[20];
int i;
sprintf(buf, "%-15f", n);
if (strstr(buf, ".")) {
i = strlen(buf);
while (i > 1 && (buf[--i] == '0' || buf[i] == ' '))
buf[i] = '\0';
if (buf[i] == '.')
buf[i] = '\0';
}
return MVM_string_ascii_decode(tc, tc->instance->VMString, buf, strlen(buf));
}
MVMObject * MVM_proc_getenvhash(MVMThreadContext *tc) {
MVMInstance * const instance = tc->instance;
MVMObject * env_hash;
#ifdef _WIN32
const MVMuint16 acp = GetACP(); /* We should get ACP at runtime. */
#endif
MVMuint32 pos = 0;
MVMString *needle = MVM_string_ascii_decode(tc, instance->VMString, STR_WITH_LEN("="));
char *env;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&needle);
env_hash = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_hash_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&env_hash);
while ((env = environ[pos++]) != NULL) {
#ifndef _WIN32
MVMString *str = MVM_string_utf8_c8_decode(tc, instance->VMString, env, strlen(env));
#else
char * const _env = ANSIToUTF8(acp, env);
MVMString *str = MVM_string_utf8_c8_decode(tc, instance->VMString, _env, strlen(_env));
#endif
MVMuint32 index = MVM_string_index(tc, str, needle, 0);
MVMString *key, *val;
MVMObject *box;
#ifdef _WIN32
MVM_free(_env);
#endif
MVM_gc_root_temp_push(tc, (MVMCollectable **)&str);
key = MVM_string_substring(tc, str, 0, index);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&key);
val = MVM_string_substring(tc, str, index + 1, -1);
box = MVM_repr_box_str(tc, MVM_hll_current(tc)->str_box_type, val);
MVM_repr_bind_key_o(tc, env_hash, key, box);
MVM_gc_root_temp_pop_n(tc, 2);
}
MVM_gc_root_temp_pop_n(tc, 2);
return env_hash;
}
MVMint64 MVM_proc_spawn(MVMThreadContext *tc, MVMString *cmd, MVMString *cwd, MVMObject *env) {
MVMint64 result, spawn_result;
uv_process_t process = {0};
uv_process_options_t process_options = {0};
int i;
char * const cmdin = MVM_string_utf8_encode_C_string(tc, cmd);
char * const _cwd = MVM_string_utf8_encode_C_string(tc, cwd);
const MVMuint64 size = MVM_repr_elems(tc, env);
MVMIter * const iter = (MVMIter *)MVM_iter(tc, env);
char **_env = malloc((size + 1) * sizeof(char *));
#ifdef _WIN32
const MVMuint16 acp = GetACP(); /* We should get ACP at runtime. */
char * const _cmd = ANSIToUTF8(acp, getenv("ComSpec"));
char *args[3];
args[0] = "/c";
args[1] = cmdin;
args[2] = NULL;
#else
char * const _cmd = "/bin/sh";
char *args[4];
args[0] = "/bin/sh";
args[1] = "-c";
args[2] = cmdin;
args[3] = NULL;
#endif
MVMROOT(tc, iter, {
MVMString * const equal = MVM_string_ascii_decode(tc, tc->instance->VMString, STR_WITH_LEN("="));
MVMROOT(tc, equal, {
MVMString *env_str;
i = 0;
while(MVM_iter_istrue(tc, iter)) {
MVM_repr_shift_o(tc, (MVMObject *)iter);
env_str = MVM_string_concatenate(tc, MVM_iterkey_s(tc, iter), equal);
env_str = MVM_string_concatenate(tc, env_str, MVM_repr_get_str(tc, MVM_iterval(tc, iter)));
_env[i++] = MVM_string_utf8_encode_C_string(tc, env_str);
}
_env[size] = NULL;
});
});
MVMString * MVM_coerce_i_s(MVMThreadContext *tc, MVMint64 i) {
char buffer[64];
int len;
/* See if we can hit the cache. */
int cache = i >= 0 && i < MVM_INT_TO_STR_CACHE_SIZE;
if (cache) {
MVMString *cached = tc->instance->int_to_str_cache[i];
if (cached)
return cached;
}
/* Otherwise, need to do the work; cache it if in range. */
len = snprintf(buffer, 64, "%lld", (long long int)i);
if (len >= 0) {
MVMString *result = MVM_string_ascii_decode(tc, tc->instance->VMString, buffer, len);
if (cache)
tc->instance->int_to_str_cache[i] = result;
return result;
}
else {
MVM_exception_throw_adhoc(tc, "Could not stringify integer");
}
}
/* Decodes a NULL-terminated ASCII string into an NFG string, creating
* a result of the specified type. The type must have the MVMString REPR. */
MVMString * MVM_string_ascii_decode_nt(MVMThreadContext *tc, MVMObject *result_type, const char *ascii) {
return MVM_string_ascii_decode(tc, result_type, ascii, strlen(ascii));
}
MVMString * MVM_coerce_i_s(MVMThreadContext *tc, MVMint64 i) {
char buffer[25];
sprintf(buffer, "%lld", i);
return MVM_string_ascii_decode(tc, tc->instance->VMString, buffer, strlen(buffer));
}
