template.c

Go to the documentation of this file.

#include "cwist/core/template/template.h"
#include <cwist/core/mem/alloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
 
static cwist_sstring *render_internal(const char **template_str, const cJSON *context, int depth);
 
#define CWIST_TEMPLATE_MAX_DEPTH 32
 
static void html_escape(const char *value, char *out, size_t out_len) {
    if (!value || out_len == 0) return;
    size_t i, j;
    for (i = 0, j = 0; value[i] && j < out_len - 1; i++) {
        const char *repl = NULL;
        switch (value[i]) {
            case '&': repl = "&amp;"; break;
            case '<': repl = "&lt;"; break;
            case '>': repl = "&gt;"; break;
            case '"': repl = "&quot;"; break;
            case '\'': repl = "&#39;"; break;
            default: break;
        }
        if (repl) {
            size_t rlen = strlen(repl);
            if (j + rlen >= out_len) break;
            memcpy(out + j, repl, rlen);
            j += rlen;
        } else {
            out[j++] = value[i];
        }
    }
    out[j] = '\0';
}
 
static void apply_filter(const char *value, const char *filter, char *out, size_t out_len) {
    if (!filter || out_len == 0) return;
    if (strcmp(filter, "upper") == 0) {
        size_t i;
        for (i = 0; i < out_len - 1 && value && value[i]; i++)
            out[i] = (char)toupper((unsigned char)value[i]);
        out[i] = '\0';
    } else if (strcmp(filter, "lower") == 0) {
        size_t i;
        for (i = 0; i < out_len - 1 && value && value[i]; i++)
            out[i] = (char)tolower((unsigned char)value[i]);
        out[i] = '\0';
    } else if (strcmp(filter, "escape") == 0 || strcmp(filter, "e") == 0) {
        html_escape(value, out, out_len);
    } else if (strcmp(filter, "trim") == 0) {
        if (!value || value[0] == '\0') {
            out[0] = '\0';
            return;
        }
        const char *s = value;
        while (isspace((unsigned char)*s)) s++;
        /* Guard against all-whitespace input: s may have advanced past the
         * last character, making e = value + vlen - 1 < s. */
        size_t vlen = strlen(value);
        const char *e = value + vlen - 1;
        while (e > s && isspace((unsigned char)*e)) e--;
        size_t len = (s > e) ? 0 : (size_t)(e - s + 1);
        if (len >= out_len) len = out_len - 1;
        memcpy(out, s, len);
        out[len] = '\0';
    } else if (strcmp(filter, "length") == 0 || strcmp(filter, "len") == 0) {
        snprintf(out, out_len, "%zu", value ? strlen(value) : 0);
    } else if (strncmp(filter, "default", 7) == 0) {
        const char *arg = NULL;
        const char *lp = strchr(filter, '(');
        const char *rp = strrchr(filter, ')');
        if (lp && rp && rp > lp) {
            arg = lp + 1;
        }
        if (value && value[0]) {
            snprintf(out, out_len, "%s", value);
        } else if (arg) {
            size_t arg_len = (size_t)(rp - arg);
            if (arg_len >= out_len) arg_len = out_len - 1;
            memcpy(out, arg, arg_len);
            out[arg_len] = '\0';
        } else {
            out[0] = '\0';
        }
    } else {
        if (value) {
            snprintf(out, out_len, "%s", value);
        } else {
            out[0] = '\0';
        }
    }
}
 
static const cJSON *get_value_from_context(const cJSON *context, const char *key) {
    if (!context || !key) return NULL;
 
    // Handle the special case of "." referring to the current context in a loop
    if (strcmp(key, ".") == 0) {
        return context;
    }
 
    char *key_copy = cwist_strdup(key);
    if (!key_copy) return NULL;
    char *ptr_to_free = key_copy;
    char *saveptr = NULL;
    char *token = strtok_r(key_copy, ".", &saveptr);
    const cJSON *current = context;
 
    while (token != NULL) {
        if (!cJSON_IsObject(current)) {
            current = NULL;
            break;
        }
        current = cJSON_GetObjectItem(current, token);
        if (!current) break;
        token = strtok_r(NULL, ".", &saveptr);
    }
 
    cwist_free(ptr_to_free);
    return current;
}
 
