Hermes Agent
ed23524817
Preserve source locations, validate malformed JSON, and add opt-in resource limits. Include executable error-guide coverage, learner pilot materials, native Windows acceptance helpers, and updated CI/documentation.
8085 lines
290 KiB
C
8085 lines
290 KiB
C
/*
|
|
Claro v2026.10.25.014405 - Networking Reliability Release
|
|
|
|
A compact, buildable Claro interpreter focused on the beginner-friendly
|
|
teaching core: readable commands, simple expressions, functions, collections,
|
|
files, JSON, imports, TRY/CATCH, stronger beginner checking, and small standard-library
|
|
built-ins.
|
|
|
|
Build:
|
|
gcc -std=c89 -pedantic-errors -Werror=implicit-function-declaration src/claro.c -O0 -o claro -lm
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifndef _WIN32
|
|
#include <strings.h>
|
|
#define strnicmp2 strncasecmp
|
|
#else
|
|
#define strnicmp2 _strnicmp
|
|
#endif
|
|
#include <ctype.h>
|
|
#include <stdarg.h>
|
|
#include <errno.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
#include <sys/stat.h>
|
|
#ifndef _WIN32
|
|
FILE *popen(const char *command, const char *mode);
|
|
int pclose(FILE *stream);
|
|
#endif
|
|
#ifndef _WIN32
|
|
#include <dirent.h>
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
#else
|
|
#include <direct.h>
|
|
#include <io.h>
|
|
#ifdef __MINGW32__
|
|
#include <dirent.h>
|
|
#endif
|
|
#define access _access
|
|
#define F_OK 0
|
|
#endif
|
|
|
|
#define CLARO_VERSION "Claro v2026.10.25.014405"
|
|
#define CLARO_MAX_CALL_DEPTH 256
|
|
#define CLARO_MAX_EXPR_DEPTH 128
|
|
#define CLARO_MAX_BLOCK_DEPTH 128
|
|
|
|
static void *xmalloc(size_t n) {
|
|
void *p = malloc(n ? n : 1);
|
|
if (!p) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(1);
|
|
}
|
|
return p;
|
|
}
|
|
static void *xrealloc(void *p, size_t n) {
|
|
void *q = realloc(p, n ? n : 1);
|
|
if (!q) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(1);
|
|
}
|
|
return q;
|
|
}
|
|
static char *xstrdup(const char *s) {
|
|
size_t n;
|
|
char *p;
|
|
if (!s)
|
|
s = "";
|
|
n = strlen(s);
|
|
p = (char *)xmalloc(n + 1);
|
|
memcpy(p, s, n + 1);
|
|
return p;
|
|
}
|
|
static int ci_cmp(const char *a, const char *b) {
|
|
while (*a && *b) {
|
|
int ca = toupper((unsigned char)*a), cb = toupper((unsigned char)*b);
|
|
if (ca != cb)
|
|
return ca - cb;
|
|
a++;
|
|
b++;
|
|
}
|
|
return (unsigned char)*a - (unsigned char)*b;
|
|
}
|
|
static int ci_eq(const char *a, const char *b) { return ci_cmp(a, b) == 0; }
|
|
static int starts_ci(const char *s, const char *p) {
|
|
while (*p) {
|
|
if (!*s)
|
|
return 0;
|
|
if (toupper((unsigned char)*s) != toupper((unsigned char)*p))
|
|
return 0;
|
|
s++;
|
|
p++;
|
|
}
|
|
return 1;
|
|
}
|
|
static char *trim_inplace(char *s) {
|
|
char *e;
|
|
while (*s && isspace((unsigned char)*s))
|
|
s++;
|
|
e = s + strlen(s);
|
|
while (e > s && isspace((unsigned char)e[-1]))
|
|
e--;
|
|
*e = 0;
|
|
return s;
|
|
}
|
|
static void first_word(const char *s, char *out, size_t n) {
|
|
size_t i = 0;
|
|
while (*s && isspace((unsigned char)*s))
|
|
s++;
|
|
while (*s && !isspace((unsigned char)*s) && i + 1 < n) {
|
|
out[i++] = *s++;
|
|
}
|
|
out[i] = 0;
|
|
}
|
|
static void upper_copy(char *d, const char *s, size_t n) {
|
|
size_t i = 0;
|
|
if (!n)
|
|
return;
|
|
while (s && s[i] && i + 1 < n) {
|
|
d[i] = (char)toupper((unsigned char)s[i]);
|
|
i++;
|
|
}
|
|
d[i] = 0;
|
|
}
|
|
static int is_blank_or_comment(const char *s) {
|
|
while (*s && isspace((unsigned char)*s))
|
|
s++;
|
|
return *s == 0 || *s == '#';
|
|
}
|
|
|
|
/* C89 bounded formatter for Claro's internal formats only. Not a public printf
|
|
replacement: supported conversions are %s, %.*s, %d, %08lx, %.15g, %.0f,
|
|
and %%. Strings are copied directly with bounds; sprintf is used only for
|
|
fixed numeric formats into a buffer sized for the largest double. */
|
|
static void claro_format_copy(char *out, size_t size, size_t *total, const char *text,
|
|
size_t length) {
|
|
size_t copy = 0;
|
|
if (size && *total < size - 1) {
|
|
copy = size - 1 - *total;
|
|
if (copy > length)
|
|
copy = length;
|
|
if (copy)
|
|
memcpy(out + *total, text, copy);
|
|
}
|
|
if (length > (size_t)INT_MAX - *total) {
|
|
fprintf(stderr, "Claro format output is too large.\n");
|
|
exit(1);
|
|
}
|
|
*total += length;
|
|
}
|
|
|
|
static int claro_vsnprintf(char *out, size_t size, const char *format, va_list args) {
|
|
size_t total = 0;
|
|
while (*format) {
|
|
const char *text;
|
|
size_t length;
|
|
char number[DBL_MAX_10_EXP + 64];
|
|
if (*format != '%') {
|
|
text = format;
|
|
while (*format && *format != '%')
|
|
format++;
|
|
length = (size_t)(format - text);
|
|
} else {
|
|
format++;
|
|
if (*format == '%') {
|
|
text = "%";
|
|
length = 1;
|
|
format++;
|
|
} else if (*format == 's') {
|
|
text = va_arg(args, const char *);
|
|
if (!text)
|
|
text = "(null)";
|
|
length = strlen(text);
|
|
format++;
|
|
} else if (strncmp(format, ".*s", 3) == 0) {
|
|
int limit = va_arg(args, int);
|
|
text = va_arg(args, const char *);
|
|
if (!text)
|
|
text = "(null)";
|
|
length = 0;
|
|
while (text[length] && (limit < 0 || length < (size_t)limit))
|
|
length++;
|
|
format += 3;
|
|
} else if (*format == 'd') {
|
|
sprintf(number, "%d", va_arg(args, int));
|
|
text = number;
|
|
length = strlen(number);
|
|
format++;
|
|
} else if (strncmp(format, "08lx", 4) == 0) {
|
|
sprintf(number, "%08lx", va_arg(args, unsigned long));
|
|
text = number;
|
|
length = strlen(number);
|
|
format += 4;
|
|
} else if (strncmp(format, ".15g", 4) == 0) {
|
|
sprintf(number, "%.15g", va_arg(args, double));
|
|
text = number;
|
|
length = strlen(number);
|
|
format += 4;
|
|
} else if (strncmp(format, ".0f", 3) == 0) {
|
|
sprintf(number, "%.0f", va_arg(args, double));
|
|
text = number;
|
|
length = strlen(number);
|
|
format += 3;
|
|
} else {
|
|
fprintf(stderr, "Unsupported internal Claro format.\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
claro_format_copy(out, size, &total, text, length);
|
|
}
|
|
if (size)
|
|
out[total < size ? total : size - 1] = 0;
|
|
return (int)total;
|
|
}
|
|
|
|
static int claro_snprintf(char *out, size_t size, const char *format, ...) {
|
|
va_list args;
|
|
int result;
|
|
va_start(args, format);
|
|
result = claro_vsnprintf(out, size, format, args);
|
|
va_end(args);
|
|
return result;
|
|
}
|
|
|
|
/* ---------- growable string ---------- */
|
|
typedef struct {
|
|
char *s;
|
|
size_t len, cap;
|
|
} Str;
|
|
static void str_init(Str *b) {
|
|
b->s = NULL;
|
|
b->len = 0;
|
|
b->cap = 0;
|
|
}
|
|
static void str_need(Str *b, size_t extra) {
|
|
size_t need = b->len + extra + 1;
|
|
if (need > b->cap) {
|
|
size_t nc = b->cap ? b->cap * 2 : 64;
|
|
while (nc < need)
|
|
nc *= 2;
|
|
b->s = (char *)xrealloc(b->s, nc);
|
|
b->cap = nc;
|
|
}
|
|
}
|
|
static void str_addn(Str *b, const char *s, size_t n) {
|
|
str_need(b, n);
|
|
memcpy(b->s + b->len, s, n);
|
|
b->len += n;
|
|
b->s[b->len] = 0;
|
|
}
|
|
static void str_add(Str *b, const char *s) {
|
|
if (s)
|
|
str_addn(b, s, strlen(s));
|
|
}
|
|
static void str_ch(Str *b, char c) {
|
|
str_need(b, 1);
|
|
b->s[b->len++] = c;
|
|
b->s[b->len] = 0;
|
|
}
|
|
static char *str_take(Str *b) {
|
|
char *s = b->s ? b->s : xstrdup("");
|
|
b->s = NULL;
|
|
b->len = b->cap = 0;
|
|
return s;
|
|
}
|
|
|
|
/* ---------- values ---------- */
|
|
typedef struct Value Value;
|
|
typedef struct {
|
|
Value *items;
|
|
int count, cap;
|
|
} List;
|
|
typedef struct {
|
|
char **keys;
|
|
Value *vals;
|
|
int count, cap;
|
|
} Map;
|
|
struct Value {
|
|
int type;
|
|
double num;
|
|
int boolean;
|
|
char *str;
|
|
List *list;
|
|
Map *map;
|
|
};
|
|
enum { V_NONE, V_NUM, V_STR, V_BOOL, V_LIST, V_MAP };
|
|
|
|
static Value v_none(void) {
|
|
Value v;
|
|
memset(&v, 0, sizeof(v));
|
|
v.type = V_NONE;
|
|
return v;
|
|
}
|
|
static Value v_num(double n) {
|
|
Value v = v_none();
|
|
v.type = V_NUM;
|
|
v.num = n;
|
|
return v;
|
|
}
|
|
static Value v_bool(int b) {
|
|
Value v = v_none();
|
|
v.type = V_BOOL;
|
|
v.boolean = b ? 1 : 0;
|
|
return v;
|
|
}
|
|
static Value v_str(const char *s) {
|
|
Value v = v_none();
|
|
v.type = V_STR;
|
|
v.str = xstrdup(s ? s : "");
|
|
return v;
|
|
}
|
|
static List *list_new(void) {
|
|
List *l = (List *)xmalloc(sizeof(List));
|
|
l->items = NULL;
|
|
l->count = l->cap = 0;
|
|
return l;
|
|
}
|
|
static Map *map_new(void) {
|
|
Map *m = (Map *)xmalloc(sizeof(Map));
|
|
m->keys = NULL;
|
|
m->vals = NULL;
|
|
m->count = m->cap = 0;
|
|
return m;
|
|
}
|
|
static Value v_list(void) {
|
|
Value v = v_none();
|
|
v.type = V_LIST;
|
|
v.list = list_new();
|
|
return v;
|
|
}
|
|
static Value v_map(void) {
|
|
Value v = v_none();
|
|
v.type = V_MAP;
|
|
v.map = map_new();
|
|
return v;
|
|
}
|
|
static Value v_copy(Value v);
|
|
static void value_free(Value v) {
|
|
int i;
|
|
if (v.type == V_STR) {
|
|
free(v.str);
|
|
} else if (v.type == V_LIST && v.list) {
|
|
for (i = 0; i < v.list->count; i++)
|
|
value_free(v.list->items[i]);
|
|
free(v.list->items);
|
|
free(v.list);
|
|
} else if (v.type == V_MAP && v.map) {
|
|
for (i = 0; i < v.map->count; i++) {
|
|
free(v.map->keys[i]);
|
|
value_free(v.map->vals[i]);
|
|
}
|
|
free(v.map->keys);
|
|
free(v.map->vals);
|
|
free(v.map);
|
|
}
|
|
}
|
|
static void list_add(List *l, Value v) {
|
|
if (l->count >= l->cap) {
|
|
l->cap = l->cap ? l->cap * 2 : 8;
|
|
l->items = (Value *)xrealloc(l->items, sizeof(Value) * l->cap);
|
|
}
|
|
l->items[l->count++] = v_copy(v);
|
|
}
|
|
static int map_index(Map *m, const char *key) {
|
|
int i;
|
|
for (i = 0; i < m->count; i++)
|
|
if (strcmp(m->keys[i], key) == 0)
|
|
return i;
|
|
return -1;
|
|
}
|
|
static void map_put(Map *m, const char *key, Value v) {
|
|
int i = map_index(m, key);
|
|
if (i >= 0) {
|
|
value_free(m->vals[i]);
|
|
m->vals[i] = v_copy(v);
|
|
return;
|
|
}
|
|
if (m->count >= m->cap) {
|
|
m->cap = m->cap ? m->cap * 2 : 8;
|
|
m->keys = (char **)xrealloc(m->keys, sizeof(char *) * m->cap);
|
|
m->vals = (Value *)xrealloc(m->vals, sizeof(Value) * m->cap);
|
|
}
|
|
m->keys[m->count] = xstrdup(key);
|
|
m->vals[m->count++] = v_copy(v);
|
|
}
|
|
static Value map_get(Map *m, const char *key) {
|
|
int i = map_index(m, key);
|
|
if (i >= 0)
|
|
return v_copy(m->vals[i]);
|
|
return v_none();
|
|
}
|
|
static Value v_copy(Value v) {
|
|
Value o = v_none();
|
|
int i;
|
|
o.type = v.type;
|
|
o.num = v.num;
|
|
o.boolean = v.boolean;
|
|
if (v.type == V_STR)
|
|
o.str = xstrdup(v.str);
|
|
else if (v.type == V_LIST) {
|
|
o = v_list();
|
|
for (i = 0; i < v.list->count; i++)
|
|
list_add(o.list, v.list->items[i]);
|
|
} else if (v.type == V_MAP) {
|
|
o = v_map();
|
|
for (i = 0; i < v.map->count; i++)
|
|
map_put(o.map, v.map->keys[i], v.map->vals[i]);
|
|
}
|
|
return o;
|
|
}
|
|
static int v_truth(Value v) {
|
|
if (v.type == V_BOOL)
|
|
return v.boolean;
|
|
if (v.type == V_NUM)
|
|
return fabs(v.num) > 0.0000001;
|
|
if (v.type == V_STR)
|
|
return v.str && v.str[0];
|
|
if (v.type == V_LIST)
|
|
return v.list && v.list->count > 0;
|
|
if (v.type == V_MAP)
|
|
return v.map && v.map->count > 0;
|
|
return 0;
|
|
}
|
|
static double v_number(Value v) {
|
|
if (v.type == V_NUM)
|
|
return v.num;
|
|
if (v.type == V_BOOL)
|
|
return v.boolean;
|
|
if (v.type == V_STR)
|
|
return atof(v.str ? v.str : "");
|
|
return 0;
|
|
}
|
|
static char *v_to_string(Value v);
|
|
static char *num_to_string(double d) {
|
|
char buf[80];
|
|
double integer;
|
|
if (fabs(d) < 9223372036854775808.0 && fabs(modf(d, &integer)) < 0.0000001)
|
|
claro_snprintf(buf, sizeof(buf), "%.0f", integer == 0.0 ? 0.0 : integer);
|
|
else
|
|
claro_snprintf(buf, sizeof(buf), "%.15g", d);
|
|
return xstrdup(buf);
|
|
}
|
|
static char *v_to_string(Value v) {
|
|
if (v.type == V_NONE)
|
|
return xstrdup("");
|
|
if (v.type == V_NUM)
|
|
return num_to_string(v.num);
|
|
if (v.type == V_BOOL)
|
|
return xstrdup(v.boolean ? "YES" : "NO");
|
|
if (v.type == V_STR)
|
|
return xstrdup(v.str ? v.str : "");
|
|
if (v.type == V_LIST)
|
|
return xstrdup("[list]");
|
|
if (v.type == V_MAP)
|
|
return xstrdup("[map]");
|
|
return xstrdup("");
|
|
}
|
|
static int parse_number_strict(const char *s, double *out) {
|
|
char *end;
|
|
double d;
|
|
if (!s)
|
|
return 0;
|
|
while (*s && isspace((unsigned char)*s))
|
|
s++;
|
|
if (!*s)
|
|
return 0;
|
|
d = strtod(s, &end);
|
|
if (end == s)
|
|
return 0;
|
|
while (end && *end && isspace((unsigned char)*end))
|
|
end++;
|
|
if (end && *end)
|
|
return 0;
|
|
if (out)
|
|
*out = d;
|
|
return 1;
|
|
}
|
|
static int value_compare(Value a, Value b) {
|
|
char *as, *bs;
|
|
int r;
|
|
double x, y;
|
|
if ((a.type == V_NUM || a.type == V_BOOL) && (b.type == V_NUM || b.type == V_BOOL)) {
|
|
x = v_number(a);
|
|
y = v_number(b);
|
|
if (x < y)
|
|
return -1;
|
|
if (x > y)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
if (a.type == V_STR && (b.type == V_NUM || b.type == V_BOOL) &&
|
|
parse_number_strict(a.str, &x)) {
|
|
y = v_number(b);
|
|
if (x < y)
|
|
return -1;
|
|
if (x > y)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
if ((a.type == V_NUM || a.type == V_BOOL) && b.type == V_STR &&
|
|
parse_number_strict(b.str, &y)) {
|
|
x = v_number(a);
|
|
if (x < y)
|
|
return -1;
|
|
if (x > y)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
if (a.type == V_STR && b.type == V_STR && parse_number_strict(a.str, &x) &&
|
|
parse_number_strict(b.str, &y)) {
|
|
if (x < y)
|
|
return -1;
|
|
if (x > y)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
as = v_to_string(a);
|
|
bs = v_to_string(b);
|
|
r = strcmp(as, bs);
|
|
free(as);
|
|
free(bs);
|
|
return r;
|
|
}
|
|
|
|
/* ---------- env/program/runtime ---------- */
|
|
typedef struct Var {
|
|
char *name;
|
|
Value val;
|
|
struct Var *next;
|
|
} Var;
|
|
typedef struct Program {
|
|
char *path;
|
|
char **lines;
|
|
int count, cap;
|
|
} Program;
|
|
typedef struct Function {
|
|
char *name;
|
|
char **params;
|
|
int pcnt;
|
|
Program *prog;
|
|
int start, end;
|
|
struct Function *next;
|
|
} Function;
|
|
typedef struct Module {
|
|
char *ns;
|
|
char *kind;
|
|
struct Module *next;
|
|
} Module;
|
|
typedef struct FieldDef {
|
|
char *name;
|
|
char *type;
|
|
struct FieldDef *next;
|
|
} FieldDef;
|
|
typedef struct ClassDef {
|
|
char *name;
|
|
FieldDef *fields;
|
|
struct ClassDef *next;
|
|
} ClassDef;
|
|
typedef struct Runtime {
|
|
Var *globals;
|
|
Var *locals;
|
|
Function *funcs;
|
|
Module *modules;
|
|
ClassDef *classes;
|
|
Str captured;
|
|
int capture;
|
|
int trace;
|
|
int error;
|
|
char *err_msg;
|
|
char *err_file;
|
|
int err_line;
|
|
const char *active_file; /* borrowed while a source line executes */
|
|
int active_line;
|
|
unsigned long steps, step_limit, read_file_limit;
|
|
int returning;
|
|
Value ret;
|
|
int call_depth;
|
|
int range_depth;
|
|
Program **programs;
|
|
int pcount, pcap;
|
|
char **import_stack;
|
|
int import_depth;
|
|
int script_argc;
|
|
char **script_argv;
|
|
} Runtime;
|
|
static void rt_error(Runtime *rt, const char *file, int line, const char *fmt, ...);
|
|
static unsigned long rt_env_limit(Runtime *rt, const char *name) {
|
|
const char *text = getenv(name);
|
|
unsigned long value = 0;
|
|
if (!text || !*text) return 0;
|
|
while (*text) {
|
|
unsigned long digit;
|
|
if (*text < '0' || *text > '9') {
|
|
rt_error(rt, "<configuration>", 1, "%s needs a non-negative whole number.", name);
|
|
return 0;
|
|
}
|
|
digit = (unsigned long)(*text++ - '0');
|
|
if (value > (ULONG_MAX - digit) / 10) {
|
|
rt_error(rt, "<configuration>", 1, "%s is too large for this build.", name);
|
|
return 0;
|
|
}
|
|
value = value * 10 + digit;
|
|
}
|
|
return value;
|
|
}
|
|
static int rt_tick(Runtime *rt) {
|
|
if (rt->error) return 0;
|
|
if (!rt->step_limit) return 1;
|
|
if (rt->steps >= rt->step_limit) {
|
|
rt_error(rt, "", 0, "Execution reached its step limit. Check the loop or raise CLARO_STEP_LIMIT.");
|
|
return 0;
|
|
}
|
|
rt->steps++;
|
|
return 1;
|
|
}
|
|
static void rt_init(Runtime *rt) {
|
|
memset(rt, 0, sizeof(*rt));
|
|
str_init(&rt->captured);
|
|
rt->ret = v_none();
|
|
rt->step_limit = rt_env_limit(rt, "CLARO_STEP_LIMIT");
|
|
rt->read_file_limit = rt_env_limit(rt, "CLARO_READ_FILE_LIMIT");
|
|
srand(1);
|
|
}
|
|
static Var *env_find(Var *v, const char *name) {
|
|
while (v) {
|
|
if (strcmp(v->name, name) == 0)
|
|
return v;
|
|
v = v->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static Value rt_get(Runtime *rt, const char *name) {
|
|
Var *v = env_find(rt->locals, name);
|
|
if (v)
|
|
return v_copy(v->val);
|
|
v = env_find(rt->globals, name);
|
|
if (v)
|
|
return v_copy(v->val);
|
|
return v_none();
|
|
}
|
|
static int rt_has(Runtime *rt, const char *name) {
|
|
return env_find(rt->locals, name) || env_find(rt->globals, name);
|
|
}
|
|
static void rt_set(Runtime *rt, const char *name, Value val) {
|
|
Var **head = rt->locals ? &rt->locals : &rt->globals;
|
|
Var *v = env_find(*head, name);
|
|
if (!v && rt->locals)
|
|
v = env_find(rt->globals, name);
|
|
if (v) {
|
|
value_free(v->val);
|
|
v->val = v_copy(val);
|
|
return;
|
|
}
|
|
v = (Var *)xmalloc(sizeof(Var));
|
|
v->name = xstrdup(name);
|
|
v->val = v_copy(val);
|
|
v->next = *head;
|
|
*head = v;
|
|
}
|
|
static void rt_set_global(Runtime *rt, const char *name, Value val) {
|
|
Var *v = env_find(rt->globals, name);
|
|
if (v) {
|
|
value_free(v->val);
|
|
v->val = v_copy(val);
|
|
return;
|
|
}
|
|
v = (Var *)xmalloc(sizeof(Var));
|
|
v->name = xstrdup(name);
|
|
v->val = v_copy(val);
|
|
v->next = rt->globals;
|
|
rt->globals = v;
|
|
}
|
|
|
|
static void rt_error(Runtime *rt, const char *file, int line, const char *fmt, ...);
|
|
static char *normalize_path_copy(const char *path) {
|
|
char *out = xstrdup(path ? path : "");
|
|
char *p;
|
|
for (p = out; *p; p++)
|
|
if (*p == '\\')
|
|
*p = '/';
|
|
return out;
|
|
}
|
|
static int claro_is_type_word(const char *s) {
|
|
return s && (ci_eq(s, "NUMBER") || ci_eq(s, "TEXT") || ci_eq(s, "YESNO") || ci_eq(s, "BOOL") ||
|
|
ci_eq(s, "BOOLEAN") || ci_eq(s, "LIST") || ci_eq(s, "MAP") || ci_eq(s, "OBJECT") ||
|
|
ci_eq(s, "ANY"));
|
|
}
|
|
static const char *claro_value_type(Value v) {
|
|
if (v.type == V_NUM)
|
|
return "NUMBER";
|
|
if (v.type == V_STR)
|
|
return "TEXT";
|
|
if (v.type == V_BOOL)
|
|
return "YESNO";
|
|
if (v.type == V_LIST)
|
|
return "LIST";
|
|
if (v.type == V_MAP)
|
|
return "MAP";
|
|
return "NONE";
|
|
}
|
|
static Value claro_default_for_type(const char *type) {
|
|
if (ci_eq(type, "NUMBER"))
|
|
return v_num(0);
|
|
if (ci_eq(type, "TEXT"))
|
|
return v_str("");
|
|
if (ci_eq(type, "YESNO") || ci_eq(type, "BOOL") || ci_eq(type, "BOOLEAN"))
|
|
return v_bool(0);
|
|
if (ci_eq(type, "LIST"))
|
|
return v_list();
|
|
if (ci_eq(type, "MAP") || ci_eq(type, "OBJECT"))
|
|
return v_map();
|
|
return v_none();
|
|
}
|
|
static int claro_type_matches(const char *type, Value v) {
|
|
if (!type || !*type || ci_eq(type, "ANY"))
|
|
return 1;
|
|
if (ci_eq(type, "NUMBER"))
|
|
return v.type == V_NUM || (v.type == V_STR && parse_number_strict(v.str, NULL));
|
|
if (ci_eq(type, "TEXT"))
|
|
return v.type == V_STR;
|
|
if (ci_eq(type, "YESNO") || ci_eq(type, "BOOL") || ci_eq(type, "BOOLEAN"))
|
|
return v.type == V_BOOL;
|
|
if (ci_eq(type, "LIST"))
|
|
return v.type == V_LIST;
|
|
if (ci_eq(type, "MAP") || ci_eq(type, "OBJECT"))
|
|
return v.type == V_MAP;
|
|
return 1;
|
|
}
|
|
static int claro_value_from_text(const char *type, const char *text, Value *out) {
|
|
double d;
|
|
if (!type || !*type || ci_eq(type, "TEXT") || ci_eq(type, "ANY")) {
|
|
if (out)
|
|
*out = v_str(text ? text : "");
|
|
return 1;
|
|
}
|
|
if (ci_eq(type, "NUMBER")) {
|
|
if (parse_number_strict(text, &d)) {
|
|
if (out)
|
|
*out = v_num(d);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
if (ci_eq(type, "YESNO") || ci_eq(type, "BOOL") || ci_eq(type, "BOOLEAN")) {
|
|
if (ci_eq(text, "YES") || ci_eq(text, "TRUE") || strcmp(text, "1") == 0) {
|
|
if (out)
|
|
*out = v_bool(1);
|
|
return 1;
|
|
}
|
|
if (ci_eq(text, "NO") || ci_eq(text, "FALSE") || strcmp(text, "0") == 0) {
|
|
if (out)
|
|
*out = v_bool(0);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
if (ci_eq(type, "LIST")) {
|
|
if (out)
|
|
*out = v_list();
|
|
return 1;
|
|
}
|
|
if (ci_eq(type, "MAP") || ci_eq(type, "OBJECT")) {
|
|
if (out)
|
|
*out = v_map();
|
|
return 1;
|
|
}
|
|
if (out)
|
|
*out = v_str(text ? text : "");
|
|
return 1;
|
|
}
|
|
static const char *runtime_type_for(Runtime *rt, const char *name, char *buf, size_t n);
|
|
static const char *declared_type_for_expr(Runtime *rt, const char *expr, char *buf, size_t n) {
|
|
char tmp[256];
|
|
const char *t = expr;
|
|
size_t i = 0;
|
|
while (t && *t && isspace((unsigned char)*t))
|
|
t++;
|
|
if (!t || !*t)
|
|
return NULL;
|
|
while (t[i] && (isalnum((unsigned char)t[i]) || t[i] == '_' || t[i] == '.') &&
|
|
i + 1 < sizeof(tmp)) {
|
|
tmp[i] = t[i];
|
|
i++;
|
|
}
|
|
tmp[i] = 0;
|
|
if (!tmp[0])
|
|
return NULL;
|
|
return runtime_type_for(rt, tmp, buf, n);
|
|
}
|
|
static void type_key_for(const char *name, char *out, size_t n) {
|
|
claro_snprintf(out, n, "__type_%s", name ? name : "");
|
|
}
|
|
static const char *runtime_type_for(Runtime *rt, const char *name, char *buf, size_t n) {
|
|
Var *entry;
|
|
type_key_for(name, buf, n);
|
|
entry = env_find(rt->locals, buf);
|
|
if (!entry)
|
|
entry = env_find(rt->globals, buf);
|
|
if (entry && entry->val.type == V_STR && entry->val.str && entry->val.str[0])
|
|
return entry->val.str;
|
|
return NULL;
|
|
}
|
|
static int rt_set_checked(Runtime *rt, const char *file, int line, const char *name,
|
|
const char *type, Value val) {
|
|
char key[320], oldbuf[320];
|
|
const char *oldtype = NULL;
|
|
char *dot;
|
|
if (!name || !*name)
|
|
return 0;
|
|
if (type && *type) {
|
|
Value metadata;
|
|
type_key_for(name, key, sizeof(key));
|
|
metadata = v_str(type);
|
|
rt_set(rt, key, metadata);
|
|
value_free(metadata);
|
|
oldtype = type;
|
|
} else
|
|
oldtype = runtime_type_for(rt, name, oldbuf, sizeof(oldbuf));
|
|
if (oldtype && !claro_type_matches(oldtype, val)) {
|
|
rt_error(rt, file, line, "%s must be %s, but got %s.", name, oldtype,
|
|
claro_value_type(val));
|
|
return 0;
|
|
}
|
|
dot = strchr(name, '.');
|
|
if (dot) {
|
|
char objname[256];
|
|
char field[256];
|
|
Value obj;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - name), name);
|
|
claro_snprintf(field, sizeof(field), "%s", dot + 1);
|
|
obj = rt_get(rt, objname);
|
|
if (obj.type != V_MAP) {
|
|
value_free(obj);
|
|
obj = v_map();
|
|
}
|
|
map_put(obj.map, field, val);
|
|
rt_set(rt, objname, obj);
|
|
value_free(obj);
|
|
}
|
|
rt_set(rt, name, val);
|
|
return 1;
|
|
}
|
|
static void graphics_note(Runtime *rt, const char *what) {
|
|
(void)what;
|
|
rt_set(rt, "GRAPHICS_READY", v_bool(1));
|
|
}
|
|
|
|
static void rt_error(Runtime *rt, const char *file, int line, const char *fmt, ...) {
|
|
va_list ap;
|
|
char buf[1024];
|
|
char *nfile;
|
|
Value message, file_value;
|
|
if (rt->error)
|
|
return;
|
|
va_start(ap, fmt);
|
|
claro_vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
va_end(ap);
|
|
if (!file || !*file)
|
|
file = rt->active_file;
|
|
if (line <= 0)
|
|
line = rt->active_line;
|
|
nfile = normalize_path_copy(file ? file : "");
|
|
rt->error = 1;
|
|
rt->err_msg = xstrdup(buf);
|
|
rt->err_file = xstrdup(nfile);
|
|
rt->err_line = line;
|
|
message = v_str(buf);
|
|
rt_set(rt, "LASTERROR", message);
|
|
value_free(message);
|
|
file_value = v_str(nfile);
|
|
rt_set(rt, "LASTERRORFILE", file_value);
|
|
value_free(file_value);
|
|
rt_set(rt, "LASTERRORLINE", v_num(line));
|
|
free(nfile);
|
|
}
|
|
static void rt_clear_error(Runtime *rt) {
|
|
rt->error = 0;
|
|
free(rt->err_msg);
|
|
free(rt->err_file);
|
|
rt->err_msg = NULL;
|
|
rt->err_file = NULL;
|
|
}
|
|
static void out_line(Runtime *rt, Value v) {
|
|
char *s = v_to_string(v);
|
|
if (rt->capture) {
|
|
str_add(&rt->captured, s);
|
|
str_ch(&rt->captured, '\n');
|
|
} else {
|
|
printf("%s\n", s);
|
|
}
|
|
free(s);
|
|
}
|
|
static void add_function(Runtime *rt, const char *name, char **params, int pcnt, Program *p,
|
|
int start, int end) {
|
|
Function *f = (Function *)xmalloc(sizeof(Function));
|
|
int i;
|
|
f->name = xstrdup(name);
|
|
f->pcnt = pcnt;
|
|
f->params = (char **)xmalloc(sizeof(char *) * (pcnt ? pcnt : 1));
|
|
for (i = 0; i < pcnt; i++)
|
|
f->params[i] = xstrdup(params[i]);
|
|
f->prog = p;
|
|
f->start = start;
|
|
f->end = end;
|
|
f->next = rt->funcs;
|
|
rt->funcs = f;
|
|
}
|
|
static Function *find_function(Runtime *rt, const char *name) {
|
|
Function *f = rt->funcs;
|
|
while (f) {
|
|
if (strcmp(f->name, name) == 0)
|
|
return f;
|
|
f = f->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static void add_module(Runtime *rt, const char *ns, const char *kind) {
|
|
Module *m = (Module *)xmalloc(sizeof(Module));
|
|
m->ns = xstrdup(ns);
|
|
m->kind = xstrdup(kind);
|
|
m->next = rt->modules;
|
|
rt->modules = m;
|
|
}
|
|
static const char *module_kind(Runtime *rt, const char *ns) {
|
|
Module *m = rt->modules;
|
|
while (m) {
|
|
if (strcmp(m->ns, ns) == 0)
|
|
return m->kind;
|
|
m = m->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static ClassDef *find_class(Runtime *rt, const char *name) {
|
|
ClassDef *c = rt->classes;
|
|
while (c) {
|
|
if (strcmp(c->name, name) == 0)
|
|
return c;
|
|
c = c->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static ClassDef *add_class(Runtime *rt, const char *name) {
|
|
ClassDef *c = find_class(rt, name);
|
|
if (c)
|
|
return c;
|
|
c = (ClassDef *)xmalloc(sizeof(ClassDef));
|
|
c->name = xstrdup(name);
|
|
c->fields = NULL;
|
|
c->next = rt->classes;
|
|
rt->classes = c;
|
|
return c;
|
|
}
|
|
static FieldDef *find_field(ClassDef *c, const char *name) {
|
|
FieldDef *f = c ? c->fields : NULL;
|
|
while (f) {
|
|
if (strcmp(f->name, name) == 0)
|
|
return f;
|
|
f = f->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static void class_add_field(ClassDef *c, const char *name, const char *type) {
|
|
FieldDef *f;
|
|
if (!c || !name || !*name)
|
|
return;
|
|
f = find_field(c, name);
|
|
if (f) {
|
|
free(f->type);
|
|
f->type = xstrdup(type && *type ? type : "ANY");
|
|
return;
|
|
}
|
|
f = (FieldDef *)xmalloc(sizeof(FieldDef));
|
|
f->name = xstrdup(name);
|
|
f->type = xstrdup(type && *type ? type : "ANY");
|
|
f->next = c->fields;
|
|
c->fields = f;
|
|
}
|
|
static const char *object_class_name(Value obj) {
|
|
int index;
|
|
if (obj.type != V_MAP || !obj.map)
|
|
return NULL;
|
|
index = map_index(obj.map, "class");
|
|
if (index >= 0 && obj.map->vals[index].type == V_STR &&
|
|
obj.map->vals[index].str && obj.map->vals[index].str[0])
|
|
return obj.map->vals[index].str;
|
|
return NULL;
|
|
}
|
|
|
|
/* ---------- tokenization / expressions ---------- */
|
|
typedef struct {
|
|
char **t;
|
|
int n, cap, pos;
|
|
int depth;
|
|
const char *error;
|
|
} Tokens;
|
|
static void toks_add(Tokens *ts, const char *s, size_t n) {
|
|
if (ts->n >= ts->cap) {
|
|
ts->cap = ts->cap ? ts->cap * 2 : 16;
|
|
ts->t = (char **)xrealloc(ts->t, sizeof(char *) * ts->cap);
|
|
}
|
|
ts->t[ts->n] = (char *)xmalloc(n + 1);
|
|
memcpy(ts->t[ts->n], s, n);
|
|
ts->t[ts->n][n] = 0;
|
|
ts->n++;
|
|
}
|
|
static Tokens tokenize(const char *s) {
|
|
Tokens ts;
|
|
size_t i = 0;
|
|
memset(&ts, 0, sizeof(ts));
|
|
while (s[i]) {
|
|
if (isspace((unsigned char)s[i])) {
|
|
i++;
|
|
continue;
|
|
}
|
|
if (s[i] == '"') {
|
|
Str b;
|
|
Str q;
|
|
str_init(&b);
|
|
str_init(&q);
|
|
i++;
|
|
while (s[i] && s[i] != '"') {
|
|
if (s[i] == '\\') {
|
|
i++;
|
|
if (s[i] == 'n')
|
|
str_ch(&b, '\n');
|
|
else if (s[i] == 't')
|
|
str_ch(&b, '\t');
|
|
else if (s[i] == 'r')
|
|
str_ch(&b, '\r');
|
|
else if (s[i] == '"')
|
|
str_ch(&b, '"');
|
|
else if (s[i] == '\\')
|
|
str_ch(&b, '\\');
|
|
else if (s[i])
|
|
str_ch(&b, s[i]);
|
|
if (s[i])
|
|
i++;
|
|
} else
|
|
str_ch(&b, s[i++]);
|
|
}
|
|
if (s[i] == '"')
|
|
i++;
|
|
else if (!ts.error)
|
|
ts.error = "Text is missing a closing quote. Add a double quote at the end.";
|
|
str_ch(&q, '\001');
|
|
str_add(&q, b.s ? b.s : "");
|
|
toks_add(&ts, q.s ? q.s : "", strlen(q.s ? q.s : ""));
|
|
free(b.s);
|
|
free(q.s);
|
|
continue;
|
|
}
|
|
if (strchr("(),", s[i])) {
|
|
toks_add(&ts, s + i, 1);
|
|
i++;
|
|
continue;
|
|
}
|
|
if ((s[i] == '!' || s[i] == '<' || s[i] == '>') && s[i + 1] == '=') {
|
|
toks_add(&ts, s + i, 2);
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (strchr("!+-*/=<>", s[i])) {
|
|
if (s[i] == '!' && !ts.error)
|
|
ts.error = "Use NOT instead of ! to reverse a condition.";
|
|
toks_add(&ts, s + i, 1);
|
|
i++;
|
|
continue;
|
|
}
|
|
{
|
|
size_t st = i;
|
|
while (s[i] && !isspace((unsigned char)s[i]) && !strchr("(),+-*/=<>!", s[i]))
|
|
i++;
|
|
toks_add(&ts, s + st, i - st);
|
|
}
|
|
}
|
|
return ts;
|
|
}
|
|
static void tokens_free(Tokens *ts) {
|
|
int i;
|
|
if (!ts)
|
|
return;
|
|
for (i = 0; i < ts->n; i++)
|
|
free(ts->t[i]);
|
|
free(ts->t);
|
|
ts->t = NULL;
|
|
ts->n = ts->cap = ts->pos = 0;
|
|
}
|
|
static int tok_end(Tokens *ts) { return ts->pos >= ts->n; }
|
|
static char *tok_peek(Tokens *ts) { return tok_end(ts) ? NULL : ts->t[ts->pos]; }
|
|
static char *tok_next(Tokens *ts) { return tok_end(ts) ? NULL : ts->t[ts->pos++]; }
|
|
static int tok_match(Tokens *ts, const char *s) {
|
|
if (!tok_end(ts) && ci_eq(ts->t[ts->pos], s)) {
|
|
ts->pos++;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
static Value parse_expr(Runtime *rt, Tokens *ts);
|
|
static Value parse_primary(Runtime *rt, Tokens *ts) {
|
|
char *t = tok_next(ts);
|
|
Value v;
|
|
if (!t) {
|
|
if (ts->n)
|
|
rt_error(rt, "", 0, "This expression needs a value after the operator.");
|
|
return v_none();
|
|
}
|
|
if (strcmp(t, "(") == 0) {
|
|
v = parse_expr(rt, ts);
|
|
if (!tok_match(ts, ")"))
|
|
rt_error(rt, "", 0, "This expression needs a closing parenthesis: ).");
|
|
return v;
|
|
}
|
|
if (strcmp(t, ")") == 0) {
|
|
rt_error(rt, "", 0, "This expression needs a value before the closing parenthesis.");
|
|
return v_none();
|
|
}
|
|
if (t[0] == '\001')
|
|
return v_str(t + 1);
|
|
if (ci_eq(t, "YES"))
|
|
return v_bool(1);
|
|
if (ci_eq(t, "NO"))
|
|
return v_bool(0);
|
|
if (ci_eq(t, "NONE"))
|
|
return v_none();
|
|
if (ci_eq(t, "LIST"))
|
|
return v_list();
|
|
if (ci_eq(t, "MAP"))
|
|
return v_map();
|
|
if ((isdigit((unsigned char)t[0]) ||
|
|
((t[0] == '-' || t[0] == '+') && isdigit((unsigned char)t[1])))) {
|
|
char *end = NULL;
|
|
double d = strtod(t, &end);
|
|
if (end && *end == 0)
|
|
return v_num(d);
|
|
}
|
|
/* Because tokenizer stores string literals as raw token text, quoted and bare identifiers are
|
|
* ambiguous. Bare identifiers resolve to variables; unresolved become strings only when they
|
|
* came from quotes. We mark quoted literals by detecting tokens that contain spaces/newlines or
|
|
* are followed by original quotes is not possible here. To keep Claro beginner-friendly,
|
|
* unresolved words become variable lookup if known, otherwise plain text. */
|
|
if (rt_has(rt, t))
|
|
return rt_get(rt, t);
|
|
if (isalpha((unsigned char)t[0]) || strchr(t, '.')) {
|
|
rt_error(rt, "", 0, "I do not know the variable \"%s\" yet.", t);
|
|
return v_none();
|
|
}
|
|
return v_str(t);
|
|
}
|
|
static Value parse_unary(Runtime *rt, Tokens *ts) {
|
|
Value v, out;
|
|
if (ts->depth >= CLARO_MAX_EXPR_DEPTH) {
|
|
rt_error(rt, "", 0, "Expression nesting exceeds the safe limit of 128. Simplify the expression.");
|
|
return v_none();
|
|
}
|
|
ts->depth++;
|
|
if (tok_match(ts, "NOT")) {
|
|
v = parse_unary(rt, ts);
|
|
out = v_bool(!v_truth(v));
|
|
value_free(v);
|
|
} else if (tok_match(ts, "-")) {
|
|
v = parse_unary(rt, ts);
|
|
out = v_num(-v_number(v));
|
|
value_free(v);
|
|
} else
|
|
out = parse_primary(rt, ts);
|
|
ts->depth--;
|
|
return out;
|
|
}
|
|
static Value parse_mul(Runtime *rt, Tokens *ts) {
|
|
Value v = parse_unary(rt, ts);
|
|
while (!tok_end(ts)) {
|
|
char *op = tok_peek(ts);
|
|
Value out;
|
|
if (strcmp(op, "*") && strcmp(op, "/"))
|
|
break;
|
|
tok_next(ts);
|
|
{
|
|
Value r = parse_unary(rt, ts);
|
|
if (strcmp(op, "*") == 0)
|
|
out = v_num(v_number(v) * v_number(r));
|
|
else
|
|
out = v_num(v_number(r) == 0 ? 0 : v_number(v) / v_number(r));
|
|
value_free(v);
|
|
value_free(r);
|
|
v = out;
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
static Value parse_add(Runtime *rt, Tokens *ts) {
|
|
Value v = parse_mul(rt, ts);
|
|
while (!tok_end(ts)) {
|
|
char *op = tok_peek(ts);
|
|
Value out;
|
|
if (strcmp(op, "+") && strcmp(op, "-"))
|
|
break;
|
|
tok_next(ts);
|
|
{
|
|
Value r = parse_mul(rt, ts);
|
|
if (strcmp(op, "+") == 0) {
|
|
double x, y;
|
|
int vn = 0, rn = 0;
|
|
if (v.type == V_NUM || v.type == V_BOOL) {
|
|
x = v_number(v);
|
|
vn = 1;
|
|
} else if (v.type == V_STR && parse_number_strict(v.str, &x))
|
|
vn = 1;
|
|
if (r.type == V_NUM || r.type == V_BOOL) {
|
|
y = v_number(r);
|
|
rn = 1;
|
|
} else if (r.type == V_STR && parse_number_strict(r.str, &y))
|
|
rn = 1;
|
|
if (vn && rn)
|
|
out = v_num(x + y);
|
|
else if (v.type == V_STR || r.type == V_STR) {
|
|
char *a = v_to_string(v), *b = v_to_string(r);
|
|
Str s;
|
|
str_init(&s);
|
|
str_add(&s, a);
|
|
str_add(&s, b);
|
|
out = v_str(s.s ? s.s : "");
|
|
free(a);
|
|
free(b);
|
|
free(s.s);
|
|
} else
|
|
out = v_num(v_number(v) + v_number(r));
|
|
} else
|
|
out = v_num(v_number(v) - v_number(r));
|
|
value_free(v);
|
|
value_free(r);
|
|
v = out;
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
static Value parse_cmp(Runtime *rt, Tokens *ts) {
|
|
Value v = parse_add(rt, ts);
|
|
while (!tok_end(ts)) {
|
|
char *op = tok_peek(ts);
|
|
int c;
|
|
Value out;
|
|
if (!(ci_eq(op, "IS") || !strcmp(op, "=") || !strcmp(op, "!=") || !strcmp(op, "<") ||
|
|
!strcmp(op, "<=") || !strcmp(op, ">") || !strcmp(op, ">=")))
|
|
break;
|
|
tok_next(ts);
|
|
{
|
|
Value r = parse_add(rt, ts);
|
|
c = value_compare(v, r);
|
|
if (ci_eq(op, "IS") || !strcmp(op, "="))
|
|
out = v_bool(c == 0);
|
|
else if (!strcmp(op, "!="))
|
|
out = v_bool(c != 0);
|
|
else if (!strcmp(op, "<"))
|
|
out = v_bool(c < 0);
|
|
else if (!strcmp(op, "<="))
|
|
out = v_bool(c <= 0);
|
|
else if (!strcmp(op, ">"))
|
|
out = v_bool(c > 0);
|
|
else
|
|
out = v_bool(c >= 0);
|
|
value_free(v);
|
|
value_free(r);
|
|
v = out;
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
static Value parse_and(Runtime *rt, Tokens *ts) {
|
|
Value v = parse_cmp(rt, ts);
|
|
while (tok_match(ts, "AND")) {
|
|
Value r = parse_cmp(rt, ts);
|
|
Value out = v_bool(v_truth(v) && v_truth(r));
|
|
value_free(v);
|
|
value_free(r);
|
|
v = out;
|
|
}
|
|
return v;
|
|
}
|
|
static Value parse_expr(Runtime *rt, Tokens *ts) {
|
|
Value v = parse_and(rt, ts);
|
|
while (tok_match(ts, "OR")) {
|
|
Value r = parse_and(rt, ts);
|
|
Value out = v_bool(v_truth(v) || v_truth(r));
|
|
value_free(v);
|
|
value_free(r);
|
|
v = out;
|
|
}
|
|
return v;
|
|
}
|
|
static Value eval_expr(Runtime *rt, const char *expr) {
|
|
Tokens ts = tokenize(expr);
|
|
Value v = v_none();
|
|
if (ts.error)
|
|
rt_error(rt, "", 0, "%s", ts.error);
|
|
else {
|
|
v = parse_expr(rt, &ts);
|
|
if (!rt->error && !tok_end(&ts))
|
|
rt_error(rt, "", 0, "Unexpected text after this expression: %s.", tok_peek(&ts));
|
|
}
|
|
tokens_free(&ts);
|
|
return v;
|
|
}
|
|
|
|
/* Better string token parsing helpers for commands. */
|
|
static char *unquote_token(const char **ps) {
|
|
const char *s = *ps;
|
|
Str b;
|
|
str_init(&b);
|
|
while (*s && isspace((unsigned char)*s))
|
|
s++;
|
|
if (*s == '"') {
|
|
s++;
|
|
while (*s && *s != '"') {
|
|
if (*s == '\\') {
|
|
s++;
|
|
if (*s == 'n')
|
|
str_ch(&b, '\n');
|
|
else if (*s == 't')
|
|
str_ch(&b, '\t');
|
|
else if (*s == 'r')
|
|
str_ch(&b, '\r');
|
|
else if (*s == '"')
|
|
str_ch(&b, '"');
|
|
else if (*s == '\\')
|
|
str_ch(&b, '\\');
|
|
else if (*s)
|
|
str_ch(&b, *s);
|
|
if (*s)
|
|
s++;
|
|
} else
|
|
str_ch(&b, *s++);
|
|
}
|
|
if (*s == '"')
|
|
s++;
|
|
} else {
|
|
while (*s && !isspace((unsigned char)*s))
|
|
str_ch(&b, *s++);
|
|
}
|
|
*ps = s;
|
|
return str_take(&b);
|
|
}
|
|
static char *expr_after_word(const char *line, const char *word) {
|
|
const char *p = line;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
while (*p && !isspace((unsigned char)*p))
|
|
p++;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
(void)word;
|
|
return xstrdup(p);
|
|
}
|
|
static char *substr(const char *a, const char *b) {
|
|
char *s;
|
|
if (b < a)
|
|
b = a;
|
|
s = (char *)xmalloc((size_t)(b - a) + 1);
|
|
memcpy(s, a, (size_t)(b - a));
|
|
s[b - a] = 0;
|
|
return s;
|
|
}
|
|
static const char *find_word_ci(const char *s, const char *word) {
|
|
size_t n = strlen(word);
|
|
int inq = 0, depth = 0;
|
|
const char *p = s;
|
|
while (*p) {
|
|
if (*p == '"' && (p == s || p[-1] != '\\'))
|
|
inq = !inq;
|
|
if (!inq) {
|
|
if (*p == '(')
|
|
depth++;
|
|
else if (*p == ')')
|
|
depth--;
|
|
if (depth == 0 && (p == s || isspace((unsigned char)p[-1])) &&
|
|
strnicmp2(p, word, n) == 0 && (p[n] == 0 || isspace((unsigned char)p[n])))
|
|
return p;
|
|
}
|
|
p++;
|
|
}
|
|
return NULL;
|
|
}
|
|
static int split_args(const char *s, char ***out) {
|
|
int count = 0, cap = 0;
|
|
char **arr = NULL;
|
|
int inq = 0, depth = 0;
|
|
const char *st = s, *p = s;
|
|
while (1) {
|
|
char c = *p;
|
|
if (c == '"' && (p == s || p[-1] != '\\'))
|
|
inq = !inq;
|
|
if (!inq) {
|
|
if (c == '(')
|
|
depth++;
|
|
else if (c == ')')
|
|
depth--;
|
|
if ((c == ',' && depth == 0) || c == 0) {
|
|
char *part = substr(st, p);
|
|
char *t = trim_inplace(part);
|
|
if (count >= cap) {
|
|
cap = cap ? cap * 2 : 4;
|
|
arr = (char **)xrealloc(arr, sizeof(char *) * cap);
|
|
}
|
|
arr[count++] = xstrdup(t);
|
|
free(part);
|
|
if (c == 0)
|
|
break;
|
|
st = p + 1;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
*out = arr;
|
|
return count;
|
|
}
|
|
static int split_simple_args(const char *s, char ***out) {
|
|
int count = 0, cap = 0;
|
|
char **arr = NULL;
|
|
const char *p = s;
|
|
if (strchr(s, ','))
|
|
return split_args(s, out);
|
|
while (*p) {
|
|
const char *st;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
if (!*p)
|
|
break;
|
|
st = p;
|
|
if (*p == '"') {
|
|
p++;
|
|
while (*p && (*p != '"' || p[-1] == '\\'))
|
|
p++;
|
|
if (*p)
|
|
p++;
|
|
} else
|
|
while (*p && !isspace((unsigned char)*p))
|
|
p++;
|
|
if (count >= cap) {
|
|
cap = cap ? cap * 2 : 4;
|
|
arr = (char **)xrealloc(arr, sizeof(char *) * cap);
|
|
}
|
|
arr[count++] = substr(st, p);
|
|
}
|
|
*out = arr;
|
|
return count;
|
|
}
|
|
static void split_args_free(char **parts, int count) {
|
|
int i;
|
|
for (i = 0; i < count; i++)
|
|
free(parts[i]);
|
|
free(parts);
|
|
}
|
|
static void call_args_free(Value *args, int count) {
|
|
int i;
|
|
for (i = 0; i < count; i++)
|
|
value_free(args[i]);
|
|
free(args);
|
|
}
|
|
|
|
static int is_word_token(const char *s) {
|
|
if (!s || !*s)
|
|
return 0;
|
|
if (!(isalpha((unsigned char)s[0]) || s[0] == '_'))
|
|
return 0;
|
|
for (s++; *s; s++)
|
|
if (!(isalnum((unsigned char)*s) || *s == '_'))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
static char *text_upper_copy(const char *s) {
|
|
char *o = xstrdup(s ? s : "");
|
|
int i;
|
|
for (i = 0; o[i]; i++)
|
|
o[i] = (char)toupper((unsigned char)o[i]);
|
|
return o;
|
|
}
|
|
static char *text_lower_copy(const char *s) {
|
|
char *o = xstrdup(s ? s : "");
|
|
int i;
|
|
for (i = 0; o[i]; i++)
|
|
o[i] = (char)tolower((unsigned char)o[i]);
|
|
return o;
|
|
}
|
|
static char *text_trim_copy(const char *s) {
|
|
char *o = xstrdup(s ? s : "");
|
|
char *t = trim_inplace(o);
|
|
char *r = xstrdup(t);
|
|
free(o);
|
|
return r;
|
|
}
|
|
static int str_starts_with(const char *s, const char *prefix) {
|
|
size_t n = strlen(prefix ? prefix : "");
|
|
return strncmp(s ? s : "", prefix ? prefix : "", n) == 0;
|
|
}
|
|
static int str_ends_with(const char *s, const char *suffix) {
|
|
size_t a = strlen(s ? s : ""), b = strlen(suffix ? suffix : "");
|
|
return b <= a && strcmp((s ? s : "") + a - b, suffix ? suffix : "") == 0;
|
|
}
|
|
static char *capture_command_output(const char *cmd, int *exit_code, size_t max_bytes) {
|
|
Str out;
|
|
char buf[512];
|
|
FILE *fp;
|
|
int capped = 0;
|
|
str_init(&out);
|
|
#ifdef _WIN32
|
|
fp = _popen(cmd, "r");
|
|
#else
|
|
fp = popen(cmd, "r");
|
|
#endif
|
|
if (!fp) {
|
|
if (exit_code)
|
|
*exit_code = -1;
|
|
return xstrdup("");
|
|
}
|
|
while (fgets(buf, sizeof(buf), fp)) {
|
|
size_t n = strlen(buf);
|
|
if (max_bytes && out.len + n > max_bytes) {
|
|
if (out.len < max_bytes) {
|
|
size_t keep = max_bytes - out.len;
|
|
char *part = substr(buf, buf + keep);
|
|
str_add(&out, part);
|
|
free(part);
|
|
}
|
|
capped = 1;
|
|
continue;
|
|
}
|
|
if (!capped)
|
|
str_add(&out, buf);
|
|
}
|
|
#ifdef _WIN32
|
|
if (exit_code && !capped)
|
|
*exit_code = _pclose(fp);
|
|
else
|
|
_pclose(fp);
|
|
#else
|
|
{
|
|
int status = pclose(fp);
|
|
if (exit_code && !capped) {
|
|
if (WIFEXITED(status))
|
|
*exit_code = WEXITSTATUS(status);
|
|
else if (WIFSIGNALED(status))
|
|
*exit_code = 128 + WTERMSIG(status);
|
|
else
|
|
*exit_code = -1;
|
|
}
|
|
}
|
|
#endif
|
|
if (capped && exit_code)
|
|
*exit_code = -2;
|
|
return str_take(&out);
|
|
}
|
|
|
|
static int claro_url_is_safe(const char *url) {
|
|
int i;
|
|
if (!url || !*url)
|
|
return 0;
|
|
if (!(starts_ci(url, "http://") || starts_ci(url, "https://") || starts_ci(url, "claro://")))
|
|
return 0;
|
|
for (i = 0; url[i]; i++) {
|
|
unsigned char c = (unsigned char)url[i];
|
|
if (c < 32 || c > 126)
|
|
return 0;
|
|
if (url[i] == '"' || url[i] == '\'' || url[i] == '`' || url[i] == '$' || url[i] == '\\' ||
|
|
url[i] == '|' || url[i] == '<' || url[i] == '>')
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
static char *claro_mock_http(const char *url, int *status) {
|
|
if (starts_ci(url, "claro://hello")) {
|
|
if (status)
|
|
*status = 200;
|
|
return xstrdup("Hello from Claro networking.");
|
|
}
|
|
if (starts_ci(url, "claro://json")) {
|
|
if (status)
|
|
*status = 200;
|
|
return xstrdup("{\"message\":\"Hello from Claro\",\"ok\":true}");
|
|
}
|
|
if (starts_ci(url, "claro://empty")) {
|
|
if (status)
|
|
*status = 204;
|
|
return xstrdup("");
|
|
}
|
|
if (status)
|
|
*status = 404;
|
|
return xstrdup("Claro mock URL was not found.");
|
|
}
|
|
static char *claro_http_get_text(const char *url, int *http_status, int *exit_code) {
|
|
char cmd[2300];
|
|
char *raw, *mark, *body;
|
|
const char *marker = "\n__CLARO_HTTP_STATUS__";
|
|
size_t max_bytes = 1024 * 1024;
|
|
if (http_status)
|
|
*http_status = 0;
|
|
if (exit_code)
|
|
*exit_code = 0;
|
|
if (starts_ci(url, "claro://"))
|
|
return claro_mock_http(url, http_status);
|
|
claro_snprintf(cmd, sizeof(cmd),
|
|
"curl -L -s -m 15 -w \"\\n__CLARO_HTTP_STATUS__%%{http_code}\" \"%s\"", url);
|
|
raw = capture_command_output(cmd, exit_code, max_bytes);
|
|
if (exit_code && *exit_code == -2) {
|
|
free(raw);
|
|
return xstrdup("");
|
|
}
|
|
mark = NULL;
|
|
{
|
|
char *scan = raw;
|
|
while ((scan = strstr(scan, marker)) != NULL) {
|
|
mark = scan;
|
|
scan++;
|
|
}
|
|
}
|
|
if (mark) {
|
|
*mark = 0;
|
|
if (http_status)
|
|
*http_status = atoi(mark + strlen(marker));
|
|
body = xstrdup(raw);
|
|
free(raw);
|
|
return body;
|
|
}
|
|
if (http_status)
|
|
*http_status = 0;
|
|
return raw;
|
|
}
|
|
static int write_text_bytes(const char *path, const char *text) {
|
|
FILE *f = fopen(path, "wb");
|
|
if (!f)
|
|
return 0;
|
|
fwrite(text ? text : "", 1, strlen(text ? text : ""), f);
|
|
fclose(f);
|
|
return 1;
|
|
}
|
|
|
|
static int copy_file_bytes(const char *src, const char *dst) {
|
|
FILE *a = fopen(src, "rb"), *b;
|
|
char buf[8192];
|
|
size_t n;
|
|
if (!a)
|
|
return 0;
|
|
b = fopen(dst, "wb");
|
|
if (!b) {
|
|
fclose(a);
|
|
return 0;
|
|
}
|
|
while ((n = fread(buf, 1, sizeof(buf), a)) > 0)
|
|
fwrite(buf, 1, n, b);
|
|
fclose(a);
|
|
fclose(b);
|
|
return 1;
|
|
}
|
|
static int make_folder(const char *path) {
|
|
#ifdef _WIN32
|
|
return _mkdir(path) == 0 || errno == EEXIST;
|
|
#else
|
|
return mkdir(path, 0777) == 0 || errno == EEXIST;
|
|
#endif
|
|
}
|
|
static int remove_folder(const char *path) {
|
|
#ifdef _WIN32
|
|
return _rmdir(path) == 0;
|
|
#else
|
|
return rmdir(path) == 0;
|
|
#endif
|
|
}
|
|
static Value list_folder_value(const char *path) {
|
|
Value arr = v_list();
|
|
#if defined(_WIN32) && !defined(__MINGW32__)
|
|
(void)path;
|
|
#else
|
|
DIR *d = opendir(path);
|
|
struct dirent *de;
|
|
if (!d)
|
|
return arr;
|
|
while ((de = readdir(d))) {
|
|
if (strcmp(de->d_name, ".") && strcmp(de->d_name, ".."))
|
|
list_add(arr.list, v_str(de->d_name));
|
|
}
|
|
closedir(d);
|
|
#endif
|
|
return arr;
|
|
}
|
|
static void value_list_sort(Value v) {
|
|
int i, j;
|
|
if (v.type != V_LIST || !v.list)
|
|
return;
|
|
for (i = 0; i < v.list->count; i++)
|
|
for (j = i + 1; j < v.list->count; j++) {
|
|
char *a = v_to_string(v.list->items[i]);
|
|
char *b = v_to_string(v.list->items[j]);
|
|
if (strcmp(a, b) > 0) {
|
|
Value tmp = v.list->items[i];
|
|
v.list->items[i] = v.list->items[j];
|
|
v.list->items[j] = tmp;
|
|
}
|
|
free(a);
|
|
free(b);
|
|
}
|
|
}
|
|
static void value_list_reverse(Value v) {
|
|
int i;
|
|
if (v.type != V_LIST || !v.list)
|
|
return;
|
|
for (i = 0; i < v.list->count / 2; i++) {
|
|
Value tmp = v.list->items[i];
|
|
v.list->items[i] = v.list->items[v.list->count - 1 - i];
|
|
v.list->items[v.list->count - 1 - i] = tmp;
|
|
}
|
|
}
|
|
|
|
/* ---------- program loading / blocks ---------- */
|
|
static Program *load_program(Runtime *rt, const char *path) {
|
|
FILE *f;
|
|
char buf[4096];
|
|
Program *p;
|
|
int i;
|
|
for (i = 0; i < rt->pcount; i++)
|
|
if (strcmp(rt->programs[i]->path, path) == 0)
|
|
return rt->programs[i];
|
|
f = fopen(path, "rb");
|
|
if (!f)
|
|
return NULL;
|
|
p = (Program *)xmalloc(sizeof(Program));
|
|
p->path = xstrdup(path);
|
|
p->lines = NULL;
|
|
p->count = p->cap = 0;
|
|
while (fgets(buf, sizeof(buf), f)) {
|
|
size_t n = strlen(buf);
|
|
while (n && (buf[n - 1] == '\n' || buf[n - 1] == '\r'))
|
|
buf[--n] = 0;
|
|
if (p->count >= p->cap) {
|
|
p->cap = p->cap ? p->cap * 2 : 32;
|
|
p->lines = (char **)xrealloc(p->lines, sizeof(char *) * p->cap);
|
|
}
|
|
p->lines[p->count++] = xstrdup(buf);
|
|
}
|
|
fclose(f);
|
|
if (rt->pcount >= rt->pcap) {
|
|
rt->pcap = rt->pcap ? rt->pcap * 2 : 16;
|
|
rt->programs = (Program **)xrealloc(rt->programs, sizeof(Program *) * rt->pcap);
|
|
}
|
|
rt->programs[rt->pcount++] = p;
|
|
return p;
|
|
}
|
|
static void program_free(Program *p) {
|
|
int i;
|
|
if (!p)
|
|
return;
|
|
for (i = 0; i < p->count; i++)
|
|
free(p->lines[i]);
|
|
free(p->lines);
|
|
free(p->path);
|
|
free(p);
|
|
}
|
|
static void runtime_programs_free(Runtime *rt) {
|
|
int i;
|
|
if (!rt)
|
|
return;
|
|
for (i = 0; i < rt->pcount; i++)
|
|
program_free(rt->programs[i]);
|
|
free(rt->programs);
|
|
rt->programs = NULL;
|
|
rt->pcount = rt->pcap = 0;
|
|
}
|
|
static void runtime_vars_free(Var **head) {
|
|
Var *v, *next;
|
|
if (!head)
|
|
return;
|
|
for (v = *head; v; v = next) {
|
|
next = v->next;
|
|
free(v->name);
|
|
value_free(v->val);
|
|
free(v);
|
|
}
|
|
*head = NULL;
|
|
}
|
|
static void runtime_free(Runtime *rt) {
|
|
Function *fn, *fn_next;
|
|
Module *m, *m_next;
|
|
ClassDef *c, *c_next;
|
|
FieldDef *field, *field_next;
|
|
int i;
|
|
if (!rt)
|
|
return;
|
|
runtime_programs_free(rt);
|
|
runtime_vars_free(&rt->locals);
|
|
runtime_vars_free(&rt->globals);
|
|
for (fn = rt->funcs; fn; fn = fn_next) {
|
|
fn_next = fn->next;
|
|
free(fn->name);
|
|
for (i = 0; i < fn->pcnt; i++)
|
|
free(fn->params[i]);
|
|
free(fn->params);
|
|
free(fn);
|
|
}
|
|
rt->funcs = NULL;
|
|
for (m = rt->modules; m; m = m_next) {
|
|
m_next = m->next;
|
|
free(m->ns);
|
|
free(m->kind);
|
|
free(m);
|
|
}
|
|
rt->modules = NULL;
|
|
for (c = rt->classes; c; c = c_next) {
|
|
c_next = c->next;
|
|
for (field = c->fields; field; field = field_next) {
|
|
field_next = field->next;
|
|
free(field->name);
|
|
free(field->type);
|
|
free(field);
|
|
}
|
|
free(c->name);
|
|
free(c);
|
|
}
|
|
rt->classes = NULL;
|
|
for (i = 0; i < rt->import_depth; i++)
|
|
free(rt->import_stack[i]);
|
|
free(rt->import_stack);
|
|
rt->import_stack = NULL;
|
|
rt->import_depth = 0;
|
|
free(rt->captured.s);
|
|
rt->captured.s = NULL;
|
|
value_free(rt->ret);
|
|
rt->ret = v_none();
|
|
free(rt->err_msg);
|
|
free(rt->err_file);
|
|
rt->err_msg = NULL;
|
|
rt->err_file = NULL;
|
|
}
|
|
static void scan_functions(Runtime *rt, Program *p, const char *prefix);
|
|
static void line_word(Program *p, int i, char *up, size_t n) {
|
|
char tmp[512], w[128];
|
|
strncpy(tmp, p->lines[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
first_word(trim_inplace(tmp), w, sizeof(w));
|
|
upper_copy(up, w, n);
|
|
}
|
|
static int line_is_block_opener(Program *p, int i, const char *up) {
|
|
char *t;
|
|
char tmp[512];
|
|
if (ci_eq(up, "IF") || ci_eq(up, "FOR") || ci_eq(up, "REPEAT") || ci_eq(up, "TEACH") ||
|
|
ci_eq(up, "TRY") || ci_eq(up, "COMMENT") || ci_eq(up, "CLASS"))
|
|
return 1;
|
|
if (ci_eq(up, "DO")) {
|
|
strncpy(tmp, p->lines[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
return find_word_ci(t, "TIMES") != NULL;
|
|
}
|
|
if (ci_eq(up, "START")) {
|
|
strncpy(tmp, p->lines[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
return starts_ci(t + 5, " TASK");
|
|
}
|
|
return 0;
|
|
}
|
|
static int line_is_block_closer(const char *up) {
|
|
return ci_eq(up, "END") || ci_eq(up, "ENDIF") || ci_eq(up, "DONE") || ci_eq(up, "UNTIL") ||
|
|
ci_eq(up, "LEARNED") || ci_eq(up, "ENDTRY") || ci_eq(up, "ENDCOMMENT") ||
|
|
ci_eq(up, "ENDCLASS") || ci_eq(up, "ENDTASK");
|
|
}
|
|
static int match_block(Program *p, int start, const char *open, const char *close, const char *mid,
|
|
int *midpos) {
|
|
int depth = 0, i;
|
|
char up[64];
|
|
if (midpos)
|
|
*midpos = -1;
|
|
for (i = start; i < p->count; i++) {
|
|
line_word(p, i, up, sizeof(up));
|
|
if (line_is_block_opener(p, i, up)) {
|
|
depth++;
|
|
continue;
|
|
}
|
|
if (mid && ci_eq(up, mid) && depth == 1) {
|
|
if (midpos && *midpos < 0)
|
|
*midpos = i;
|
|
continue;
|
|
}
|
|
if (depth > 1 && line_is_block_closer(up)) {
|
|
depth--;
|
|
continue;
|
|
}
|
|
if (depth == 1 && (ci_eq(up, close) || ci_eq(up, "END"))) {
|
|
depth--;
|
|
if (depth == 0)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
static int find_done(Program *p, int start) {
|
|
int depth = 0, i;
|
|
char up[64];
|
|
for (i = start; i < p->count; i++) {
|
|
line_word(p, i, up, sizeof(up));
|
|
if (line_is_block_opener(p, i, up)) {
|
|
depth++;
|
|
continue;
|
|
}
|
|
if (line_is_block_closer(up)) {
|
|
depth--;
|
|
if (depth == 0)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/* ---------- JSON ---------- */
|
|
typedef struct {
|
|
const char *s;
|
|
int depth;
|
|
const char *error;
|
|
} JsonP;
|
|
#define CLARO_MAX_JSON_DEPTH 128
|
|
static void jp_ws(JsonP *j) {
|
|
while (*j->s && isspace((unsigned char)*j->s))
|
|
j->s++;
|
|
}
|
|
static unsigned long jp_hex4(JsonP *j) {
|
|
unsigned long value = 0;
|
|
int i, digit;
|
|
for (i = 0; i < 4; i++) {
|
|
char c = *j->s;
|
|
if (c >= '0' && c <= '9') digit = c - '0';
|
|
else if (c >= 'a' && c <= 'f') digit = c - 'a' + 10;
|
|
else if (c >= 'A' && c <= 'F') digit = c - 'A' + 10;
|
|
else { j->error = "JSON Unicode escapes need four hexadecimal digits."; return 0; }
|
|
value = value * 16 + (unsigned long)digit;
|
|
j->s++;
|
|
}
|
|
return value;
|
|
}
|
|
static void jp_utf8(JsonP *j, Str *b, unsigned long code) {
|
|
unsigned long low;
|
|
if (code >= 0xd800UL && code <= 0xdbffUL) {
|
|
if (j->s[0] != '\\' || j->s[1] != 'u') {
|
|
j->error = "JSON Unicode needs a matching low surrogate.";
|
|
return;
|
|
}
|
|
j->s += 2;
|
|
low = jp_hex4(j);
|
|
if (j->error) return;
|
|
if (low < 0xdc00UL || low > 0xdfffUL) {
|
|
j->error = "JSON Unicode needs a matching low surrogate.";
|
|
return;
|
|
}
|
|
code = 0x10000UL + (code - 0xd800UL) * 1024 + low - 0xdc00UL;
|
|
} else if (code >= 0xdc00UL && code <= 0xdfffUL) {
|
|
j->error = "JSON Unicode has an unmatched low surrogate.";
|
|
return;
|
|
}
|
|
if (!code) { j->error = "JSON text cannot contain a zero character."; return; }
|
|
if (code < 0x80UL) str_ch(b, (char)code);
|
|
else if (code < 0x800UL) {
|
|
str_ch(b, (char)(0xc0UL | (code >> 6)));
|
|
str_ch(b, (char)(0x80UL | (code & 63)));
|
|
} else if (code < 0x10000UL) {
|
|
str_ch(b, (char)(0xe0UL | (code >> 12)));
|
|
str_ch(b, (char)(0x80UL | ((code >> 6) & 63)));
|
|
str_ch(b, (char)(0x80UL | (code & 63)));
|
|
} else {
|
|
str_ch(b, (char)(0xf0UL | (code >> 18)));
|
|
str_ch(b, (char)(0x80UL | ((code >> 12) & 63)));
|
|
str_ch(b, (char)(0x80UL | ((code >> 6) & 63)));
|
|
str_ch(b, (char)(0x80UL | (code & 63)));
|
|
}
|
|
}
|
|
static char *jp_string(JsonP *j) {
|
|
Str b;
|
|
char escaped;
|
|
str_init(&b);
|
|
jp_ws(j);
|
|
if (*j->s != '"') { j->error = "JSON object keys need double quotes."; return xstrdup(""); }
|
|
j->s++;
|
|
while (*j->s && *j->s != '"' && !j->error) {
|
|
if (*j->s == '\\') {
|
|
j->s++;
|
|
if (!*j->s) { j->error = "JSON text is missing a closing quote."; break; }
|
|
escaped = *j->s++;
|
|
if (escaped == 'n') str_ch(&b, '\n');
|
|
else if (escaped == 't') str_ch(&b, '\t');
|
|
else if (escaped == 'r') str_ch(&b, '\r');
|
|
else if (escaped == 'b') str_ch(&b, '\b');
|
|
else if (escaped == 'f') str_ch(&b, '\f');
|
|
else if (escaped == 'u') {
|
|
unsigned long code = jp_hex4(j);
|
|
if (!j->error) jp_utf8(j, &b, code);
|
|
} else if (escaped == '"' || escaped == '\\' || escaped == '/') str_ch(&b, escaped);
|
|
else j->error = "JSON has an invalid text escape.";
|
|
} else if ((unsigned char)*j->s < 32) j->error = "JSON text contains an unescaped control character.";
|
|
else str_ch(&b, *j->s++);
|
|
}
|
|
if (*j->s == '"') j->s++;
|
|
else if (!j->error) j->error = "JSON text is missing a closing quote.";
|
|
return str_take(&b);
|
|
}
|
|
static Value jp_value(JsonP *j);
|
|
static Value jp_array(JsonP *j) {
|
|
Value arr = v_list();
|
|
j->s++;
|
|
jp_ws(j);
|
|
if (*j->s == ']') { j->s++; return arr; }
|
|
while (!j->error) {
|
|
Value v = jp_value(j);
|
|
if (!j->error) list_add(arr.list, v);
|
|
value_free(v);
|
|
if (j->error) break;
|
|
jp_ws(j);
|
|
if (*j->s == ']') { j->s++; break; }
|
|
if (*j->s != ',') { j->error = "JSON list needs a comma or closing bracket."; break; }
|
|
j->s++;
|
|
}
|
|
return arr;
|
|
}
|
|
static Value jp_object(JsonP *j) {
|
|
Value obj = v_map();
|
|
j->s++;
|
|
jp_ws(j);
|
|
if (*j->s == '}') { j->s++; return obj; }
|
|
while (!j->error) {
|
|
char *key = jp_string(j);
|
|
Value v = v_none();
|
|
jp_ws(j);
|
|
if (!j->error && *j->s != ':') j->error = "JSON object needs a colon after its key.";
|
|
if (!j->error) { j->s++; v = jp_value(j); }
|
|
if (!j->error) map_put(obj.map, key, v);
|
|
value_free(v);
|
|
free(key);
|
|
if (j->error) break;
|
|
jp_ws(j);
|
|
if (*j->s == '}') { j->s++; break; }
|
|
if (*j->s != ',') { j->error = "JSON object needs a comma or closing brace."; break; }
|
|
j->s++;
|
|
}
|
|
return obj;
|
|
}
|
|
static Value jp_value(JsonP *j) {
|
|
const char *scan;
|
|
char *end;
|
|
double number;
|
|
Value result;
|
|
jp_ws(j);
|
|
if (*j->s == '"') {
|
|
char *text = jp_string(j);
|
|
result = v_str(text);
|
|
free(text);
|
|
return result;
|
|
}
|
|
if (*j->s == '[' || *j->s == '{') {
|
|
if (j->depth >= CLARO_MAX_JSON_DEPTH) {
|
|
j->error = "JSON nesting exceeds the safe limit of 128. Simplify the data.";
|
|
return v_none();
|
|
}
|
|
j->depth++;
|
|
result = *j->s == '[' ? jp_array(j) : jp_object(j);
|
|
j->depth--;
|
|
return result;
|
|
}
|
|
if (!strncmp(j->s, "true", 4)) { j->s += 4; return v_bool(1); }
|
|
if (!strncmp(j->s, "false", 5)) { j->s += 5; return v_bool(0); }
|
|
if (!strncmp(j->s, "null", 4)) { j->s += 4; return v_none(); }
|
|
scan = j->s;
|
|
if (*scan == '-') scan++;
|
|
if (*scan == '0') scan++;
|
|
else if (*scan >= '1' && *scan <= '9') while (isdigit((unsigned char)*scan)) scan++;
|
|
else { j->error = "JSON needs a value here."; return v_none(); }
|
|
if (*scan == '.') {
|
|
scan++;
|
|
if (!isdigit((unsigned char)*scan)) { j->error = "JSON number needs digits after its decimal point."; return v_none(); }
|
|
while (isdigit((unsigned char)*scan)) scan++;
|
|
}
|
|
if (*scan == 'e' || *scan == 'E') {
|
|
scan++;
|
|
if (*scan == '+' || *scan == '-') scan++;
|
|
if (!isdigit((unsigned char)*scan)) { j->error = "JSON number needs exponent digits."; return v_none(); }
|
|
while (isdigit((unsigned char)*scan)) scan++;
|
|
}
|
|
number = strtod(j->s, &end);
|
|
if (end != scan || number > DBL_MAX || number < -DBL_MAX) {
|
|
j->error = "JSON number is outside the supported range.";
|
|
return v_none();
|
|
}
|
|
j->s = scan;
|
|
return v_num(number);
|
|
}
|
|
static Value parse_json_text(Runtime *rt, const char *text) {
|
|
JsonP j;
|
|
Value result;
|
|
memset(&j, 0, sizeof(j));
|
|
j.s = text;
|
|
result = jp_value(&j);
|
|
jp_ws(&j);
|
|
if (!j.error && *j.s) j.error = "JSON has unexpected text after its value.";
|
|
if (j.error) {
|
|
value_free(result);
|
|
rt_error(rt, "", 0, "%s", j.error);
|
|
return v_none();
|
|
}
|
|
return result;
|
|
}
|
|
static void json_escape(Str *b, const char *s) {
|
|
str_ch(b, '"');
|
|
while (s && *s) {
|
|
if (*s == '"') {
|
|
str_add(b, "\\\"");
|
|
} else if (*s == '\\') {
|
|
str_add(b, "\\\\");
|
|
} else if (*s == '\n') {
|
|
str_add(b, "\\n");
|
|
} else if ((unsigned char)*s < 32) {
|
|
static const char hex[] = "0123456789abcdef";
|
|
unsigned char c = (unsigned char)*s;
|
|
str_add(b, "\\u00");
|
|
str_ch(b, hex[c >> 4]);
|
|
str_ch(b, hex[c & 15]);
|
|
} else
|
|
str_ch(b, *s);
|
|
s++;
|
|
}
|
|
str_ch(b, '"');
|
|
}
|
|
static void json_write(Str *b, Value v, int pretty, int indent);
|
|
static void indent_add(Str *b, int n) {
|
|
int i;
|
|
for (i = 0; i < n; i++)
|
|
str_ch(b, ' ');
|
|
}
|
|
static void json_write(Str *b, Value v, int pretty, int indent) {
|
|
int i;
|
|
char *s;
|
|
if (v.type == V_STR) {
|
|
json_escape(b, v.str);
|
|
} else if (v.type == V_NUM) {
|
|
s = num_to_string(v.num);
|
|
str_add(b, s);
|
|
free(s);
|
|
} else if (v.type == V_BOOL) {
|
|
str_add(b, v.boolean ? "true" : "false");
|
|
} else if (v.type == V_NONE) {
|
|
str_add(b, "null");
|
|
} else if (v.type == V_LIST) {
|
|
str_ch(b, '[');
|
|
if (pretty && v.list->count)
|
|
str_ch(b, '\n');
|
|
for (i = 0; i < v.list->count; i++) {
|
|
if (pretty)
|
|
indent_add(b, indent + 2);
|
|
json_write(b, v.list->items[i], pretty, indent + 2);
|
|
if (i + 1 < v.list->count)
|
|
str_ch(b, ',');
|
|
if (pretty)
|
|
str_ch(b, '\n');
|
|
}
|
|
if (pretty && v.list->count)
|
|
indent_add(b, indent);
|
|
str_ch(b, ']');
|
|
} else if (v.type == V_MAP) {
|
|
str_ch(b, '{');
|
|
if (pretty && v.map->count)
|
|
str_ch(b, '\n');
|
|
for (i = 0; i < v.map->count; i++) {
|
|
if (pretty)
|
|
indent_add(b, indent + 2);
|
|
json_escape(b, v.map->keys[i]);
|
|
str_ch(b, ':');
|
|
if (pretty)
|
|
str_ch(b, ' ');
|
|
json_write(b, v.map->vals[i], pretty, indent + 2);
|
|
if (i + 1 < v.map->count)
|
|
str_ch(b, ',');
|
|
if (pretty)
|
|
str_ch(b, '\n');
|
|
}
|
|
if (pretty && v.map->count)
|
|
indent_add(b, indent);
|
|
str_ch(b, '}');
|
|
}
|
|
}
|
|
static char *make_json(Value v, int pretty) {
|
|
Str b;
|
|
str_init(&b);
|
|
json_write(&b, v, pretty, 0);
|
|
return str_take(&b);
|
|
}
|
|
|
|
/* ---------- stdlib built-ins ---------- */
|
|
static int builtin_required_args(const char *kind, const char *fn, const char **shape) {
|
|
if (strcmp(kind, "text") == 0) {
|
|
if (strcmp(fn, "upper") == 0 || strcmp(fn, "lower") == 0) {
|
|
if (shape)
|
|
*shape = "value";
|
|
return 1;
|
|
}
|
|
if (strcmp(fn, "contains") == 0 || strcmp(fn, "endswith") == 0 ||
|
|
strcmp(fn, "split2") == 0) {
|
|
if (shape)
|
|
*shape = "text, part";
|
|
return 2;
|
|
}
|
|
}
|
|
if (strcmp(kind, "math") == 0) {
|
|
if (strcmp(fn, "abs") == 0) {
|
|
if (shape)
|
|
*shape = "value";
|
|
return 1;
|
|
}
|
|
if (strcmp(fn, "clamp") == 0) {
|
|
if (shape)
|
|
*shape = "value, lower, upper";
|
|
return 3;
|
|
}
|
|
}
|
|
if (strcmp(kind, "random") == 0) {
|
|
if (strcmp(fn, "seed") == 0) {
|
|
if (shape)
|
|
*shape = "value";
|
|
return 1;
|
|
}
|
|
if (strcmp(fn, "int") == 0) {
|
|
if (shape)
|
|
*shape = "lower, upper";
|
|
return 2;
|
|
}
|
|
}
|
|
if (strcmp(kind, "csv") == 0) {
|
|
if (strcmp(fn, "read") == 0) {
|
|
if (shape)
|
|
*shape = "text";
|
|
return 1;
|
|
}
|
|
if (strcmp(fn, "write") == 0) {
|
|
if (shape)
|
|
*shape = "rows";
|
|
return 1;
|
|
}
|
|
}
|
|
if (strcmp(kind, "path") == 0) {
|
|
if (strcmp(fn, "join") == 0) {
|
|
if (shape)
|
|
*shape = "folder, name";
|
|
return 2;
|
|
}
|
|
if (strcmp(fn, "basename") == 0 || strcmp(fn, "dirname") == 0 || strcmp(fn, "ext") == 0 ||
|
|
strcmp(fn, "stem") == 0 || strcmp(fn, "absolute") == 0) {
|
|
if (shape)
|
|
*shape = "path";
|
|
return 1;
|
|
}
|
|
}
|
|
if (strcmp(kind, "collections") == 0) {
|
|
if (strcmp(fn, "length") == 0 || strcmp(fn, "reversed") == 0 || strcmp(fn, "keys") == 0 ||
|
|
strcmp(fn, "values") == 0) {
|
|
if (shape)
|
|
*shape = "collection";
|
|
return 1;
|
|
}
|
|
if (strcmp(fn, "contains") == 0 || strcmp(fn, "index") == 0 || strcmp(fn, "has_key") == 0) {
|
|
if (shape)
|
|
*shape = "collection, value";
|
|
return 2;
|
|
}
|
|
if (strcmp(fn, "join") == 0) {
|
|
if (shape)
|
|
*shape = "collection, separator";
|
|
return 2;
|
|
}
|
|
if (strcmp(fn, "get") == 0) {
|
|
if (shape)
|
|
*shape = "map, key";
|
|
return 2;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
static Value builtin_call(Runtime *rt, const char *name, Value *args, int argc, int *handled) {
|
|
char ns[128], fn[128];
|
|
const char *dot = strrchr(name, '.');
|
|
const char *kind = NULL;
|
|
const char *shape = NULL;
|
|
int required;
|
|
*handled = 0;
|
|
if (!dot)
|
|
return v_none();
|
|
claro_snprintf(ns, sizeof(ns), "%.*s", (int)(dot - name), name);
|
|
claro_snprintf(fn, sizeof(fn), "%s", dot + 1);
|
|
kind = module_kind(rt, ns);
|
|
if (!kind)
|
|
return v_none();
|
|
*handled = 1;
|
|
required = builtin_required_args(kind, fn, &shape);
|
|
if (required > argc) {
|
|
rt_error(rt, "", 0, "%s.%s needs %d argument%s, but got %d. Try: CALL %s.%s WITH %s.", ns,
|
|
fn, required, required == 1 ? "" : "s", argc, ns, fn,
|
|
shape ? shape : "the required values");
|
|
return v_none();
|
|
}
|
|
if (strcmp(kind, "text") == 0) {
|
|
char *a = argc > 0 ? v_to_string(args[0]) : xstrdup("");
|
|
char *b = argc > 1 ? v_to_string(args[1]) : xstrdup("");
|
|
int i;
|
|
if (strcmp(fn, "upper") == 0) {
|
|
Value r;
|
|
for (i = 0; a[i]; i++)
|
|
a[i] = (char)toupper((unsigned char)a[i]);
|
|
r = v_str(a);
|
|
free(a);
|
|
free(b);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "lower") == 0) {
|
|
Value r;
|
|
for (i = 0; a[i]; i++)
|
|
a[i] = (char)tolower((unsigned char)a[i]);
|
|
r = v_str(a);
|
|
free(a);
|
|
free(b);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "contains") == 0) {
|
|
Value r = v_bool(strstr(a, b) != NULL);
|
|
free(a);
|
|
free(b);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "endswith") == 0) {
|
|
size_t la = strlen(a), lb = strlen(b);
|
|
Value r = v_bool(lb <= la && strcmp(a + la - lb, b) == 0);
|
|
free(a);
|
|
free(b);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "split2") == 0) {
|
|
char *pos = strstr(a, b);
|
|
Value arr = v_list();
|
|
if (pos) {
|
|
char *left = substr(a, pos);
|
|
list_add(arr.list, v_str(left));
|
|
list_add(arr.list, v_str(pos + strlen(b)));
|
|
free(left);
|
|
} else
|
|
list_add(arr.list, v_str(a));
|
|
free(a);
|
|
free(b);
|
|
return arr;
|
|
}
|
|
free(a);
|
|
free(b);
|
|
}
|
|
if (strcmp(kind, "math") == 0) {
|
|
if (strcmp(fn, "abs") == 0)
|
|
return v_num(fabs(v_number(args[0])));
|
|
if (strcmp(fn, "clamp") == 0) {
|
|
double x = v_number(args[0]), lo = v_number(args[1]), hi = v_number(args[2]);
|
|
if (x < lo)
|
|
x = lo;
|
|
if (x > hi)
|
|
x = hi;
|
|
return v_num(x);
|
|
}
|
|
}
|
|
if (strcmp(kind, "random") == 0) {
|
|
if (strcmp(fn, "seed") == 0) {
|
|
srand((unsigned)v_number(args[0]));
|
|
return v_none();
|
|
}
|
|
if (strcmp(fn, "int") == 0) {
|
|
int a = (int)v_number(args[0]), b = (int)v_number(args[1]);
|
|
double span, r;
|
|
if (a > b) {
|
|
rt_error(rt, "", 0,
|
|
"random.int needs the lower bound to be less than or equal to the upper "
|
|
"bound.");
|
|
return v_none();
|
|
}
|
|
span = (double)b - (double)a + 1.0;
|
|
r = (double)a + fmod((double)rand(), span);
|
|
return v_num((double)r);
|
|
}
|
|
}
|
|
if (strcmp(kind, "csv") == 0) {
|
|
if (strcmp(fn, "read") == 0) {
|
|
char *txt = argc > 0 ? v_to_string(args[0]) : xstrdup("");
|
|
char *del = argc > 1 ? v_to_string(args[1]) : xstrdup(",");
|
|
char d = del[0] ? del[0] : ',';
|
|
Value rows = v_list();
|
|
const char *p = txt;
|
|
while (*p) {
|
|
Value row = v_list();
|
|
Str field;
|
|
int inq = 0;
|
|
str_init(&field);
|
|
while (*p && *p != '\n' && *p != '\r') {
|
|
if (*p == '"') {
|
|
if (inq && p[1] == '"') {
|
|
str_ch(&field, '"');
|
|
p += 2;
|
|
continue;
|
|
}
|
|
inq = !inq;
|
|
p++;
|
|
continue;
|
|
}
|
|
if (!inq && *p == d) {
|
|
list_add(row.list, v_str(field.s ? field.s : ""));
|
|
field.len = 0;
|
|
if (field.s)
|
|
field.s[0] = 0;
|
|
p++;
|
|
continue;
|
|
}
|
|
str_ch(&field, *p++);
|
|
}
|
|
list_add(row.list, v_str(field.s ? field.s : ""));
|
|
free(field.s);
|
|
list_add(rows.list, row);
|
|
while (*p == '\r' || *p == '\n')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
free(del);
|
|
return rows;
|
|
}
|
|
if (strcmp(fn, "write") == 0) {
|
|
char *del = argc > 1 ? v_to_string(args[1]) : xstrdup(",");
|
|
char d = del[0] ? del[0] : ',';
|
|
Str out;
|
|
int i, j;
|
|
str_init(&out);
|
|
if (argc > 0 && args[0].type == V_LIST) {
|
|
for (i = 0; i < args[0].list->count; i++) {
|
|
Value row = args[0].list->items[i];
|
|
if (row.type == V_LIST) {
|
|
for (j = 0; j < row.list->count; j++) {
|
|
char *f = v_to_string(row.list->items[j]);
|
|
int quote = strchr(f, d) || strchr(f, '\n') || strchr(f, '"');
|
|
if (j)
|
|
str_ch(&out, d);
|
|
if (quote) {
|
|
const char *q = f;
|
|
str_ch(&out, '"');
|
|
while (*q) {
|
|
if (*q == '"')
|
|
str_add(&out, "\"\"");
|
|
else
|
|
str_ch(&out, *q);
|
|
q++;
|
|
}
|
|
str_ch(&out, '"');
|
|
} else
|
|
str_add(&out, f);
|
|
free(f);
|
|
}
|
|
}
|
|
str_ch(&out, '\n');
|
|
}
|
|
}
|
|
free(del);
|
|
return v_str(out.s ? out.s : "");
|
|
}
|
|
}
|
|
if (strcmp(kind, "path") == 0) {
|
|
char *a = argc > 0 ? v_to_string(args[0]) : xstrdup("");
|
|
if (strcmp(fn, "join") == 0) {
|
|
char *b = argc > 1 ? v_to_string(args[1]) : xstrdup("");
|
|
Str out;
|
|
size_t n = strlen(a);
|
|
str_init(&out);
|
|
str_add(&out, a);
|
|
if (a[0] && b[0] && a[n - 1] != '/' && a[n - 1] != '\\')
|
|
str_ch(&out, '/');
|
|
while (*b == '/' || *b == '\\')
|
|
b++;
|
|
str_add(&out, b);
|
|
free(a);
|
|
return v_str(out.s ? out.s : "");
|
|
}
|
|
if (strcmp(fn, "basename") == 0) {
|
|
char *slash = strrchr(a, '/'), *back = strrchr(a, '\\'), *cut = slash;
|
|
Value r;
|
|
if (back && (!cut || back > cut))
|
|
cut = back;
|
|
r = v_str(cut ? cut + 1 : a);
|
|
free(a);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "dirname") == 0) {
|
|
char *slash = strrchr(a, '/'), *back = strrchr(a, '\\'), *cut = slash;
|
|
if (back && (!cut || back > cut))
|
|
cut = back;
|
|
if (!cut) {
|
|
free(a);
|
|
return v_str("");
|
|
}
|
|
if (cut == a) {
|
|
free(a);
|
|
return v_str("/");
|
|
}
|
|
*cut = 0;
|
|
{
|
|
Value r = v_str(a);
|
|
free(a);
|
|
return r;
|
|
}
|
|
}
|
|
if (strcmp(fn, "ext") == 0 || strcmp(fn, "stem") == 0) {
|
|
char *slash = strrchr(a, '/'), *back = strrchr(a, '\\'), *base = slash;
|
|
char *dot;
|
|
if (back && (!base || back > base))
|
|
base = back;
|
|
base = base ? base + 1 : a;
|
|
dot = strrchr(base, '.');
|
|
if (!dot || dot == base) {
|
|
Value r = v_str(strcmp(fn, "stem") == 0 ? base : "");
|
|
free(a);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "ext") == 0) {
|
|
Value r = v_str(dot + 1);
|
|
free(a);
|
|
return r;
|
|
}
|
|
*dot = 0;
|
|
{
|
|
Value r = v_str(base);
|
|
free(a);
|
|
return r;
|
|
}
|
|
}
|
|
if (strcmp(fn, "absolute") == 0) {
|
|
int yes =
|
|
(a[0] == '/' || a[0] == '\\' || ((isalpha((unsigned char)a[0])) && a[1] == ':'));
|
|
free(a);
|
|
return v_bool(yes);
|
|
}
|
|
free(a);
|
|
}
|
|
if (strcmp(kind, "collections") == 0) {
|
|
Value source = argc > 0 ? args[0] : v_none();
|
|
if (strcmp(fn, "length") == 0) {
|
|
if (source.type == V_LIST && source.list)
|
|
return v_num(source.list->count);
|
|
if (source.type == V_MAP && source.map)
|
|
return v_num(source.map->count);
|
|
return v_num(0);
|
|
}
|
|
if (strcmp(fn, "contains") == 0 && source.type == V_LIST && source.list) {
|
|
int i;
|
|
Value needle = argc > 1 ? args[1] : v_none();
|
|
for (i = 0; i < source.list->count; i++)
|
|
if (value_compare(source.list->items[i], needle) == 0)
|
|
return v_bool(1);
|
|
return v_bool(0);
|
|
}
|
|
if (strcmp(fn, "index") == 0 && source.type == V_LIST && source.list) {
|
|
int i;
|
|
Value needle = argc > 1 ? args[1] : v_none();
|
|
for (i = 0; i < source.list->count; i++)
|
|
if (value_compare(source.list->items[i], needle) == 0)
|
|
return v_num(i + 1);
|
|
return v_num(0);
|
|
}
|
|
if (strcmp(fn, "join") == 0 && source.type == V_LIST && source.list) {
|
|
char *separator = argc > 1 ? v_to_string(args[1]) : xstrdup("");
|
|
Str out;
|
|
int i;
|
|
str_init(&out);
|
|
for (i = 0; i < source.list->count; i++) {
|
|
char *part = v_to_string(source.list->items[i]);
|
|
if (i)
|
|
str_add(&out, separator);
|
|
str_add(&out, part);
|
|
free(part);
|
|
}
|
|
free(separator);
|
|
return v_str(out.s ? out.s : "");
|
|
}
|
|
if (strcmp(fn, "reversed") == 0 && source.type == V_LIST && source.list) {
|
|
Value out = v_list();
|
|
int i;
|
|
for (i = source.list->count - 1; i >= 0; i--)
|
|
list_add(out.list, source.list->items[i]);
|
|
return out;
|
|
}
|
|
if (strcmp(fn, "has_key") == 0 && source.type == V_MAP && source.map) {
|
|
char *key = argc > 1 ? v_to_string(args[1]) : xstrdup("");
|
|
int found = map_index(source.map, key) >= 0;
|
|
free(key);
|
|
return v_bool(found);
|
|
}
|
|
if (strcmp(fn, "get") == 0 && source.type == V_MAP && source.map) {
|
|
char *key = argc > 1 ? v_to_string(args[1]) : xstrdup("");
|
|
int index = map_index(source.map, key);
|
|
Value fallback = argc > 2 ? args[2] : v_none();
|
|
Value r = index >= 0 ? v_copy(source.map->vals[index]) : v_copy(fallback);
|
|
free(key);
|
|
return r;
|
|
}
|
|
if (strcmp(fn, "keys") == 0 && source.type == V_MAP && source.map) {
|
|
Value out = v_list();
|
|
int i;
|
|
for (i = 0; i < source.map->count; i++)
|
|
list_add(out.list, v_str(source.map->keys[i]));
|
|
return out;
|
|
}
|
|
if (strcmp(fn, "values") == 0 && source.type == V_MAP && source.map) {
|
|
Value out = v_list();
|
|
int i;
|
|
for (i = 0; i < source.map->count; i++)
|
|
list_add(out.list, source.map->vals[i]);
|
|
return out;
|
|
}
|
|
}
|
|
return v_none();
|
|
}
|
|
|
|
/* ---------- execution ---------- */
|
|
static void exec_range(Runtime *rt, Program *p, int start, int end);
|
|
static int parse_params(char *s, char ***out) {
|
|
char **arr = NULL;
|
|
int cnt = 0, cap = 0;
|
|
char *tok = strtok(s, ",");
|
|
while (tok) {
|
|
char *t = trim_inplace(tok);
|
|
if (*t) {
|
|
if (cnt >= cap) {
|
|
cap = cap ? cap * 2 : 4;
|
|
arr = (char **)xrealloc(arr, sizeof(char *) * cap);
|
|
}
|
|
arr[cnt++] = xstrdup(t);
|
|
}
|
|
tok = strtok(NULL, ",");
|
|
}
|
|
*out = arr;
|
|
return cnt;
|
|
}
|
|
static int parse_simple_params(char *s, char ***out) {
|
|
char **arr = NULL;
|
|
int cnt = 0, cap = 0;
|
|
char *tok = strtok(s, " \t\r\n");
|
|
while (tok) {
|
|
if (cnt >= cap) {
|
|
cap = cap ? cap * 2 : 4;
|
|
arr = (char **)xrealloc(arr, sizeof(char *) * cap);
|
|
}
|
|
arr[cnt++] = xstrdup(tok);
|
|
tok = strtok(NULL, " \t\r\n");
|
|
}
|
|
*out = arr;
|
|
return cnt;
|
|
}
|
|
static void parse_teach_parts(char *t, char **name_out, char ***params_out, int *pcnt_out) {
|
|
char *name, *takes, *returns;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
t += 5;
|
|
while (*t && isspace((unsigned char)*t))
|
|
t++;
|
|
name = t;
|
|
while (*t && !isspace((unsigned char)*t))
|
|
t++;
|
|
if (*t)
|
|
*t++ = 0;
|
|
returns = (char *)find_word_ci(t, "RETURNS");
|
|
if (returns)
|
|
*returns = 0;
|
|
takes = (char *)find_word_ci(t, "TAKES");
|
|
if (takes) {
|
|
takes += 5;
|
|
pcnt = parse_params(takes, ¶ms);
|
|
} else {
|
|
char *simple = trim_inplace(t);
|
|
if (*simple)
|
|
pcnt = strchr(simple, ',') ? parse_params(simple, ¶ms)
|
|
: parse_simple_params(simple, ¶ms);
|
|
}
|
|
*name_out = name;
|
|
*params_out = params;
|
|
*pcnt_out = pcnt;
|
|
}
|
|
static void scan_functions(Runtime *rt, Program *p, const char *prefix) {
|
|
int i;
|
|
for (i = 0; i < p->count; i++) {
|
|
char tmp[1024], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, p->lines[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (strcmp(up, "CLASS") == 0) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
char *cn = trim_inplace(cls);
|
|
int end = match_block(p, i, "CLASS", "ENDCLASS", NULL, NULL);
|
|
ClassDef *c = NULL;
|
|
int j;
|
|
if (*cn)
|
|
c = add_class(rt, cn);
|
|
for (j = i + 1; j < (end < 0 ? p->count : end); j++) {
|
|
char itmp[1024], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(itmp, p->lines[j], sizeof(itmp) - 1);
|
|
itmp[sizeof(itmp) - 1] = 0;
|
|
it = trim_inplace(itmp);
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (strcmp(iup, "HAS") == 0) {
|
|
const char *fp = it + 3;
|
|
char *fn = unquote_token(&fp);
|
|
char *ft = unquote_token(&fp);
|
|
char *ftt = trim_inplace(ft);
|
|
if (c)
|
|
class_add_field(c, trim_inplace(fn), *ftt ? ftt : "ANY");
|
|
free(fn);
|
|
free(ft);
|
|
} else if (strcmp(iup, "TEACH") == 0) {
|
|
char *mname;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
char fname[256];
|
|
int mend = match_block(p, j, "TEACH", "LEARNED", NULL, NULL);
|
|
parse_teach_parts(it, &mname, ¶ms, &pcnt);
|
|
if (c && *mname) {
|
|
claro_snprintf(fname, sizeof(fname), "%s.%s", c->name, mname);
|
|
if (!find_function(rt, fname))
|
|
add_function(rt, fname, params, pcnt, p, j + 1,
|
|
mend < 0 ? (end < 0 ? p->count : end) : mend);
|
|
}
|
|
split_args_free(params, pcnt);
|
|
if (mend >= 0)
|
|
j = mend;
|
|
}
|
|
}
|
|
free(cls);
|
|
if (end >= 0)
|
|
i = end;
|
|
continue;
|
|
}
|
|
if (strcmp(up, "TEACH") == 0) {
|
|
char *name;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
char fname[256];
|
|
int end = match_block(p, i, "TEACH", "LEARNED", NULL, NULL);
|
|
parse_teach_parts(t, &name, ¶ms, &pcnt);
|
|
claro_snprintf(fname, sizeof(fname), "%s%s", prefix ? prefix : "", name);
|
|
if (!find_function(rt, fname))
|
|
add_function(rt, fname, params, pcnt, p, i + 1, end < 0 ? p->count : end);
|
|
split_args_free(params, pcnt);
|
|
if (end >= 0)
|
|
i = end;
|
|
}
|
|
}
|
|
}
|
|
static int call_object_method(Runtime *rt, const char *name, Value *args, int argc) {
|
|
const char *dot = strchr(name, '.');
|
|
char objname[128], method[128], fname[256], fieldname[256];
|
|
Value obj, cv;
|
|
ClassDef *c;
|
|
Function *f;
|
|
Var *old;
|
|
FieldDef *fd;
|
|
int i;
|
|
if (!dot)
|
|
return 0;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - name), name);
|
|
claro_snprintf(method, sizeof(method), "%s", dot + 1);
|
|
obj = rt_get(rt, objname);
|
|
if (obj.type != V_MAP || !obj.map)
|
|
return 0;
|
|
cv = map_get(obj.map, "class");
|
|
if (cv.type != V_STR || !cv.str || !cv.str[0])
|
|
return 0;
|
|
claro_snprintf(fname, sizeof(fname), "%s.%s", cv.str, method);
|
|
f = find_function(rt, fname);
|
|
if (!f) {
|
|
rt_error(rt, "", 0, "%s does not know how to do %s yet.", cv.str, method);
|
|
return 1;
|
|
}
|
|
c = find_class(rt, cv.str);
|
|
old = rt->locals;
|
|
rt->locals = NULL;
|
|
rt_set(rt, "self", obj);
|
|
if (c) {
|
|
for (fd = c->fields; fd; fd = fd->next) {
|
|
Value fv = map_get(obj.map, fd->name);
|
|
rt_set(rt, fd->name, fv);
|
|
claro_snprintf(fieldname, sizeof(fieldname), "__type_%s", fd->name);
|
|
rt_set(rt, fieldname, v_str(fd->type));
|
|
}
|
|
}
|
|
for (i = 0; i < f->pcnt; i++)
|
|
rt_set(rt, f->params[i], i < argc ? args[i] : v_none());
|
|
rt->returning = 0;
|
|
exec_range(rt, f->prog, f->start, f->end);
|
|
if (c) {
|
|
for (fd = c->fields; fd; fd = fd->next) {
|
|
Value fv = rt_get(rt, fd->name);
|
|
map_put(obj.map, fd->name, fv);
|
|
}
|
|
}
|
|
if (rt->returning) {
|
|
rt_set(rt, "RESULT", rt->ret);
|
|
rt->returning = 0;
|
|
}
|
|
rt->locals = old;
|
|
rt_set(rt, objname, obj);
|
|
if (c) {
|
|
for (fd = c->fields; fd; fd = fd->next) {
|
|
Value fv = map_get(obj.map, fd->name);
|
|
claro_snprintf(fieldname, sizeof(fieldname), "%s.%s", objname, fd->name);
|
|
rt_set_checked(rt, "", 0, fieldname, fd->type, fv);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
static void call_function(Runtime *rt, const char *name, Value *args, int argc) {
|
|
int handled = 0, i;
|
|
Value br = builtin_call(rt, name, args, argc, &handled);
|
|
if (handled) {
|
|
rt_set(rt, "RESULT", br);
|
|
return;
|
|
}
|
|
if (rt->call_depth >= CLARO_MAX_CALL_DEPTH) {
|
|
rt_error(rt, "", 0,
|
|
"Claro function call depth exceeded the safe limit of %d. Simplify the recursion "
|
|
"or add a stopping condition.",
|
|
CLARO_MAX_CALL_DEPTH);
|
|
return;
|
|
}
|
|
rt->call_depth++;
|
|
if (call_object_method(rt, name, args, argc)) {
|
|
rt->call_depth--;
|
|
return;
|
|
}
|
|
{
|
|
Function *f = find_function(rt, name);
|
|
if (!f) {
|
|
rt_error(rt, "", 0, "Unknown function: %s", name);
|
|
rt->call_depth--;
|
|
return;
|
|
}
|
|
{
|
|
Var *old = rt->locals;
|
|
rt->locals = NULL;
|
|
for (i = 0; i < f->pcnt; i++)
|
|
rt_set(rt, f->params[i], i < argc ? args[i] : v_none());
|
|
rt->returning = 0;
|
|
exec_range(rt, f->prog, f->start, f->end);
|
|
if (rt->returning) {
|
|
rt_set(rt, "RESULT", rt->ret);
|
|
rt->returning = 0;
|
|
}
|
|
rt->locals = old;
|
|
}
|
|
}
|
|
rt->call_depth--;
|
|
}
|
|
static int stack_has(Runtime *rt, const char *path) {
|
|
int i;
|
|
for (i = 0; i < rt->import_depth; i++)
|
|
if (strcmp(rt->import_stack[i], path) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
static int export_allows(char **exports, int ec, const char *name) {
|
|
int i;
|
|
if (ec == 0)
|
|
return 1;
|
|
for (i = 0; i < ec; i++)
|
|
if (strcmp(exports[i], name) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
static void do_import(Runtime *rt, const char *path, const char *ns, const char *curfile,
|
|
int line) {
|
|
Program *p;
|
|
char *prefix = NULL;
|
|
char **exports = NULL;
|
|
int ec = 0, i;
|
|
if (stack_has(rt, path)) {
|
|
rt_error(rt, curfile, line, "Import cycle detected at: %s", path);
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/text.claro") && ns) {
|
|
add_module(rt, ns, "text");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/math.claro") && ns) {
|
|
add_module(rt, ns, "math");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/random.claro") && ns) {
|
|
add_module(rt, ns, "random");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/csv.claro") && ns) {
|
|
add_module(rt, ns, "csv");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/path.claro") && ns) {
|
|
add_module(rt, ns, "path");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/collections.claro") && ns) {
|
|
add_module(rt, ns, "collections");
|
|
return;
|
|
}
|
|
if (strstr(path, "lib/time.claro") && ns) {
|
|
add_module(rt, ns, "time");
|
|
return;
|
|
}
|
|
p = load_program(rt, path);
|
|
if (!p) {
|
|
rt_error(rt, curfile, line, "Could not import file: %s", path);
|
|
return;
|
|
}
|
|
rt->import_stack = (char **)xrealloc(rt->import_stack, sizeof(char *) * (rt->import_depth + 1));
|
|
rt->import_stack[rt->import_depth++] = xstrdup(path);
|
|
for (i = 0; i < p->count; i++) {
|
|
char tmp[1024], up[64], w[64];
|
|
char *t;
|
|
strncpy(tmp, p->lines[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (strcmp(up, "EXPORT") == 0) {
|
|
t += 6;
|
|
t = trim_inplace(t);
|
|
if (ci_eq(t, "ALL")) {
|
|
ec = 0;
|
|
break;
|
|
}
|
|
ec = parse_params(t, &exports);
|
|
break;
|
|
}
|
|
}
|
|
if (ns) {
|
|
Str pr;
|
|
Var *v;
|
|
str_init(&pr);
|
|
str_add(&pr, ns);
|
|
str_ch(&pr, '.');
|
|
prefix = str_take(&pr);
|
|
scan_functions(rt, p, prefix);
|
|
exec_range(rt, p, 0, p->count); /* copy exported vars */
|
|
for (v = rt->globals; v; v = v->next) {
|
|
if (strncmp(v->name, prefix, strlen(prefix)) != 0 &&
|
|
export_allows(exports, ec, v->name)) {
|
|
char nn[256];
|
|
claro_snprintf(nn, sizeof(nn), "%s%s", prefix, v->name);
|
|
if (!rt_has(rt, nn))
|
|
rt_set_global(rt, nn, v->val);
|
|
}
|
|
}
|
|
} else {
|
|
scan_functions(rt, p, "");
|
|
exec_range(rt, p, 0, p->count);
|
|
}
|
|
rt->import_depth--;
|
|
free(rt->import_stack[rt->import_depth]);
|
|
rt->import_stack[rt->import_depth] = NULL;
|
|
split_args_free(exports, ec);
|
|
free(prefix);
|
|
}
|
|
static void create_object_value(Runtime *rt, const char *file, int line, const char *cls,
|
|
const char *var) {
|
|
Value obj, class_name;
|
|
ClassDef *c;
|
|
FieldDef *fd;
|
|
char fullname[256];
|
|
if (!cls || !*cls || !var || !*var) {
|
|
rt_error(rt, file, line, "NEW needs a class and a name. Try: NEW Player player");
|
|
return;
|
|
}
|
|
obj = v_map();
|
|
c = find_class(rt, cls);
|
|
class_name = v_str(cls);
|
|
map_put(obj.map, "class", class_name);
|
|
value_free(class_name);
|
|
rt_set_checked(rt, file, line, var, "OBJECT", obj);
|
|
value_free(obj);
|
|
if (c) {
|
|
for (fd = c->fields; fd; fd = fd->next) {
|
|
Value def = claro_default_for_type(fd->type);
|
|
claro_snprintf(fullname, sizeof(fullname), "%s.%s", var, fd->name);
|
|
rt_set_checked(rt, file, line, fullname, fd->type, def);
|
|
value_free(def);
|
|
}
|
|
}
|
|
}
|
|
static void exec_line_body(Runtime *rt, Program *p, int *pcp, const char *raw) {
|
|
char buf[4096], up[64], w[128];
|
|
char *t;
|
|
int pc = *pcp;
|
|
strncpy(buf, raw, sizeof(buf) - 1);
|
|
buf[sizeof(buf) - 1] = 0;
|
|
t = trim_inplace(buf);
|
|
if (is_blank_or_comment(t))
|
|
return;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (strcmp(up, "COMMENT") == 0) {
|
|
int end = match_block(p, pc, "COMMENT", "ENDCOMMENT", NULL, NULL);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "SAY") == 0) {
|
|
char *e = expr_after_word(t, "SAY");
|
|
Value v = eval_expr(rt, e);
|
|
if (!rt->error)
|
|
out_line(rt, v);
|
|
value_free(v);
|
|
free(e);
|
|
return;
|
|
}
|
|
if (strcmp(up, "CLASS") == 0) {
|
|
int end = match_block(p, pc, "CLASS", "ENDCLASS", NULL, NULL);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "NEW") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
char *cls = substr(t + 3, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
create_object_value(rt, p->path, pc + 1, trim_inplace(cls), trim_inplace(var));
|
|
free(cls);
|
|
free(var);
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
char *cls = unquote_token(&pcur);
|
|
char *var = xstrdup(trim_inplace((char *)pcur));
|
|
create_object_value(rt, p->path, pc + 1, trim_inplace(cls), trim_inplace(var));
|
|
free(cls);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "START") == 0) {
|
|
if (starts_ci(t + 5, " TASK")) {
|
|
const char *pcur = t + 10;
|
|
char *name = unquote_token(&pcur);
|
|
int end = match_block(p, pc, "START", "ENDTASK", NULL, NULL);
|
|
exec_range(rt, p, pc + 1, end);
|
|
if (name && *name) {
|
|
char done[256];
|
|
claro_snprintf(done, sizeof(done), "TASK_%s_DONE", trim_inplace(name));
|
|
rt_set(rt, done, v_bool(1));
|
|
}
|
|
*pcp = end < 0 ? pc : end;
|
|
free(name);
|
|
return;
|
|
}
|
|
}
|
|
if (strcmp(up, "YIELD") == 0) {
|
|
return;
|
|
}
|
|
if (strcmp(up, "WAIT") == 0) {
|
|
return;
|
|
}
|
|
if (strcmp(up, "TASK") == 0) {
|
|
if (starts_ci(t + 4, " STATUS")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
char *name = substr(t + 11, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
char key[256];
|
|
Value done;
|
|
claro_snprintf(key, sizeof(key), "TASK_%s_DONE", trim_inplace(name));
|
|
done = rt_get(rt, key);
|
|
rt_set(rt, var, v_str(v_truth(done) ? "DONE" : "PENDING"));
|
|
free(name);
|
|
free(var);
|
|
} else
|
|
rt_error(rt, p->path, pc + 1,
|
|
"TASK STATUS needs AS. Try: TASK STATUS helloTask AS status");
|
|
return;
|
|
}
|
|
}
|
|
if (strcmp(up, "OPEN") == 0 || strcmp(up, "CLEAR") == 0 || strcmp(up, "DRAW") == 0 ||
|
|
strcmp(up, "UPDATE") == 0 || strcmp(up, "CLOSE") == 0) {
|
|
graphics_note(rt, up);
|
|
return;
|
|
}
|
|
if (strcmp(up, "HTTP") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as && starts_ci(t + 4, " GET")) {
|
|
char *ue = substr(t + 8, as);
|
|
char *after = xstrdup(trim_inplace((char *)as + 2));
|
|
const char *status_word = find_word_ci(after, "STATUS");
|
|
char *var = status_word ? substr(after, status_word) : xstrdup(after);
|
|
char *status_var = status_word ? xstrdup(trim_inplace((char *)status_word + 6)) : NULL;
|
|
Value uv = eval_expr(rt, ue);
|
|
char *url = v_to_string(uv);
|
|
int code = 0, http = 0;
|
|
char *out;
|
|
if (!claro_url_is_safe(url)) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP GET needs a safe http://, https://, or claro:// URL.");
|
|
free(ue);
|
|
free(after);
|
|
free(var);
|
|
free(status_var);
|
|
free(url);
|
|
return;
|
|
}
|
|
out = claro_http_get_text(url, &http, &code);
|
|
if (code == -2) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP response exceeds the safe size limit of 1048576 bytes.");
|
|
free(out);
|
|
free(url);
|
|
free(ue);
|
|
free(after);
|
|
free(var);
|
|
free(status_var);
|
|
return;
|
|
}
|
|
rt_set(rt, trim_inplace(var), v_str(out));
|
|
rt_set(rt, "LASTEXIT", v_num(code));
|
|
rt_set(rt, "LASTHTTP", v_num(http));
|
|
if (status_var && *status_var)
|
|
rt_set(rt, status_var, v_num(http));
|
|
free(out);
|
|
free(url);
|
|
free(ue);
|
|
free(after);
|
|
free(var);
|
|
free(status_var);
|
|
return;
|
|
}
|
|
if (as && starts_ci(t + 4, " STATUS")) {
|
|
char *ue = substr(t + 11, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value uv = eval_expr(rt, ue);
|
|
char *url = v_to_string(uv);
|
|
int code = 0, http = 0;
|
|
char *out;
|
|
if (!claro_url_is_safe(url)) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP STATUS needs a safe http://, https://, or claro:// URL.");
|
|
free(ue);
|
|
free(var);
|
|
free(url);
|
|
return;
|
|
}
|
|
out = claro_http_get_text(url, &http, &code);
|
|
if (code == -2) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP response exceeds the safe size limit of 1048576 bytes.");
|
|
free(out);
|
|
free(url);
|
|
free(ue);
|
|
free(var);
|
|
return;
|
|
}
|
|
rt_set(rt, trim_inplace(var), v_num(http));
|
|
rt_set(rt, "LASTEXIT", v_num(code));
|
|
rt_set(rt, "LASTHTTP", v_num(http));
|
|
free(out);
|
|
free(url);
|
|
free(ue);
|
|
free(var);
|
|
return;
|
|
}
|
|
if (starts_ci(t + 4, " SAVE")) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
const char *as2 = find_word_ci(t, "AS");
|
|
if (to) {
|
|
char *ue = substr(t + 9, to);
|
|
char *pe = as2 ? substr(to + 2, as2) : xstrdup(to + 2);
|
|
char *status_var = as2 ? xstrdup(trim_inplace((char *)as2 + 2)) : NULL;
|
|
Value uv = eval_expr(rt, ue), pv = eval_expr(rt, pe);
|
|
char *url = v_to_string(uv), *path = v_to_string(pv);
|
|
int code = 0, http = 0;
|
|
char *out;
|
|
if (!claro_url_is_safe(url)) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP SAVE needs a safe http://, https://, or claro:// URL.");
|
|
free(ue);
|
|
free(pe);
|
|
free(status_var);
|
|
free(url);
|
|
free(path);
|
|
return;
|
|
}
|
|
out = claro_http_get_text(url, &http, &code);
|
|
if (code == -2) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP response exceeds the safe size limit of 1048576 bytes.");
|
|
free(out);
|
|
free(url);
|
|
free(path);
|
|
free(ue);
|
|
free(pe);
|
|
free(status_var);
|
|
return;
|
|
}
|
|
if (!write_text_bytes(path, out))
|
|
rt_error(rt, p->path, pc + 1, "Could not save HTTP response to file.");
|
|
if (status_var && *status_var)
|
|
rt_set(rt, status_var, v_num(http));
|
|
rt_set(rt, "LASTEXIT", v_num(code));
|
|
rt_set(rt, "LASTHTTP", v_num(http));
|
|
free(out);
|
|
free(url);
|
|
free(path);
|
|
free(ue);
|
|
free(pe);
|
|
free(status_var);
|
|
return;
|
|
}
|
|
}
|
|
if (as && starts_ci(t + 4, " CHECK")) {
|
|
char *ue = substr(t + 10, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value uv = eval_expr(rt, ue);
|
|
char *url = v_to_string(uv);
|
|
rt_set(rt, var, v_bool(claro_url_is_safe(url)));
|
|
free(url);
|
|
free(ue);
|
|
free(var);
|
|
return;
|
|
}
|
|
rt_error(rt, p->path, pc + 1,
|
|
"HTTP needs GET, STATUS, SAVE, or CHECK. Try: HTTP GET \"claro://hello\" AS page");
|
|
return;
|
|
}
|
|
if (strcmp(up, "OBJECT") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as && starts_ci(t + 6, " CLASS")) {
|
|
char *oe = substr(t + 12, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value ov = eval_expr(rt, oe);
|
|
const char *cn = object_class_name(ov);
|
|
Value class_name = v_str(cn ? cn : "");
|
|
rt_set_checked(rt, p->path, pc + 1, var, "TEXT", class_name);
|
|
value_free(class_name);
|
|
value_free(ov);
|
|
free(oe);
|
|
free(var);
|
|
} else if (as && starts_ci(t + 6, " FIELDS")) {
|
|
char *oe = substr(t + 13, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value ov = eval_expr(rt, oe);
|
|
Value arr = v_list();
|
|
int i;
|
|
if (ov.type == V_MAP && ov.map) {
|
|
for (i = 0; i < ov.map->count; i++) {
|
|
if (strcmp(ov.map->keys[i], "class") != 0 &&
|
|
!starts_ci(ov.map->keys[i], "__type_")) {
|
|
Value field_name = v_str(ov.map->keys[i]);
|
|
list_add(arr.list, field_name);
|
|
value_free(field_name);
|
|
}
|
|
}
|
|
}
|
|
rt_set_checked(rt, p->path, pc + 1, var, "LIST", arr);
|
|
value_free(ov);
|
|
value_free(arr);
|
|
free(oe);
|
|
free(var);
|
|
} else
|
|
rt_error(rt, p->path, pc + 1,
|
|
"OBJECT needs CLASS or FIELDS. Try: OBJECT CLASS player AS kind");
|
|
return;
|
|
}
|
|
if (strcmp(up, "TYPE") == 0 && starts_ci(t, "TYPE OF")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
char *expr = substr(t + 7, as);
|
|
const char *pcur = as + 2;
|
|
char *var = unquote_token(&pcur);
|
|
char *extra = xstrdup(trim_inplace((char *)pcur));
|
|
if (extra && *extra)
|
|
rt_error(rt, p->path, pc + 1,
|
|
"TYPE OF %s has extra text after result name %s. Keep only the "
|
|
"expression, AS, and one result name.",
|
|
trim_inplace(expr), trim_inplace(var));
|
|
else {
|
|
char dbuf[320];
|
|
const char *decl = declared_type_for_expr(rt, expr, dbuf, sizeof(dbuf));
|
|
Value v = eval_expr(rt, expr);
|
|
rt_set_checked(rt, p->path, pc + 1, var, "TEXT",
|
|
v_str(decl ? decl : claro_value_type(v)));
|
|
}
|
|
free(expr);
|
|
free(var);
|
|
free(extra);
|
|
} else
|
|
rt_error(rt, p->path, pc + 1, "TYPE OF needs AS. Try: TYPE OF score AS kind");
|
|
return;
|
|
}
|
|
if (strcmp(up, "CHECK") == 0 && starts_ci(t, "CHECK TYPE")) {
|
|
const char *is = find_word_ci(t, "IS");
|
|
if (is) {
|
|
char *expr = substr(t + 10, is);
|
|
char *ty = xstrdup(trim_inplace((char *)is + 2));
|
|
char dbuf[320];
|
|
const char *decl = declared_type_for_expr(rt, expr, dbuf, sizeof(dbuf));
|
|
Value v = eval_expr(rt, expr);
|
|
if (decl && !ci_eq(decl, ty) && !ci_eq(ty, "ANY")) {
|
|
rt_error(rt, p->path, pc + 1, "Type check failed: expected %s, but %s is %s.", ty,
|
|
trim_inplace(expr), decl);
|
|
} else if (!decl && !claro_type_matches(ty, v)) {
|
|
rt_error(rt, p->path, pc + 1, "Type check failed: expected %s, but got %s.", ty,
|
|
claro_value_type(v));
|
|
}
|
|
free(expr);
|
|
free(ty);
|
|
} else
|
|
rt_error(rt, p->path, pc + 1, "CHECK TYPE needs IS. Try: CHECK TYPE score IS NUMBER.");
|
|
return;
|
|
}
|
|
if (strcmp(up, "SET") == 0) {
|
|
char *rest = t + 3;
|
|
const char *to = find_word_ci(rest, "TO");
|
|
const char *as = find_word_ci(rest, "AS");
|
|
if (as && to && as < to) {
|
|
char *name = substr(rest, as);
|
|
char *type = substr(as + 2, to);
|
|
char *n = trim_inplace(name);
|
|
char *ty = trim_inplace(type);
|
|
Value v = eval_expr(rt, to + 2);
|
|
rt_set_checked(rt, p->path, pc + 1, n, ty, v);
|
|
value_free(v);
|
|
free(name);
|
|
free(type);
|
|
} else if (to) {
|
|
char *name = substr(rest, to);
|
|
char *n = trim_inplace(name);
|
|
char *space = strchr(n, ' ');
|
|
const char *type = NULL;
|
|
if (space) {
|
|
*space = 0;
|
|
if (claro_is_type_word(trim_inplace(space + 1)))
|
|
type = trim_inplace(space + 1);
|
|
else {
|
|
*space = ' ';
|
|
}
|
|
}
|
|
{
|
|
Value v = eval_expr(rt, to + 2);
|
|
rt_set_checked(rt, p->path, pc + 1, n, type, v);
|
|
value_free(v);
|
|
}
|
|
free(name);
|
|
} else {
|
|
const char *pcur = rest;
|
|
char *name = unquote_token(&pcur);
|
|
char *n = trim_inplace(name);
|
|
const char *save = pcur;
|
|
char *maybe = unquote_token(&pcur);
|
|
char *ty = trim_inplace(maybe);
|
|
if (claro_is_type_word(ty)) {
|
|
char *after = trim_inplace((char *)pcur);
|
|
Value v = *after ? eval_expr(rt, after) : claro_default_for_type(ty);
|
|
if (*n)
|
|
rt_set_checked(rt, p->path, pc + 1, n, ty, v);
|
|
value_free(v);
|
|
} else {
|
|
Value v = eval_expr(rt, save);
|
|
if (*n)
|
|
rt_set_checked(rt, p->path, pc + 1, n, NULL, v);
|
|
value_free(v);
|
|
}
|
|
free(maybe);
|
|
free(name);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "ASK") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
char input[1024];
|
|
char *prompt_text = NULL;
|
|
char *var = NULL;
|
|
char *type = NULL;
|
|
if (as) {
|
|
char *prompt_expr = substr(t + 3, as);
|
|
const char *pcur = as + 2;
|
|
var = unquote_token(&pcur);
|
|
{
|
|
char *rest = xstrdup(trim_inplace((char *)pcur));
|
|
if (claro_is_type_word(rest))
|
|
type = rest;
|
|
else
|
|
free(rest);
|
|
}
|
|
{
|
|
Value prompt = eval_expr(rt, prompt_expr);
|
|
prompt_text = v_to_string(prompt);
|
|
value_free(prompt);
|
|
}
|
|
free(prompt_expr);
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
prompt_text = unquote_token(&pcur);
|
|
var = unquote_token(&pcur);
|
|
{
|
|
char *rest = xstrdup(trim_inplace((char *)pcur));
|
|
if (claro_is_type_word(rest))
|
|
type = rest;
|
|
else
|
|
free(rest);
|
|
}
|
|
}
|
|
if (prompt_text && prompt_text[0]) {
|
|
if (rt->capture) {
|
|
str_add(&rt->captured, prompt_text);
|
|
str_ch(&rt->captured, '\n');
|
|
} else {
|
|
printf("%s\n", prompt_text);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
if (var && *trim_inplace(var)) {
|
|
Value val = v_none();
|
|
if (fgets(input, sizeof(input), stdin)) {
|
|
size_t n = strlen(input);
|
|
while (n && (input[n - 1] == '\n' || input[n - 1] == '\r'))
|
|
input[--n] = 0;
|
|
} else
|
|
input[0] = 0;
|
|
if (type && *type) {
|
|
if (!claro_value_from_text(type, input, &val)) {
|
|
rt_error(rt, p->path, pc + 1, "%s needs %s input. Try a value like %s.",
|
|
trim_inplace(var), type,
|
|
ci_eq(type, "NUMBER") ? "5" : (ci_eq(type, "YESNO") ? "YES" : "text"));
|
|
} else
|
|
rt_set_checked(rt, p->path, pc + 1, trim_inplace(var), type, val);
|
|
} else {
|
|
val = v_str(input);
|
|
rt_set_checked(rt, p->path, pc + 1, trim_inplace(var), NULL, val);
|
|
}
|
|
value_free(val);
|
|
} else
|
|
rt_error(rt, p->path, pc + 1,
|
|
"ASK needs a variable name. Try: ASK \"What is your name?\" name");
|
|
free(prompt_text);
|
|
free(var);
|
|
free(type);
|
|
return;
|
|
}
|
|
if (strcmp(up, "IF") == 0) {
|
|
int elsepos = -1;
|
|
int end = match_block(p, pc, "IF", "ENDIF", "ELSE", &elsepos);
|
|
char *e = expr_after_word(t, "IF");
|
|
Value cond = eval_expr(rt, e);
|
|
free(e);
|
|
if (v_truth(cond))
|
|
exec_range(rt, p, pc + 1, elsepos >= 0 ? elsepos : end);
|
|
else if (elsepos >= 0)
|
|
exec_range(rt, p, elsepos + 1, end);
|
|
value_free(cond);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "DO") == 0) {
|
|
int end = find_done(p, pc);
|
|
const char *times = find_word_ci(t, "TIMES");
|
|
if (!times) {
|
|
const char *pcur = t + 2;
|
|
char *name = unquote_token(&pcur);
|
|
char **parts = NULL;
|
|
int ac = 0, i;
|
|
Value *args = NULL;
|
|
char *n = trim_inplace(name);
|
|
if (*trim_inplace((char *)pcur))
|
|
ac = split_simple_args(pcur, &parts);
|
|
args = (Value *)xmalloc(sizeof(Value) * (ac ? ac : 1));
|
|
for (i = 0; i < ac; i++)
|
|
args[i] = eval_expr(rt, parts[i]);
|
|
call_function(rt, n, args, ac);
|
|
split_args_free(parts, ac);
|
|
call_args_free(args, ac);
|
|
free(name);
|
|
return;
|
|
} else {
|
|
char *e = substr(t + 2, times);
|
|
Value times_value = eval_expr(rt, e);
|
|
int n = (int)v_number(times_value);
|
|
int i;
|
|
value_free(times_value);
|
|
free(e);
|
|
for (i = 0; i < n && !rt->error && !rt->returning; i++)
|
|
exec_range(rt, p, pc + 1, end);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
}
|
|
if (strcmp(up, "FOR") == 0) {
|
|
int end = find_done(p, pc);
|
|
if (starts_ci(t, "FOR EACH")) {
|
|
char *r = t + 8;
|
|
const char *in = find_word_ci(r, "IN");
|
|
char *vars = substr(r, in ? in : r);
|
|
char *expr = xstrdup(in ? in + 2 : "");
|
|
Value col = eval_expr(rt, expr);
|
|
char *comma = strchr(vars, ',');
|
|
if (comma && col.type == V_MAP) {
|
|
char *k, *v;
|
|
int i;
|
|
*comma = 0;
|
|
k = trim_inplace(vars);
|
|
v = trim_inplace(comma + 1);
|
|
for (i = 0; i < col.map->count && !rt->error && !rt->returning; i++) {
|
|
rt_set(rt, k, v_str(col.map->keys[i]));
|
|
rt_set(rt, v, col.map->vals[i]);
|
|
exec_range(rt, p, pc + 1, end);
|
|
}
|
|
} else if (col.type == V_LIST) {
|
|
char *v = trim_inplace(vars);
|
|
int i;
|
|
for (i = 0; i < col.list->count && !rt->error && !rt->returning; i++) {
|
|
rt_set(rt, v, col.list->items[i]);
|
|
exec_range(rt, p, pc + 1, end);
|
|
}
|
|
}
|
|
value_free(col);
|
|
free(vars);
|
|
free(expr);
|
|
} else {
|
|
char var[128];
|
|
const char *from = find_word_ci(t, "FROM"), *to = find_word_ci(t, "TO"),
|
|
*step = find_word_ci(t, "STEP");
|
|
double a, b, s = 1;
|
|
if (from && to) {
|
|
claro_snprintf(var, sizeof(var), "%.*s", (int)(from - (t + 3)), t + 3);
|
|
{
|
|
char *vt = trim_inplace(var);
|
|
memmove(var, vt, strlen(vt) + 1);
|
|
}
|
|
{
|
|
char *ea = substr(from + 4, to);
|
|
char *eb = step ? substr(to + 2, step) : xstrdup(to + 2);
|
|
a = v_number(eval_expr(rt, ea));
|
|
b = v_number(eval_expr(rt, eb));
|
|
if (step)
|
|
s = v_number(eval_expr(rt, step + 4));
|
|
free(ea);
|
|
free(eb);
|
|
}
|
|
if (s == 0)
|
|
s = 1;
|
|
if (s > 0) {
|
|
for (; a <= b && !rt->error && !rt->returning; a += s) {
|
|
rt_set(rt, var, v_num(a));
|
|
exec_range(rt, p, pc + 1, end);
|
|
}
|
|
} else {
|
|
for (; a >= b && !rt->error && !rt->returning; a += s) {
|
|
rt_set(rt, var, v_num(a));
|
|
exec_range(rt, p, pc + 1, end);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "REPEAT") == 0) {
|
|
int end = match_block(p, pc, "REPEAT", "UNTIL", NULL, NULL);
|
|
char *cond;
|
|
int again = 0;
|
|
if (end < 0) {
|
|
rt_error(rt, p->path, pc + 1, "REPEAT needs UNTIL and a stopping condition.");
|
|
return;
|
|
}
|
|
cond = p->lines[end] + 5;
|
|
do {
|
|
exec_range(rt, p, pc + 1, end);
|
|
if (rt->error || rt->returning)
|
|
break;
|
|
rt->active_file = p->path;
|
|
rt->active_line = end + 1;
|
|
{
|
|
Value condition = eval_expr(rt, cond);
|
|
again = !v_truth(condition);
|
|
value_free(condition);
|
|
}
|
|
} while (again && !rt->error);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "TEACH") == 0) {
|
|
int end = match_block(p, pc, "TEACH", "LEARNED", NULL, NULL);
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "RETURN") == 0) {
|
|
char *e = expr_after_word(t, "RETURN");
|
|
rt->ret = eval_expr(rt, e);
|
|
rt->returning = 1;
|
|
free(e);
|
|
return;
|
|
}
|
|
if (strcmp(up, "CALL") == 0) {
|
|
char *rest = t + 4;
|
|
const char *with = find_word_ci(rest, "WITH");
|
|
char *name = with ? substr(rest, with) : xstrdup(rest);
|
|
char **parts = NULL;
|
|
int ac = 0, i;
|
|
Value *args = NULL;
|
|
char *n = trim_inplace(name);
|
|
if (with)
|
|
ac = split_args(with + 4, &parts);
|
|
args = (Value *)xmalloc(sizeof(Value) * (ac ? ac : 1));
|
|
for (i = 0; i < ac; i++)
|
|
args[i] = eval_expr(rt, parts[i]);
|
|
call_function(rt, n, args, ac);
|
|
split_args_free(parts, ac);
|
|
call_args_free(args, ac);
|
|
free(name);
|
|
return;
|
|
}
|
|
if (strcmp(up, "IMPORT") == 0) {
|
|
const char *pcur = t + 6;
|
|
char *path = unquote_token(&pcur);
|
|
char *ns = NULL;
|
|
while (*pcur && isspace((unsigned char)*pcur))
|
|
pcur++;
|
|
if (starts_ci(pcur, "AS")) {
|
|
pcur += 2;
|
|
ns = xstrdup(trim_inplace((char *)pcur));
|
|
}
|
|
do_import(rt, path, ns, p->path, pc + 1);
|
|
free(path);
|
|
free(ns);
|
|
return;
|
|
}
|
|
if (strcmp(up, "ADD") == 0) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
if (to) {
|
|
char *ex = substr(t + 3, to);
|
|
char *var = xstrdup(trim_inplace((char *)to + 2));
|
|
Value v = eval_expr(rt, ex);
|
|
Value l = rt_get(rt, var);
|
|
if (l.type == V_LIST) {
|
|
list_add(l.list, v);
|
|
rt_set(rt, var, l);
|
|
}
|
|
free(ex);
|
|
free(var);
|
|
value_free(v);
|
|
value_free(l);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "COUNT") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
if (starts_ci(t + 5, " ARGUMENTS")) {
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
rt_set(rt, var, v_num(rt->script_argc));
|
|
free(var);
|
|
} else {
|
|
char *ex = substr(t + 5, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value v = eval_expr(rt, ex);
|
|
rt_set(
|
|
rt, var,
|
|
v_num(v.type == V_LIST ? v.list->count : (v.type == V_MAP ? v.map->count : 0)));
|
|
value_free(v);
|
|
free(ex);
|
|
free(var);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "GET") == 0) {
|
|
const char *at = find_word_ci(t, "AT"), *key = find_word_ci(t, "KEY"),
|
|
*as = find_word_ci(t, "AS");
|
|
if (as && starts_ci(t + 3, " ALL ARGUMENTS")) {
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value arr = v_list();
|
|
int i;
|
|
for (i = 0; i < rt->script_argc; i++)
|
|
list_add(arr.list, v_str(rt->script_argv[i]));
|
|
rt_set(rt, var, arr);
|
|
free(var);
|
|
} else if (as && starts_ci(t + 3, " ARGUMENT")) {
|
|
char *ie = substr(t + 12, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value index_value = eval_expr(rt, ie);
|
|
int idx = (int)v_number(index_value);
|
|
Value argument_value;
|
|
value_free(index_value);
|
|
argument_value =
|
|
v_str(idx >= 1 && idx <= rt->script_argc ? rt->script_argv[idx - 1] : "");
|
|
rt_set(rt, var, argument_value);
|
|
value_free(argument_value);
|
|
free(ie);
|
|
free(var);
|
|
} else if (as && starts_ci(t + 3, " ENV")) {
|
|
const char *pcur = t + 7;
|
|
char *name = substr(pcur, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value nv = eval_expr(rt, name);
|
|
char *ns = v_to_string(nv);
|
|
const char *ev = getenv(ns);
|
|
Value result = v_str(ev ? ev : "");
|
|
rt_set(rt, var, result);
|
|
value_free(result);
|
|
free(ns);
|
|
value_free(nv);
|
|
free(name);
|
|
free(var);
|
|
} else if (as && at) {
|
|
char *ce = substr(t + 3, at);
|
|
char *ie = substr(at + 2, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value c = eval_expr(rt, ce), iv = eval_expr(rt, ie);
|
|
int idx = (int)v_number(iv);
|
|
value_free(iv);
|
|
if (c.type == V_LIST && idx >= 1 && idx <= c.list->count)
|
|
rt_set(rt, var, c.list->items[idx - 1]);
|
|
else {
|
|
Value empty = v_str("");
|
|
rt_set(rt, var, empty);
|
|
value_free(empty);
|
|
}
|
|
value_free(c);
|
|
free(ce);
|
|
free(ie);
|
|
free(var);
|
|
} else if (as && key) {
|
|
char *ce = substr(t + 3, key);
|
|
char *ke = substr(key + 3, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value c = eval_expr(rt, ce);
|
|
Value kv = eval_expr(rt, ke);
|
|
char *ks = v_to_string(kv);
|
|
if (c.type == V_MAP) {
|
|
Value got = map_get(c.map, ks);
|
|
rt_set(rt, var, got);
|
|
value_free(got);
|
|
} else
|
|
rt_set(rt, var, v_str(""));
|
|
free(ks);
|
|
value_free(c);
|
|
value_free(kv);
|
|
free(ce);
|
|
free(ke);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "PUT") == 0) {
|
|
const char *key = find_word_ci(t, "KEY"), *val = find_word_ci(t, "VALUE"),
|
|
*as = find_word_ci(t, "AS"), *into = find_word_ci(t, "INTO");
|
|
if (key && val) {
|
|
char *me = substr(t + 3, key);
|
|
char *ke = substr(key + 3, val);
|
|
char *ve = xstrdup(val + 5);
|
|
Value m = eval_expr(rt, me);
|
|
Value k = eval_expr(rt, ke);
|
|
Value v = eval_expr(rt, ve);
|
|
char *ks = v_to_string(k);
|
|
if (m.type == V_MAP) {
|
|
char *mn = trim_inplace(me);
|
|
map_put(m.map, ks, v);
|
|
rt_set(rt, mn, m);
|
|
}
|
|
free(ks);
|
|
free(me);
|
|
free(ke);
|
|
free(ve);
|
|
value_free(m);
|
|
value_free(k);
|
|
value_free(v);
|
|
} else if (as && into) {
|
|
char *ke = substr(t + 3, as);
|
|
char *ve = substr(as + 2, into);
|
|
char *mn = xstrdup(trim_inplace((char *)into + 4));
|
|
Value m = rt_get(rt, mn);
|
|
Value k = eval_expr(rt, ke);
|
|
Value v = eval_expr(rt, ve);
|
|
char *ks = v_to_string(k);
|
|
if (m.type == V_MAP) {
|
|
map_put(m.map, ks, v);
|
|
rt_set(rt, mn, m);
|
|
}
|
|
free(ks);
|
|
free(ke);
|
|
free(ve);
|
|
free(mn);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "WRITE") == 0 || strcmp(up, "APPEND") == 0) {
|
|
if (starts_ci(t + strlen(w), " FILE")) {
|
|
const char *pcur = t + strlen(w) + 5;
|
|
const char *with = find_word_ci(pcur, "WITH");
|
|
if (with) {
|
|
char *pe = substr(pcur, with);
|
|
char *ve = xstrdup(with + 4);
|
|
Value pv = eval_expr(rt, pe);
|
|
Value vv = eval_expr(rt, ve);
|
|
char *path = v_to_string(pv), *text = v_to_string(vv);
|
|
FILE *f = fopen(path, strcmp(up, "APPEND") == 0 ? "ab" : "wb");
|
|
if (!f)
|
|
rt_error(rt, p->path, pc + 1, "Could not write file: %s", strerror(errno));
|
|
else {
|
|
fwrite(text, 1, strlen(text), f);
|
|
fclose(f);
|
|
}
|
|
free(path);
|
|
free(text);
|
|
value_free(pv);
|
|
value_free(vv);
|
|
free(pe);
|
|
free(ve);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "READ") == 0) {
|
|
const char *pcur = t + 4;
|
|
const char *as = find_word_ci(pcur, "AS");
|
|
if (as && starts_ci(pcur, " FILE")) {
|
|
char *pe = substr(pcur + 5, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
FILE *f = fopen(path, "rb");
|
|
if (!f)
|
|
rt_error(rt, p->path, pc + 1, "Could not read file: %s", strerror(errno));
|
|
else {
|
|
Str b;
|
|
int c;
|
|
Value contents;
|
|
unsigned long bytes = 0;
|
|
str_init(&b);
|
|
while ((c = fgetc(f)) != EOF) {
|
|
if (rt->read_file_limit && bytes >= rt->read_file_limit) {
|
|
rt_error(rt, p->path, pc + 1,
|
|
"READ FILE exceeded the configured file limit. Raise CLARO_READ_FILE_LIMIT if needed.");
|
|
break;
|
|
}
|
|
str_ch(&b, (char)c);
|
|
if (rt->read_file_limit) bytes++;
|
|
}
|
|
if (ferror(f)) rt_error(rt, p->path, pc + 1, "Could not finish reading the file.");
|
|
fclose(f);
|
|
contents = v_str(b.s ? b.s : "");
|
|
if (!rt->error) rt_set(rt, var, contents);
|
|
value_free(contents);
|
|
free(b.s);
|
|
}
|
|
free(path);
|
|
value_free(pv);
|
|
free(pe);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "EXISTS") == 0) {
|
|
const char *pcur = t + 6;
|
|
const char *as = find_word_ci(pcur, "AS");
|
|
if (as && starts_ci(pcur, " FILE")) {
|
|
char *pe = substr(pcur + 5, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
rt_set(rt, var, v_bool(access(path, F_OK) == 0));
|
|
free(path);
|
|
value_free(pv);
|
|
free(pe);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "CREATE") == 0) {
|
|
const char *pcur = t + 6;
|
|
if (starts_ci(pcur, " FOLDER")) {
|
|
char *pe = xstrdup(pcur + 7);
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
if (!make_folder(path))
|
|
rt_error(rt, p->path, pc + 1, "Could not create folder: %s", strerror(errno));
|
|
free(path);
|
|
value_free(pv);
|
|
free(pe);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "COPY") == 0) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
if (starts_ci(t + 4, " FILE") && to) {
|
|
char *se = substr(t + 9, to);
|
|
char *de = xstrdup(to + 2);
|
|
Value sv = eval_expr(rt, se), dv = eval_expr(rt, de);
|
|
char *src = v_to_string(sv), *dst = v_to_string(dv);
|
|
if (!copy_file_bytes(src, dst))
|
|
rt_error(rt, p->path, pc + 1, "Could not copy file");
|
|
free(src);
|
|
free(dst);
|
|
free(se);
|
|
free(de);
|
|
value_free(sv);
|
|
value_free(dv);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "MOVE") == 0) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
if (starts_ci(t + 4, " FILE") && to) {
|
|
char *se = substr(t + 9, to);
|
|
char *de = xstrdup(to + 2);
|
|
Value sv = eval_expr(rt, se), dv = eval_expr(rt, de);
|
|
char *src = v_to_string(sv), *dst = v_to_string(dv);
|
|
if (rename(src, dst) != 0)
|
|
rt_error(rt, p->path, pc + 1, "Could not move file: %s", strerror(errno));
|
|
free(src);
|
|
free(dst);
|
|
free(se);
|
|
free(de);
|
|
value_free(sv);
|
|
value_free(dv);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "LIST") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (starts_ci(t + 4, " FOLDER") && as) {
|
|
char *pe = substr(t + 11, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
Value entries = list_folder_value(path);
|
|
rt_set(rt, var, entries);
|
|
value_free(entries);
|
|
value_free(pv);
|
|
free(path);
|
|
free(pe);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "DELETE") == 0) {
|
|
const char *pcur = t + 6;
|
|
if (starts_ci(pcur, " FILE")) {
|
|
char *pe = xstrdup(pcur + 5);
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
remove(path);
|
|
free(path);
|
|
value_free(pv);
|
|
free(pe);
|
|
} else if (starts_ci(pcur, " FOLDER")) {
|
|
char *pe = xstrdup(pcur + 7);
|
|
Value pv = eval_expr(rt, pe);
|
|
char *path = v_to_string(pv);
|
|
remove_folder(path);
|
|
free(path);
|
|
value_free(pv);
|
|
free(pe);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "PARSE") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
char *ex = substr(t + 10, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value s = eval_expr(rt, ex);
|
|
char *txt = v_to_string(s);
|
|
Value parsed = parse_json_text(rt, txt);
|
|
if (!rt->error) rt_set(rt, var, parsed);
|
|
value_free(parsed);
|
|
value_free(s);
|
|
free(txt);
|
|
free(ex);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "MAKE") == 0) {
|
|
int pretty = strstr(t, "JSON PRETTY") != NULL;
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
const char *st = strstr(t, pretty ? "JSON PRETTY" : "JSON");
|
|
char *ex = substr(st + (pretty ? 11 : 4), as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value v = eval_expr(rt, ex);
|
|
char *js = make_json(v, pretty);
|
|
Value encoded = v_str(js);
|
|
rt_set(rt, var, encoded);
|
|
value_free(encoded);
|
|
value_free(v);
|
|
free(js);
|
|
free(ex);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "TEXT") == 0) {
|
|
char restup[64], op[64];
|
|
const char *as = find_word_ci(t, "AS");
|
|
const char *pcur = t + 4;
|
|
first_word(pcur, op, sizeof(op));
|
|
upper_copy(restup, op, sizeof(restup));
|
|
while (*pcur && isspace((unsigned char)*pcur))
|
|
pcur++;
|
|
while (*pcur && !isspace((unsigned char)*pcur))
|
|
pcur++;
|
|
if (as) {
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
if (!strcmp(restup, "STARTS") || !strcmp(restup, "ENDS")) {
|
|
const char *with = find_word_ci(pcur, "WITH");
|
|
if (with) {
|
|
char *left = substr(pcur, with);
|
|
char *right = substr(with + 4, as);
|
|
Value lv = eval_expr(rt, left), rv = eval_expr(rt, right);
|
|
char *ls = v_to_string(lv), *rs = v_to_string(rv);
|
|
size_t ll = strlen(ls), rl = strlen(rs);
|
|
int ok = !strcmp(restup, "STARTS")
|
|
? (rl <= ll && strncmp(ls, rs, rl) == 0)
|
|
: (rl <= ll && strcmp(ls + ll - rl, rs) == 0);
|
|
rt_set(rt, var, v_bool(ok));
|
|
free(left);
|
|
free(right);
|
|
free(ls);
|
|
free(rs);
|
|
}
|
|
} else if (!strcmp(restup, "REPLACE")) {
|
|
const char *from = find_word_ci(pcur, "FROM");
|
|
const char *to = from ? find_word_ci(from + 4, "TO") : NULL;
|
|
if (from && to) {
|
|
char *src = substr(pcur, from);
|
|
char *old = substr(from + 4, to);
|
|
char *neu = substr(to + 2, as);
|
|
Value sv = eval_expr(rt, src), ov = eval_expr(rt, old), nv = eval_expr(rt, neu);
|
|
char *ss = v_to_string(sv), *os = v_to_string(ov), *ns = v_to_string(nv);
|
|
Str b;
|
|
char *pos;
|
|
str_init(&b);
|
|
if (os[0]) {
|
|
char *cur = ss;
|
|
while ((pos = strstr(cur, os))) {
|
|
str_addn(&b, cur, (size_t)(pos - cur));
|
|
str_add(&b, ns);
|
|
cur = pos + strlen(os);
|
|
}
|
|
str_add(&b, cur);
|
|
rt_set(rt, var, v_str(b.s ? b.s : ""));
|
|
} else
|
|
rt_set(rt, var, v_str(ss));
|
|
free(b.s);
|
|
free(src);
|
|
free(old);
|
|
free(neu);
|
|
free(ss);
|
|
free(os);
|
|
free(ns);
|
|
}
|
|
} else {
|
|
char *ex = substr(pcur, as);
|
|
Value v = eval_expr(rt, ex);
|
|
char *txt = v_to_string(v);
|
|
if (!strcmp(restup, "UPPER")) {
|
|
char *r = text_upper_copy(txt);
|
|
Value result = v_str(r);
|
|
rt_set(rt, var, result);
|
|
value_free(result);
|
|
free(r);
|
|
} else if (!strcmp(restup, "LOWER")) {
|
|
char *r = text_lower_copy(txt);
|
|
Value result = v_str(r);
|
|
rt_set(rt, var, result);
|
|
value_free(result);
|
|
free(r);
|
|
} else if (!strcmp(restup, "TRIM")) {
|
|
char *r = text_trim_copy(txt);
|
|
Value result = v_str(r);
|
|
rt_set(rt, var, result);
|
|
value_free(result);
|
|
free(r);
|
|
} else if (!strcmp(restup, "LENGTH")) {
|
|
rt_set(rt, var, v_num((double)strlen(txt)));
|
|
} else if (!strcmp(restup, "CONTAINS")) {
|
|
char *left = NULL, *right = NULL;
|
|
const char *needle = find_word_ci(pcur, "NEEDLE");
|
|
if (!needle)
|
|
needle = find_word_ci(pcur, "TEXT");
|
|
if (needle) {
|
|
left = substr(pcur, needle);
|
|
right = substr(needle + 6, as);
|
|
} else {
|
|
char **args = NULL;
|
|
int n = split_args(pcur, &args);
|
|
if (n >= 2) {
|
|
left = xstrdup(args[0]);
|
|
right = substr(args[1], as);
|
|
}
|
|
split_args_free(args, n);
|
|
}
|
|
if (left && right) {
|
|
Value lv = eval_expr(rt, left), rv = eval_expr(rt, right);
|
|
char *ls = v_to_string(lv), *rs = v_to_string(rv);
|
|
rt_set(rt, var, v_bool(strstr(ls, rs) != NULL));
|
|
free(ls);
|
|
free(rs);
|
|
}
|
|
free(left);
|
|
free(right);
|
|
}
|
|
value_free(v);
|
|
free(txt);
|
|
free(ex);
|
|
}
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "RANDOM") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as && starts_ci(t + 6, " NUMBER")) {
|
|
char *range = substr(t + 13, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
char **args = NULL;
|
|
int n = split_args(range, &args);
|
|
double a = 1, b = 100;
|
|
if (n >= 2) {
|
|
a = v_number(eval_expr(rt, args[0]));
|
|
b = v_number(eval_expr(rt, args[1]));
|
|
} else {
|
|
char *tmp = range;
|
|
char *one = unquote_token((const char **)&tmp);
|
|
char *two = unquote_token((const char **)&tmp);
|
|
if (*one)
|
|
a = v_number(eval_expr(rt, one));
|
|
if (*two)
|
|
b = v_number(eval_expr(rt, two));
|
|
free(one);
|
|
free(two);
|
|
}
|
|
split_args_free(args, n);
|
|
if (b < a) {
|
|
double c = a;
|
|
a = b;
|
|
b = c;
|
|
}
|
|
rt_set(rt, var, v_num((int)a + (rand() % ((int)(b - a + 1)))));
|
|
free(range);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "RUN") == 0) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as && starts_ci(t + 3, " COMMAND")) {
|
|
char *ex = substr(t + 11, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value cv = eval_expr(rt, ex);
|
|
char *cmd = v_to_string(cv);
|
|
int code = 0;
|
|
char *out = capture_command_output(cmd, &code, 0);
|
|
Value output = v_str(out);
|
|
rt_set(rt, var, output);
|
|
value_free(output);
|
|
rt_set(rt, "LASTEXIT", v_num(code));
|
|
value_free(cv);
|
|
free(out);
|
|
free(cmd);
|
|
free(ex);
|
|
free(var);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "SORT") == 0) {
|
|
char *name = xstrdup(trim_inplace(t + 4));
|
|
Value v = rt_get(rt, name);
|
|
value_list_sort(v);
|
|
rt_set(rt, name, v);
|
|
value_free(v);
|
|
free(name);
|
|
return;
|
|
}
|
|
if (strcmp(up, "REVERSE") == 0) {
|
|
char *name = xstrdup(trim_inplace(t + 7));
|
|
Value v = rt_get(rt, name);
|
|
value_list_reverse(v);
|
|
rt_set(rt, name, v);
|
|
free(name);
|
|
return;
|
|
}
|
|
if (strcmp(up, "FIND") == 0) {
|
|
const char *in = find_word_ci(t, "IN"), *as = find_word_ci(t, "AS");
|
|
if (in && as) {
|
|
char *needle = substr(t + 4, in);
|
|
char *listname = substr(in + 2, as);
|
|
char *var = xstrdup(trim_inplace((char *)as + 2));
|
|
Value nv = eval_expr(rt, needle), lv = eval_expr(rt, listname);
|
|
int found = 0, i;
|
|
if (lv.type == V_LIST) {
|
|
for (i = 0; i < lv.list->count; i++)
|
|
if (value_compare(nv, lv.list->items[i]) == 0) {
|
|
found = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
rt_set(rt, var, v_num(found));
|
|
free(needle);
|
|
free(listname);
|
|
free(var);
|
|
value_free(nv);
|
|
value_free(lv);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "REMOVE") == 0) {
|
|
const char *from = find_word_ci(t, "FROM");
|
|
if (from) {
|
|
char *needle = substr(t + 6, from);
|
|
char *listname = xstrdup(trim_inplace((char *)from + 4));
|
|
Value nv = eval_expr(rt, needle), lv = rt_get(rt, listname);
|
|
int i, j;
|
|
if (lv.type == V_LIST) {
|
|
for (i = 0; i < lv.list->count; i++)
|
|
if (value_compare(nv, lv.list->items[i]) == 0) {
|
|
value_free(lv.list->items[i]);
|
|
for (j = i; j < lv.list->count - 1; j++)
|
|
lv.list->items[j] = lv.list->items[j + 1];
|
|
lv.list->count--;
|
|
break;
|
|
}
|
|
rt_set(rt, listname, lv);
|
|
}
|
|
free(needle);
|
|
free(listname);
|
|
value_free(nv);
|
|
value_free(lv);
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(up, "TRY") == 0) {
|
|
int catchpos = -1, end = match_block(p, pc, "TRY", "ENDTRY", "CATCH", &catchpos);
|
|
exec_range(rt, p, pc + 1, catchpos >= 0 ? catchpos : end);
|
|
if (rt->error) {
|
|
rt_clear_error(rt);
|
|
if (catchpos >= 0)
|
|
exec_range(rt, p, catchpos + 1, end);
|
|
}
|
|
*pcp = end < 0 ? pc : end;
|
|
return;
|
|
}
|
|
if (strcmp(up, "RAISE") == 0) {
|
|
char *e = expr_after_word(t, "RAISE");
|
|
Value v = eval_expr(rt, e);
|
|
char *s = v_to_string(v);
|
|
rt_error(rt, p->path, pc + 1, "%s", s);
|
|
free(s);
|
|
free(e);
|
|
return;
|
|
}
|
|
if (strcmp(up, "CREATE") == 0 || strcmp(up, "MOVE") == 0 || strcmp(up, "SHOW") == 0 ||
|
|
strcmp(up, "HIDE") == 0 || strcmp(up, "EXPORT") == 0 || strcmp(up, "LEARNED") == 0 ||
|
|
strcmp(up, "ENDIF") == 0 || strcmp(up, "ELSE") == 0 || strcmp(up, "DONE") == 0 ||
|
|
strcmp(up, "ENDTRY") == 0 || strcmp(up, "CATCH") == 0 || strcmp(up, "ENDCOMMENT") == 0 ||
|
|
strcmp(up, "END") == 0 || strcmp(up, "WAIT") == 0) {
|
|
return;
|
|
}
|
|
rt_error(rt, p->path, pc + 1, "Unknown command: %s", w);
|
|
}
|
|
static void exec_line(Runtime *rt, Program *p, int *pcp, const char *raw) {
|
|
const char *saved_file = rt->active_file;
|
|
int saved_line = rt->active_line;
|
|
rt->active_file = p->path;
|
|
rt->active_line = *pcp + 1;
|
|
if (rt_tick(rt))
|
|
exec_line_body(rt, p, pcp, raw);
|
|
rt->active_file = saved_file;
|
|
rt->active_line = saved_line;
|
|
}
|
|
static void exec_range(Runtime *rt, Program *p, int start, int end) {
|
|
int pc;
|
|
/* Function calls have their own guard; count additional control-block frames. */
|
|
if (rt->range_depth - rt->call_depth > CLARO_MAX_BLOCK_DEPTH) {
|
|
rt_error(rt, p->path, start + 1,
|
|
"Block nesting exceeds the safe limit of 128. Simplify the nested blocks.");
|
|
return;
|
|
}
|
|
if (!rt_tick(rt)) return;
|
|
rt->range_depth++;
|
|
if (end < 0 || end > p->count)
|
|
end = p->count;
|
|
for (pc = start; pc < end && !rt->error && !rt->returning; pc++)
|
|
exec_line(rt, p, &pc, p->lines[pc]);
|
|
rt->range_depth--;
|
|
}
|
|
static int run_file(Runtime *rt, const char *path) {
|
|
Program *p = load_program(rt, path);
|
|
int rc;
|
|
if (!p) {
|
|
fprintf(stderr, "Could not open %s: %s\n", path, strerror(errno));
|
|
return 1;
|
|
}
|
|
scan_functions(rt, p, "");
|
|
exec_range(rt, p, 0, p->count);
|
|
rc = rt->error ? 1 : 0;
|
|
if (rt->error && !rt->capture)
|
|
fprintf(stderr, "%s:%d: %s\n", rt->err_file ? rt->err_file : path, rt->err_line,
|
|
rt->err_msg ? rt->err_msg : "error");
|
|
runtime_programs_free(rt);
|
|
return rc;
|
|
}
|
|
|
|
/* ---------- formatter/check/test runner ---------- */
|
|
static int fmt_file(const char *path) {
|
|
FILE *f = fopen(path, "rb");
|
|
char line[4096];
|
|
int indent = 0;
|
|
if (!f) {
|
|
fprintf(stderr, "Could not open %s\n", path);
|
|
return 1;
|
|
}
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char *t = trim_inplace(line), w[64], up[64];
|
|
int opens = 0, i;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "ENDIF") || !strcmp(up, "LEARNED") || !strcmp(up, "DONE") ||
|
|
!strcmp(up, "ENDTRY") || !strcmp(up, "ELSE") || !strcmp(up, "CATCH") ||
|
|
!strcmp(up, "ENDCOMMENT") || !strcmp(up, "ENDCLASS") || !strcmp(up, "ENDTASK") ||
|
|
!strcmp(up, "END"))
|
|
indent -= 4;
|
|
if (indent < 0)
|
|
indent = 0;
|
|
for (i = 0; i < indent; i++)
|
|
putchar(' ');
|
|
puts(t);
|
|
opens = !strcmp(up, "TEACH") || !strcmp(up, "IF") || !strcmp(up, "FOR") ||
|
|
!strcmp(up, "TRY") || !strcmp(up, "CLASS") || !strcmp(up, "START") ||
|
|
!strcmp(up, "COMMENT") || !strcmp(up, "REPEAT") || !strcmp(up, "ELSE") ||
|
|
!strcmp(up, "CATCH") || (!strcmp(up, "DO") && find_word_ci(t, "TIMES"));
|
|
if (opens)
|
|
indent += 4;
|
|
}
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
static const char *check_commands[] = {
|
|
"SAY", "SET", "ASK", "IF", "ELSE", "ENDIF", "DO", "DONE",
|
|
"FOR", "REPEAT", "UNTIL", "TEACH", "LEARNED", "RETURN", "CALL", "IMPORT",
|
|
"ADD", "COUNT", "GET", "PUT", "WRITE", "APPEND", "READ", "EXISTS",
|
|
"DELETE", "PARSE", "MAKE", "TRY", "CATCH", "ENDTRY", "RAISE", "CREATE",
|
|
"COPY", "MOVE", "LIST", "TEXT", "RANDOM", "RUN", "SORT", "REVERSE",
|
|
"FIND", "REMOVE", "SHOW", "HIDE", "EXPORT", "COMMENT", "ENDCOMMENT", "END",
|
|
"WAIT", "YIELD", "TASK", "CLASS", "HAS", "ENDCLASS", "NEW", "START",
|
|
"ENDTASK", "OPEN", "CLEAR", "DRAW", "UPDATE", "CLOSE", "HTTP", "OBJECT",
|
|
"TYPE", "CHECK", NULL};
|
|
static int known_command(const char *up) {
|
|
int i;
|
|
for (i = 0; check_commands[i]; i++)
|
|
if (strcmp(up, check_commands[i]) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
static int levenshtein(const char *a, const char *b) {
|
|
int la = (int)strlen(a), lb = (int)strlen(b), i, j;
|
|
int *dp = (int *)xmalloc(sizeof(int) * (la + 1) * (lb + 1));
|
|
for (i = 0; i <= la; i++)
|
|
dp[i * (lb + 1)] = i;
|
|
for (j = 0; j <= lb; j++)
|
|
dp[j] = j;
|
|
for (i = 1; i <= la; i++)
|
|
for (j = 1; j <= lb; j++) {
|
|
int c = tolower((unsigned char)a[i - 1]) == tolower((unsigned char)b[j - 1]) ? 0 : 1;
|
|
int x = dp[(i - 1) * (lb + 1) + j] + 1, y = dp[i * (lb + 1) + j - 1] + 1,
|
|
z = dp[(i - 1) * (lb + 1) + j - 1] + c;
|
|
int m = x < y ? x : y;
|
|
if (z < m)
|
|
m = z;
|
|
dp[i * (lb + 1) + j] = m;
|
|
}
|
|
i = dp[la * (lb + 1) + lb];
|
|
free(dp);
|
|
return i;
|
|
}
|
|
|
|
static const char *suggest_command_name(const char *up) {
|
|
const char *best = NULL;
|
|
int bd = 999, i;
|
|
if (strcmp(up, "PRINT") == 0 || strcmp(up, "PRNT") == 0 || strcmp(up, "ECHO") == 0 ||
|
|
strcmp(up, "SAI") == 0)
|
|
return "SAY";
|
|
for (i = 0; check_commands[i]; i++) {
|
|
int d = levenshtein(up, check_commands[i]);
|
|
if (d < bd) {
|
|
bd = d;
|
|
best = check_commands[i];
|
|
}
|
|
}
|
|
return (best && bd <= 2) ? best : NULL;
|
|
}
|
|
static void check_add_var(Var **vars, const char *name) {
|
|
char tmp[256];
|
|
char *t;
|
|
Var *v;
|
|
if (!name)
|
|
return;
|
|
strncpy(tmp, name, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (!*t)
|
|
return;
|
|
if (env_find(*vars, t))
|
|
return;
|
|
v = (Var *)xmalloc(sizeof(Var));
|
|
memset(v, 0, sizeof(Var));
|
|
v->name = xstrdup(t);
|
|
v->next = *vars;
|
|
*vars = v;
|
|
}
|
|
static char *check_var_after_as(const char *line) {
|
|
const char *as = find_word_ci(line, "AS");
|
|
if (!as)
|
|
return NULL;
|
|
return xstrdup(trim_inplace((char *)as + 2));
|
|
}
|
|
static char *check_between_words(const char *line, const char *a, const char *b) {
|
|
const char *pa = find_word_ci(line, a);
|
|
const char *pb;
|
|
if (!pa)
|
|
return NULL;
|
|
pa += strlen(a);
|
|
pb = find_word_ci(pa, b);
|
|
if (!pb)
|
|
return NULL;
|
|
return substr(pa, pb);
|
|
}
|
|
typedef struct CheckBlock {
|
|
const char *expect;
|
|
const char *open;
|
|
int line;
|
|
} CheckBlock;
|
|
static CheckBlock check_block(const char *expect, const char *open, int line) {
|
|
CheckBlock block;
|
|
block.expect = expect;
|
|
block.open = open;
|
|
block.line = line;
|
|
return block;
|
|
}
|
|
|
|
static void check_vars_free(Var **vars) {
|
|
Var *v, *next;
|
|
if (!vars)
|
|
return;
|
|
for (v = *vars; v; v = next) {
|
|
next = v->next;
|
|
free(v->name);
|
|
value_free(v->val);
|
|
free(v);
|
|
}
|
|
*vars = NULL;
|
|
}
|
|
static int check_file(const char *path) {
|
|
FILE *f = fopen(path, "rb");
|
|
char line[4096];
|
|
int line_no = 0, errs = 0, sp = 0;
|
|
CheckBlock stack[256];
|
|
Var *vars = NULL;
|
|
check_add_var(&vars, "RESULT");
|
|
check_add_var(&vars, "LASTERROR");
|
|
check_add_var(&vars, "LASTERRORFILE");
|
|
check_add_var(&vars, "LASTERRORLINE");
|
|
check_add_var(&vars, "LASTEXIT");
|
|
check_add_var(&vars, "LASTHTTP");
|
|
if (!f) {
|
|
fprintf(stderr, "Could not open %s\n", path);
|
|
return 1;
|
|
}
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
line_no++;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!known_command(up)) {
|
|
const char *sug = suggest_command_name(up);
|
|
printf("%s:%d: I do not know the command \"%s\".", path, line_no, w);
|
|
if (sug)
|
|
printf(" Did you mean \"%s\"?", sug);
|
|
printf("\n");
|
|
errs++;
|
|
continue;
|
|
}
|
|
|
|
if (sp >= CLARO_MAX_BLOCK_DEPTH &&
|
|
(!strcmp(up, "IF") || !strcmp(up, "TEACH") || !strcmp(up, "CLASS") ||
|
|
!strcmp(up, "FOR") || !strcmp(up, "TRY") || !strcmp(up, "COMMENT") ||
|
|
!strcmp(up, "REPEAT") || (!strcmp(up, "DO") && find_word_ci(t, "TIMES")) ||
|
|
(!strcmp(up, "START") && starts_ci(t + 5, " TASK")))) {
|
|
printf("%s:%d: Block nesting exceeds the safe limit of 128. Simplify the nested blocks.\n",
|
|
path, line_no);
|
|
errs++;
|
|
sp = 0;
|
|
break;
|
|
}
|
|
|
|
if (!strcmp(up, "IF")) {
|
|
if (!*trim_inplace(t + 2)) {
|
|
printf("%s:%d: IF needs a condition. Try: IF score = 10\n", path, line_no);
|
|
errs++;
|
|
}
|
|
stack[sp++] = check_block("ENDIF", "IF", line_no);
|
|
} else if (!strcmp(up, "CLASS")) {
|
|
stack[sp++] = check_block("ENDCLASS", "CLASS", line_no);
|
|
} else if (!strcmp(up, "START")) {
|
|
if (starts_ci(t + 5, " TASK"))
|
|
stack[sp++] = check_block("ENDTASK", "START", line_no);
|
|
} else if (!strcmp(up, "NEW")) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
char *cls = unquote_token(&pcur);
|
|
name = unquote_token(&pcur);
|
|
if (name && *trim_inplace(name))
|
|
check_add_var(&vars, name);
|
|
else {
|
|
printf("%s:%d: NEW needs a class and a name. Try: NEW Player player\n", path,
|
|
line_no);
|
|
errs++;
|
|
}
|
|
free(cls);
|
|
free(name);
|
|
}
|
|
} else if (!strcmp(up, "TEACH")) {
|
|
if (!*trim_inplace(t + 5)) {
|
|
printf("%s:%d: TEACH needs a function name. Try: TEACH greet name\n", path,
|
|
line_no);
|
|
errs++;
|
|
} else {
|
|
char *function_name = NULL;
|
|
char **parameters = NULL;
|
|
int count = 0, index;
|
|
parse_teach_parts(t, &function_name, ¶meters, &count);
|
|
for (index = 0; index < count; index++)
|
|
check_add_var(&vars, parameters[index]);
|
|
split_args_free(parameters, count);
|
|
/* function_name points into the borrowed line buffer. */
|
|
}
|
|
stack[sp++] = check_block("LEARNED", "TEACH", line_no);
|
|
} else if (!strcmp(up, "DO")) {
|
|
if (find_word_ci(t, "TIMES")) {
|
|
stack[sp++] = check_block("DONE", "DO", line_no);
|
|
}
|
|
} else if (!strcmp(up, "FOR")) {
|
|
char *name = NULL;
|
|
if (find_word_ci(t, "EACH")) {
|
|
const char *each = find_word_ci(t, "EACH");
|
|
const char *in = find_word_ci(t, "IN");
|
|
if (!in) {
|
|
printf("%s:%d: FOR EACH needs IN. Try: FOR EACH item IN list\n", path, line_no);
|
|
errs++;
|
|
} else {
|
|
char *comma;
|
|
name = substr(each + 4, in);
|
|
comma = strchr(name, ',');
|
|
if (comma) {
|
|
*comma = 0;
|
|
check_add_var(&vars, name);
|
|
check_add_var(&vars, comma + 1);
|
|
} else
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
} else {
|
|
const char *from = find_word_ci(t, "FROM");
|
|
if (!from) {
|
|
printf("%s:%d: FOR needs FROM. Try: FOR i FROM 1 TO 5\n", path, line_no);
|
|
errs++;
|
|
} else {
|
|
name = substr(t + 3, from);
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
if (!find_word_ci(t, "TO")) {
|
|
printf("%s:%d: FOR needs TO. Try: FOR i FROM 1 TO 5\n", path, line_no);
|
|
errs++;
|
|
}
|
|
}
|
|
}
|
|
stack[sp++] = check_block("DONE", "FOR", line_no);
|
|
} else if (!strcmp(up, "TRY")) {
|
|
stack[sp++] = check_block("ENDTRY", "TRY", line_no);
|
|
} else if (!strcmp(up, "COMMENT")) {
|
|
stack[sp++] = check_block("ENDCOMMENT", "COMMENT", line_no);
|
|
} else if (!strcmp(up, "REPEAT")) {
|
|
stack[sp++] = check_block("UNTIL", "REPEAT", line_no);
|
|
} else if (!strcmp(up, "ELSE")) {
|
|
if (sp == 0 || strcmp(stack[sp - 1].expect, "ENDIF") != 0) {
|
|
printf("%s:%d: ELSE must be inside an IF block.\n", path, line_no);
|
|
errs++;
|
|
}
|
|
} else if (!strcmp(up, "CATCH")) {
|
|
if (sp == 0 || strcmp(stack[sp - 1].expect, "ENDTRY") != 0) {
|
|
printf("%s:%d: CATCH must be inside a TRY block.\n", path, line_no);
|
|
errs++;
|
|
}
|
|
} else if (!strcmp(up, "ENDIF") || !strcmp(up, "LEARNED") || !strcmp(up, "DONE") ||
|
|
!strcmp(up, "ENDTRY") || !strcmp(up, "ENDCOMMENT") || !strcmp(up, "ENDCLASS") ||
|
|
!strcmp(up, "ENDTASK") || !strcmp(up, "UNTIL") || !strcmp(up, "END")) {
|
|
if (!strcmp(up, "END")) {
|
|
if (sp == 0) {
|
|
printf("%s:%d: unexpected END\n", path, line_no);
|
|
errs++;
|
|
} else
|
|
sp--;
|
|
} else if (sp == 0 || strcmp(stack[sp - 1].expect, up) != 0) {
|
|
printf("%s:%d: unexpected %s\n", path, line_no, up);
|
|
errs++;
|
|
} else
|
|
sp--;
|
|
}
|
|
|
|
if (!strcmp(up, "HAS")) {
|
|
const char *pcur = t + 3;
|
|
char *name = unquote_token(&pcur);
|
|
if (name && *trim_inplace(name))
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
|
|
if (!strcmp(up, "SET")) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
if (!to) {
|
|
const char *pcur = t + 3;
|
|
char *name = unquote_token(&pcur);
|
|
if (!*trim_inplace(name) || !*trim_inplace((char *)pcur)) {
|
|
printf("%s:%d: SET needs a name and a value. Try: SET name \"Alex\"\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
} else {
|
|
char *name = substr(t + 3, to);
|
|
if (!*trim_inplace(name)) {
|
|
printf("%s:%d: SET needs a variable name. Try: SET score 0\n", path,
|
|
line_no);
|
|
errs++;
|
|
} else
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
}
|
|
if (!strcmp(up, "ASK")) {
|
|
char *name = NULL;
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
const char *pcur = as + 2;
|
|
name = unquote_token(&pcur);
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
char *prompt = unquote_token(&pcur);
|
|
free(prompt);
|
|
name = unquote_token(&pcur);
|
|
}
|
|
if (!name || !*trim_inplace(name)) {
|
|
printf("%s:%d: ASK needs a variable name. Try: ASK \"What is your name?\" name\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
if (!strcmp(up, "COUNT") || !strcmp(up, "READ") || !strcmp(up, "EXISTS") ||
|
|
!strcmp(up, "PARSE") || !strcmp(up, "MAKE")) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
} else if (!strcmp(up, "COUNT")) {
|
|
printf("%s:%d: COUNT needs AS. Try: COUNT items AS total\n", path, line_no);
|
|
errs++;
|
|
}
|
|
}
|
|
if (!strcmp(up, "GET")) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
} else {
|
|
printf("%s:%d: GET needs AS. Try: GET items AT 1 AS item\n", path, line_no);
|
|
errs++;
|
|
}
|
|
}
|
|
if (!strcmp(up, "HTTP")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
char *name = xstrdup(trim_inplace((char *)as + 2));
|
|
const char *status = find_word_ci(name, "STATUS");
|
|
if (status) {
|
|
char *primary = substr(name, status);
|
|
check_add_var(&vars, primary);
|
|
check_add_var(&vars, trim_inplace((char *)status + 6));
|
|
free(primary);
|
|
} else
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
}
|
|
if (!strcmp(up, "TASK")) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
}
|
|
if (!strcmp(up, "CALL")) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
}
|
|
if (!strcmp(up, "TEXT") || !strcmp(up, "TYPE") || !strcmp(up, "OBJECT") ||
|
|
!strcmp(up, "RANDOM") || !strcmp(up, "RUN") || !strcmp(up, "LIST") ||
|
|
!strcmp(up, "FIND") || (!strcmp(up, "GET") && find_word_ci(t, "AS"))) {
|
|
char *name = check_var_after_as(t);
|
|
if (name) {
|
|
check_add_var(&vars, name);
|
|
free(name);
|
|
}
|
|
}
|
|
if (!strcmp(up, "SAY") || !strcmp(up, "IF") || !strcmp(up, "RETURN")) {
|
|
const char *expr = t + strlen(w);
|
|
Tokens ts = tokenize(expr);
|
|
int i;
|
|
if (ts.error) {
|
|
printf("%s:%d: %s\n", path, line_no, ts.error);
|
|
errs++;
|
|
}
|
|
for (i = 0; i < ts.n; i++) {
|
|
char *tok = ts.t[i];
|
|
if (isalpha((unsigned char)tok[0]) && !ci_eq(tok, "YES") && !ci_eq(tok, "NO") &&
|
|
!ci_eq(tok, "AND") && !ci_eq(tok, "OR") && !ci_eq(tok, "NOT") &&
|
|
!ci_eq(tok, "IS") && !ci_eq(tok, "LIST") && !ci_eq(tok, "MAP") &&
|
|
!env_find(vars, tok)) {
|
|
Var *v = vars;
|
|
char *best = NULL;
|
|
int bd = 999;
|
|
while (v) {
|
|
int d = levenshtein(tok, v->name);
|
|
if (d < bd) {
|
|
bd = d;
|
|
best = v->name;
|
|
}
|
|
v = v->next;
|
|
}
|
|
if (best && bd <= 2)
|
|
printf(
|
|
"%s:%d: I do not know the variable \"%s\" yet. Did you mean \"%s\"?\n",
|
|
path, line_no, tok, best);
|
|
else
|
|
printf("%s:%d: I do not know the variable \"%s\" yet.\n", path, line_no,
|
|
tok);
|
|
errs++;
|
|
}
|
|
}
|
|
tokens_free(&ts);
|
|
}
|
|
}
|
|
fclose(f);
|
|
while (sp > 0) {
|
|
CheckBlock b = stack[--sp];
|
|
const char *ending = b.expect;
|
|
if (!strcmp(b.open, "IF") || !strcmp(b.open, "TEACH") ||
|
|
!strcmp(b.open, "DO") || !strcmp(b.open, "FOR"))
|
|
ending = "END";
|
|
printf("%s:%d: %s block opened here needs %s\n", path, b.line, b.open, ending);
|
|
errs++;
|
|
}
|
|
if (errs == 0)
|
|
printf("OK\n");
|
|
check_vars_free(&vars);
|
|
return errs ? 1 : 0;
|
|
}
|
|
|
|
static const char *type_env_get(Var *types, const char *name) {
|
|
Var *v = env_find(types, name);
|
|
if (v && v->val.type == V_STR)
|
|
return v->val.str;
|
|
return NULL;
|
|
}
|
|
static void type_env_free(Var **types) {
|
|
Var *v, *next;
|
|
if (!types)
|
|
return;
|
|
for (v = *types; v; v = next) {
|
|
next = v->next;
|
|
free(v->name);
|
|
value_free(v->val);
|
|
free(v);
|
|
}
|
|
*types = NULL;
|
|
}
|
|
static void type_env_set(Var **types, const char *name, const char *type) {
|
|
Var *v;
|
|
char tmp[256];
|
|
char *t;
|
|
if (!name || !type || !*type)
|
|
return;
|
|
strncpy(tmp, name, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (!*t)
|
|
return;
|
|
v = env_find(*types, t);
|
|
if (v) {
|
|
value_free(v->val);
|
|
v->val = v_str(type);
|
|
return;
|
|
}
|
|
v = (Var *)xmalloc(sizeof(Var));
|
|
memset(v, 0, sizeof(Var));
|
|
v->name = xstrdup(t);
|
|
v->val = v_str(type);
|
|
v->next = *types;
|
|
*types = v;
|
|
}
|
|
static const char *simple_expr_type(Var *types, const char *expr) {
|
|
char tmp[512];
|
|
char *t;
|
|
double d;
|
|
size_t i = 0;
|
|
int in_string = 0;
|
|
if (!expr)
|
|
return NULL;
|
|
strncpy(tmp, expr, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (!*t)
|
|
return NULL;
|
|
if (*t == '"')
|
|
return "TEXT";
|
|
if (parse_number_strict(t, &d))
|
|
return "NUMBER";
|
|
if (ci_eq(t, "YES") || ci_eq(t, "NO") || ci_eq(t, "TRUE") || ci_eq(t, "FALSE"))
|
|
return "YESNO";
|
|
if (ci_eq(t, "LIST"))
|
|
return "LIST";
|
|
if (ci_eq(t, "MAP"))
|
|
return "MAP";
|
|
if (starts_ci(t, "NEW "))
|
|
return "OBJECT";
|
|
for (i = 0; t[i]; i++) {
|
|
if (t[i] == '"')
|
|
in_string = !in_string;
|
|
if (!in_string && strchr("+-*/", t[i])) {
|
|
char *left = substr(t, t + i), *right = xstrdup(t + i + 1);
|
|
const char *lt, *rt;
|
|
lt = simple_expr_type(types, left);
|
|
rt = simple_expr_type(types, right);
|
|
free(left);
|
|
free(right);
|
|
if ((lt && ci_eq(lt, "TEXT")) || (rt && ci_eq(rt, "TEXT")))
|
|
return "TEXT";
|
|
if (lt && rt && ci_eq(lt, "NUMBER") && ci_eq(rt, "NUMBER"))
|
|
return "NUMBER";
|
|
return NULL;
|
|
}
|
|
}
|
|
i = 0;
|
|
while (t[i] && (isalnum((unsigned char)t[i]) || t[i] == '_' || t[i] == '.'))
|
|
i++;
|
|
if (i > 0 && t[i] == 0)
|
|
return type_env_get(types, t);
|
|
return NULL;
|
|
}
|
|
static int return_value_extra_tokens(const char *expr, char *value, size_t value_size) {
|
|
char tmp[512], *t, *p;
|
|
if (!expr || !value || value_size == 0)
|
|
return 0;
|
|
strncpy(tmp, expr, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (!*t || strpbrk(t, "+-*/\"") != NULL)
|
|
return 0;
|
|
p = t;
|
|
while (*p && !isspace((unsigned char)*p))
|
|
p++;
|
|
if (!*p)
|
|
return 0;
|
|
*p++ = 0;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
if (!*p)
|
|
return 0;
|
|
claro_snprintf(value, value_size, "%s", t);
|
|
return 1;
|
|
}
|
|
static const char *text_operand_for_operator(Var *types, const char *expr, char wanted) {
|
|
static char operand[256];
|
|
char tmp[512];
|
|
char *t;
|
|
size_t i;
|
|
int in_string = 0;
|
|
if (!expr)
|
|
return NULL;
|
|
strncpy(tmp, expr, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
for (i = 0; t[i]; i++) {
|
|
char *left, *right;
|
|
const char *lt, *rt;
|
|
if (t[i] == '"')
|
|
in_string = !in_string;
|
|
if (!in_string && t[i] == wanted) {
|
|
left = substr(t, t + i);
|
|
right = xstrdup(t + i + 1);
|
|
lt = simple_expr_type(types, left);
|
|
rt = simple_expr_type(types, right);
|
|
if (lt && ci_eq(lt, "TEXT")) {
|
|
claro_snprintf(operand, sizeof(operand), "%s", trim_inplace(left));
|
|
free(left);
|
|
free(right);
|
|
return operand;
|
|
}
|
|
if (rt && ci_eq(rt, "TEXT")) {
|
|
claro_snprintf(operand, sizeof(operand), "%s", trim_inplace(right));
|
|
free(left);
|
|
free(right);
|
|
return operand;
|
|
}
|
|
free(left);
|
|
free(right);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
static char text_operator_for_number_return(Var *types, const char *expr) {
|
|
const char ops[] = "+-*/";
|
|
int i;
|
|
for (i = 0; ops[i]; i++)
|
|
if (text_operand_for_operator(types, expr, ops[i]))
|
|
return ops[i];
|
|
return 0;
|
|
}
|
|
static int type_words_match(const char *need, const char *got) {
|
|
if (!need || !*need || ci_eq(need, "ANY") || ci_eq(got, "ANY"))
|
|
return 1;
|
|
if (!got || !*got)
|
|
return 1;
|
|
if (ci_eq(need, got))
|
|
return 1;
|
|
if ((ci_eq(need, "LIST") || ci_eq(need, "MAP")) && starts_ci(got, need))
|
|
return 1;
|
|
if (starts_ci(need, "LIST OF") && ci_eq(got, "LIST"))
|
|
return 1;
|
|
if (starts_ci(need, "MAP OF") && ci_eq(got, "MAP"))
|
|
return 1;
|
|
if ((ci_eq(need, "YESNO") || ci_eq(need, "BOOL") || ci_eq(need, "BOOLEAN")) &&
|
|
(ci_eq(got, "YESNO") || ci_eq(got, "BOOL") || ci_eq(got, "BOOLEAN")))
|
|
return 1;
|
|
if (ci_eq(need, "OBJECT") && (ci_eq(got, "MAP") || starts_ci(got, "OBJECT:")))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
static const char *container_member_type(const char *type, const char *kind) {
|
|
const char *p;
|
|
static char buf[128];
|
|
if (!type || !kind)
|
|
return NULL;
|
|
if (!starts_ci(type, kind))
|
|
return NULL;
|
|
p = type + strlen(kind);
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
if (!starts_ci(p, "OF"))
|
|
return NULL;
|
|
p += 2;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
if (!*p)
|
|
return NULL;
|
|
claro_snprintf(buf, sizeof(buf), "%s", p);
|
|
return trim_inplace(buf);
|
|
}
|
|
static void parse_set_for_typecheck2(const char *t, char **name, char **type, char **expr) {
|
|
const char *rest = t + 3;
|
|
const char *to = find_word_ci(rest, "TO");
|
|
const char *as = find_word_ci(rest, "AS");
|
|
*name = NULL;
|
|
*type = NULL;
|
|
*expr = NULL;
|
|
if (as && to && as < to) {
|
|
*name = substr(rest, as);
|
|
*type = substr(as + 2, to);
|
|
*expr = xstrdup(to + 2);
|
|
return;
|
|
}
|
|
if (to) {
|
|
char *before = substr(rest, to);
|
|
const char *pcur = before;
|
|
char *var = unquote_token(&pcur);
|
|
char *maybe = unquote_token(&pcur);
|
|
char *mt = trim_inplace(maybe);
|
|
*name = xstrdup(trim_inplace(var));
|
|
if (claro_is_type_word(mt))
|
|
*type = xstrdup(mt);
|
|
*expr = xstrdup(to + 2);
|
|
free(before);
|
|
free(var);
|
|
free(maybe);
|
|
return;
|
|
}
|
|
{
|
|
const char *pcur = rest;
|
|
char *var = unquote_token(&pcur);
|
|
const char *after_var = pcur;
|
|
char *maybe = unquote_token(&pcur);
|
|
char *mt = trim_inplace(maybe);
|
|
char *remaining = trim_inplace((char *)pcur);
|
|
int uppercase_candidate = 1;
|
|
char *q;
|
|
for (q = mt; *q; q++)
|
|
if (isalpha((unsigned char)*q) && !isupper((unsigned char)*q))
|
|
uppercase_candidate = 0;
|
|
*name = xstrdup(trim_inplace(var));
|
|
if (!*remaining && (ci_eq(mt, "LIST") || ci_eq(mt, "MAP"))) {
|
|
/* A bare container word constructs a value, not an empty annotation. */
|
|
*expr = xstrdup(mt);
|
|
} else if (claro_is_type_word(mt)) {
|
|
*type = xstrdup(mt);
|
|
*expr = xstrdup(remaining);
|
|
} else if (strchr(trim_inplace(var), '.') && *remaining && strchr(mt, ' ') == NULL &&
|
|
uppercase_candidate) {
|
|
*type = xstrdup(mt);
|
|
*expr = xstrdup(remaining);
|
|
} else {
|
|
*expr = xstrdup(trim_inplace((char *)after_var));
|
|
}
|
|
free(var);
|
|
free(maybe);
|
|
}
|
|
}
|
|
typedef struct TypeParamCheck {
|
|
char *func;
|
|
char *param;
|
|
char *type;
|
|
int pos;
|
|
struct TypeParamCheck *next;
|
|
} TypeParamCheck;
|
|
typedef struct TypeFieldCheck {
|
|
char *cls;
|
|
char *field;
|
|
char *type;
|
|
struct TypeFieldCheck *next;
|
|
} TypeFieldCheck;
|
|
typedef struct TypeMethodCheck {
|
|
char *cls;
|
|
char *method;
|
|
struct TypeMethodCheck *next;
|
|
} TypeMethodCheck;
|
|
typedef struct TypeArityCheck {
|
|
char *func;
|
|
int arity;
|
|
struct TypeArityCheck *next;
|
|
} TypeArityCheck;
|
|
typedef struct TypeReturnCheck {
|
|
char *func;
|
|
char *type;
|
|
struct TypeReturnCheck *next;
|
|
} TypeReturnCheck;
|
|
static void add_type_param_check(TypeParamCheck **checks, const char *func, const char *param,
|
|
const char *type, int pos) {
|
|
TypeParamCheck *c;
|
|
if (!func || !*func || !param || !*param || !type || !*type)
|
|
return;
|
|
c = (TypeParamCheck *)xmalloc(sizeof(TypeParamCheck));
|
|
c->func = xstrdup(func);
|
|
c->param = xstrdup(param);
|
|
c->type = xstrdup(type);
|
|
c->pos = pos;
|
|
c->next = *checks;
|
|
*checks = c;
|
|
}
|
|
static const char *type_param_check_for(TypeParamCheck *checks, const char *func, int pos,
|
|
const char **param) {
|
|
TypeParamCheck *c = checks;
|
|
while (c) {
|
|
if (c->pos == pos && ci_eq(c->func, func)) {
|
|
if (param)
|
|
*param = c->param;
|
|
return c->type;
|
|
}
|
|
c = c->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static void add_type_arity_check(TypeArityCheck **checks, const char *func, int arity) {
|
|
TypeArityCheck *c;
|
|
if (!func || !*func)
|
|
return;
|
|
c = (TypeArityCheck *)xmalloc(sizeof(TypeArityCheck));
|
|
c->func = xstrdup(func);
|
|
c->arity = arity;
|
|
c->next = *checks;
|
|
*checks = c;
|
|
}
|
|
static int type_arity_check_for(TypeArityCheck *checks, const char *func) {
|
|
TypeArityCheck *c = checks;
|
|
while (c) {
|
|
if (ci_eq(c->func, func))
|
|
return c->arity;
|
|
c = c->next;
|
|
}
|
|
return -1;
|
|
}
|
|
static void add_type_return_check(TypeReturnCheck **checks, const char *func, const char *type) {
|
|
TypeReturnCheck *c;
|
|
if (!func || !*func || !type || !*type)
|
|
return;
|
|
c = (TypeReturnCheck *)xmalloc(sizeof(TypeReturnCheck));
|
|
c->func = xstrdup(func);
|
|
c->type = xstrdup(type);
|
|
c->next = *checks;
|
|
*checks = c;
|
|
}
|
|
static const char *type_return_check_for(TypeReturnCheck *checks, const char *func) {
|
|
TypeReturnCheck *c = checks;
|
|
while (c) {
|
|
if (ci_eq(c->func, func))
|
|
return c->type;
|
|
c = c->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static void add_type_field_check(TypeFieldCheck **checks, const char *cls, const char *field,
|
|
const char *type) {
|
|
TypeFieldCheck *c;
|
|
if (!cls || !*cls || !field || !*field || !type || !*type)
|
|
return;
|
|
c = (TypeFieldCheck *)xmalloc(sizeof(TypeFieldCheck));
|
|
c->cls = xstrdup(cls);
|
|
c->field = xstrdup(field);
|
|
c->type = xstrdup(type);
|
|
c->next = *checks;
|
|
*checks = c;
|
|
}
|
|
static const char *type_field_check_for(TypeFieldCheck *checks, const char *cls,
|
|
const char *field) {
|
|
TypeFieldCheck *c = checks;
|
|
while (c) {
|
|
if (ci_eq(c->cls, cls) && ci_eq(c->field, field))
|
|
return c->type;
|
|
c = c->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
static void add_type_method_check(TypeMethodCheck **checks, const char *cls, const char *method) {
|
|
TypeMethodCheck *c;
|
|
if (!cls || !*cls || !method || !*method)
|
|
return;
|
|
c = (TypeMethodCheck *)xmalloc(sizeof(TypeMethodCheck));
|
|
c->cls = xstrdup(cls);
|
|
c->method = xstrdup(method);
|
|
c->next = *checks;
|
|
*checks = c;
|
|
}
|
|
static int type_method_check_for(TypeMethodCheck *checks, const char *cls, const char *method) {
|
|
TypeMethodCheck *c = checks;
|
|
while (c) {
|
|
if (ci_eq(c->cls, cls) && ci_eq(c->method, method))
|
|
return 1;
|
|
c = c->next;
|
|
}
|
|
return 0;
|
|
}
|
|
static int type_method_name_exists(TypeMethodCheck *checks, const char *method) {
|
|
TypeMethodCheck *c = checks;
|
|
while (c) {
|
|
if (ci_eq(c->method, method))
|
|
return 1;
|
|
c = c->next;
|
|
}
|
|
return 0;
|
|
}
|
|
static int param_index_named(char **params, int pcnt, const char *name) {
|
|
int i;
|
|
char tmp[256];
|
|
char *p;
|
|
for (i = 0; i < pcnt; i++) {
|
|
strncpy(tmp, params[i], sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
p = trim_inplace(tmp);
|
|
if (ci_eq(p, name))
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
static const char *duplicate_param_name(char **params, int pcnt) {
|
|
int i, j;
|
|
char left[256], right[256];
|
|
for (i = 0; i < pcnt; i++) {
|
|
claro_snprintf(left, sizeof(left), "%s", trim_inplace(params[i]));
|
|
for (j = 0; j < i; j++) {
|
|
claro_snprintf(right, sizeof(right), "%s", trim_inplace(params[j]));
|
|
if (ci_eq(left, right))
|
|
return params[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
static void collect_teach_param_checks_from_body(TypeParamCheck **checks, FILE *f,
|
|
const char *func_name, char **params, int pcnt) {
|
|
char line[4096];
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char inner[4096], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(inner, line, sizeof(inner) - 1);
|
|
inner[sizeof(inner) - 1] = 0;
|
|
it = trim_inplace(inner);
|
|
if (is_blank_or_comment(it))
|
|
continue;
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (!strcmp(iup, "END") || !strcmp(iup, "LEARNED"))
|
|
break;
|
|
if (!strcmp(iup, "CHECK") && starts_ci(it, "CHECK TYPE")) {
|
|
const char *is = find_word_ci(it, "IS");
|
|
if (is) {
|
|
char *expr = substr(it + 10, is);
|
|
char *need = xstrdup(trim_inplace((char *)is + 2));
|
|
char *en = trim_inplace(expr);
|
|
int idx = param_index_named(params, pcnt, en);
|
|
if (idx >= 0)
|
|
add_type_param_check(checks, func_name, en, need, idx);
|
|
free(expr);
|
|
free(need);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
static TypeParamCheck *collect_function_param_type_checks(FILE *f) {
|
|
TypeParamCheck *checks = NULL;
|
|
char line[4096];
|
|
char current_class[128] = "";
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", trim_inplace(cls));
|
|
free(cls);
|
|
continue;
|
|
}
|
|
if ((!strcmp(up, "END") || !strcmp(up, "ENDCLASS")) && current_class[0]) {
|
|
current_class[0] = 0;
|
|
continue;
|
|
}
|
|
if (!strcmp(up, "TEACH")) {
|
|
char teachline[4096];
|
|
char *fname = NULL;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
char full_name[256];
|
|
strncpy(teachline, t, sizeof(teachline) - 1);
|
|
teachline[sizeof(teachline) - 1] = 0;
|
|
parse_teach_parts(teachline, &fname, ¶ms, &pcnt);
|
|
if (current_class[0])
|
|
claro_snprintf(full_name, sizeof(full_name), "%s.%s", current_class, fname);
|
|
else
|
|
claro_snprintf(full_name, sizeof(full_name), "%s", fname);
|
|
collect_teach_param_checks_from_body(&checks, f, full_name, params, pcnt);
|
|
split_args_free(params, pcnt);
|
|
}
|
|
}
|
|
rewind(f);
|
|
return checks;
|
|
}
|
|
static TypeArityCheck *collect_function_arity_checks(FILE *f) {
|
|
TypeArityCheck *checks = NULL;
|
|
char line[4096];
|
|
char current_class[128] = "";
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", trim_inplace(cls));
|
|
free(cls);
|
|
continue;
|
|
}
|
|
if ((!strcmp(up, "END") || !strcmp(up, "ENDCLASS")) && current_class[0]) {
|
|
current_class[0] = 0;
|
|
continue;
|
|
}
|
|
if (!strcmp(up, "TEACH")) {
|
|
char teachline[4096];
|
|
char *fname = NULL;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
char full_name[256];
|
|
strncpy(teachline, t, sizeof(teachline) - 1);
|
|
teachline[sizeof(teachline) - 1] = 0;
|
|
parse_teach_parts(teachline, &fname, ¶ms, &pcnt);
|
|
if (current_class[0])
|
|
claro_snprintf(full_name, sizeof(full_name), "%s.%s", current_class, fname);
|
|
else
|
|
claro_snprintf(full_name, sizeof(full_name), "%s", fname);
|
|
add_type_arity_check(&checks, full_name, pcnt);
|
|
split_args_free(params, pcnt);
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char inner[4096], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(inner, line, sizeof(inner) - 1);
|
|
inner[sizeof(inner) - 1] = 0;
|
|
it = trim_inplace(inner);
|
|
if (is_blank_or_comment(it))
|
|
continue;
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (!strcmp(iup, "END") || !strcmp(iup, "LEARNED"))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
rewind(f);
|
|
return checks;
|
|
}
|
|
static TypeReturnCheck *collect_function_return_type_checks(FILE *f) {
|
|
TypeReturnCheck *checks = NULL;
|
|
char line[4096];
|
|
char current_class[128] = "";
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", trim_inplace(cls));
|
|
free(cls);
|
|
continue;
|
|
}
|
|
if ((!strcmp(up, "END") || !strcmp(up, "ENDCLASS")) && current_class[0]) {
|
|
current_class[0] = 0;
|
|
continue;
|
|
}
|
|
if (!strcmp(up, "TEACH")) {
|
|
char teachline[4096], full_name[256], *fname = NULL, **params = NULL;
|
|
int pcnt = 0;
|
|
const char *returns;
|
|
strncpy(teachline, t, sizeof(teachline) - 1);
|
|
teachline[sizeof(teachline) - 1] = 0;
|
|
returns = find_word_ci(teachline, "RETURNS");
|
|
parse_teach_parts(teachline, &fname, ¶ms, &pcnt);
|
|
if (returns) {
|
|
char ret[128], first_ret[128];
|
|
const char *p = returns + 7;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
claro_snprintf(ret, sizeof(ret), "%s", p);
|
|
if (sscanf(ret, "%127s", first_ret) == 1) {
|
|
if (current_class[0])
|
|
claro_snprintf(full_name, sizeof(full_name), "%s.%s", current_class, fname);
|
|
else
|
|
claro_snprintf(full_name, sizeof(full_name), "%s", fname);
|
|
add_type_return_check(&checks, full_name, first_ret);
|
|
}
|
|
}
|
|
split_args_free(params, pcnt);
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char inner[4096], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(inner, line, sizeof(inner) - 1);
|
|
inner[sizeof(inner) - 1] = 0;
|
|
it = trim_inplace(inner);
|
|
if (is_blank_or_comment(it))
|
|
continue;
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (!strcmp(iup, "END") || !strcmp(iup, "LEARNED"))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
rewind(f);
|
|
return checks;
|
|
}
|
|
static TypeFieldCheck *collect_class_field_type_checks(FILE *f) {
|
|
TypeFieldCheck *checks = NULL;
|
|
char line[4096];
|
|
char current_class[128] = "";
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", trim_inplace(cls));
|
|
free(cls);
|
|
continue;
|
|
}
|
|
if (current_class[0] && !strcmp(up, "TEACH")) {
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char inner[4096], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(inner, line, sizeof(inner) - 1);
|
|
inner[sizeof(inner) - 1] = 0;
|
|
it = trim_inplace(inner);
|
|
if (is_blank_or_comment(it))
|
|
continue;
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (!strcmp(iup, "END") || !strcmp(iup, "LEARNED"))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if ((!strcmp(up, "END") || !strcmp(up, "ENDCLASS")) && current_class[0]) {
|
|
current_class[0] = 0;
|
|
continue;
|
|
}
|
|
if (current_class[0] && !strcmp(up, "HAS")) {
|
|
const char *pcur = t + 3;
|
|
char *field = unquote_token(&pcur);
|
|
char *type = unquote_token(&pcur);
|
|
add_type_field_check(&checks, current_class, trim_inplace(field), trim_inplace(type));
|
|
free(field);
|
|
free(type);
|
|
}
|
|
}
|
|
rewind(f);
|
|
return checks;
|
|
}
|
|
static TypeMethodCheck *collect_class_method_type_checks(FILE *f) {
|
|
TypeMethodCheck *checks = NULL;
|
|
char line[4096];
|
|
char current_class[128] = "";
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", trim_inplace(cls));
|
|
free(cls);
|
|
continue;
|
|
}
|
|
if ((!strcmp(up, "END") || !strcmp(up, "ENDCLASS")) && current_class[0]) {
|
|
current_class[0] = 0;
|
|
continue;
|
|
}
|
|
if (current_class[0] && !strcmp(up, "TEACH")) {
|
|
char teachline[4096];
|
|
char *fname = NULL;
|
|
char **params = NULL;
|
|
int pcnt = 0;
|
|
strncpy(teachline, t, sizeof(teachline) - 1);
|
|
teachline[sizeof(teachline) - 1] = 0;
|
|
parse_teach_parts(teachline, &fname, ¶ms, &pcnt);
|
|
add_type_method_check(&checks, current_class, trim_inplace(fname));
|
|
split_args_free(params, pcnt);
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char inner[4096], iup[64], iw[128];
|
|
char *it;
|
|
strncpy(inner, line, sizeof(inner) - 1);
|
|
inner[sizeof(inner) - 1] = 0;
|
|
it = trim_inplace(inner);
|
|
if (is_blank_or_comment(it))
|
|
continue;
|
|
first_word(it, iw, sizeof(iw));
|
|
upper_copy(iup, iw, sizeof(iup));
|
|
if (!strcmp(iup, "END") || !strcmp(iup, "LEARNED"))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
rewind(f);
|
|
return checks;
|
|
}
|
|
static void type_checks_free(TypeParamCheck *params, TypeArityCheck *arities,
|
|
TypeReturnCheck *returns, TypeFieldCheck *fields,
|
|
TypeMethodCheck *methods) {
|
|
while (params) {
|
|
TypeParamCheck *next = params->next;
|
|
free(params->func); free(params->param); free(params->type); free(params);
|
|
params = next;
|
|
}
|
|
while (arities) {
|
|
TypeArityCheck *next = arities->next;
|
|
free(arities->func); free(arities); arities = next;
|
|
}
|
|
while (returns) {
|
|
TypeReturnCheck *next = returns->next;
|
|
free(returns->func); free(returns->type); free(returns); returns = next;
|
|
}
|
|
while (fields) {
|
|
TypeFieldCheck *next = fields->next;
|
|
free(fields->cls); free(fields->field); free(fields->type); free(fields); fields = next;
|
|
}
|
|
while (methods) {
|
|
TypeMethodCheck *next = methods->next;
|
|
free(methods->cls); free(methods->method); free(methods); methods = next;
|
|
}
|
|
}
|
|
static int typecheck_file(const char *path) {
|
|
FILE *f = fopen(path, "rb");
|
|
char line[4096];
|
|
int line_no = 0, errs = 0;
|
|
Var *types = NULL;
|
|
TypeParamCheck *param_checks = NULL;
|
|
TypeFieldCheck *field_checks = NULL;
|
|
TypeMethodCheck *method_checks = NULL;
|
|
TypeArityCheck *arity_checks = NULL;
|
|
TypeReturnCheck *return_checks = NULL;
|
|
char current_func[256] = "";
|
|
char current_method[256] = "";
|
|
char current_class[128] = "";
|
|
char declared_classes[128][256];
|
|
char declared_functions[128][256];
|
|
char declared_methods[128][256];
|
|
char declared_fields[128][256];
|
|
char declared_objects[128][256];
|
|
int declared_class_count = 0, declared_function_count = 0, declared_method_count = 0,
|
|
declared_field_count = 0, declared_object_count = 0;
|
|
int in_teach = 0, return_seen = 0, top_level_return_seen = 0, nested_blocks = 0,
|
|
conditional_paths_complete = 1;
|
|
int branch_returned[64], branch_has_else[64];
|
|
if (!f) {
|
|
fprintf(stderr, "Could not open %s\n", path);
|
|
return 1;
|
|
}
|
|
param_checks = collect_function_param_type_checks(f);
|
|
arity_checks = collect_function_arity_checks(f);
|
|
return_checks = collect_function_return_type_checks(f);
|
|
field_checks = collect_class_field_type_checks(f);
|
|
method_checks = collect_class_method_type_checks(f);
|
|
type_env_set(&types, "RESULT", "ANY");
|
|
type_env_set(&types, "LASTERROR", "TEXT");
|
|
type_env_set(&types, "LASTERRORFILE", "TEXT");
|
|
type_env_set(&types, "LASTERRORLINE", "NUMBER");
|
|
type_env_set(&types, "LASTEXIT", "NUMBER");
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char tmp[4096], up[64], w[128];
|
|
char *t;
|
|
line_no++;
|
|
strncpy(tmp, line, sizeof(tmp) - 1);
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
t = trim_inplace(tmp);
|
|
if (is_blank_or_comment(t))
|
|
continue;
|
|
first_word(t, w, sizeof(w));
|
|
upper_copy(up, w, sizeof(up));
|
|
if (!strcmp(up, "CLASS")) {
|
|
const char *pcur = t + 5;
|
|
char *cls = unquote_token(&pcur);
|
|
char *name = trim_inplace(cls);
|
|
char *extra = trim_inplace((char *)pcur);
|
|
int duplicate = 0, ci;
|
|
for (ci = 0; ci < declared_class_count; ci++)
|
|
if (ci_eq(declared_classes[ci], name)) {
|
|
duplicate = 1;
|
|
break;
|
|
}
|
|
if (!*name) {
|
|
printf("%s:%d: CLASS needs a class name. Add a name after CLASS, such as CLASS "
|
|
"Player.\n",
|
|
path, line_no);
|
|
errs++;
|
|
current_class[0] = 0;
|
|
} else if (*extra) {
|
|
printf("%s:%d: Class %s has extra text after its name. Keep only the class name "
|
|
"after CLASS.\n",
|
|
path, line_no, name);
|
|
errs++;
|
|
} else if (duplicate) {
|
|
printf("%s:%d: Class %s is declared more than once. Give each class a different "
|
|
"name.\n",
|
|
path, line_no, name);
|
|
errs++;
|
|
} else if (declared_class_count < 128)
|
|
claro_snprintf(declared_classes[declared_class_count++],
|
|
sizeof(declared_classes[0]), "%s", name);
|
|
claro_snprintf(current_class, sizeof(current_class), "%s", name);
|
|
declared_field_count = 0;
|
|
free(cls);
|
|
} else if (current_class[0] && !strcmp(up, "HAS")) {
|
|
const char *pcur = t + 3;
|
|
char *field = unquote_token(&pcur);
|
|
char *field_type = unquote_token(&pcur);
|
|
char *name = trim_inplace(field);
|
|
char *ft = trim_inplace(field_type);
|
|
char *extra = trim_inplace((char *)pcur);
|
|
int duplicate = 0, fi;
|
|
for (fi = 0; fi < declared_field_count; fi++)
|
|
if (ci_eq(declared_fields[fi], name)) {
|
|
duplicate = 1;
|
|
break;
|
|
}
|
|
if (!*name) {
|
|
printf("%s:%d: Class %s needs a field name. Add a name and type after HAS, such as "
|
|
"HAS score NUMBER.\n",
|
|
path, line_no, current_class);
|
|
errs++;
|
|
} else if (duplicate) {
|
|
printf("%s:%d: Class %s declares field %s more than once. Give each field a "
|
|
"different name.\n",
|
|
path, line_no, current_class, name);
|
|
errs++;
|
|
} else if (!*ft) {
|
|
printf("%s:%d: Class %s field %s is missing a type. Add a type such as NUMBER, "
|
|
"TEXT, YESNO, LIST, or MAP after the field name.\n",
|
|
path, line_no, current_class, name);
|
|
errs++;
|
|
} else if (!claro_is_type_word(ft)) {
|
|
printf("%s:%d: Class %s field %s uses an unknown type %s. Use a Claro type such as "
|
|
"NUMBER, TEXT, YESNO, LIST, or MAP.\n",
|
|
path, line_no, current_class, name, ft);
|
|
errs++;
|
|
} else if (*extra) {
|
|
printf("%s:%d: Class %s field %s has extra text after type %s. Keep only the field "
|
|
"name and one type.\n",
|
|
path, line_no, current_class, name, ft);
|
|
errs++;
|
|
} else if (declared_field_count < 128)
|
|
claro_snprintf(declared_fields[declared_field_count++], sizeof(declared_fields[0]),
|
|
"%s", name);
|
|
free(field);
|
|
free(field_type);
|
|
} else if (!strcmp(up, "TEACH")) {
|
|
char teachline[4096], full_name[256], *fname = NULL, **params = NULL;
|
|
int pcnt = 0;
|
|
int duplicate_method = 0;
|
|
strncpy(teachline, t, sizeof(teachline) - 1);
|
|
teachline[sizeof(teachline) - 1] = 0;
|
|
parse_teach_parts(teachline, &fname, ¶ms, &pcnt);
|
|
if (current_class[0])
|
|
claro_snprintf(full_name, sizeof(full_name), "%s.%s", current_class, fname);
|
|
else
|
|
claro_snprintf(full_name, sizeof(full_name), "%s", fname);
|
|
{
|
|
const char *returns = find_word_ci(t, "RETURNS");
|
|
if (returns) {
|
|
const char *rp = returns + 7;
|
|
char ret[128], first_ret[128], *extra;
|
|
while (*rp && isspace((unsigned char)*rp))
|
|
rp++;
|
|
claro_snprintf(ret, sizeof(ret), "%s", rp);
|
|
if (sscanf(ret, "%127s", first_ret) == 1) {
|
|
extra = trim_inplace((char *)rp + strlen(first_ret));
|
|
if (*extra) {
|
|
printf("%s:%d: %s %s has extra text after return type %s. Keep only "
|
|
"the function name, parameters, and one return type.\n",
|
|
path, line_no, current_class[0] ? "Method" : "Function",
|
|
full_name, first_ret);
|
|
errs++;
|
|
}
|
|
} else {
|
|
printf("%s:%d: %s %s needs a return type after RETURNS. Add a type such as "
|
|
"NUMBER.\n",
|
|
path, line_no, current_class[0] ? "Method" : "Function", full_name);
|
|
errs++;
|
|
}
|
|
}
|
|
}
|
|
if (!fname || !*trim_inplace(fname)) {
|
|
if (current_class[0])
|
|
printf("%s:%d: Method %s needs a method name. Add a name after TEACH, such as "
|
|
"TEACH show.\n",
|
|
path, line_no, current_class);
|
|
else
|
|
printf("%s:%d: TEACH needs a function name. Add a name after TEACH, such as "
|
|
"TEACH greet.\n",
|
|
path, line_no);
|
|
errs++;
|
|
}
|
|
if (!fname)
|
|
fname = xstrdup("");
|
|
if (current_class[0])
|
|
claro_snprintf(full_name, sizeof(full_name), "%s.%s", current_class, fname);
|
|
else
|
|
claro_snprintf(full_name, sizeof(full_name), "%s", fname);
|
|
if (current_class[0]) {
|
|
int mi;
|
|
for (mi = 0; mi < declared_method_count; mi++)
|
|
if (ci_eq(declared_methods[mi], full_name)) {
|
|
duplicate_method = 1;
|
|
break;
|
|
}
|
|
if (duplicate_method) {
|
|
printf("%s:%d: Method %s is declared more than once. Give each method a "
|
|
"different name.\n",
|
|
path, line_no, full_name);
|
|
errs++;
|
|
} else if (declared_method_count < 128)
|
|
claro_snprintf(declared_methods[declared_method_count++],
|
|
sizeof(declared_methods[0]), "%s", full_name);
|
|
} else {
|
|
int fi, duplicate_function = 0;
|
|
for (fi = 0; fi < declared_function_count; fi++)
|
|
if (ci_eq(declared_functions[fi], full_name)) {
|
|
duplicate_function = 1;
|
|
break;
|
|
}
|
|
if (duplicate_function) {
|
|
printf("%s:%d: Function %s is declared more than once. Give each function a "
|
|
"different name.\n",
|
|
path, line_no, full_name);
|
|
errs++;
|
|
} else if (declared_function_count < 128)
|
|
claro_snprintf(declared_functions[declared_function_count++],
|
|
sizeof(declared_functions[0]), "%s", full_name);
|
|
}
|
|
{
|
|
const char *duplicate = duplicate_param_name(params, pcnt);
|
|
if (duplicate) {
|
|
printf("%s:%d: %s %s declares parameter %s more than once. Give each parameter "
|
|
"a different name.\n",
|
|
path, line_no, current_class[0] ? "Method" : "Function", full_name,
|
|
trim_inplace((char *)duplicate));
|
|
errs++;
|
|
}
|
|
}
|
|
{
|
|
int pi;
|
|
for (pi = 0; pi < pcnt; pi++)
|
|
type_env_set(&types, params[pi], "ANY");
|
|
}
|
|
current_func[0] = 0;
|
|
current_method[0] = 0;
|
|
return_seen = 0;
|
|
top_level_return_seen = 0;
|
|
nested_blocks = 0;
|
|
conditional_paths_complete = 1;
|
|
in_teach = 1;
|
|
if (current_class[0])
|
|
claro_snprintf(current_method, sizeof(current_method), "%s", full_name);
|
|
if (current_class[0]) {
|
|
TypeFieldCheck *fc;
|
|
for (fc = field_checks; fc; fc = fc->next)
|
|
if (ci_eq(fc->cls, current_class))
|
|
type_env_set(&types, fc->field, fc->type);
|
|
}
|
|
{
|
|
const char *declared_return = type_return_check_for(return_checks, full_name);
|
|
if (declared_return && !claro_is_type_word(declared_return)) {
|
|
printf("%s:%d: %s %s declares an unknown return type %s. Use a Claro type such "
|
|
"as NUMBER, TEXT, YESNO, LIST, or MAP.\n",
|
|
path, line_no, strchr(full_name, '.') ? "Method" : "Function", full_name,
|
|
declared_return);
|
|
errs++;
|
|
} else if (declared_return)
|
|
claro_snprintf(current_func, sizeof(current_func), "%s", full_name);
|
|
}
|
|
split_args_free(params, pcnt);
|
|
} else if (!strcmp(up, "IF")) {
|
|
if (in_teach) {
|
|
if (nested_blocks < 64) {
|
|
branch_returned[nested_blocks] = 0;
|
|
branch_has_else[nested_blocks] = 0;
|
|
}
|
|
nested_blocks++;
|
|
}
|
|
} else if (!strcmp(up, "ELSE")) {
|
|
if (in_teach && nested_blocks > 0 && nested_blocks <= 64) {
|
|
if (!branch_returned[nested_blocks - 1])
|
|
conditional_paths_complete = 0;
|
|
branch_has_else[nested_blocks - 1] = 1;
|
|
branch_returned[nested_blocks - 1] = 0;
|
|
}
|
|
} else if (!strcmp(up, "END") || !strcmp(up, "LEARNED") || !strcmp(up, "ENDIF")) {
|
|
if (in_teach && nested_blocks > 0) {
|
|
int nested_complete = (nested_blocks <= 64 && branch_has_else[nested_blocks - 1] &&
|
|
branch_returned[nested_blocks - 1]);
|
|
if (nested_blocks <= 64 &&
|
|
(!branch_has_else[nested_blocks - 1] || !branch_returned[nested_blocks - 1]))
|
|
conditional_paths_complete = 0;
|
|
nested_blocks--;
|
|
if (nested_complete && nested_blocks > 0 && nested_blocks <= 64)
|
|
branch_returned[nested_blocks - 1] = 1;
|
|
} else if (in_teach) {
|
|
if (current_func[0] && !return_seen) {
|
|
const char *need = type_return_check_for(return_checks, current_func);
|
|
printf("%s:%d: %s %s declares RETURNS %s but has no RETURN statement. Add "
|
|
"RETURN with a %s value.\n",
|
|
path, line_no, strchr(current_func, '.') ? "Method" : "Function",
|
|
current_func, need, need);
|
|
errs++;
|
|
} else if (current_func[0] &&
|
|
(!top_level_return_seen && !conditional_paths_complete)) {
|
|
const char *need = type_return_check_for(return_checks, current_func);
|
|
printf("%s:%d: %s %s declares RETURNS %s but does not return a %s value on "
|
|
"every path. Add RETURN to each branch or after the conditional.\n",
|
|
path, line_no, strchr(current_func, '.') ? "Method" : "Function",
|
|
current_func, need, need);
|
|
errs++;
|
|
}
|
|
in_teach = 0;
|
|
current_func[0] = 0;
|
|
current_method[0] = 0;
|
|
} else
|
|
current_class[0] = 0;
|
|
} else if (!strcmp(up, "RETURN") && current_func[0]) {
|
|
const char *need = type_return_check_for(return_checks, current_func);
|
|
char *return_expr = trim_inplace(t + 6);
|
|
const char *got = simple_expr_type(types, return_expr);
|
|
return_seen = 1;
|
|
if (nested_blocks == 0)
|
|
top_level_return_seen = 1;
|
|
else if (nested_blocks <= 64)
|
|
branch_returned[nested_blocks - 1] = 1;
|
|
if (need && !*return_expr) {
|
|
printf("%s:%d: %s %s needs a %s value after RETURN. Add a %s expression.\n", path,
|
|
line_no, strchr(current_func, '.') ? "Method" : "Function", current_func,
|
|
need, need);
|
|
errs++;
|
|
} else if (need && !got) {
|
|
char first_value[128];
|
|
if (return_value_extra_tokens(return_expr, first_value, sizeof(first_value))) {
|
|
printf("%s:%d: %s %s has extra text after return value %s. Keep only one "
|
|
"expression after RETURN.\n",
|
|
path, line_no, strchr(current_func, '.') ? "Method" : "Function",
|
|
current_func, first_value);
|
|
} else {
|
|
printf("%s:%d: %s %s's return value could not be understood yet. Use a %s "
|
|
"expression after RETURN.\n",
|
|
path, line_no, strchr(current_func, '.') ? "Method" : "Function",
|
|
current_func, need);
|
|
}
|
|
errs++;
|
|
} else if (need && got && !type_words_match(need, got)) {
|
|
char text_operator = (ci_eq(need, "NUMBER") && ci_eq(got, "TEXT"))
|
|
? text_operator_for_number_return(types, return_expr)
|
|
: 0;
|
|
const char *text_operand =
|
|
text_operator ? text_operand_for_operator(types, return_expr, text_operator)
|
|
: NULL;
|
|
if (text_operand) {
|
|
printf("%s:%d: Type mismatch for return from %s: %s needs NUMBER values, but "
|
|
"%s looks like TEXT.\n",
|
|
path, line_no, current_func,
|
|
text_operator == '+'
|
|
? "addition"
|
|
: (text_operator == '-'
|
|
? "subtraction"
|
|
: (text_operator == '*' ? "multiplication" : "division")),
|
|
text_operand);
|
|
} else {
|
|
printf("%s:%d: Type mismatch for return from %s: expected %s, but this value "
|
|
"looks like %s.\n",
|
|
path, line_no, current_func, need, got);
|
|
}
|
|
errs++;
|
|
}
|
|
} else if (!strcmp(up, "SET")) {
|
|
char *name = NULL, *type = NULL, *expr = NULL;
|
|
const char *got, *old;
|
|
const char *as = find_word_ci(t + 3, "AS"), *to = find_word_ci(t + 3, "TO");
|
|
if (as && !to) {
|
|
const char *pcur = as + 2;
|
|
char *typed_name = substr(t + 3, as);
|
|
char *typed_type = unquote_token(&pcur);
|
|
char *nt = trim_inplace(typed_name);
|
|
char *tt = trim_inplace(typed_type);
|
|
if (*nt && *tt) {
|
|
printf("%s:%d: SET %s needs TO after type %s. Try: SET %s AS %s TO 10.\n", path,
|
|
line_no, nt, tt, nt, tt);
|
|
errs++;
|
|
}
|
|
free(typed_name);
|
|
free(typed_type);
|
|
continue;
|
|
}
|
|
parse_set_for_typecheck2(t, &name, &type, &expr);
|
|
if (name && *trim_inplace(name)) {
|
|
char *nt = trim_inplace(name);
|
|
char *tt = type ? trim_inplace(type) : NULL;
|
|
if (!tt && (!expr || !*trim_inplace(expr)) && strchr(nt, '.')) {
|
|
printf(
|
|
"%s:%d: SET %s needs a value. Add one expression after the field name.\n",
|
|
path, line_no, nt);
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
if (as && to && as < to) {
|
|
char value[128];
|
|
if (!*trim_inplace((char *)to + 2)) {
|
|
printf("%s:%d: SET %s needs a value after type %s and TO. Add one "
|
|
"expression.\n",
|
|
path, line_no, nt, tt ? tt : "the declared type");
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
if (return_value_extra_tokens(to + 2, value, sizeof(value))) {
|
|
printf("%s:%d: SET %s has extra text after value %s. Keep only the field "
|
|
"name, type, TO, and one expression.\n",
|
|
path, line_no, nt, value);
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
} else if (tt && *tt) {
|
|
char value[128];
|
|
if (!expr || !*trim_inplace(expr)) {
|
|
printf("%s:%d: SET %s needs a value after type %s. Add one expression.\n",
|
|
path, line_no, nt, tt);
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
if (return_value_extra_tokens(expr, value, sizeof(value))) {
|
|
printf("%s:%d: SET %s has extra text after value %s. Keep only the field "
|
|
"name, type, and one expression.\n",
|
|
path, line_no, nt, value);
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
}
|
|
got = simple_expr_type(types, expr);
|
|
if (current_method[0] && current_class[0] && !strchr(nt, '.') &&
|
|
!type_env_get(types, nt) &&
|
|
!type_field_check_for(field_checks, current_class, nt)) {
|
|
if (got) {
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or add HAS "
|
|
"%s %s to the class.\n",
|
|
path, line_no, current_class, nt, nt, got);
|
|
} else {
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or add the "
|
|
"field to the class with the right type.\n",
|
|
path, line_no, current_class, nt);
|
|
}
|
|
errs++;
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
continue;
|
|
}
|
|
old = type_env_get(types, nt);
|
|
if (tt && *tt) {
|
|
if (current_method[0] && current_class[0] && !strchr(nt, '.')) {
|
|
const char *declared =
|
|
type_field_check_for(field_checks, current_class, nt);
|
|
if (declared && tt && !claro_is_type_word(tt)) {
|
|
printf("%s:%d: Field %s in %s needs a known type such as NUMBER, TEXT, "
|
|
"or YESNO, but %s is not a Claro type. Use %s for %s.\n",
|
|
path, line_no, nt, current_method, tt, declared, nt);
|
|
errs++;
|
|
got = NULL;
|
|
} else if (declared && tt && !type_words_match(declared, tt)) {
|
|
printf("%s:%d: Type mismatch for field %s in %s: class declares %s, "
|
|
"but this assignment says %s. Use %s for %s.\n",
|
|
path, line_no, nt, current_method, declared, tt, declared, nt);
|
|
errs++;
|
|
got = NULL;
|
|
} else if (declared && got && !type_words_match(declared, got)) {
|
|
printf("%s:%d: Type mismatch for field %s in %s: expected %s, but this "
|
|
"value looks like %s.\n",
|
|
path, line_no, nt, current_method, declared, got);
|
|
errs++;
|
|
}
|
|
}
|
|
if (strchr(nt, '.')) {
|
|
char objname[128], fieldname[128];
|
|
char *dot = strchr(nt, '.');
|
|
const char *objtype;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - nt), nt);
|
|
claro_snprintf(fieldname, sizeof(fieldname), "%s", dot + 1);
|
|
objtype = type_env_get(types, objname);
|
|
if (objtype && starts_ci(objtype, "OBJECT:")) {
|
|
const char *declared =
|
|
type_field_check_for(field_checks, objtype + 7, fieldname);
|
|
if (declared && tt && !claro_is_type_word(tt)) {
|
|
printf("%s:%d: Field %s needs a known type such as NUMBER, TEXT, "
|
|
"or YESNO, but %s is not a Claro type. Use %s for %s.\n",
|
|
path, line_no, nt, tt, declared, fieldname);
|
|
errs++;
|
|
} else if (declared && tt && !type_words_match(declared, tt)) {
|
|
printf("%s:%d: Type mismatch for field %s: class declares %s, but "
|
|
"this assignment says %s. Use %s for %s.\n",
|
|
path, line_no, nt, declared, tt, declared, fieldname);
|
|
errs++;
|
|
} else if (declared && got && !type_words_match(declared, got)) {
|
|
char text_operator =
|
|
(ci_eq(declared, "NUMBER") && ci_eq(got, "TEXT"))
|
|
? (text_operand_for_operator(types, expr, '+')
|
|
? '+'
|
|
: (text_operand_for_operator(types, expr, '-')
|
|
? '-'
|
|
: (text_operand_for_operator(types, expr, '*')
|
|
? '*'
|
|
: (text_operand_for_operator(types,
|
|
expr, '/')
|
|
? '/'
|
|
: 0))))
|
|
: 0;
|
|
const char *text_operand =
|
|
text_operator
|
|
? text_operand_for_operator(types, expr, text_operator)
|
|
: NULL;
|
|
if (text_operand) {
|
|
printf("%s:%d: Type mismatch for field %s: %s needs NUMBER "
|
|
"values, but %s looks like TEXT.\n",
|
|
path, line_no, nt,
|
|
text_operator == '+'
|
|
? "addition"
|
|
: (text_operator == '-'
|
|
? "subtraction"
|
|
: (text_operator == '*' ? "multiplication"
|
|
: "division")),
|
|
text_operand);
|
|
} else {
|
|
printf("%s:%d: Type mismatch for field %s: expected %s, but "
|
|
"this value looks like %s.\n",
|
|
path, line_no, nt, declared, got);
|
|
}
|
|
errs++;
|
|
} else if (!declared) {
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or "
|
|
"add HAS %s %s to the class.\n",
|
|
path, line_no, objtype + 7, fieldname, fieldname, tt);
|
|
errs++;
|
|
} else if (got && !type_words_match(tt, got)) {
|
|
printf("%s:%d: Type mismatch for %s: expected %s, but this value "
|
|
"looks like %s.\n",
|
|
path, line_no, nt, tt, got);
|
|
errs++;
|
|
}
|
|
} else if (got && !type_words_match(tt, got)) {
|
|
printf("%s:%d: Type mismatch for %s: expected %s, but this value looks "
|
|
"like %s.\n",
|
|
path, line_no, nt, tt, got);
|
|
errs++;
|
|
}
|
|
} else if (got && !type_words_match(tt, got)) {
|
|
printf("%s:%d: Type mismatch for %s: expected %s, but this value looks "
|
|
"like %s.\n",
|
|
path, line_no, nt, tt, got);
|
|
errs++;
|
|
}
|
|
type_env_set(&types, nt, tt);
|
|
} else if (old) {
|
|
if (got && !type_words_match(old, got)) {
|
|
if (strchr(nt, '.')) {
|
|
char text_operator =
|
|
(ci_eq(old, "NUMBER") && ci_eq(got, "TEXT"))
|
|
? (text_operand_for_operator(types, expr, '+')
|
|
? '+'
|
|
: (text_operand_for_operator(types, expr, '-')
|
|
? '-'
|
|
: (text_operand_for_operator(types, expr, '*')
|
|
? '*'
|
|
: (text_operand_for_operator(types, expr,
|
|
'/')
|
|
? '/'
|
|
: 0))))
|
|
: 0;
|
|
const char *text_operand =
|
|
text_operator
|
|
? text_operand_for_operator(types, expr, text_operator)
|
|
: NULL;
|
|
if (text_operand)
|
|
printf("%s:%d: Type mismatch for field %s: %s needs NUMBER values, "
|
|
"but %s looks like TEXT.\n",
|
|
path, line_no, nt,
|
|
text_operator == '+'
|
|
? "addition"
|
|
: (text_operator == '-'
|
|
? "subtraction"
|
|
: (text_operator == '*' ? "multiplication"
|
|
: "division")),
|
|
text_operand);
|
|
else
|
|
printf("%s:%d: Type mismatch for field %s: expected %s, but this "
|
|
"value looks like %s.\n",
|
|
path, line_no, nt, old, got);
|
|
} else if (in_teach && current_class[0] &&
|
|
type_field_check_for(field_checks, current_class, nt)) {
|
|
const char *declared =
|
|
type_field_check_for(field_checks, current_class, nt);
|
|
char text_operator =
|
|
(ci_eq(declared, "NUMBER") && ci_eq(got, "TEXT"))
|
|
? (text_operand_for_operator(types, expr, '+')
|
|
? '+'
|
|
: (text_operand_for_operator(types, expr, '-')
|
|
? '-'
|
|
: (text_operand_for_operator(types, expr, '*')
|
|
? '*'
|
|
: (text_operand_for_operator(types, expr,
|
|
'/')
|
|
? '/'
|
|
: 0))))
|
|
: 0;
|
|
const char *text_operand =
|
|
text_operator
|
|
? text_operand_for_operator(types, expr, text_operator)
|
|
: NULL;
|
|
if (text_operand)
|
|
printf("%s:%d: Type mismatch for field %s in %s: %s needs NUMBER "
|
|
"values, but %s looks like TEXT.\n",
|
|
path, line_no, nt, current_method,
|
|
text_operator == '+'
|
|
? "addition"
|
|
: (text_operator == '-'
|
|
? "subtraction"
|
|
: (text_operator == '*' ? "multiplication"
|
|
: "division")),
|
|
text_operand);
|
|
else
|
|
printf("%s:%d: Type mismatch for field %s in %s: expected %s, but "
|
|
"this value looks like %s.\n",
|
|
path, line_no, nt, current_method, declared, got);
|
|
errs++;
|
|
} else
|
|
printf("%s:%d: Type mismatch for %s: it was first set as %s, but this "
|
|
"value looks like %s.\n",
|
|
path, line_no, nt, old, got);
|
|
errs++;
|
|
}
|
|
} else if (strchr(nt, '.')) {
|
|
char objname[128], fieldname[128];
|
|
char *dot = strchr(nt, '.');
|
|
const char *objtype;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - nt), nt);
|
|
claro_snprintf(fieldname, sizeof(fieldname), "%s", dot + 1);
|
|
objtype = type_env_get(types, objname);
|
|
if (objtype && starts_ci(objtype, "OBJECT:")) {
|
|
const char *cls = objtype + 7;
|
|
if (!type_field_check_for(field_checks, cls, fieldname)) {
|
|
if (got && !strchr(expr, '+') && !strchr(expr, '-') &&
|
|
!strchr(expr, '*') && !strchr(expr, '/'))
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or "
|
|
"add HAS %s %s to the class.\n",
|
|
path, line_no, cls, fieldname, fieldname, got);
|
|
else
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or "
|
|
"add the field to the class with the right type.\n",
|
|
path, line_no, cls, fieldname);
|
|
errs++;
|
|
} else {
|
|
const char *fieldtype =
|
|
type_field_check_for(field_checks, cls, fieldname);
|
|
if (got && !type_words_match(fieldtype, got)) {
|
|
printf("%s:%d: Type mismatch for field %s.%s: expected %s, but "
|
|
"this value looks like %s.\n",
|
|
path, line_no, objname, fieldname, fieldtype, got);
|
|
errs++;
|
|
}
|
|
}
|
|
} else {
|
|
printf("%s:%d: Object %s is not known yet. Create it with NEW ClassName %s "
|
|
"before setting %s.\n",
|
|
path, line_no, objname, objname, nt);
|
|
errs++;
|
|
}
|
|
} else if (got)
|
|
type_env_set(&types, nt, got);
|
|
else
|
|
type_env_set(&types, nt, "ANY");
|
|
}
|
|
free(name);
|
|
free(type);
|
|
free(expr);
|
|
} else if (!strcmp(up, "ADD")) {
|
|
const char *to = find_word_ci(t, "TO");
|
|
if (to) {
|
|
char *expr = substr(t + 3, to);
|
|
char *name = xstrdup(trim_inplace((char *)to + 2));
|
|
const char *listtype = type_env_get(types, name);
|
|
const char *need = container_member_type(listtype, "LIST");
|
|
const char *got = simple_expr_type(types, expr);
|
|
if (need && got && !type_words_match(need, got)) {
|
|
printf("%s:%d: Type mismatch for list %s: expected %s item, but this value "
|
|
"looks like %s.\n",
|
|
path, line_no, name, need, got);
|
|
errs++;
|
|
}
|
|
free(expr);
|
|
free(name);
|
|
}
|
|
} else if (!strcmp(up, "PUT")) {
|
|
const char *key = find_word_ci(t, "KEY"), *val = find_word_ci(t, "VALUE");
|
|
if (key && val) {
|
|
char *name = substr(t + 3, key);
|
|
char *expr = xstrdup(trim_inplace((char *)val + 5));
|
|
char *nt = trim_inplace(name);
|
|
const char *maptype = type_env_get(types, nt);
|
|
const char *need = container_member_type(maptype, "MAP");
|
|
const char *got = simple_expr_type(types, expr);
|
|
if (need && got && !type_words_match(need, got)) {
|
|
printf("%s:%d: Type mismatch for map %s: expected %s value, but this value "
|
|
"looks like %s.\n",
|
|
path, line_no, nt, need, got);
|
|
errs++;
|
|
}
|
|
free(name);
|
|
free(expr);
|
|
}
|
|
} else if (!strcmp(up, "ASK")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
char *name = NULL, *type = NULL;
|
|
if (as) {
|
|
const char *pcur = as + 2;
|
|
name = unquote_token(&pcur);
|
|
{
|
|
char *rest = xstrdup(trim_inplace((char *)pcur));
|
|
if (claro_is_type_word(rest))
|
|
type = rest;
|
|
else
|
|
free(rest);
|
|
}
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
char *prompt = unquote_token(&pcur);
|
|
free(prompt);
|
|
name = unquote_token(&pcur);
|
|
{
|
|
char *rest = xstrdup(trim_inplace((char *)pcur));
|
|
if (claro_is_type_word(rest))
|
|
type = rest;
|
|
else
|
|
free(rest);
|
|
}
|
|
}
|
|
if (name && *trim_inplace(name))
|
|
type_env_set(&types, trim_inplace(name), type ? type : "TEXT");
|
|
free(name);
|
|
free(type);
|
|
} else if (!strcmp(up, "IMPORT")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (as) {
|
|
const char *pcur = as + 2;
|
|
char *alias = unquote_token(&pcur);
|
|
if (alias && *trim_inplace(alias))
|
|
type_env_set(&types, trim_inplace(alias), "MODULE");
|
|
free(alias);
|
|
}
|
|
} else if (!strcmp(up, "TYPE") && starts_ci(t, "TYPE OF")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
if (!as) {
|
|
if (!*trim_inplace(t + 7))
|
|
printf("%s:%d: TYPE OF needs an expression, AS, and a result name. Try: TYPE "
|
|
"OF score AS kind.\n",
|
|
path, line_no);
|
|
else
|
|
printf("%s:%d: TYPE OF needs AS. Try: TYPE OF score AS kind.\n", path, line_no);
|
|
errs++;
|
|
} else {
|
|
char *expr = substr(t + 7, as);
|
|
const char *pcur = as + 2;
|
|
char *name = unquote_token(&pcur);
|
|
char *extra = xstrdup(trim_inplace((char *)pcur));
|
|
if (!*trim_inplace(expr)) {
|
|
printf("%s:%d: TYPE OF needs an expression before AS. Try: TYPE OF score AS "
|
|
"kind.\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else if (!name || !*trim_inplace(name)) {
|
|
printf("%s:%d: TYPE OF needs a result name after AS. Try: TYPE OF score AS "
|
|
"kind.\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else if (extra && *extra) {
|
|
printf("%s:%d: TYPE OF %s has extra text after result name %s. Keep only the "
|
|
"expression, AS, and one result name.\n",
|
|
path, line_no, trim_inplace(expr), trim_inplace(name));
|
|
errs++;
|
|
} else if (name && *trim_inplace(name))
|
|
type_env_set(&types, name, "TEXT");
|
|
free(expr);
|
|
free(name);
|
|
free(extra);
|
|
}
|
|
} else if (!strcmp(up, "NEW")) {
|
|
const char *as = find_word_ci(t, "AS");
|
|
char *name = NULL;
|
|
char *cls = NULL;
|
|
char *extra = NULL;
|
|
char objtype[256];
|
|
if (as) {
|
|
const char *pcur = as + 2;
|
|
cls = substr(t + 3, as);
|
|
name = unquote_token(&pcur);
|
|
extra = xstrdup(trim_inplace((char *)pcur));
|
|
} else {
|
|
const char *pcur = t + 3;
|
|
cls = unquote_token(&pcur);
|
|
name = unquote_token(&pcur);
|
|
extra = xstrdup(trim_inplace((char *)pcur));
|
|
}
|
|
claro_snprintf(objtype, sizeof(objtype), "OBJECT:%s", trim_inplace(cls));
|
|
if (name && *trim_inplace(name)) {
|
|
TypeFieldCheck *fc;
|
|
char fullname[256];
|
|
char *nt = trim_inplace(name);
|
|
char *ct = trim_inplace(cls);
|
|
int duplicate = 0, class_known = 0, oi, ci;
|
|
if (extra && *extra) {
|
|
printf("%s:%d: NEW %s has extra text after object name %s. Keep only the class "
|
|
"and object names.\n",
|
|
path, line_no, ct, nt);
|
|
errs++;
|
|
}
|
|
for (ci = 0; ci < declared_class_count; ci++)
|
|
if (ci_eq(declared_classes[ci], ct)) {
|
|
class_known = 1;
|
|
break;
|
|
}
|
|
if (declared_class_count > 0 && !class_known) {
|
|
printf("%s:%d: Class %s is not known yet. Check the class name or declare "
|
|
"CLASS %s before creating %s.\n",
|
|
path, line_no, ct, ct, nt);
|
|
errs++;
|
|
}
|
|
for (oi = 0; oi < declared_object_count; oi++)
|
|
if (ci_eq(declared_objects[oi], nt)) {
|
|
duplicate = 1;
|
|
break;
|
|
}
|
|
if (duplicate) {
|
|
printf("%s:%d: Object %s is created more than once. Give each object a "
|
|
"different name.\n",
|
|
path, line_no, nt);
|
|
errs++;
|
|
} else if (declared_object_count < 128)
|
|
claro_snprintf(declared_objects[declared_object_count++],
|
|
sizeof(declared_objects[0]), "%s", nt);
|
|
type_env_set(&types, nt, objtype);
|
|
for (fc = field_checks; fc; fc = fc->next) {
|
|
if (ci_eq(fc->cls, ct)) {
|
|
claro_snprintf(fullname, sizeof(fullname), "%s.%s", nt, fc->field);
|
|
type_env_set(&types, fullname, fc->type);
|
|
}
|
|
}
|
|
} else if (cls && *trim_inplace(cls)) {
|
|
printf("%s:%d: NEW %s needs an object name. Add a name after the class, such as "
|
|
"NEW %s player.\n",
|
|
path, line_no, trim_inplace(cls), trim_inplace(cls));
|
|
errs++;
|
|
} else {
|
|
printf("%s:%d: NEW needs a class name. Add a class and object name, such as NEW "
|
|
"Player player.\n",
|
|
path, line_no);
|
|
errs++;
|
|
}
|
|
free(cls);
|
|
free(name);
|
|
free(extra);
|
|
} else if ((!strcmp(up, "DO") && !find_word_ci(t, "TIMES")) || !strcmp(up, "CALL")) {
|
|
char *fname = NULL;
|
|
char **parts = NULL;
|
|
int ac = 0, i, is_method = 0;
|
|
char lookup[256], display[256];
|
|
if (!strcmp(up, "DO")) {
|
|
const char *pcur = t + 2;
|
|
fname = unquote_token(&pcur);
|
|
if (*trim_inplace((char *)pcur))
|
|
ac = split_simple_args(pcur, &parts);
|
|
} else {
|
|
char *rest = t + 4;
|
|
const char *with = find_word_ci(rest, "WITH");
|
|
fname = with ? substr(rest, with) : xstrdup(rest);
|
|
if (with && *trim_inplace((char *)with + 4))
|
|
ac = split_args(with + 4, &parts);
|
|
}
|
|
claro_snprintf(lookup, sizeof(lookup), "%s", trim_inplace(fname));
|
|
claro_snprintf(display, sizeof(display), "%s", lookup);
|
|
{
|
|
char *dot = strchr(lookup, '.');
|
|
if (dot) {
|
|
char objname[128];
|
|
const char *objtype;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - lookup), lookup);
|
|
objtype = type_env_get(types, objname);
|
|
if (objtype && starts_ci(objtype, "OBJECT:")) {
|
|
char method[128];
|
|
const char *cls = objtype + 7;
|
|
claro_snprintf(method, sizeof(method), "%s", dot + 1);
|
|
if (!type_method_check_for(method_checks, cls, method)) {
|
|
printf("%s:%d: Object %s has no method %s. Check the method name or "
|
|
"add TEACH %s inside CLASS %s.\n",
|
|
path, line_no, cls, method, method, cls);
|
|
errs++;
|
|
}
|
|
claro_snprintf(lookup, sizeof(lookup), "%s.%s", cls, method);
|
|
claro_snprintf(display, sizeof(display), "%s", lookup);
|
|
is_method = 1;
|
|
} else if (!objtype || (!starts_ci(objtype, "MODULE") &&
|
|
(!strcmp(up, "DO") ||
|
|
type_method_name_exists(method_checks, dot + 1)))) {
|
|
printf("%s:%d: Object %s is not known yet. Create it with NEW ClassName %s "
|
|
"before calling %s.\n",
|
|
path, line_no, objname, objname, lookup);
|
|
errs++;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < ac; i++) {
|
|
const char *param = NULL;
|
|
const char *need = type_param_check_for(param_checks, lookup, i, ¶m);
|
|
const char *got = simple_expr_type(types, parts[i]);
|
|
if (need && got && !type_words_match(need, got)) {
|
|
printf("%s:%d: Type mismatch for %s %s: parameter %s needs %s, but this "
|
|
"argument looks like %s.\n",
|
|
path, line_no, is_method ? "method" : "function", display,
|
|
param ? param : "argument", need, got);
|
|
errs++;
|
|
}
|
|
}
|
|
{
|
|
TypeParamCheck *pc = param_checks;
|
|
while (pc) {
|
|
if (ci_eq(pc->func, lookup) && pc->pos >= ac) {
|
|
printf("%s:%d: %s %s needs argument %s as %s, but this call does not "
|
|
"provide it.\n",
|
|
path, line_no, is_method ? "Method" : "Function", display, pc->param,
|
|
pc->type);
|
|
errs++;
|
|
}
|
|
pc = pc->next;
|
|
}
|
|
}
|
|
{
|
|
int expected = type_arity_check_for(arity_checks, lookup);
|
|
if (expected >= 0 && ac > expected) {
|
|
printf("%s:%d: %s %s only accepts %d %s, but this call gives %d. Remove the "
|
|
"extra %s.\n",
|
|
path, line_no, is_method ? "Method" : "Function", display, expected,
|
|
expected == 1 ? "argument" : "arguments", ac,
|
|
ac - expected == 1 ? "argument" : "arguments");
|
|
errs++;
|
|
} else if (expected >= 0 && ac < expected) {
|
|
int has_checked_missing = 0;
|
|
TypeParamCheck *mpc = param_checks;
|
|
while (mpc) {
|
|
if (ci_eq(mpc->func, lookup) && mpc->pos >= ac) {
|
|
has_checked_missing = 1;
|
|
break;
|
|
}
|
|
mpc = mpc->next;
|
|
}
|
|
if (!has_checked_missing) {
|
|
printf("%s:%d: %s %s needs %d %s, but this call gives %d. Add the missing "
|
|
"%s.\n",
|
|
path, line_no, is_method ? "Method" : "Function", display, expected,
|
|
expected == 1 ? "argument" : "arguments", ac,
|
|
expected - ac == 1 ? "argument" : "arguments");
|
|
errs++;
|
|
}
|
|
} else if ((!strcmp(up, "DO") || !strcmp(up, "CALL")) && !is_method &&
|
|
!strchr(lookup, '.') && expected < 0) {
|
|
printf("%s:%d: Function %s is not known yet. Check the function name or add "
|
|
"TEACH %s before calling it.\n",
|
|
path, line_no, lookup, lookup);
|
|
errs++;
|
|
}
|
|
}
|
|
split_args_free(parts, ac);
|
|
free(fname);
|
|
} else if (!strcmp(up, "CHECK") && starts_ci(t, "CHECK TYPE")) {
|
|
const char *is = find_word_ci(t, "IS");
|
|
if (is) {
|
|
char *expr = substr(t + 10, is);
|
|
char *need = xstrdup(trim_inplace((char *)is + 2));
|
|
char *et = trim_inplace(expr);
|
|
const char *got;
|
|
char first_type[64];
|
|
int first_type_len = 0;
|
|
if (current_func[0] && !strchr(et, '.')) {
|
|
TypeParamCheck *pc;
|
|
for (pc = param_checks; pc; pc = pc->next) {
|
|
if (ci_eq(pc->func, current_func) && ci_eq(pc->param, et)) {
|
|
type_env_set(&types, et, pc->type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
got = simple_expr_type(types, et);
|
|
if (!*et) {
|
|
printf("%s:%d: CHECK TYPE needs an expression before IS. Try: CHECK TYPE score "
|
|
"IS NUMBER.\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else if (!*trim_inplace(need)) {
|
|
printf("%s:%d: CHECK TYPE %s needs a type after IS. Try: CHECK TYPE %s IS "
|
|
"NUMBER.\n",
|
|
path, line_no, et, et);
|
|
errs++;
|
|
} else if (sscanf(need, "%63s%n", first_type, &first_type_len) == 1 &&
|
|
claro_is_type_word(first_type) && *trim_inplace(need + first_type_len)) {
|
|
printf("%s:%d: CHECK TYPE %s has extra text after type %s. Keep only the "
|
|
"expression, IS, and one type.\n",
|
|
path, line_no, et, first_type);
|
|
errs++;
|
|
} else if (!claro_is_type_word(need)) {
|
|
printf("%s:%d: CHECK TYPE needs a known type such as NUMBER, TEXT, YESNO, "
|
|
"LIST, or MAP, but %s is not a Claro type.\n",
|
|
path, line_no, need);
|
|
errs++;
|
|
} else if (got && !type_words_match(need, got)) {
|
|
const char *method_field =
|
|
(current_method[0] && current_class[0] && !strchr(et, '.'))
|
|
? type_field_check_for(field_checks, current_class, et)
|
|
: NULL;
|
|
if (method_field) {
|
|
printf(
|
|
"%s:%d: Type check failed in %s: expected %s, but %s looks like %s.\n",
|
|
path, line_no, current_method, need, et, got);
|
|
} else {
|
|
printf("%s:%d: Type check failed: expected %s, but %s looks like %s.\n",
|
|
path, line_no, need, et, got);
|
|
}
|
|
errs++;
|
|
} else if (!got && current_method[0] && current_class[0] && !strchr(et, '.') &&
|
|
!type_env_get(types, et) &&
|
|
!type_field_check_for(field_checks, current_class, et)) {
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or add HAS %s "
|
|
"%s to the class.\n",
|
|
path, line_no, current_class, et, et, need);
|
|
errs++;
|
|
} else if (!got && strchr(et, '.')) {
|
|
char objname[128], fieldname[128];
|
|
char *dot = strchr(et, '.');
|
|
const char *objtype;
|
|
claro_snprintf(objname, sizeof(objname), "%.*s", (int)(dot - et), et);
|
|
claro_snprintf(fieldname, sizeof(fieldname), "%s", dot + 1);
|
|
objtype = type_env_get(types, objname);
|
|
if (objtype && starts_ci(objtype, "OBJECT:")) {
|
|
const char *declared =
|
|
type_field_check_for(field_checks, objtype + 7, fieldname);
|
|
if (declared && !type_words_match(need, declared)) {
|
|
printf("%s:%d: Type check failed: expected %s, but %s looks like %s.\n",
|
|
path, line_no, need, et, declared);
|
|
errs++;
|
|
} else if (!declared) {
|
|
printf("%s:%d: Object %s has no field %s. Check the field name or add "
|
|
"HAS %s %s to the class.\n",
|
|
path, line_no, objtype + 7, fieldname, fieldname, need);
|
|
errs++;
|
|
}
|
|
} else if (!objtype) {
|
|
printf("%s:%d: Object %s is not known yet. Create it with NEW ClassName %s "
|
|
"before checking %s.\n",
|
|
path, line_no, objname, objname, et);
|
|
errs++;
|
|
}
|
|
}
|
|
free(expr);
|
|
free(need);
|
|
} else if (!*trim_inplace(t + 10)) {
|
|
printf("%s:%d: CHECK TYPE needs an expression, IS, and a type. Try: CHECK TYPE "
|
|
"score IS NUMBER.\n",
|
|
path, line_no);
|
|
errs++;
|
|
} else {
|
|
printf("%s:%d: CHECK TYPE needs IS. Try: CHECK TYPE score IS NUMBER.\n", path,
|
|
line_no);
|
|
errs++;
|
|
}
|
|
}
|
|
}
|
|
fclose(f);
|
|
type_checks_free(param_checks, arity_checks, return_checks, field_checks, method_checks);
|
|
type_env_free(&types);
|
|
if (errs == 0)
|
|
printf("Type check OK\n");
|
|
return errs ? 1 : 0;
|
|
}
|
|
static char *read_file_text(const char *path) {
|
|
FILE *f = fopen(path, "rb");
|
|
Str b;
|
|
int c;
|
|
if (!f)
|
|
return NULL;
|
|
str_init(&b);
|
|
while ((c = fgetc(f)) != EOF)
|
|
str_ch(&b, (char)c);
|
|
fclose(f);
|
|
return str_take(&b);
|
|
}
|
|
/* Golden output files may be checked out as CRLF on Windows while Claro captures output as LF.
|
|
* Normalize only test expectations so test results represent behavior, not Git line-ending
|
|
* settings. */
|
|
static char *read_test_expectation(const char *path) {
|
|
char *raw = read_file_text(path);
|
|
Str normalized;
|
|
size_t i;
|
|
if (!raw)
|
|
return NULL;
|
|
str_init(&normalized);
|
|
for (i = 0; raw[i]; i++) {
|
|
if (raw[i] == '\015') {
|
|
if (raw[i + 1] == '\012')
|
|
continue;
|
|
str_ch(&normalized, '\012');
|
|
} else
|
|
str_ch(&normalized, raw[i]);
|
|
}
|
|
free(raw);
|
|
return str_take(&normalized);
|
|
}
|
|
static int run_one_test(const char *path) {
|
|
char outpath[512];
|
|
char *dot;
|
|
char *expect, *got;
|
|
int rc, ok;
|
|
Runtime rt;
|
|
claro_snprintf(outpath, sizeof(outpath), "%s", path);
|
|
dot = strrchr(outpath, '.');
|
|
if (dot)
|
|
strcpy(dot, ".out");
|
|
expect = read_test_expectation(outpath);
|
|
if (!expect)
|
|
return 0;
|
|
rt_init(&rt);
|
|
rt.capture = 1;
|
|
rc = run_file(&rt, path);
|
|
got = rt.captured.s ? xstrdup(rt.captured.s) : xstrdup("");
|
|
ok = (rc == 0 && strcmp(got, expect) == 0);
|
|
printf("%s %s\n", ok ? "PASS" : "FAIL", path);
|
|
if (!ok)
|
|
printf("Expected:\n%s\nGot:\n%s\n", expect, got);
|
|
free(expect);
|
|
free(got);
|
|
return ok ? 0 : 1;
|
|
}
|
|
static int run_tests(void) {
|
|
int fails = 0;
|
|
#ifndef _WIN32
|
|
DIR *d = opendir("tests");
|
|
struct dirent *de;
|
|
if (!d) {
|
|
fprintf(stderr, "No tests directory\n");
|
|
return 1;
|
|
}
|
|
while ((de = readdir(d))) {
|
|
if (strstr(de->d_name, ".claro")) {
|
|
char path[512];
|
|
claro_snprintf(path, sizeof(path), "tests/%s", de->d_name);
|
|
fails += run_one_test(path);
|
|
}
|
|
}
|
|
closedir(d);
|
|
#else
|
|
struct _finddata_t fd;
|
|
#if defined(_MSC_VER) && _MSC_VER < 1300
|
|
/* The VC6 CRT returns long here and does not define intptr_t. */
|
|
long h;
|
|
#else
|
|
intptr_t h;
|
|
#endif
|
|
h = _findfirst("tests/*.claro", &fd);
|
|
if (h == -1) {
|
|
fprintf(stderr, "No tests directory\n");
|
|
return 1;
|
|
}
|
|
do {
|
|
char path[512];
|
|
claro_snprintf(path, sizeof(path), "tests/%s", fd.name);
|
|
fails += run_one_test(path);
|
|
} while (_findnext(h, &fd) == 0);
|
|
_findclose(h);
|
|
#endif
|
|
printf("%s: %d failure(s)\n", fails ? "FAIL" : "PASS", fails);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
static int write_text_file_simple(const char *path, const char *text) {
|
|
FILE *f = fopen(path, "wb");
|
|
if (!f)
|
|
return 0;
|
|
fputs(text, f);
|
|
fclose(f);
|
|
return 1;
|
|
}
|
|
static int project_name_safe(const char *name) {
|
|
int i;
|
|
if (!name || !*name)
|
|
return 0;
|
|
if (strlen(name) > 64)
|
|
return 0;
|
|
if (name[0] == '.' || name[0] == '-' || name[0] == '_')
|
|
return 0;
|
|
for (i = 0; name[i]; i++) {
|
|
unsigned char c = (unsigned char)name[i];
|
|
if (!(isalnum(c) || c == '_' || c == '-'))
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
static int create_new_project(const char *name) {
|
|
char path[512];
|
|
char text[1024];
|
|
if (!name || !*name) {
|
|
fprintf(stderr, "Project needs a name. Try: claro new MyProject\n");
|
|
return 1;
|
|
}
|
|
if (strlen(name) > 64) {
|
|
fprintf(stderr, "Project names must be 64 characters or fewer.\n");
|
|
return 1;
|
|
}
|
|
if (!project_name_safe(name)) {
|
|
fprintf(stderr, "Project names may use only letters, numbers, dash, and underscore.\n");
|
|
return 1;
|
|
}
|
|
if (!make_folder(name)) {
|
|
fprintf(stderr, "Could not create project folder: %s\n", name);
|
|
return 1;
|
|
}
|
|
claro_snprintf(path, sizeof(path), "%s/main.claro", name);
|
|
write_text_file_simple(
|
|
path,
|
|
"SAY \"Welcome to Claro!\"\n\nSET name \"Learner\"\nSAY \"Hello \" + name\n\nTEACH "
|
|
"greet person\n SAY \"Nice to meet you, \" + person\nEND\n\nDO greet \"Friend\"\n");
|
|
claro_snprintf(path, sizeof(path), "%s/packages", name);
|
|
make_folder(path);
|
|
claro_snprintf(path, sizeof(path), "%s/claro.project", name);
|
|
claro_snprintf(
|
|
text, sizeof(text),
|
|
"manifest-version: 1\nname: %s\nmain: main.claro\nversion: v2026.10.25.014405\npackages:\n",
|
|
name);
|
|
write_text_file_simple(path, text);
|
|
claro_snprintf(path, sizeof(path), "%s/claro.lock", name);
|
|
write_text_file_simple(path,
|
|
"# Claro package lock\nlock-version: 1\nversion: v2026.10.25.014405\n");
|
|
claro_snprintf(path, sizeof(path), "%s/README.md", name);
|
|
write_text_file_simple(
|
|
path, "# My Claro Project\n\nBuild Claro, then run this project with:\n\n```bash\nclaro "
|
|
"run\n```\n\nUse packages with:\n\n```bash\nclaro package add text\nclaro package "
|
|
"list\nclaro package doctor\n```\n");
|
|
printf("Created Claro project: %s\n", name);
|
|
printf("Next steps:\n cd %s\n claro run\n", name);
|
|
return 0;
|
|
}
|
|
static int run_repl(void) {
|
|
Runtime rt;
|
|
char line[4096];
|
|
Program p;
|
|
rt_init(&rt);
|
|
memset(&p, 0, sizeof(p));
|
|
p.path = xstrdup("<repl>");
|
|
p.count = 1;
|
|
p.cap = 1;
|
|
p.lines = (char **)xmalloc(sizeof(char *));
|
|
printf("%s\n", CLARO_VERSION);
|
|
printf("Type HELP for help, or EXIT to leave.\n");
|
|
while (1) {
|
|
int pc = 0;
|
|
printf("> ");
|
|
fflush(stdout);
|
|
if (!fgets(line, sizeof(line), stdin))
|
|
break;
|
|
{
|
|
size_t n = strlen(line);
|
|
while (n && (line[n - 1] == '\n' || line[n - 1] == '\r'))
|
|
line[--n] = 0;
|
|
}
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (ci_eq(t, "EXIT") || ci_eq(t, "QUIT"))
|
|
break;
|
|
if (ci_eq(t, "HELP")) {
|
|
printf("Try: SAY \"Hello\"\n");
|
|
printf("Try: SET name \"Jon\"\n");
|
|
printf("Try: SAY name\n");
|
|
continue;
|
|
}
|
|
if (!*t)
|
|
continue;
|
|
p.lines[0] = t;
|
|
exec_line(&rt, &p, &pc, t);
|
|
if (rt.error) {
|
|
fprintf(stderr, "%s:%d: %s\n", rt.err_file ? rt.err_file : "<repl>", rt.err_line,
|
|
rt.err_msg ? rt.err_msg : "error");
|
|
rt_clear_error(&rt);
|
|
}
|
|
}
|
|
}
|
|
runtime_free(&rt);
|
|
free(p.path);
|
|
free(p.lines);
|
|
return 0;
|
|
}
|
|
|
|
static int file_exists_simple(const char *path);
|
|
static int path_exists_simple(const char *path) {
|
|
struct stat st;
|
|
return path && *path && stat(path, &st) == 0;
|
|
}
|
|
static int package_name_too_long(const char *name) { return name && strlen(name) > 64; }
|
|
static int package_name_safe(const char *name) {
|
|
int i;
|
|
if (!name || !*name)
|
|
return 0;
|
|
if (package_name_too_long(name))
|
|
return 0;
|
|
if (name[0] == '.' || name[0] == '-' || name[0] == '_')
|
|
return 0;
|
|
for (i = 0; name[i]; i++) {
|
|
unsigned char c = (unsigned char)name[i];
|
|
if (!(isalnum(c) || c == '_' || c == '-'))
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
static void package_checksum(const char *name, char *out, size_t n) {
|
|
unsigned long h = 5381;
|
|
const char *p = name ? name : "";
|
|
while (*p) {
|
|
h = ((h << 5) + h) + (unsigned char)(*p++);
|
|
}
|
|
p = "|local|1|claro";
|
|
while (*p) {
|
|
h = ((h << 5) + h) + (unsigned char)(*p++);
|
|
}
|
|
claro_snprintf(out, n, "%08lx", h);
|
|
}
|
|
static void ensure_project_file(void) {
|
|
if (!file_exists_simple("claro.project"))
|
|
write_text_file_simple("claro.project",
|
|
"manifest-version: 1\nname: ClaroProject\nmain: "
|
|
"main.claro\nversion: v2026.10.25.014405\npackages:\n");
|
|
}
|
|
static char *project_value(const char *key) {
|
|
char *txt = read_file_text("claro.project");
|
|
size_t kn = strlen(key);
|
|
char *p, *out = NULL;
|
|
if (!txt)
|
|
return NULL;
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, key, kn) == 0 && t[kn] == ':') {
|
|
out = xstrdup(trim_inplace(t + kn + 1));
|
|
break;
|
|
}
|
|
}
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
return out;
|
|
}
|
|
static int package_has_name(const char *name) {
|
|
char *txt = read_file_text("claro.project");
|
|
char *p;
|
|
int found = 0;
|
|
if (!txt)
|
|
return 0;
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
if (strcmp(pkg, name) == 0) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
return found;
|
|
}
|
|
static int project_package_names_safe(void) {
|
|
char *txt = read_file_text("claro.project");
|
|
char *p;
|
|
char seen[128][65];
|
|
int seen_count = 0;
|
|
if (!txt)
|
|
return 1;
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
int i;
|
|
if (*pkg && !package_name_safe(pkg)) {
|
|
printf("BAD package name: %s\n", pkg);
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
if (*pkg) {
|
|
for (i = 0; i < seen_count; i++) {
|
|
if (strcmp(seen[i], pkg) == 0) {
|
|
printf("DUPLICATE package: %s\n", pkg);
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
}
|
|
if (seen_count < 128)
|
|
claro_snprintf(seen[seen_count++], sizeof(seen[0]), "%s", pkg);
|
|
}
|
|
}
|
|
}
|
|
if (save) {
|
|
*p = save;
|
|
p++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
return 1;
|
|
}
|
|
static int write_package_lock(void) {
|
|
char *txt = read_file_text("claro.project");
|
|
FILE *f;
|
|
char *p;
|
|
if (!txt)
|
|
return 0;
|
|
if (!project_package_names_safe()) {
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
f = fopen("claro.lock", "wb");
|
|
if (!f) {
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
fputs("# Claro package lock\nlock-version: 1\nversion: v2026.10.25.014405\n", f);
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
if (*pkg) {
|
|
char sum[32];
|
|
package_checksum(pkg, sum, sizeof(sum));
|
|
fprintf(f, "package: %s\nchecksum: %s\n", pkg, sum);
|
|
}
|
|
}
|
|
}
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
fclose(f);
|
|
free(txt);
|
|
return 1;
|
|
}
|
|
static int append_package_to_project(const char *name) {
|
|
FILE *f;
|
|
if (package_name_too_long(name)) {
|
|
fprintf(stderr, "Package names must be 64 characters or fewer.\n");
|
|
return 0;
|
|
}
|
|
if (!package_name_safe(name)) {
|
|
fprintf(stderr, "Package names may use only letters, numbers, dash, and underscore.\n");
|
|
return 0;
|
|
}
|
|
ensure_project_file();
|
|
if (package_has_name(name)) {
|
|
printf("Package already listed: %s\n", name);
|
|
return 1;
|
|
}
|
|
f = fopen("claro.project", "ab");
|
|
if (!f)
|
|
return 0;
|
|
fprintf(f, "package: %s\n", name);
|
|
fclose(f);
|
|
write_package_lock();
|
|
return 1;
|
|
}
|
|
static int remove_package_from_project(const char *name) {
|
|
char *txt = read_file_text("claro.project");
|
|
FILE *f;
|
|
char *p;
|
|
int removed = 0;
|
|
if (!txt)
|
|
return 0;
|
|
f = fopen("claro.project", "wb");
|
|
if (!f) {
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
int skip = 0;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *copy = xstrdup(line);
|
|
char *t = trim_inplace(copy);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
if (strcmp(pkg, name) == 0) {
|
|
skip = 1;
|
|
removed = 1;
|
|
}
|
|
}
|
|
free(copy);
|
|
}
|
|
if (!skip)
|
|
fprintf(f, "%s\n", line);
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
fclose(f);
|
|
free(txt);
|
|
if (!write_package_lock())
|
|
return -1;
|
|
return removed;
|
|
}
|
|
static void create_package_folder(const char *name) {
|
|
char path[1024], meta[1280], readme[1280], sum[32];
|
|
make_folder("packages");
|
|
claro_snprintf(path, sizeof(path), "packages/%s", name);
|
|
make_folder(path);
|
|
claro_snprintf(meta, sizeof(meta), "%s/claro.package", path);
|
|
package_checksum(name, sum, sizeof(sum));
|
|
{
|
|
char text[1024];
|
|
claro_snprintf(text, sizeof(text),
|
|
"manifest-version: 1\nname: %s\nversion: 1\nsource: local\nchecksum: %s\n",
|
|
name, sum);
|
|
write_text_file_simple(meta, text);
|
|
}
|
|
claro_snprintf(readme, sizeof(readme), "%s/README.md", path);
|
|
if (!file_exists_simple(readme)) {
|
|
char text[512];
|
|
claro_snprintf(text, sizeof(text), "# %s\n\nThis is a local Claro package folder.\n", name);
|
|
write_text_file_simple(readme, text);
|
|
}
|
|
}
|
|
static int list_project_packages(void) {
|
|
char *txt = read_file_text("claro.project");
|
|
char *p;
|
|
int count = 0;
|
|
printf("Packages in claro.project:\n");
|
|
if (!txt) {
|
|
printf(" (no claro.project yet)\n");
|
|
return 0;
|
|
}
|
|
if (!project_package_names_safe()) {
|
|
free(txt);
|
|
return 1;
|
|
}
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
if (*pkg) {
|
|
printf(" %s\n", pkg);
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
if (!count)
|
|
printf(" (none)\n");
|
|
free(txt);
|
|
return 0;
|
|
}
|
|
static int package_lock_checksum_ok(const char *name) {
|
|
char *txt = read_file_text("claro.lock");
|
|
char *p;
|
|
int in_pkg = 0, fields = 0, matches = 0;
|
|
char expected[32];
|
|
if (!txt)
|
|
return 0;
|
|
package_checksum(name, expected, sizeof(expected));
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
in_pkg = (strcmp(pkg, name) == 0);
|
|
} else if (in_pkg && strnicmp2(t, "checksum:", 9) == 0) {
|
|
char *sum = trim_inplace(t + 9);
|
|
fields++;
|
|
if (strcmp(sum, expected) == 0)
|
|
matches++;
|
|
}
|
|
}
|
|
if (save) {
|
|
*p = save;
|
|
p++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int lock_packages_match_project(void) {
|
|
char *txt = read_file_text("claro.lock");
|
|
char *p;
|
|
char seen[128][65];
|
|
int seen_count = 0;
|
|
int ok = 1;
|
|
if (!txt)
|
|
return 1;
|
|
p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
int i;
|
|
if (*pkg && !package_name_safe(pkg)) {
|
|
printf(" BAD lock package name: %s\n", pkg);
|
|
ok = 0;
|
|
} else if (*pkg) {
|
|
for (i = 0; i < seen_count; i++) {
|
|
if (strcmp(seen[i], pkg) == 0) {
|
|
printf(" DUPLICATE lock package: %s\n", pkg);
|
|
ok = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (seen_count < 128)
|
|
claro_snprintf(seen[seen_count++], sizeof(seen[0]), "%s", pkg);
|
|
if (!package_has_name(pkg)) {
|
|
printf(" BAD lock package not in claro.project: %s\n", pkg);
|
|
ok = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (save) {
|
|
*p = save;
|
|
p++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
return ok;
|
|
}
|
|
static int package_manifest_version_matches(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0;
|
|
int matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 17 && strncmp(line, "manifest-version:", 17) == 0) {
|
|
const char *value = line + 17;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == 1 && value[0] == '1')
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_project_name_valid(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0;
|
|
int nonempty = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 5 && strncmp(line, "name:", 5) == 0) {
|
|
const char *value = line + 5;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if (value < end)
|
|
nonempty++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && nonempty == 1;
|
|
}
|
|
static int package_manifest_name_matches(const char *text, const char *name) {
|
|
const char *p = text;
|
|
size_t n = strlen(name);
|
|
int fields = 0;
|
|
int matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 5 && strncmp(line, "name:", 5) == 0) {
|
|
const char *value = line + 5;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == n && strncmp(value, name, n) == 0)
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_manifest_version_value_matches(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0;
|
|
int matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 8 && strncmp(line, "version:", 8) == 0) {
|
|
const char *value = line + 8;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == 1 && value[0] == '1')
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_manifest_source_matches(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0;
|
|
int matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 7 && strncmp(line, "source:", 7) == 0) {
|
|
const char *value = line + 7;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == 5 && strncmp(value, "local", 5) == 0)
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_manifest_checksum_matches(const char *text, const char *expected) {
|
|
const char *p = text;
|
|
size_t n = strlen(expected);
|
|
int fields = 0;
|
|
int matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p;
|
|
const char *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
if ((size_t)(end - line) >= 9 && strncmp(line, "checksum:", 9) == 0) {
|
|
const char *value = line + 9;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == n && strncmp(value, expected, n) == 0)
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_lock_version_matches(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0, matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p, *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
while (line < end && isspace((unsigned char)*line))
|
|
line++;
|
|
if ((size_t)(end - line) >= 13 && strnicmp2(line, "lock-version:", 13) == 0) {
|
|
const char *value = line + 13;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == 1 && value[0] == '1')
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_lock_release_version_matches(const char *text) {
|
|
const char *p = text;
|
|
int fields = 0, matches = 0;
|
|
while (p && *p) {
|
|
const char *line = p, *end;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
end = p;
|
|
while (line < end && isspace((unsigned char)*line))
|
|
line++;
|
|
if ((size_t)(end - line) >= 8 && strncmp(line, "version:", 8) == 0) {
|
|
const char *value = line + 8;
|
|
fields++;
|
|
while (value < end && isspace((unsigned char)*value))
|
|
value++;
|
|
while (end > value && isspace((unsigned char)end[-1]))
|
|
end--;
|
|
if ((size_t)(end - value) == strlen(CLARO_VERSION + 6) &&
|
|
strncmp(value, CLARO_VERSION + 6, strlen(CLARO_VERSION + 6)) == 0)
|
|
matches++;
|
|
}
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
return fields == 1 && matches == 1;
|
|
}
|
|
static int package_doctor(void) {
|
|
int ok = 1;
|
|
char *mainfile;
|
|
char *txt;
|
|
printf("%s\n", CLARO_VERSION);
|
|
printf("Package/project doctor:\n");
|
|
printf(" %s claro.project\n", file_exists_simple("claro.project") ? "OK" : "MISSING");
|
|
if (!file_exists_simple("claro.project"))
|
|
ok = 0;
|
|
mainfile = project_value("main");
|
|
if (mainfile && *mainfile) {
|
|
printf(" %s main script: %s\n", file_exists_simple(mainfile) ? "OK" : "MISSING", mainfile);
|
|
if (!file_exists_simple(mainfile))
|
|
ok = 0;
|
|
} else {
|
|
printf(" MISSING main setting\n");
|
|
ok = 0;
|
|
}
|
|
printf(" %s packages folder\n", path_exists_simple("packages") ? "OK" : "MISSING");
|
|
if (!path_exists_simple("packages"))
|
|
ok = 0;
|
|
printf(" %s claro.lock\n", file_exists_simple("claro.lock") ? "OK" : "MISSING");
|
|
if (!file_exists_simple("claro.lock"))
|
|
ok = 0;
|
|
txt = read_file_text("claro.lock");
|
|
if (txt && !package_lock_version_matches(txt)) {
|
|
printf(" BAD lock version: expected exactly one lock-version: 1 line\n");
|
|
ok = 0;
|
|
}
|
|
if (txt && !package_lock_release_version_matches(txt)) {
|
|
printf(
|
|
" BAD lock release version: expected exactly one version: v2026.10.25.014405 line\n");
|
|
ok = 0;
|
|
}
|
|
free(txt);
|
|
txt = read_file_text("claro.project");
|
|
if (txt && !project_package_names_safe()) {
|
|
ok = 0;
|
|
}
|
|
if (txt && !package_manifest_version_matches(txt)) {
|
|
printf(" BAD project manifest version: expected 1\n");
|
|
ok = 0;
|
|
}
|
|
if (txt && !package_project_name_valid(txt)) {
|
|
printf(" BAD project manifest name: expected a non-empty name\n");
|
|
ok = 0;
|
|
}
|
|
if (txt) {
|
|
char *p = txt;
|
|
while (*p) {
|
|
char *line = p;
|
|
char save;
|
|
while (*p && *p != '\n' && *p != '\r')
|
|
p++;
|
|
save = *p;
|
|
*p = 0;
|
|
{
|
|
char *t = trim_inplace(line);
|
|
if (strnicmp2(t, "package:", 8) == 0) {
|
|
char *pkg = trim_inplace(t + 8);
|
|
if (*pkg) {
|
|
char meta[512], *mt, sum[32];
|
|
if (!package_name_safe(pkg)) {
|
|
printf(" BAD package name: %s\n", pkg);
|
|
ok = 0;
|
|
} else {
|
|
claro_snprintf(meta, sizeof(meta), "packages/%s/claro.package", pkg);
|
|
mt = read_file_text(meta);
|
|
if (mt && !package_manifest_version_value_matches(mt)) {
|
|
printf(" BAD package version: %s\n", pkg);
|
|
ok = 0;
|
|
} else if (mt && !package_manifest_source_matches(mt)) {
|
|
printf(" BAD package source: %s\n", pkg);
|
|
ok = 0;
|
|
} else if (mt && !package_manifest_version_matches(mt)) {
|
|
printf(" BAD package manifest version: %s. Keep exactly one "
|
|
"manifest-version: 1 line in packages/%s/claro.package.\n",
|
|
pkg, pkg);
|
|
ok = 0;
|
|
} else if (mt && strstr(mt, "checksum:")) {
|
|
if (!package_manifest_name_matches(mt, pkg)) {
|
|
printf(" BAD package manifest name: %s\n", pkg);
|
|
ok = 0;
|
|
} else {
|
|
printf(" OK package manifest: %s\n", pkg);
|
|
package_checksum(pkg, sum, sizeof(sum));
|
|
if (package_manifest_checksum_matches(mt, sum))
|
|
printf(" OK package checksum: %s\n", pkg);
|
|
else {
|
|
printf(" BAD package checksum: %s\n", pkg);
|
|
ok = 0;
|
|
}
|
|
if (package_lock_checksum_ok(pkg))
|
|
printf(" OK lock checksum: %s\n", pkg);
|
|
else {
|
|
printf(" BAD lock checksum: %s\n", pkg);
|
|
ok = 0;
|
|
}
|
|
}
|
|
} else {
|
|
printf(" MISSING package manifest: %s\n", pkg);
|
|
ok = 0;
|
|
}
|
|
free(mt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (save)
|
|
p++;
|
|
while (*p == '\n' || *p == '\r')
|
|
p++;
|
|
}
|
|
free(txt);
|
|
}
|
|
if (!lock_packages_match_project())
|
|
ok = 0;
|
|
free(mainfile);
|
|
printf("%s\n",
|
|
ok ? "Package/project files look ready." : "Package/project files need attention.");
|
|
return ok ? 0 : 1;
|
|
}
|
|
static int run_package_cmd(int argc, char **argv, int arg) {
|
|
if (arg >= argc) {
|
|
printf("Package commands:\n claro package init\n claro package add NAME\n claro package "
|
|
"remove NAME\n claro package list\n claro package doctor\n claro package lock\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "init") == 0) {
|
|
ensure_project_file();
|
|
if (!project_package_names_safe())
|
|
return 1;
|
|
make_folder("packages");
|
|
if (!write_package_lock())
|
|
return 1;
|
|
printf("Package project ready: claro.project, claro.lock, packages/\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "add") == 0 && arg + 1 < argc) {
|
|
const char *name = argv[arg + 1];
|
|
int already;
|
|
if (package_name_too_long(name)) {
|
|
fprintf(stderr, "Package names must be 64 characters or fewer.\n");
|
|
return 1;
|
|
}
|
|
if (!package_name_safe(name)) {
|
|
fprintf(stderr, "Package names may use only letters, numbers, dash, and underscore.\n");
|
|
return 1;
|
|
}
|
|
ensure_project_file();
|
|
if (!project_package_names_safe())
|
|
return 1;
|
|
make_folder("packages");
|
|
already = package_has_name(name);
|
|
if (!append_package_to_project(name))
|
|
return 1;
|
|
create_package_folder(name);
|
|
if (!write_package_lock())
|
|
return 1;
|
|
if (!already)
|
|
printf("Added package: %s\n", name);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "remove") == 0 && arg + 1 < argc) {
|
|
const char *name = argv[arg + 1];
|
|
int removed;
|
|
removed = remove_package_from_project(name);
|
|
if (removed < 0)
|
|
return 1;
|
|
if (removed)
|
|
printf("Removed package from project: %s\n", name);
|
|
else
|
|
printf("Package was not listed: %s\n", name);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "list") == 0)
|
|
return list_project_packages();
|
|
if (strcmp(argv[arg], "doctor") == 0)
|
|
return package_doctor();
|
|
if (strcmp(argv[arg], "lock") == 0 || strcmp(argv[arg], "update") == 0) {
|
|
ensure_project_file();
|
|
make_folder("packages");
|
|
if (write_package_lock()) {
|
|
printf("Updated claro.lock\n");
|
|
return 0;
|
|
}
|
|
fprintf(stderr, "Could not write claro.lock\n");
|
|
return 1;
|
|
}
|
|
printf("Unknown package command. Try: claro package init\n");
|
|
return 1;
|
|
}
|
|
static int print_ide_info(void) {
|
|
printf("{\n");
|
|
printf(" \"language\": \"Claro\",\n");
|
|
printf(" \"version\": \"v2026.10.25.014405\",\n");
|
|
printf(" \"file_extensions\": [\".claro\"],\n");
|
|
printf(" \"keywords\": "
|
|
"[\"SAY\",\"ASK\",\"SET\",\"IF\",\"ELSE\",\"ENDIF\",\"END\",\"REPEAT\",\"UNTIL\","
|
|
"\"TEACH\",\"TAKES\",\"RETURNS\",\"CHECK\",\"TYPE\",\"LEARNED\",\"DO\",\"CALL\","
|
|
"\"WITH\",\"RETURN\",\"CLASS\",\"HAS\",\"NEW\",\"IMPORT\",\"TRY\",\"CATCH\",\"ENDTRY\","
|
|
"\"START TASK\",\"YIELD\",\"WAIT TASK\",\"TASK STATUS\",\"HTTP CHECK\",\"HTTP "
|
|
"GET\",\"HTTP SAVE\",\"OPEN WINDOW\"],\n");
|
|
printf(" \"types\": [\"NUMBER\",\"TEXT\",\"YESNO\",\"LIST\",\"LIST OF TEXT\",\"LIST OF "
|
|
"NUMBER\",\"LIST OF YESNO\",\"MAP\",\"MAP OF TEXT\",\"MAP OF NUMBER\",\"MAP OF "
|
|
"YESNO\",\"OBJECT\",\"ANY\"],\n");
|
|
printf(" \"commands\": [\n");
|
|
printf(" {\"name\": \"run\", \"usage\": \"claro run\", \"description\": \"Run main.claro or "
|
|
"the project main script\"},\n");
|
|
printf(" {\"name\": \"check\", \"usage\": \"claro check file.claro\", \"description\": "
|
|
"\"Check beginner syntax and block mistakes\"},\n");
|
|
printf(" {\"name\": \"typecheck\", \"usage\": \"claro typecheck file.claro\", "
|
|
"\"description\": \"Check static types before running\"},\n");
|
|
printf(" {\"name\": \"fmt\", \"usage\": \"claro fmt file.claro\", \"description\": \"Print "
|
|
"a formatted version of a script\"},\n");
|
|
printf(" {\"name\": \"test\", \"usage\": \"claro test\", \"description\": \"Run golden "
|
|
"tests\"}\n");
|
|
printf(" ],\n");
|
|
printf(" \"snippets\": [\n");
|
|
printf(" {\"name\": \"hello\", \"prefix\": \"say\", \"body\": \"SAY \\\"Hello!\\\"\"},\n");
|
|
printf(" {\"name\": \"if_else\", \"prefix\": \"if\", \"body\": \"IF condition\\n SAY "
|
|
"\\\"Yes\\\"\\nELSE\\n SAY \\\"No\\\"\\nEND\"},\n");
|
|
printf(" {\"name\": \"function\", \"prefix\": \"teach\", \"body\": \"TEACH name item\\n "
|
|
"SAY item\\nEND\"},\n");
|
|
printf(" {\"name\": \"typed_list\", \"prefix\": \"listof\", \"body\": \"SET names AS LIST "
|
|
"OF TEXT TO LIST\\nADD \\\"Ada\\\" TO names\"},\n");
|
|
printf(" {\"name\": \"task\", \"prefix\": \"task\", \"body\": \"START TASK helloTask\\n "
|
|
"SAY \\\"Inside task\\\"\\n YIELD\\nENDTASK\\nTASK STATUS helloTask AS status\\nSAY "
|
|
"status\\nWAIT TASK helloTask\"}\n");
|
|
printf(" ],\n");
|
|
printf(" \"diagnostics\": [\n");
|
|
printf(" {\"source\": \"claro check\", \"format\": \"path:line: message\", \"description\": "
|
|
"\"Syntax and block-structure diagnostics\"},\n");
|
|
printf(" {\"source\": \"claro typecheck\", \"format\": \"path:line: message\", "
|
|
"\"description\": \"Static type diagnostics for variables and containers\"}\n");
|
|
printf(" ]\n");
|
|
printf("}\n");
|
|
return 0;
|
|
}
|
|
static void print_help(void) {
|
|
printf("%s\n", CLARO_VERSION);
|
|
printf("Usage:\n");
|
|
printf(" claro file.claro Run a Claro script\n");
|
|
printf(" claro run Run main.claro in this folder\n");
|
|
printf(" claro test Run the built-in tests\n");
|
|
printf(" claro check file.claro Check a script for beginner mistakes\n");
|
|
printf(" claro typecheck file.claro Check simple static types\n");
|
|
printf(" claro fmt file.claro Print a formatted version\n");
|
|
printf(" claro repl Try one line at a time\n");
|
|
printf(" claro new MyProject Create a starter project\n");
|
|
printf(" claro examples List included examples\n");
|
|
printf(" claro doctor Check this Claro folder\n");
|
|
printf(" claro validate Run stable package validation\n");
|
|
printf(" claro package init|add|remove|list|doctor Manage Claro packages\n");
|
|
printf(" claro ide Print editor keyword metadata\n");
|
|
}
|
|
static int show_examples(void) {
|
|
const char *items[] = {"hello.claro",
|
|
"name_input.claro",
|
|
"quiz.claro",
|
|
"calculator.claro",
|
|
"guessing_game.claro",
|
|
"shopping_list.claro",
|
|
"save_and_load_file.claro",
|
|
"simple_functions.claro",
|
|
"text_and_lists.claro",
|
|
"text_polish.claro",
|
|
"practical_scripting.claro",
|
|
"type_hardening.claro",
|
|
"typed_ask.claro",
|
|
"objects_classes.claro",
|
|
"networking.claro",
|
|
NULL};
|
|
int i;
|
|
printf("Included beginner examples:\n");
|
|
for (i = 0; items[i]; i++)
|
|
printf(" examples/%s\n", items[i]);
|
|
printf("\nRun one with: claro examples/hello.claro\n");
|
|
return 0;
|
|
}
|
|
static int file_exists_simple(const char *path) {
|
|
FILE *f = fopen(path, "rb");
|
|
if (f) {
|
|
fclose(f);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
static int run_doctor(void) {
|
|
int ok = 1;
|
|
const char *files[] = {"src/claro.c",
|
|
"README.md",
|
|
"assets/Claro_Logo.jpg",
|
|
"lessons/01_hello.claro",
|
|
"examples/hello.claro",
|
|
"tests/01_hello.claro",
|
|
NULL};
|
|
int i;
|
|
printf("%s\n", CLARO_VERSION);
|
|
printf("Doctor check:\n");
|
|
for (i = 0; files[i]; i++) {
|
|
int has = file_exists_simple(files[i]);
|
|
printf(" %s %s\n", has ? "OK" : "MISSING", files[i]);
|
|
if (!has)
|
|
ok = 0;
|
|
}
|
|
printf("%s\n", ok ? "Claro folder looks ready." : "Some Claro files are missing.");
|
|
return ok ? 0 : 1;
|
|
}
|
|
static int run_validate(void) {
|
|
int fails = 0, i;
|
|
const char *checks[] = {"lessons/01_hello.claro",
|
|
"lessons/02_ask_name.claro",
|
|
"lessons/03_variables.claro",
|
|
"lessons/04_math.claro",
|
|
"lessons/05_if_else.claro",
|
|
"lessons/06_loops.claro",
|
|
"lessons/07_lists.claro",
|
|
"lessons/08_functions.claro",
|
|
"lessons/09_files.claro",
|
|
"lessons/10_final_quiz.claro",
|
|
"examples/hello.claro",
|
|
"examples/name_input.claro",
|
|
"examples/quiz.claro",
|
|
"examples/calculator.claro",
|
|
"examples/guessing_game.claro",
|
|
"examples/shopping_list.claro",
|
|
"examples/save_and_load_file.claro",
|
|
"examples/simple_functions.claro",
|
|
"examples/text_and_lists.claro",
|
|
"examples/text_polish.claro",
|
|
"examples/practical_scripting.claro",
|
|
"examples/type_hardening.claro",
|
|
"examples/objects_classes.claro",
|
|
"examples/networking.claro",
|
|
NULL};
|
|
printf("%s\n", CLARO_VERSION);
|
|
printf("Stable package validation:\n");
|
|
fails += run_doctor();
|
|
fails += run_tests();
|
|
printf("Checking lessons and main examples:\n");
|
|
for (i = 0; checks[i]; i++) {
|
|
printf(" %s\n", checks[i]);
|
|
fails += check_file(checks[i]);
|
|
}
|
|
{
|
|
const char *typecheck_good[] = {
|
|
"tests/typecheck_function_branch_complete_good.claro",
|
|
"tests/typecheck_function_nested_branch_complete_good.claro",
|
|
"tests/typecheck_function_compat_branch_complete_good.claro",
|
|
"tests/typecheck_function_return_expression_good.claro",
|
|
"tests/typecheck_function_return_multiplication_good.claro",
|
|
"tests/typecheck_method_call_good.claro",
|
|
"tests/typecheck_method_field_assignment_good.claro",
|
|
"tests/typecheck_method_text_concat_good.claro",
|
|
"tests/typecheck_method_compat_text_concat_good.claro",
|
|
"tests/typecheck_method_text_field_assignment_good.claro",
|
|
"tests/typecheck_method_compat_text_field_assignment_good.claro",
|
|
"tests/typecheck_method_compat_yesno_field_assignment_good.claro",
|
|
"tests/typecheck_method_inline_field_annotation_as_to_good.claro",
|
|
"tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro",
|
|
"tests/typecheck_method_field_check_type_good.claro",
|
|
"tests/typecheck_method_compat_field_check_type_good.claro",
|
|
"tests/typecheck_method_compat_return_good.claro",
|
|
"tests/typecheck_method_compat_lowercase_return_good.claro",
|
|
"tests/typecheck_method_compat_return_multiplication_good.claro",
|
|
"tests/typecheck_method_compat_return_addition_good.claro",
|
|
"tests/typecheck_method_nested_branch_complete_good.claro",
|
|
"tests/typecheck_method_return_expression_good.claro",
|
|
"tests/typecheck_method_return_addition_good.claro",
|
|
"tests/typecheck_method_return_good.claro",
|
|
"tests/typecheck_nested_container_good.claro",
|
|
"tests/typecheck_object_alias_method_call_good.claro",
|
|
"tests/typecheck_object_alias_method_do_good.claro",
|
|
"tests/typecheck_object_field_alias_good.claro",
|
|
"tests/typecheck_object_field_check_type_chained_alias_text_good.claro",
|
|
"tests/typecheck_object_field_check_type_yesno_good.claro",
|
|
"tests/typecheck_object_field_division_good.claro",
|
|
"tests/typecheck_object_field_multiplication_good.claro",
|
|
"tests/typecheck_object_field_text_concat_good.claro",
|
|
"tests/typecheck_object_field_text_concat_reverse_good.claro",
|
|
"tests/typecheck_object_field_subtraction_good.claro",
|
|
NULL};
|
|
const char *typecheck_bad[] = {
|
|
"tests/typecheck_function_branch_missing_return_bad.claro",
|
|
"tests/typecheck_function_call_missing_unchecked_arg_bad.claro",
|
|
"tests/typecheck_function_call_unknown_bad.claro",
|
|
"tests/typecheck_function_extra_arg_bad.claro",
|
|
"tests/typecheck_function_missing_arg_bad.claro",
|
|
"tests/typecheck_function_missing_return_bad.claro",
|
|
"tests/typecheck_function_compat_missing_return_bad.claro",
|
|
"tests/typecheck_function_return_expression_bad.claro",
|
|
"tests/typecheck_function_return_arithmetic_bad.claro",
|
|
"tests/typecheck_invalid_expected_type_bad.claro",
|
|
"tests/typecheck_missing_expression_bad.claro",
|
|
"tests/typecheck_missing_expression_with_is_bad.claro",
|
|
"tests/typecheck_invalid_return_type_bad.claro",
|
|
"tests/typecheck_method_call_bad.claro",
|
|
"tests/typecheck_method_call_unknown_method_bad.claro",
|
|
"tests/typecheck_method_call_unknown_object_bad.claro",
|
|
"tests/typecheck_method_call_unknown_object_unknown_method_bad.claro",
|
|
"tests/typecheck_method_compat_return_bad.claro",
|
|
"tests/typecheck_method_compat_return_multiplication_bad.claro",
|
|
"tests/typecheck_method_duplicate_name_bad.claro",
|
|
"tests/typecheck_duplicate_field_bad.claro",
|
|
"tests/typecheck_duplicate_class_bad.claro",
|
|
"tests/typecheck_method_extra_arg_bad.claro",
|
|
"tests/typecheck_method_invalid_return_type_bad.claro",
|
|
"tests/typecheck_method_missing_arg_bad.claro",
|
|
"tests/typecheck_method_missing_return_bad.claro",
|
|
"tests/typecheck_method_missing_unchecked_arg_bad.claro",
|
|
"tests/typecheck_method_return_bad.claro",
|
|
"tests/typecheck_method_return_addition_bad.claro",
|
|
"tests/typecheck_method_return_expression_bad.claro",
|
|
"tests/typecheck_method_second_method_bad.claro",
|
|
"tests/typecheck_method_second_method_extra_arg_bad.claro",
|
|
"tests/typecheck_method_unknown_method_bad.claro",
|
|
"tests/typecheck_method_field_assignment_bad.claro",
|
|
"tests/typecheck_method_short_field_missing_value_bad.claro",
|
|
"tests/typecheck_method_compat_short_field_missing_value_bad.claro",
|
|
"tests/typecheck_method_compat_unknown_field_bad.claro",
|
|
"tests/typecheck_method_unknown_field_typed_bad.claro",
|
|
"tests/typecheck_method_compat_unknown_field_typed_bad.claro",
|
|
"tests/typecheck_method_unknown_field_expression_bad.claro",
|
|
"tests/typecheck_method_text_field_assignment_bad.claro",
|
|
"tests/typecheck_method_compat_text_field_assignment_bad.claro",
|
|
"tests/typecheck_method_yesno_field_assignment_bad.claro",
|
|
"tests/typecheck_method_compat_yesno_field_assignment_bad.claro",
|
|
"tests/typecheck_method_field_check_type_bad.claro",
|
|
"tests/typecheck_method_compat_field_check_type_bad.claro",
|
|
"tests/typecheck_method_unknown_object_bad.claro",
|
|
"tests/typecheck_object_alias_method_bad.claro",
|
|
"tests/typecheck_object_alias_method_call_bad.claro",
|
|
"tests/typecheck_object_field_addition_bad.claro",
|
|
"tests/typecheck_object_field_after_method_bad.claro",
|
|
"tests/typecheck_object_field_alias_bad.claro",
|
|
"tests/typecheck_object_field_chained_alias_bad.claro",
|
|
"tests/typecheck_object_field_division_bad.claro",
|
|
"tests/typecheck_object_field_multiplication_bad.claro",
|
|
"tests/typecheck_object_field_subtraction_bad.claro",
|
|
"tests/typecheck_object_field_typed_bad.claro",
|
|
"tests/typecheck_object_field_missing_value_bad.claro",
|
|
"tests/typecheck_object_field_unknown_object_bad.claro",
|
|
"tests/typecheck_object_field_unknown_typed_bad.claro",
|
|
"tests/typecheck_missing_field_type_bad.claro",
|
|
"tests/typecheck_extra_class_tokens_bad.claro",
|
|
"tests/typecheck_extra_new_tokens_bad.claro",
|
|
"tests/typecheck_extra_field_tokens_bad.claro",
|
|
NULL};
|
|
for (i = 0; typecheck_good[i]; i++)
|
|
fails += typecheck_file(typecheck_good[i]);
|
|
for (i = 0; typecheck_bad[i]; i++)
|
|
if (typecheck_file(typecheck_bad[i]) == 0)
|
|
fails++;
|
|
}
|
|
fails += typecheck_file("tests/typecheck_good.claro");
|
|
fails += typecheck_file("tests/typecheck_container_good.claro");
|
|
fails += typecheck_file("tests/typecheck_function_good.claro");
|
|
fails += typecheck_file("tests/typecheck_function_return_good.claro");
|
|
fails += typecheck_file("tests/typecheck_function_compat_return_good.claro");
|
|
fails += typecheck_file("tests/typecheck_function_multi_good.claro");
|
|
fails += typecheck_file("tests/typecheck_method_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_expression_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_compound_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_subtraction_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_text_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_text_concat_fields_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_yesno_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_check_type_number_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_check_type_text_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_check_type_text_yesno_good.claro");
|
|
fails += typecheck_file("tests/typecheck_object_field_check_type_chained_alias_good.claro");
|
|
fails += typecheck_file("tests/37_object_field_types.claro");
|
|
if (typecheck_file("tests/typecheck_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_container_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_duplicate_param_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_return_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_return_extra_tokens_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_compat_return_extra_tokens_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_compat_empty_return_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_compat_return_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_empty_return_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_multi_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_missing_unchecked_arg_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_function_unknown_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_method_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_method_branch_missing_return_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_text_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_yesno_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_unknown_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_unknown_text_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_unknown_yesno_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_unknown_expression_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_expression_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_compound_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_text_expression_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_text_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_yesno_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_number_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_unknown_number_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_unknown_text_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_unknown_yesno_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_unknown_object_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_alias_bad.claro") == 0)
|
|
fails++;
|
|
if (typecheck_file("tests/typecheck_object_field_check_type_chained_alias_bad.claro") == 0)
|
|
fails++;
|
|
printf(
|
|
"%s\n",
|
|
fails ? "Validation found problems."
|
|
: "Validation passed. Claro v2026.10.25.014405 foundation checks are ready for use.");
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
int arg = 1, trace = 0;
|
|
if (argc < 2) {
|
|
print_help();
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "--trace") == 0 || strcmp(argv[arg], "trace") == 0) {
|
|
trace = 1;
|
|
arg++;
|
|
}
|
|
if (arg >= argc)
|
|
return 0;
|
|
if (strcmp(argv[arg], "help") == 0 || strcmp(argv[arg], "--help") == 0) {
|
|
print_help();
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "test") == 0)
|
|
return run_tests();
|
|
if (strcmp(argv[arg], "repl") == 0)
|
|
return run_repl();
|
|
if (strcmp(argv[arg], "examples") == 0)
|
|
return show_examples();
|
|
if (strcmp(argv[arg], "doctor") == 0)
|
|
return run_doctor();
|
|
if (strcmp(argv[arg], "validate") == 0)
|
|
return run_validate();
|
|
if (strcmp(argv[arg], "package") == 0)
|
|
return run_package_cmd(argc, argv, arg + 1);
|
|
if (strcmp(argv[arg], "ide") == 0)
|
|
return print_ide_info();
|
|
if (strcmp(argv[arg], "new") == 0 && arg + 1 < argc)
|
|
return create_new_project(argv[arg + 1]);
|
|
if (strcmp(argv[arg], "fmt") == 0 && arg + 1 < argc)
|
|
return fmt_file(argv[arg + 1]);
|
|
if (strcmp(argv[arg], "check") == 0 && arg + 1 < argc)
|
|
return check_file(argv[arg + 1]);
|
|
if (strcmp(argv[arg], "typecheck") == 0 && arg + 1 < argc)
|
|
return typecheck_file(argv[arg + 1]);
|
|
if (strcmp(argv[arg], "version") == 0 || strcmp(argv[arg], "--version") == 0) {
|
|
puts(CLARO_VERSION);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[arg], "run") == 0) {
|
|
arg++;
|
|
if (arg >= argc) {
|
|
Runtime rt;
|
|
int rc;
|
|
char *mainfile = project_value("main");
|
|
if (!mainfile || !*mainfile) {
|
|
if (mainfile)
|
|
free(mainfile);
|
|
mainfile = xstrdup("main.claro");
|
|
}
|
|
rt_init(&rt);
|
|
rt.trace = trace;
|
|
rt.script_argc = 0;
|
|
rt.script_argv = NULL;
|
|
rc = run_file(&rt, mainfile);
|
|
free(mainfile);
|
|
runtime_free(&rt);
|
|
return rc;
|
|
}
|
|
}
|
|
{
|
|
Runtime rt;
|
|
int rc;
|
|
rt_init(&rt);
|
|
rt.trace = trace;
|
|
rt.script_argc = argc - arg - 1;
|
|
rt.script_argv = argv + arg + 1;
|
|
rc = run_file(&rt, argv[arg]);
|
|
runtime_free(&rt);
|
|
return rc;
|
|
}
|
|
}
|