HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/modules/shell.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

shell.c
View Options

#include <compat.h> // IWYU pragma: keep
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#define popen _popen
#define pclose _pclose
#else
#include <sys/wait.h>
#endif
#include "ant.h"
#include "errors.h"
#include "internal.h"
#include "modules/symbol.h"
static ant_value_t builtin_shell_text(ant_t *js, ant_value_t *args, int nargs);
static ant_value_t builtin_shell_lines(ant_t *js, ant_value_t *args, int nargs);
static ant_value_t shell_exec(ant_t *js, const char *cmd, size_t cmd_len) {
ant_value_t result = js_mkobj(js);
FILE *fp = popen(cmd, "r");
if (!fp) {
js_set(js, result, "stdout", js_mkstr(js, "", 0));
js_set(js, result, "stderr", js_mkstr(js, "Failed to execute command", 25));
js_set(js, result, "exitCode", js_mknum(1));
return result;
}
char *output = NULL;
size_t output_size = 0;
size_t output_capacity = 4096;
output = malloc(output_capacity);
if (!output) {
pclose(fp);
return js_mkerr(js, "Out of memory");
}
char buffer[4096];
while (fgets(buffer, sizeof(buffer), fp) != NULL) {
size_t len = strlen(buffer);
if (output_size + len >= output_capacity) {
output_capacity *= 2;
char *new_output = realloc(output, output_capacity);
if (!new_output) {
free(output);
pclose(fp);
return js_mkerr(js, "Out of memory");
}
output = new_output;
}
memcpy(output + output_size, buffer, len);
output_size += len;
}
int status = pclose(fp);
#ifdef _WIN32
int exit_code = status;
#else
int exit_code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
#endif
if (output_size > 0 && output[output_size - 1] == '\n') output_size--;
ant_value_t stdout_val = js_mkstr(js, output, output_size);
free(output);
js_set(js, result, "exitCode", js_mknum(exit_code));
js_set(js, result, "text", js_heavy_mkfun(js, builtin_shell_text, stdout_val));
js_set(js, result, "lines", js_heavy_mkfun(js, builtin_shell_lines, stdout_val));
return result;
}
static ant_value_t builtin_shell_text(ant_t *js, ant_value_t *args, int nargs) {
(void)args;
(void)nargs;
ant_value_t fn = js_getcurrentfunc(js);
return js_get_slot(fn, SLOT_DATA);
}
static ant_value_t builtin_shell_lines(ant_t *js, ant_value_t *args, int nargs) {
(void)args;
(void)nargs;
ant_value_t fn = js_getcurrentfunc(js);
ant_value_t stdout_val = js_get_slot(fn, SLOT_DATA);
size_t text_len;
char *text = js_getstr(js, stdout_val, &text_len);
if (!text) return js_mkarr(js);
ant_value_t lines_array = js_mkarr(js);
size_t line_start = 0;
for (size_t i = 0; i <= text_len; i++) {
if (i == text_len || text[i] == '\n') {
size_t line_len = i - line_start;
ant_value_t line_val = js_mkstr(js, text + line_start, line_len);
js_arr_push(js, lines_array, line_val);
line_start = i + 1;
}
}
return lines_array;
}
static ant_value_t builtin_shell_dollar(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkerr(js, "$() requires at least one argument");
if (!is_special_object(args[0])) {
if (vtype(args[0]) == T_STR) {
size_t cmd_len;
char *cmd = js_getstr(js, args[0], &cmd_len);
if (!cmd) return js_mkerr(js, "Failed to get command string");
return shell_exec(js, cmd, cmd_len);
}
return js_mkerr(js, "$() requires a template string");
}
ant_value_t strings_array = args[0];
char *command = malloc(4096);
if (!command) return js_mkerr(js, "Out of memory");
size_t cmd_pos = 0;
size_t cmd_capacity = 4096;
ant_value_t length_val = js_get(js, strings_array, "length");
int length = (int)js_getnum(length_val);
for (int i = 0; i < length; i++) {
char idx_str[32];
snprintf(idx_str, sizeof(idx_str), "%d", i);
ant_value_t str_val = js_get(js, strings_array, idx_str);
if (vtype(str_val) == T_STR) {
size_t str_len;
char *str = js_getstr(js, str_val, &str_len);
if (cmd_pos + str_len >= cmd_capacity) {
cmd_capacity *= 2;
char *new_cmd = realloc(command, cmd_capacity);
if (!new_cmd) {
free(command);
return js_mkerr(js, "Out of memory");
}
command = new_cmd;
}
memcpy(command + cmd_pos, str, str_len);
cmd_pos += str_len;
}
if (i + 1 < nargs) {
ant_value_t val = args[i + 1];
char val_str[256];
size_t val_len = 0;
if (vtype(val) == T_STR) {
size_t len;
char *s = js_getstr(js, val, &len);
val_len = len < sizeof(val_str) - 1 ? len : sizeof(val_str) - 1;
memcpy(val_str, s, val_len);
} else if (vtype(val) == T_NUM) {
val_len = snprintf(val_str, sizeof(val_str), "%g", js_getnum(val));
}
if (cmd_pos + val_len >= cmd_capacity) {
cmd_capacity *= 2;
char *new_cmd = realloc(command, cmd_capacity);
if (!new_cmd) {
free(command);
return js_mkerr(js, "Out of memory");
}
command = new_cmd;
}
memcpy(command + cmd_pos, val_str, val_len);
cmd_pos += val_len;
}
}
command[cmd_pos] = '\0';
ant_value_t result = shell_exec(js, command, cmd_pos);
free(command);
return result;
}
ant_value_t shell_library(ant_t *js) {
ant_value_t lib = js_mkobj(js);
js_set(js, lib, "$", js_mkfun(builtin_shell_dollar));
js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "shell", 5));
return lib;
}

Owner Packages

  • No Owners