static cwist_sstring *render_internal(const char **template_str, const cJSON *context, int depth) {
    if (!template_str || !*template_str || depth > CWIST_TEMPLATE_MAX_DEPTH) return NULL;
 
    cwist_sstring *output = cwist_sstring_create();
    if (!output) return NULL;
    const char *p = *template_str;
    const char *start = p;
 
    while (*p) {
        if (p[0] == '{' && p[1] == '#') {
            /* Comment: {# ... #} -- skip silently. */
            cwist_sstring_append_len(output, start, p - start);
            p += 2;
            while (*p && !(p[0] == '#' && p[1] == '}')) p++;
            if (p[0] == '#' && p[1] == '}') p += 2;
            start = p;
            continue;
        }
        if (p[0] == '{' && (p[1] == '{' || p[1] == '%')) {
            /* Append text since last tag */
            cwist_sstring_append_len(output, start, p - start);
 
            if (p[1] == '{') { /* Variable: {{ key [| filter] }} */
                p += 2;
                const char *var_start = p;
                while (*p && (p[0] != '}' || p[1] != '}')) p++;
 
                char var_buf[256] = {0};
                size_t var_len = (size_t)(p - var_start);
                if (var_len >= sizeof(var_buf)) var_len = sizeof(var_buf) - 1;
                memcpy(var_buf, var_start, var_len);
 
                char *trimmed_var = var_buf;
                while (*trimmed_var == ' ') trimmed_var++;
                char *end = trimmed_var + strlen(trimmed_var) - 1;
                while (end > trimmed_var && *end == ' ') *end-- = '\0';
 
                char *filter = NULL;
                char *pipe = strstr(trimmed_var, "|");
                if (pipe) {
                    *pipe = '\0';
                    char *ve = pipe - 1;
                    while (ve >= trimmed_var && isspace((unsigned char)*ve)) *ve-- = '\0';
                    filter = pipe + 1;
                    while (*filter == ' ') filter++;
                    char *fe = filter + strlen(filter) - 1;
                    while (fe > filter && *fe == ' ') *fe-- = '\0';
                }
 
                const cJSON *value = get_value_from_context(context, trimmed_var);
                if (value) {
                    char num_str[64] = {0};
                    const char *raw = NULL;
                    if (cJSON_IsString(value)) {
                        raw = value->valuestring;
                    } else if (cJSON_IsNumber(value)) {
                        snprintf(num_str, sizeof(num_str), "%g", value->valuedouble);
                        raw = num_str;
                    } else if (cJSON_IsTrue(value)) {
                        raw = "true";
                    } else if (cJSON_IsFalse(value)) {
                        raw = "false";
                    }
                    if (raw) {
                        if (filter) {
                            char filtered[512] = {0};
                            apply_filter(raw, filter, filtered, sizeof(filtered));
                            cwist_sstring_append(output, filtered);
                        } else {
                            cwist_sstring_append(output, raw);
                        }
                    }
                }
                p += 2;
                start = p;
 
            } else if (p[1] == '%') { /* Tag: {% ... %} */
                p += 2;
                const char *tag_start = p;
                while (*p && (p[0] != '%' || p[1] != '}')) p++;
 
                char tag[256] = {0};
                size_t tag_len = (size_t)(p - tag_start);
                if (tag_len >= sizeof(tag)) tag_len = sizeof(tag) - 1;
                memcpy(tag, tag_start, tag_len);
 
                char *tag_saveptr = NULL;
                char *cmd = strtok_r(tag, " \t\n", &tag_saveptr);
                if (!cmd) {
                    p += 2;
                    start = p;
                    continue;
                }
 
                if (strcmp(cmd, "if") == 0) {
                    char *tok = strtok_r(NULL, " \t\n", &tag_saveptr);
                    bool negate = false;
                    if (tok && strcmp(tok, "not") == 0) {
                        negate = true;
                        tok = strtok_r(NULL, " \t\n", &tag_saveptr);
                    }
                    const cJSON *val = tok ? get_value_from_context(context, tok) : NULL;
                    bool cond = false;
                    if (val) {
                        cond = cJSON_IsTrue(val) ||
                               (cJSON_IsString(val) && strlen(val->valuestring) > 0) ||
                               (cJSON_IsObject(val) && cJSON_GetArraySize(val) > 0) ||
                               (cJSON_IsArray(val) && cJSON_GetArraySize(val) > 0) ||
                               (cJSON_IsNumber(val) && val->valuedouble != 0);
                    }
                    if (negate) cond = !cond;
 
                    const char *block_start = p + 2;
                    const char *else_pos = NULL;
                    const char *block_end = NULL;
                    const char *scan = block_start;
                    int nested = 0;
                    while (*scan) {
                        if (scan[0] == '{' && scan[1] == '%') {
                            const char *inner = scan + 2;
                            while (*inner == ' ' || *inner == '\t' || *inner == '\n') inner++;
                            if (strncmp(inner, "if ", 3) == 0 || strncmp(inner, "if\t", 3) == 0 ||
                                strncmp(inner, "if\n", 3) == 0) {
                                nested++;
                            } else if (strncmp(inner, "endif", 5) == 0) {
                                if (nested == 0) {
                                    block_end = scan;
                                    break;
                                }
                                nested--;
                            } else if (!else_pos && nested == 0 && strncmp(inner, "else", 4) == 0 &&
                                       (inner[4] == ' ' || inner[4] == '\t' || inner[4] == '\n' ||
                                        inner[4] == '%')) {
                                else_pos = scan;
                            }
                        }
                        scan++;
                    }
 
                    if (cond) {
                        const char *block_p = block_start;
                        cwist_sstring *rendered_block =
                            render_internal(&block_p, context, depth + 1);
                        if (rendered_block) {
                            cwist_sstring_append(output, rendered_block->data);
                            cwist_sstring_destroy(rendered_block);
                        }
                    } else if (else_pos) {
                        const char *else_close = strstr(else_pos, "%}");
                        const char *else_p =
                            else_close ? else_close + 2 : else_pos + strlen("{% else %}");
                        cwist_sstring *rendered_block =
                            render_internal(&else_p, context, depth + 1);
                        if (rendered_block) {
                            cwist_sstring_append(output, rendered_block->data);
                            cwist_sstring_destroy(rendered_block);
                        }
                    }
 
                    if (block_end) {
                        const char *endif_close = strstr(block_end, "%}");
                        p = endif_close ? endif_close + 2 : block_end + strlen("{% endif %}");
                    } else {
                        p += 2;
                    }
                    start = p;
 
                } else if (strcmp(cmd, "for") == 0) {
                    char *item_name = strtok_r(NULL, " \t\n", &tag_saveptr);
                    strtok_r(NULL, " \t\n", &tag_saveptr); /* "in" */
                    char *array_name = strtok_r(NULL, " \t\n", &tag_saveptr);
 
                    const cJSON *array = (array_name && context)
                                             ? get_value_from_context(context, array_name)
                                             : NULL;
 
                    const char *block_start = p + 2;
                    /* Scan for the matching endfor, counting nested for tags
                     * so that {% for %}...{% for %}...{% endfor %}...{% endfor %}
                     * is handled correctly. */
                    const char *block_end = NULL;
                    {
                        const char *scan = block_start;
                        int depth = 0;
                        while (*scan) {
                            if (scan[0] == '{' && scan[1] == '%') {
                                const char *tag = scan + 2;
                                while (*tag == ' ' || *tag == '\t' || *tag == '\n') tag++;
                                if (strncmp(tag, "for ", 4) == 0 ||
                                    strncmp(tag, "for\t", 4) == 0 ||
                                    strncmp(tag, "for\n", 4) == 0) {
                                    depth++;
                                } else if (strncmp(tag, "endfor", 6) == 0) {
                                    if (depth == 0) {
                                        block_end = scan;
                                        break;
                                    }
                                    depth--;
                                }
                            }
                            scan++;
                        }
                    }
 
                    if (item_name && cJSON_IsArray(array)) {
                        cJSON *item;
                        cJSON_ArrayForEach(item, array) {
                            cJSON *loop_context = cJSON_Duplicate(context, 1);
                            if (!loop_context) continue;
                            cJSON_AddItemToObject(loop_context, item_name,
                                                  cJSON_Duplicate(item, 1));
 
                            const char *loop_p = block_start;
                            cwist_sstring *rendered_block =
                                render_internal(&loop_p, loop_context, depth + 1);
                            if (rendered_block) {
                                cwist_sstring_append(output, rendered_block->data);
                                cwist_sstring_destroy(rendered_block);
                            }
                            cJSON_Delete(loop_context);
                        }
                    }
                    if (block_end) {
                        const char *endfor_close = strstr(block_end, "%}");
                        p = endfor_close ? endfor_close + 2 : block_end + strlen("{% endfor %}");
                    } else {
                        p += 2;
                    }
                    start = p;
 
                } else if (strcmp(cmd, "include") == 0) {
                    char *inc_cmd = strstr(tag, "include");
                    char *path = inc_cmd ? inc_cmd + strlen("include") : NULL;
                    if (path) {
                        while (*path == ' ' || *path == '\t' || *path == '\n') path++;
                        char *end = path + strlen(path) - 1;
                        while (end > path &&
                               (*end == ' ' || *end == '\t' || *end == '\n' || *end == '"'))
                            *end-- = '\0';
                        if (path[0] == '"') path++;
                        if (path[0]) {
                            cwist_sstring *included = cwist_template_render_file(path, context);
                            if (included) {
                                cwist_sstring_append(output, included->data);
                                cwist_sstring_destroy(included);
                            }
                        }
                    }
                    p += 2;
                    start = p;
 
                } else if (strcmp(cmd, "endif") == 0 || strcmp(cmd, "endfor") == 0 ||
                           strcmp(cmd, "else") == 0) {
                    *template_str = p + 2;
                    return output;
                } else {
                    p += 2;
                    start = p;
                }
            }
        } else {
            p++;
        }
    }
 
    cwist_sstring_append_len(output, start, p - start);
    *template_str = p;
    return output;
}
 
cwist_sstring *cwist_template_render(const char *template_str, const cJSON *context) {
    const char *p = template_str;
    return render_internal(&p, context, 0);
}
 
cwist_sstring *cwist_template_render_file(const char *file_path, const cJSON *context) {
    if (!file_path) return NULL;
    FILE *f = fopen(file_path, "rb");
    if (!f) {
        perror("Failed to open template file");
        return NULL;
    }
 
    fseek(f, 0, SEEK_END);
    long len = ftell(f);
    fseek(f, 0, SEEK_SET);
    if (len < 0) {
        fclose(f);
        return NULL;
    }
 
    char *template_str CWIST_DEFER_FREE = cwist_alloc((size_t)len + 1);
    if (!template_str) {
        fclose(f);
        return NULL;
    }
 
    size_t read_len = fread(template_str, 1, (size_t)len, f);
    template_str[read_len] = '\0';
    fclose(f);
 
    return cwist_template_render(template_str, context);
}