Add new me_compile_chunk() and me_variable struct sanitized

Author: FrancescAlted

CODE_QUALITY.md

@@ -0,0 +1,64 @@
+# Code Quality Tools
+
+## Setup (For Contributors)
+
+After cloning the repository, install the Git hooks:
+
+```bash
+./scripts/install-hooks.sh
+```
+
+This will install the pre-commit hook that checks for trailing whitespace.
+
+## Trailing Whitespace
+
+Trailing whitespace is automatically prevented by the pre-commit hook and can be checked/fixed using the provided tools.
+
+### Pre-commit Hook
+
+The Git pre-commit hook automatically checks for trailing whitespace before each commit.
+
+**First-time setup:**
+```bash
+./scripts/install-hooks.sh
+```
+
+If trailing whitespace is detected, the commit will be blocked with instructions on how to fix it.
+
+To bypass the check (not recommended):
+```bash
+git commit --no-verify
+```
+
+### Manual Checking
+
+Check for trailing whitespace:
+```bash
+make check-whitespace
+# or
+./check-whitespace.sh
+```
+
+Fix trailing whitespace:
+```bash
+make fix-whitespace
+# or
+./check-whitespace.sh --fix
+```
+
+### Files Checked
+
+The tools check these file types:
+- `*.c` - C source files
+- `*.h` - C header files
+- `*.md` - Markdown documentation
+
+Build artifacts in `build/` and `.git/` are excluded.
+
+### CI Integration
+
+Add to your CI pipeline:
+```yaml
+- name: Check trailing whitespace
+  run: make check-whitespace
+```

Makefile

@@ -98,3 +98,11 @@ clean:
 # Pattern rule for object files (if needed for future extensions)
 $(BUILDDIR)/%.o: $(SRCDIR)/%.c $(LIB_HDR) | $(BUILDDIR)
 	$(CC) $(CFLAGS) -c $< -o $@
+
+# Check for trailing whitespace
+check-whitespace:
+	@./check-whitespace.sh
+
+# Fix trailing whitespace
+fix-whitespace:
+	@./check-whitespace.sh --fix

README.md

@@ -15,12 +15,39 @@ miniexpr is designed to be embedded directly into larger projects, not distribut
 
 ### `me_compile()`
 ```c
-me_expr *me_compile(const char *expression, const me_variable *variables, 
-                    int var_count, void *output, int nitems, 
+me_expr *me_compile(const char *expression, const me_variable *variables,
+                    int var_count, void *output, int nitems,
                     me_dtype dtype, int *error);
 ```
 Parses an expression string and creates a compiled expression tree. Variables are bound at compile time. Returns `NULL` on error.
 
