me_variable_ex -> -me_variable, an remove (unncessary now) me_compile_ex()

Author: FrancescAlted

doc/data-types.md

@@ -292,7 +292,7 @@ Both methods require explicit variable dtypes when the computation type differs
 
 `ME_STRING` represents fixed-size UCS4 (`uint32_t`) strings. Each element is a
 NUL-terminated array of codepoints with no embedded NULs. You must provide the
-per-element byte size via `me_variable_ex` (`itemsize` must be a multiple of 4
+per-element byte size via `me_variable` (`itemsize` must be a multiple of 4
 and include the terminator). The maximum string length in codepoints is
 `itemsize / 4 - 1`.
 
@@ -309,13 +309,13 @@ uint32_t names[][8] = {
     {'b','e','t','a',0,0,0,0},
 };
 
-me_variable_ex vars[] = {
+me_variable vars[] = {
     {"name", ME_STRING, names, ME_VARIABLE, NULL, sizeof(names[0])}
 };
 
 int error;
 me_expr *expr = NULL;
-if (me_compile_ex("startswith(name, \"alp\")", vars, 1, ME_BOOL, &error, &expr) != ME_COMPILE_SUCCESS) { /* handle error */ }
+if (me_compile("startswith(name, \"alp\")", vars, 1, ME_BOOL, &error, &expr) != ME_COMPILE_SUCCESS) { /* handle error */ }
 ```
 
 String literals are UTF-8 and support escapes like `\n`, `\t`, `\\`, `\"`, `\'`,

doc/dsl-usage.md

@@ -29,7 +29,7 @@ def kernel(x):
 ```
 
 Signature arguments must match the variables you pass to `me_compile()` by name
-(order does not matter). (Callback functions registered via `me_variable_ex` are
+(order does not matter). (Callback functions registered via `me_variable` are
 not listed in the signature.)
 
 Note: The order of the variables array still defines the pointer order passed to
@@ -323,7 +323,7 @@ Logical operator precedence matches Python: `not` binds tighter than `and`, whic
 - Predicates: `startswith(a, b)`, `endswith(a, b)`, `contains(a, b)` (string-to-string)
 
 String variables must be provided with dtype `ME_STRING` and a fixed `itemsize`
-via `me_variable_ex` (itemsize is bytes per element and must be a multiple of 4).
+via `me_variable` (itemsize is bytes per element and must be a multiple of 4).
 String expressions always yield boolean output.
 
 Example (element-wise string match with a scalar condition):
@@ -407,7 +407,7 @@ print(sum(a))
 ### User-defined Functions
 
 You can register custom C functions or closures and call them from DSL by
-including them in the `me_variable_ex` list passed to `me_compile_ex()`.
+including them in the `me_variable` list passed to `me_compile()`.
 
 Rules:
 - Function/closure entries must use `ME_FUNCTION*` or `ME_CLOSURE*` in `type`.
@@ -422,14 +422,14 @@ static double clamp01(double x) {
     return x < 0.0 ? 0.0 : (x > 1.0 ? 1.0 : x);
 }
 
-me_variable_ex vars[] = {
+me_variable vars[] = {
     {"x", ME_FLOAT64, x, ME_VARIABLE, NULL, 0},
     {"clamp01", ME_FLOAT64, clamp01, ME_FUNCTION1 | ME_FLAG_PURE, NULL, 0},
 };
 
 me_expr *expr = NULL;
 int err = 0;
-me_compile_ex("def kernel(x):\n    return clamp01(x)\n", vars, 2, ME_FLOAT64, &err, &expr);
+me_compile("def kernel(x):\n    return clamp01(x)\n", vars, 2, ME_FLOAT64, &err, &expr);
 ```
 
 Example (closure with context):
@@ -439,7 +439,7 @@ static double scale(void *ctx, double x) {
 }
 
 double factor = 2.0;
-me_variable_ex vars[] = {
+me_variable vars[] = {
     {"x", ME_FLOAT64, x, ME_VARIABLE, NULL, 0},
     {"scale", ME_FLOAT64, scale, ME_CLOSURE1 | ME_FLAG_PURE, &factor, 0},
 };

doc/strings.md

@@ -12,21 +12,21 @@ string operations.
 
 ## API: Variables and Compilation
 
-Use `me_variable_ex` to supply `itemsize` for string variables:
+Use `me_variable` to supply `itemsize` for string variables:
 
 ```c
 uint32_t names[][8] = {
     {'a','l','p','h','a',0,0,0},
     {'b','e','t','a',0,0,0,0},
 };
 
-me_variable_ex vars[] = {
+me_variable vars[] = {
     {"name", ME_STRING, names, ME_VARIABLE, NULL, sizeof(names[0])}
 };
 
 me_expr *expr = NULL;
 int err = 0;
-if (me_compile_ex("contains(name, \"et\")", vars, 1, ME_BOOL, &err, &expr) != ME_COMPILE_SUCCESS) {
+if (me_compile("contains(name, \"et\")", vars, 1, ME_BOOL, &err, &expr) != ME_COMPILE_SUCCESS) {
     /* handle error */
 }
 ```

examples/14_string_ops.c

@@ -72,11 +72,11 @@ static int run_expr(const char *expr_str, const void **vars, int nvars,
     me_expr *expr = NULL;
     int err = 0;
 
-    me_variable_ex variables[] = {
+    me_variable variables[] = {
         {"name", ME_STRING, vars[0], ME_VARIABLE, NULL, sizeof(uint32_t) * 8}
     };
 
-    int rc = me_compile_ex(expr_str, variables, nvars, ME_BOOL, &err, &expr);
+    int rc = me_compile(expr_str, variables, nvars, ME_BOOL, &err, &expr);
     if (rc != ME_COMPILE_SUCCESS) {
         printf("compile failed (%d) at %d for: %s\n", rc, err, expr_str);
         return rc;

examples/17_dsl_user_function.c

@@ -37,14 +37,14 @@ int main(void) {
     int n = (int)(sizeof(x) / sizeof(x[0]));
     double out[5];
 
-    me_variable_ex vars[] = {
+    me_variable vars[] = {
         {"x", ME_FLOAT64, NULL, 0, NULL, 0},
         {"clamp01", ME_FLOAT64, clamp01, ME_FUNCTION1 | ME_FLAG_PURE, NULL, 0},
     };
 
     int err = 0;
     me_expr *expr = NULL;
-    if (me_compile_ex(dsl_source, vars, 2, ME_FLOAT64, &err, &expr) != ME_COMPILE_SUCCESS) {
+    if (me_compile(dsl_source, vars, 2, ME_FLOAT64, &err, &expr) != ME_COMPILE_SUCCESS) {
         printf("Compile error at %d\n", err);
         return 1;
     }

examples/README.md

@@ -422,7 +422,7 @@ def mandelbrot(cr, ci):
 
 - **What it demonstrates**: Registering a custom C function for DSL evaluation
 - **Expressions**: Calling a user-defined function from a DSL program
-- **Concepts**: `me_variable_ex` function entries, explicit return dtype
+- **Concepts**: `me_variable` function entries, explicit return dtype
 - **Best for**: Extending DSL with domain-specific helpers
 
 **Run it:**

src/functions.c

@@ -629,7 +629,7 @@ static double npr(double n, double r) { return ncr(n, r) * fac(r); }
 #pragma function (floor)
 #endif
 
-static const me_variable_ex functions[] = {
+static const me_variable functions[] = {
     /* must be in alphabetical order */
     /* Format: {name, dtype, address, type, context} */
     {"abs", 0, fabs, ME_FUNCTION1 | ME_FLAG_PURE, 0},
@@ -715,9 +715,9 @@ static const me_variable_ex functions[] = {
     {0, 0, 0, 0, 0}
 };
 
-static const me_variable_ex* find_builtin(const char* name, int len) {
+static const me_variable* find_builtin(const char* name, int len) {
     int imin = 0;
-    int imax = sizeof(functions) / sizeof(me_variable_ex) - 2;
+    int imax = sizeof(functions) / sizeof(me_variable) - 2;
 
     /*Binary search.*/
     while (imax >= imin) {
@@ -745,9 +745,9 @@ bool me_is_builtin_function_name(const char* name, size_t len) {
     return find_builtin(name, (int)len) != NULL;
 }
 
-static const me_variable_ex* find_lookup(const state* s, const char* name, int len) {
+static const me_variable* find_lookup(const state* s, const char* name, int len) {
     int iters;
-    const me_variable_ex* var;
+    const me_variable* var;
     if (!s->lookup) return 0;
 
     for (var = s->lookup, iters = s->lookup_len; iters; ++var, --iters) {
@@ -2998,7 +2998,7 @@ static void read_identifier_token(state* s) {
         return;
     }
 
-    const me_variable_ex* var = find_lookup(s, start, s->next - start);
+    const me_variable* var = find_lookup(s, start, s->next - start);
     if (!var) {
         var = find_builtin(start, s->next - start);
     }

src/functions.h

@@ -36,7 +36,7 @@ typedef struct state {
     const uint32_t* str_data;
     size_t str_len;
 
-    const me_variable_ex* lookup;
+    const me_variable* lookup;
     int lookup_len;
 } state;