ccharts 3.0.0

data/ext/ccharts/vendor/ccharts_abi.c

@@ -0,0 +1,620 @@
+/* Generated by scripts/sync_sources.py from abi/ccharts_abi.c — do not edit.
+ * Change the original and re-run the script. */
+/*
+ * ccharts_abi.c — the one translation unit that instantiates ccharts.h.
+ *
+ * Everything here is marshalling and validation; no chart logic lives in this
+ * file. The internals reused from the header (cc_dim_ok, cc_trim_whitespace,
+ * cc_parse_ts, ...) are visible because CCHARTS_IMPLEMENTATION is defined
+ * below, which is precisely why this layer has to exist at all.
+ */
+
+/* ccharts.h calls gmtime_r, which is POSIX rather than ISO C: under a strict
+ * dialect (-std=c99 -pedantic, which is what Rust's cc crate and several
+ * package builds default to) glibc would hide the declaration. Requesting the
+ * POSIX feature set here keeps every consumer's flags free of it. MSVC uses
+ * gmtime_s and needs nothing. */
+#if !defined(_WIN32) && !defined(_POSIX_C_SOURCE)
+#define _POSIX_C_SOURCE 200809L
+#endif
+
+#define CCHARTS_IMPLEMENTATION
+#include "ccharts.h"
+
+#include <math.h>
+#include <limits.h>
+
+#include "ccharts_abi.h"
+
+struct ccharts_data {
+    cc_ohlc_t* rows;
+    int32_t n;
+};
+
+/* Largest candle count the C library can carry (it uses int for the size). */
+#define CCHARTS_MAX_ROWS ((int32_t)(INT_MAX / (int)sizeof(cc_ohlc_t)))
+
+/* ---------------------------- Building data ---------------------------- */
+
+/* Wraps an already-parsed cc_ohlc_t array, taking ownership of it. */
+static ccharts_status wrap_rows(cc_ohlc_t* rows, int32_t n, ccharts_data** out) {
+    ccharts_data* data = (ccharts_data*)malloc(sizeof(ccharts_data));
+    if (data == NULL) {
+        free(rows);
+        return CCHARTS_ERR_NOMEM;
+    }
+    data->rows = rows;
+    data->n = n;
+    *out = data;
+    return CCHARTS_OK;
+}
+
+int32_t ccharts_from_arrays(const double* open, const double* high,
+                                   const double* low, const double* close,
+                                   const int64_t* ts, int32_t n,
+                                   ccharts_data** out) {
+    cc_ohlc_t* rows;
+    int32_t i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (open == NULL || high == NULL || low == NULL || close == NULL) {
+        return CCHARTS_ERR_INVALID_ARG;
+    }
+    if (n <= 0 || n > CCHARTS_MAX_ROWS) return CCHARTS_ERR_INVALID_ARG;
+
+    for (i = 0; i < n; i++) {
+        if (!isfinite(open[i]) || !isfinite(high[i]) ||
+            !isfinite(low[i]) || !isfinite(close[i])) {
+            return CCHARTS_ERR_NON_FINITE;
+        }
+    }
+
+    rows = (cc_ohlc_t*)calloc((size_t)n, sizeof(cc_ohlc_t));
+    if (rows == NULL) return CCHARTS_ERR_NOMEM;
+
+    for (i = 0; i < n; i++) {
+        rows[i].open = open[i];
+        rows[i].high = high[i];
+        rows[i].low = low[i];
+        rows[i].close = close[i];
+        rows[i].timestamp = (ts != NULL) ? (long long)ts[i] : 0;
+    }
+    return wrap_rows(rows, n, out);
+}
+
+int32_t ccharts_parse_json(const char* json, ccharts_data** out) {
+    cc_ohlc_t* rows = NULL;
+    int n = 0;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (json == NULL) return CCHARTS_ERR_INVALID_ARG;
+
+    if (cc_json_to_ohlc(json, &rows, &n) != 0 || n <= 0) {
+        free(rows);
+        return CCHARTS_ERR_PARSE;
+    }
+    return wrap_rows(rows, (int32_t)n, out);
+}
+
+/* Counts the lines cc_str_to_ohlc would actually store: a line contributes a
+ * candle when it holds at least one non-whitespace character (it trims with
+ * cc_trim_whitespace and skips what is left empty). */
+static int32_t count_csv_rows(const char* csv, char line_separator) {
+    int32_t rows = 0;
+    int has_content = 0;
+    const char* p;
+
+    for (p = csv; ; p++) {
+        if (*p == '\0' || *p == line_separator) {
+            if (has_content) {
+                if (rows == CCHARTS_MAX_ROWS) return rows;
+                rows++;
+            }
+            has_content = 0;
+            if (*p == '\0') break;
+        } else if (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\r') {
+            has_content = 1;
+        }
+    }
+    return rows;
+}
+
+int32_t ccharts_parse_csv(const char* csv, char value_separator,
+                                 char line_separator, ccharts_data** out) {
+    cc_ohlc_t* rows = NULL;
+    int32_t n;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (csv == NULL || value_separator == '\0' || line_separator == '\0') {
+        return CCHARTS_ERR_INVALID_ARG;
+    }
+
+    n = count_csv_rows(csv, line_separator);
+    if (n <= 0) return CCHARTS_ERR_PARSE;
+
+    if (cc_str_to_ohlc(csv, (int)n, &rows, value_separator, line_separator) != 0) {
+        free(rows);
+        return CCHARTS_ERR_NOMEM;
+    }
+    return wrap_rows(rows, n, out);
+}
+
+int32_t ccharts_data_len(const ccharts_data* data) {
+    return (data != NULL) ? data->n : 0;
+}
+
+void ccharts_data_free(ccharts_data* data) {
+    if (data != NULL) {
+        free(data->rows);
+        free(data);
+    }
+}
+
+/* ------------------------------ Rendering ------------------------------ */
+
+typedef char* (*cc_renderer)(const cc_ohlc_t*, int, int, int, const cc_settings_t*);
+
+static ccharts_status render(cc_renderer draw, const ccharts_data* data,
+                             int32_t width, int32_t height,
+                             const ccharts_settings* settings,
+                             char** out, size_t* out_len) {
+    cc_settings_t resolved = {0};
+    char* chart;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (data == NULL || data->rows == NULL || data->n <= 0) {
+        return CCHARTS_ERR_INVALID_ARG;
+    }
+    /* ccharts.h answers invalid dimensions with an empty string; the ABI
+     * reports them instead, using the library's own bounds check. */
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    if (settings != NULL) {
+        resolved.rise_color = settings->rise_color;
+        resolved.fall_color = settings->fall_color;
+        resolved.bg_color = settings->bg_color;
+        resolved.area_color = settings->area_color;
+        resolved.single_color = (int)settings->single_color;
+        resolved.show_prices = (int)settings->show_prices;
+        resolved.show_times = (int)settings->show_times;
+    }
+
+    chart = draw(data->rows, (int)data->n, (int)width, (int)height, &resolved);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+int32_t ccharts_line(const ccharts_data* data, int32_t width,
+                            int32_t height, const ccharts_settings* settings,
+                            char** out, size_t* out_len) {
+    return render(cc_line_create, data, width, height, settings, out, out_len);
+}
+
+int32_t ccharts_candle(const ccharts_data* data, int32_t width,
+                              int32_t height, const ccharts_settings* settings,
+                              char** out, size_t* out_len) {
+    return render(cc_candle_create, data, width, height, settings, out, out_len);
+}
+
+void ccharts_string_free(char* s) {
+    free(s);
+}
+
+/* -------------------------------- Pie -------------------------------- */
+
+/* Copies the caller's per-slice palette into a NULL-terminated array, which
+ * is what cc_pie_settings_t expects; returns CCHARTS_OK and leaves *out
+ * pointing at the copy (free with free()) or NULL for the default palette. */
+static ccharts_status resolve_pie_colors(const char* const* colors,
+                                         int32_t color_count,
+                                         const char*** out) {
+    const char** copy;
+    int32_t i;
+
+    *out = NULL;
+    if (colors == NULL || color_count <= 0) return CCHARTS_OK;
+
+    copy = (const char**)calloc((size_t)color_count + 1, sizeof(const char*));
+    if (copy == NULL) return CCHARTS_ERR_NOMEM;
+    for (i = 0; i < color_count; i++) copy[i] = colors[i];
+    *out = copy;
+    return CCHARTS_OK;
+}
+
+int32_t ccharts_pie_from_slices(const ccharts_pie_slice* slices, int32_t count,
+                                int32_t width, int32_t height,
+                                int32_t donut,
+                                const char* const* colors, int32_t color_count,
+                                int32_t show_legend, int32_t show_pct,
+                                double slice_gap, double inner_radius_ratio,
+                                int32_t legend_format, double start_angle,
+                                int32_t counter_clockwise,
+                                const char* center_text,
+                                char** out, size_t* out_len) {
+    cc_pie_settings_t ps;
+    cc_pie_slice_t* slice_rows = NULL;
+    const char** resolved_colors = NULL;
+    ccharts_status status;
+    char* chart;
+    int32_t i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (slices == NULL || count <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    /* NaN/inf must not reach the renderer: cc_pie_create guards values with a
+     * positive-range check, but +inf would slip through (inf > 0 is true) and
+     * corrupt the angle math, and non-finite option doubles (slice_gap,
+     * inner_radius_ratio, start_angle) would poison the geometry. Mirror the
+     * ABI's finite guard for prices. */
+    for (i = 0; i < count; i++) {
+        if (!isfinite(slices[i].value)) return CCHARTS_ERR_NON_FINITE;
+    }
+    if (!isfinite(slice_gap) || !isfinite(inner_radius_ratio) ||
+        !isfinite(start_angle)) {
+        return CCHARTS_ERR_NON_FINITE;
+    }
+
+    status = resolve_pie_colors(colors, color_count, &resolved_colors);
+    if (status != CCHARTS_OK) return status;
+
+    slice_rows = (cc_pie_slice_t*)calloc((size_t)count, sizeof(cc_pie_slice_t));
+    if (slice_rows == NULL) {
+        free(resolved_colors);
+        return CCHARTS_ERR_NOMEM;
+    }
+    for (i = 0; i < count; i++) {
+        slice_rows[i].label = slices[i].label;
+        slice_rows[i].value = slices[i].value;
+    }
+
+    memset(&ps, 0, sizeof(ps));
+    ps.colors = resolved_colors;
+    ps.donut = (int)donut;
+    ps.show_legend = (int)show_legend;
+    ps.show_pct = (int)show_pct;
+    ps.slice_gap = slice_gap;
+    ps.inner_radius_ratio = inner_radius_ratio;
+    ps.legend_format = (int)legend_format;
+    ps.start_angle = start_angle;
+    ps.counter_clockwise = (int)counter_clockwise;
+    ps.center_text = center_text;
+
+    chart = cc_pie_create(slice_rows, (int)count, (int)width, (int)height, &ps);
+    free(slice_rows);
+    free(resolved_colors);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ------------------------------ Histogram ------------------------------ */
+
+int32_t ccharts_hist(const double* samples, int32_t count,
+                     int32_t width, int32_t height,
+                     const ccharts_hist_settings* settings,
+                     char** out, size_t* out_len) {
+    cc_hist_settings_t hs;
+    char* chart;
+    int32_t i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (samples == NULL || count <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    for (i = 0; i < count; i++) {
+        if (!isfinite(samples[i])) return CCHARTS_ERR_NON_FINITE;
+    }
+
+    memset(&hs, 0, sizeof(hs));
+    if (settings != NULL) {
+        hs.rise_color = settings->rise_color;
+        hs.bg_color = settings->bg_color;
+        hs.bin_count = (int)settings->bin_count;
+        hs.min_value = settings->min_value;
+        hs.max_value = settings->max_value;
+        hs.show_bins = (int)settings->show_bins;
+        hs.show_prices = (int)settings->show_prices;
+        /* NaN min/max is the "auto" sentinel (allowed); inf must not reach
+         * the binned geometry, so reject any other non-finite value. */
+        if (settings->min_value == settings->min_value &&
+            !isfinite(settings->min_value)) return CCHARTS_ERR_NON_FINITE;
+        if (settings->max_value == settings->max_value &&
+            !isfinite(settings->max_value)) return CCHARTS_ERR_NON_FINITE;
+    } else {
+        hs.bin_count = 0;                 /* auto */
+        hs.min_value = 0.0 / 0.0;         /* auto sentinel (NaN) */
+        hs.max_value = 0.0 / 0.0;         /* auto sentinel (NaN) */
+    }
+
+    chart = cc_hist_create(samples, (int)count, (int)width, (int)height, &hs);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ------------------------------ Sparkline ------------------------------ */
+
+int32_t ccharts_spark(const double* samples, int32_t count,
+                      int32_t width, int32_t height,
+                      const ccharts_spark_settings* settings,
+                      char** out, size_t* out_len) {
+    cc_spark_settings_t ss;
+    char* chart;
+    int32_t i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (samples == NULL || count <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    /* NaN/inf samples would poison the column-average min/max math (and
+     * lround in the mapping), so reject them at the boundary like every
+     * other price path. */
+    for (i = 0; i < count; i++) {
+        if (!isfinite(samples[i])) return CCHARTS_ERR_NON_FINITE;
+    }
+
+    memset(&ss, 0, sizeof(ss));
+    if (settings != NULL) {
+        ss.rise_color = settings->rise_color;
+        ss.area_color = settings->area_color;
+        ss.min_above = (int)settings->min_above;
+        ss.min_below = (int)settings->min_below;
+    }
+
+    chart = cc_spark_create(samples, (int)count, (int)width, (int)height, &ss);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ------------------------------ Bar chart ------------------------------ */
+
+int32_t ccharts_bar(const ccharts_bar_slice* items, int32_t count,
+                    int32_t width, int32_t height,
+                    const ccharts_bar_settings* settings,
+                    char** out, size_t* out_len) {
+    cc_bar_settings_t bs;
+    char* chart;
+    int32_t i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (items == NULL || count <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    /* NaN/inf bar values would poison the column max/min math (and lround in
+     * the pixel mapping), so reject them at the boundary like every other
+     * price path. Negative values are clamped to zero by the renderer, not
+     * rejected. */
+    for (i = 0; i < count; i++) {
+        if (!isfinite(items[i].value)) return CCHARTS_ERR_NON_FINITE;
+    }
+
+    memset(&bs, 0, sizeof(bs));
+    if (settings != NULL) {
+        bs.rise_color = settings->rise_color;
+        bs.bg_color = settings->bg_color;
+        bs.show_labels = (int)settings->show_labels;
+        bs.show_prices = (int)settings->show_prices;
+    }
+
+    /* ccharts_bar_slice and cc_bar_item_t have identical {label, value}
+     * layout; a cast (rather than a copy) hand is all the FFI needs. */
+    chart = cc_bar_create((const cc_bar_item_t*)items, (int)count,
+                          (int)width, (int)height, &bs);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ---------------------------- Stacked bar chart -------------------------- */
+
+int32_t ccharts_stack(const ccharts_stack_series* series, int32_t series_count,
+                      int32_t width, int32_t height,
+                      const ccharts_stack_settings* settings,
+                      char** out, size_t* out_len) {
+    cc_stack_settings_t ss;
+    char* chart;
+    int32_t cats, s, c;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    /* settings is required here: the values lengths are carried only by
+     * settings->cats, so a NULL settings is a marshalling error, not a
+     * "use defaults" signal. */
+    if (series == NULL || series_count <= 0 || settings == NULL ||
+        settings->cats <= 0) {
+        return CCHARTS_ERR_INVALID_ARG;
+    }
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    cats = (int32_t)settings->cats;
+    /* The settings->series count, when supplied, must agree with the
+     * argument (a 2-D marshalling sanity check for the bindings). */
+    if (settings->series > 0 && settings->series != series_count) {
+        return CCHARTS_ERR_INVALID_ARG;
+    }
+
+    /* NaN/inf stack values would poison the column-total / pixel math, so
+     * reject them at the boundary like every other price path. Negative
+     * values are clamped to zero by the renderer, not rejected. */
+    for (s = 0; s < series_count; s++) {
+        if (series[s].values == NULL) return CCHARTS_ERR_INVALID_ARG;
+        for (c = 0; c < cats; c++) {
+            if (!isfinite(series[s].values[c])) return CCHARTS_ERR_NON_FINITE;
+        }
+    }
+
+    memset(&ss, 0, sizeof(ss));
+    ss.colors = settings->colors;
+    ss.bg_color = settings->bg_color;
+    ss.cat_labels = settings->cat_labels;
+    ss.series = (int)settings->series;
+    ss.cats = (int)cats;
+    ss.show_labels = (int)settings->show_labels;
+    ss.show_prices = (int)settings->show_prices;
+
+    /* ccharts_stack_series and cc_stack_series_t have identical {name,
+     * values} layout; a cast (rather than a copy hand) is all the FFI needs. */
+    chart = cc_stack_create((const cc_stack_series_t*)series, (int)series_count,
+                            (int)width, (int)height, &ss);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ------------------------------ Heatmap chart ---------------------------- */
+
+int32_t ccharts_heat(const double* values, int32_t rows, int32_t cols,
+                     int32_t width, int32_t height,
+                     const ccharts_heat_settings* settings,
+                     char** out, size_t* out_len) {
+    cc_heat_settings_t hs;
+    char* chart;
+    int64_t n, i;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (values == NULL || rows <= 0 || cols <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    /* NaN/inf values would poison the min/max and block-average math (and
+     * lround in the colour mapping), so reject them at the boundary like
+     * every other price path. Counted in 64-bit: rows*cols is not bounded
+     * by cc_dim_ok (only width/height are). */
+    n = (int64_t)rows * (int64_t)cols;
+    for (i = 0; i < n; i++) {
+        if (!isfinite(values[i])) return CCHARTS_ERR_NON_FINITE;
+    }
+
+    memset(&hs, 0, sizeof(hs));
+    if (settings != NULL) {
+        hs.low_color = settings->low_color;
+        hs.high_color = settings->high_color;
+        hs.mid_color = settings->mid_color;
+        hs.bg_color = settings->bg_color;
+        hs.row_labels = settings->row_labels;
+        hs.col_labels = settings->col_labels;
+        hs.show_labels = (int)settings->show_labels;
+    }
+
+    /* The caller's row-major values array matches cc_heat_create's layout
+     * exactly, so no copy is needed as long as it stays valid for the call. */
+    chart = cc_heat_create(values, (int)rows, (int)cols,
+                           (int)width, (int)height, &hs);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ------------------------------ Box plot ------------------------------ */
+
+int32_t ccharts_box(const ccharts_box_category* cats, int32_t cat_count,
+                    int32_t width, int32_t height,
+                    const ccharts_box_settings* settings,
+                    char** out, size_t* out_len) {
+    cc_box_settings_t bs;
+    char* chart;
+    int32_t c;
+
+    if (out == NULL) return CCHARTS_ERR_INVALID_ARG;
+    *out = NULL;
+    if (out_len != NULL) *out_len = 0;
+    if (cats == NULL || cat_count <= 0) return CCHARTS_ERR_INVALID_ARG;
+    if (!cc_dim_ok((int)width, (int)height)) return CCHARTS_ERR_DIMENSIONS;
+
+    /* A NULL samples array or n <= 0 is a marshalling error (no five-number
+     * summary without samples), and NaN/inf samples would poison the sort /
+     * nearest-rank / pixel math, so both are rejected at the boundary.
+     * Negative values are fine — a box has no zero baseline. */
+    for (c = 0; c < cat_count; c++) {
+        int32_t k;
+        if (cats[c].samples == NULL || cats[c].n <= 0) {
+            return CCHARTS_ERR_INVALID_ARG;
+        }
+        for (k = 0; k < cats[c].n; k++) {
+            if (!isfinite(cats[c].samples[k])) return CCHARTS_ERR_NON_FINITE;
+        }
+    }
+
+    memset(&bs, 0, sizeof(bs));
+    if (settings != NULL) {
+        bs.rise_color = settings->rise_color;
+        bs.area_color = settings->area_color;
+        bs.bg_color = settings->bg_color;
+        bs.show_prices = (int)settings->show_prices;
+    }
+
+    /* ccharts_box_category and cc_box_category_t have identical {name,
+     * samples, n} layout; a cast (rather than a copy hand) is all the FFI
+     * needs. */
+    chart = cc_box_create((const cc_box_category_t*)cats, (int)cat_count,
+                          (int)width, (int)height, &bs);
+    if (chart == NULL) return CCHARTS_ERR_NOMEM;
+
+    *out = chart;
+    if (out_len != NULL) *out_len = strlen(chart);
+    return CCHARTS_OK;
+}
+
+/* ---------------------------- Introspection ---------------------------- */
+
+const char* ccharts_color(int32_t index) {
+    static const char* const table[CCHARTS_COLOR_COUNT] = {
+        CC_COLOR_BLACK, CC_COLOR_RED, CC_COLOR_GREEN, CC_COLOR_YELLOW,
+        CC_COLOR_BLUE, CC_COLOR_MAGENTA, CC_COLOR_CYAN, CC_COLOR_WHITE,
+        CC_COLOR_BRIGHT_BLACK, CC_COLOR_BRIGHT_RED, CC_COLOR_BRIGHT_GREEN,
+        CC_COLOR_BRIGHT_YELLOW, CC_COLOR_BRIGHT_BLUE, CC_COLOR_BRIGHT_MAGENTA,
+        CC_COLOR_BRIGHT_CYAN, CC_COLOR_BRIGHT_WHITE, CC_COLOR_RESET
+    };
+    if (index < 0 || index >= CCHARTS_COLOR_COUNT) return NULL;
+    return table[index];
+}
+
+const char* ccharts_error_message(int32_t status) {
+    switch (status) {
+        case CCHARTS_OK:              return "ok";
+        case CCHARTS_ERR_INVALID_ARG: return "invalid argument";
+        case CCHARTS_ERR_PARSE:       return "could not parse the input data";
+        case CCHARTS_ERR_NOMEM:       return "out of memory";
+        case CCHARTS_ERR_NON_FINITE:  return "OHLC values must be finite (no NaN or inf)";
+        case CCHARTS_ERR_DIMENSIONS:  return "width and height must be positive and within the limits";
+        default:                      return "unknown error";
+    }
+}
+
+const char* ccharts_version(void) { return CCHARTS_VERSION; }
+
+int32_t ccharts_max_dim(void) { return (int32_t)CC_MAX_DIM; }
+
+int32_t ccharts_max_cells(void) { return (int32_t)CC_MAX_CELLS; }