+### `me_compile_chunk()`
+```c
+me_expr *me_compile_chunk(const char *expression, const me_variable *variables,
+                          int var_count, me_dtype dtype, int *error);
+```
+Compiles an expression for chunked evaluation. This variant is optimized for use with `me_eval_chunk()` and `me_eval_chunk_threadsafe()`, where variable and output pointers are provided during evaluation rather than compilation.
+
+**Simple Usage**: Just provide variable names - everything else is optional:
+
+```c
+me_variable vars[] = {{"x"}, {"y"}};  // Just the names!
+me_expr *expr = me_compile_chunk("x + y", vars, 2, ME_FLOAT64, &err);
+
+// Later, provide data in the same order as vars array
+const void *data[] = {x_array, y_array};  // x first, y second
+me_eval_chunk(expr, data, 2, output, nitems);
+```
+
+For mixed types:
+```c
+me_variable vars[] = {{"temp", ME_FLOAT64}, {"count", ME_INT32}};
+```
+
+Variables are matched by position (order) in the arrays. Unspecified fields (address, type, context) default to NULL/0.
+
+Returns `NULL` on error.
+
 ### `me_eval()`
 ```c
 void me_eval(const me_expr *n);
@@ -74,6 +101,18 @@ To use miniexpr in your project, simply include the source files (`miniexpr.c` a
 
 For examples and detailed usage, see the [Getting Started Guide](doc/get-started.md).
 
+## Contributing
+
+After cloning the repository, install the Git hooks:
+
+```bash
+./scripts/install-hooks.sh
+```
+
+This sets up automatic checks for code quality (e.g., trailing whitespace).
+
+See [CODE_QUALITY.md](CODE_QUALITY.md) for more details on code quality tools.
+
 ## License
 
 BSD 3-Clause License. See [LICENSE](LICENSE) for details.

bench/benchmark_all_types.c

@@ -29,7 +29,7 @@ int main() {
         int32_t *result = malloc(n * sizeof(int32_t));
         for (int i = 0; i < n; i++) a[i] = i;
 
-        me_variable vars[] = {{"a", a}};
+        me_variable vars[] = {{"a", ME_INT32, a}};
         int err;
         me_expr *expr = me_compile("a+5", vars, 1, result, n, ME_INT32, &err);
 
@@ -51,7 +51,7 @@ int main() {
         uint64_t *result = malloc(n * sizeof(uint64_t));
         for (int i = 0; i < n; i++) a[i] = i;
 
-        me_variable vars[] = {{"a", a}};
+        me_variable vars[] = {{"a", ME_INT32, a}};
         int err;
         me_expr *expr = me_compile("a+5", vars, 1, result, n, ME_UINT64, &err);
 
@@ -73,7 +73,7 @@ int main() {
         float *result = malloc(n * sizeof(float));
         for (int i = 0; i < n; i++) a[i] = i * 0.1f;
 
-        me_variable vars[] = {{"a", a}};
+        me_variable vars[] = {{"a", ME_INT32, a}};
         int err;
         me_expr *expr = me_compile("a+5", vars, 1, result, n, ME_FLOAT32, &err);
 
@@ -95,7 +95,7 @@ int main() {
         double *result = malloc(n * sizeof(double));
         for (int i = 0; i < n; i++) a[i] = i * 0.1;
 
-        me_variable vars[] = {{"a", a}};
+        me_variable vars[] = {{"a", ME_INT32, a}};
         int err;
         me_expr *expr = me_compile("a+5", vars, 1, result, n, ME_FLOAT64, &err);
 
@@ -117,7 +117,7 @@ int main() {
         float complex *result = malloc(n * sizeof(float complex));
         for (int i = 0; i < n; i++) a[i] = (float) i + (float) i * I;
 
-        me_variable vars[] = {{"a", a}};
+        me_variable vars[] = {{"a", ME_INT32, a}};
         int err;
         me_expr *expr = me_compile("a+5", vars, 1, result, n, ME_COMPLEX64, &err);
 
@@ -146,7 +146,7 @@ int main() {
             b[i] = n - i;
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", ME_INT32, a}, {"b", ME_INT32, b}};
         int err;
         me_expr *expr = me_compile("sqrt(a*a+b*b)", vars, 2, result, n, ME_INT32, &err);
 
@@ -173,7 +173,7 @@ int main() {
             b[i] = n - i;
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", ME_UINT64, a}, {"b", ME_UINT64, b}};
         int err;
         me_expr *expr = me_compile("sqrt(a*a+b*b)", vars, 2, result, n, ME_UINT64, &err);
 
@@ -200,7 +200,7 @@ int main() {
             b[i] = (n - i) * 0.1f;
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", ME_FLOAT32, a}, {"b", ME_FLOAT32, b}};
         int err;
         me_expr *expr = me_compile("sqrt(a*a+b*b)", vars, 2, result, n, ME_FLOAT32, &err);
 
@@ -227,7 +227,7 @@ int main() {
             b[i] = (n - i) * 0.1;
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", ME_FLOAT64, a}, {"b", ME_FLOAT64, b}};
         int err;
         me_expr *expr = me_compile("sqrt(a*a+b*b)", vars, 2, result, n, ME_FLOAT64, &err);
 
@@ -254,7 +254,7 @@ int main() {
             b[i] = (float) (n - i) * 0.1f + (float) (n - i) * 0.1f * I;
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", ME_COMPLEX64, a}, {"b", ME_COMPLEX64, b}};
         int err;
         me_expr *expr = me_compile("sqrt(a*a+b*b)", vars, 2, result, n, ME_COMPLEX64, &err);
 

bench/benchmark_chunked.c

@@ -28,11 +28,12 @@ void benchmark_expression(const char *expr_str, int total_size, int chunk_size)
         b[i] = (total_size - i) * 0.05;
     }
 
-    me_variable vars[] = {{"a", a}, {"b", b}};
+    // Variables for compilation (just the names)
+    me_variable vars[] = {{"a"}, {"b"}};
     int err;
 
-    // Compile expression
-    me_expr *expr = me_compile(expr_str, vars, 2, result, total_size, ME_FLOAT64, &err);
+    // Compile expression for chunked evaluation
+    me_expr *expr = me_compile_chunk(expr_str, vars, 2, ME_FLOAT64, &err);
     if (!expr) {
         printf("Failed to compile expression\n");
         free(a);
@@ -41,11 +42,12 @@ void benchmark_expression(const char *expr_str, int total_size, int chunk_size)
         return;
     }
 
-    // Benchmark 1: Monolithic evaluation
+    // Benchmark 1: Monolithic evaluation (using me_eval_chunk with full array)
     const int iterations = 10;
     double start = get_time();
     for (int iter = 0; iter < iterations; iter++) {
-        me_eval(expr);
+        const void *vars_full[2] = {a, b};
+        me_eval_chunk(expr, vars_full, 2, result, total_size);
     }
     double monolithic_time = (get_time() - start) / iterations;
 

bench/benchmark_mixed_types.c

@@ -33,8 +33,8 @@ void benchmark_mixed_types(const char *expr_str, ExprType expr_type, int nitems)
 
     // MiniExpr with type promotion
     me_variable vars[] = {
-        {"a", a_i64, ME_VARIABLE, NULL, ME_INT64},
-        {"b", b_f32, ME_VARIABLE, NULL, ME_FLOAT32}
+        {"a", ME_INT64, a_i64},
+        {"b", ME_FLOAT32, b_f32}
     };
 
     int err;

bench/benchmark_threadsafe.c

@@ -53,10 +53,10 @@ void benchmark_threads(const char *expr_str, int total_size, int num_threads) {
         b[i] = (total_size - i) * 0.05;
     }
 
-    // Compile
-    me_variable vars[] = {{"a", a}, {"b", b}};
+    // Variables for compilation (just the names)
+    me_variable vars[] = {{"a"}, {"b"}};
     int err;
-    me_expr *expr = me_compile(expr_str, vars, 2, result, total_size, ME_FLOAT64, &err);
+    me_expr *expr = me_compile_chunk(expr_str, vars, 2, ME_FLOAT64, &err);
     if (!expr) {
         printf("Failed to compile\n");
         free(a);
@@ -70,7 +70,8 @@ void benchmark_threads(const char *expr_str, int total_size, int num_threads) {
     // Benchmark serial evaluation
     double serial_start = get_time();
     for (int iter = 0; iter < iterations; iter++) {
-        me_eval(expr);
+        const void *vars_full[2] = {a, b};
+        me_eval_chunk(expr, vars_full, 2, result, total_size);
     }
     double serial_time = (get_time() - serial_start) / iterations;
 

bench/benchmark_types.c

@@ -46,7 +46,7 @@ void benchmark_expression(const char *type_name, me_dtype dtype, int use_double,
             }
         }
 
-        me_variable vars[] = {{"a", a}, {"b", b}};
+        me_variable vars[] = {{"a", dtype, a}, {"b", dtype, b}};
         int err;
 
         printf("\n--- Vector size: %d, iterations: %d ---\n", n, iterations);

check-whitespace.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+#
+# Script to check for and optionally fix trailing whitespace
+# Usage:
+#   ./check-whitespace.sh        # Check only
+#   ./check-whitespace.sh --fix  # Fix trailing whitespace
+#
+
+FIX=0
+if [ "$1" = "--fix" ] || [ "$1" = "-f" ]; then
+    FIX=1
+fi
+
+# Find files with trailing whitespace
+FILES=$(find . -type f \( -name '*.c' -o -name '*.h' -o -name '*.md' \) \
+    -not -path './build/*' \
+    -not -path './.git/*' \
+    -exec grep -l ' $' {} \; 2>/dev/null)
+
+if [ -z "$FILES" ]; then
+    echo "✅ No trailing whitespace found"
+    exit 0
+fi
+
+if [ $FIX -eq 1 ]; then
+    echo "🔧 Fixing trailing whitespace in:"
+    echo "$FILES" | sed 's/^/  /'
+    find . -type f \( -name '*.c' -o -name '*.h' -o -name '*.md' \) \
+        -not -path './build/*' \
+        -not -path './.git/*' \
+        -exec sed -i '' 's/[[:space:]]*$//' {} \;
+    echo "✅ Fixed!"
+    exit 0
+else
+    echo "❌ Trailing whitespace found in:"
+    echo "$FILES" | sed 's/^/  /'
+    echo ""
+    echo "To fix, run:"
+    echo "  $0 --fix"
+    exit 1
+fi