sagui.h

Go to the documentation of this file.

/*                         _
 *   ___  __ _  __ _ _   _(_)
 *  / __|/ _` |/ _` | | | | |
 *  \__ \ (_| | (_| | |_| | |
 *  |___/\__,_|\__, |\__,_|_|
 *             |___/
 *
 * Cross-platform library which helps to develop web servers or frameworks.
 *
 * Copyright (C) 2016-2024 Silvio Clecio <silvioprog@gmail.com>
 *
 * Sagui library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * Sagui library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Sagui library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
#ifndef SAGUI_H
#define SAGUI_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
 
#ifndef SG_EXTERN
#ifdef _WIN32
#ifdef BUILDING_LIBSAGUI
#define SG_EXTERN __declspec(dllexport) extern
#else /* _WIN32 */
#define SG_EXTERN __declspec(dllimport) extern
#endif /* _WIN32 */
#else /* BUILDING_LIBSAGUI */
#define SG_EXTERN extern
#endif /* BUILDING_LIBSAGUI */
#endif /* SG_EXTERN */
 
#ifndef __SG_UNUSED
#define __SG_UNUSED __attribute__((unused))
#endif /* __SG_UNUSED */
 
#ifndef __SG_MALLOC
#define __SG_MALLOC __attribute__((malloc))
#endif /* __SG_MALLOC */
 
#ifndef __SG_FORMAT
#define __SG_FORMAT(...) __attribute__((format(printf, __VA_ARGS__)))
#endif /* __SG_FORMAT */
 
#define SG_VERSION_MAJOR 3
#define SG_VERSION_MINOR 5
#define SG_VERSION_PATCH 0
#define SG_VERSION_HEX                                                         \
  ((SG_VERSION_MAJOR << 16) | (SG_VERSION_MINOR << 8) | (SG_VERSION_PATCH))
 
#define SG_ERR_SIZE 256
 
typedef void *(*sg_malloc_func)(size_t size);
 
typedef void *(*sg_realloc_func)(void *ptr, size_t size);
 
typedef void (*sg_free_func)(void *ptr);
 
typedef double (*sg_pow_func)(double x, double y);
 
typedef double (*sg_fmod_func)(double x, double y);
 
typedef void (*sg_err_cb)(void *cls, const char *err);
 
typedef ssize_t (*sg_write_cb)(void *handle, uint64_t offset, const char *buf,
                               size_t size);
 
typedef ssize_t (*sg_read_cb)(void *handle, uint64_t offset, char *buf,
                              size_t size);
 
typedef void (*sg_free_cb)(void *handle);
 
typedef int (*sg_save_cb)(void *handle, bool overwritten);
 
typedef int (*sg_save_as_cb)(void *handle, const char *path, bool overwritten);
 
SG_EXTERN unsigned int sg_version(void);
 
SG_EXTERN const char *sg_version_str(void);
 
SG_EXTERN int sg_mm_set(sg_malloc_func malloc_func,
                        sg_realloc_func realloc_func, sg_free_func free_func);
 
SG_EXTERN void *sg_malloc(size_t size) __SG_MALLOC;
 
SG_EXTERN void *sg_alloc(size_t size) __SG_MALLOC;
 
SG_EXTERN void *sg_realloc(void *ptr, size_t size) __SG_MALLOC;
 
SG_EXTERN void sg_free(void *ptr);
 
SG_EXTERN int sg_math_set(sg_pow_func pow_func, sg_fmod_func fmod_func);
 
SG_EXTERN char *sg_strerror(int errnum, char *errmsg, size_t errlen);
 
SG_EXTERN bool sg_is_post(const char *method);
 
SG_EXTERN char *sg_extract_entrypoint(const char *path) __SG_MALLOC;
 
SG_EXTERN char *sg_tmpdir(void) __SG_MALLOC;
 
SG_EXTERN ssize_t sg_eor(bool err);
 
SG_EXTERN int sg_ip(const void *socket, char *buf, size_t size);
 
struct sg_str;
 
SG_EXTERN struct sg_str *sg_str_new(void) __SG_MALLOC;
 
SG_EXTERN void sg_str_free(struct sg_str *str);
 
SG_EXTERN int sg_str_write(struct sg_str *str, const char *val, size_t len);
 
SG_EXTERN int sg_str_printf_va(struct sg_str *str, const char *fmt, va_list ap);
 
SG_EXTERN int sg_str_printf(struct sg_str *str, const char *fmt, ...)
  __SG_FORMAT(2, 3);
 
SG_EXTERN const char *sg_str_content(struct sg_str *str);
 
SG_EXTERN size_t sg_str_length(struct sg_str *str);
 
SG_EXTERN int sg_str_clear(struct sg_str *str);
 
struct sg_strmap;
 
typedef int (*sg_strmap_iter_cb)(void *cls, struct sg_strmap *pair);
 
typedef int (*sg_strmap_sort_cb)(void *cls, struct sg_strmap *pair_a,
                                 struct sg_strmap *pair_b);
 
SG_EXTERN const char *sg_strmap_name(struct sg_strmap *pair);
 
SG_EXTERN const char *sg_strmap_val(struct sg_strmap *pair);
 
SG_EXTERN int sg_strmap_add(struct sg_strmap **map, const char *name,
                            const char *val);
 
SG_EXTERN int sg_strmap_set(struct sg_strmap **map, const char *name,
                            const char *val);
 
SG_EXTERN int sg_strmap_find(struct sg_strmap *map, const char *name,
                             struct sg_strmap **pair);
 
SG_EXTERN const char *sg_strmap_get(struct sg_strmap *map, const char *name);
 
SG_EXTERN int sg_strmap_rm(struct sg_strmap **map, const char *name);
 
SG_EXTERN int sg_strmap_iter(struct sg_strmap *map, sg_strmap_iter_cb cb,
                             void *cls);
 
SG_EXTERN int sg_strmap_sort(struct sg_strmap **map, sg_strmap_sort_cb cb,
                             void *cls);
 
SG_EXTERN unsigned int sg_strmap_count(struct sg_strmap *map);
 
SG_EXTERN int sg_strmap_next(struct sg_strmap **next);
 
SG_EXTERN void sg_strmap_cleanup(struct sg_strmap **map);
 
struct sg_httpauth;
 
struct sg_httpupld;
 
struct sg_httpreq;
 
struct sg_httpres;
 
struct sg_httpsrv;
 
typedef void (*sg_httpsrv_cli_cb)(void *cls, const void *client, bool *closed);
 
typedef bool (*sg_httpauth_cb)(void *cls, struct sg_httpauth *auth,
                               struct sg_httpreq *req, struct sg_httpres *res);
 
typedef int (*sg_httpupld_cb)(void *cls, void **handle, const char *dir,
                              const char *field, const char *name,
                              const char *mime, const char *encoding);
 
typedef int (*sg_httpuplds_iter_cb)(void *cls, struct sg_httpupld *upld);
 
typedef void (*sg_httpreq_cb)(void *cls, struct sg_httpreq *req,
                              struct sg_httpres *res);
 
SG_EXTERN int sg_httpauth_set_realm(struct sg_httpauth *auth,
                                    const char *realm);
 
SG_EXTERN const char *sg_httpauth_realm(struct sg_httpauth *auth);
 
SG_EXTERN int sg_httpauth_deny2(struct sg_httpauth *auth, const char *reason,
                                const char *content_type, unsigned int status);
 
SG_EXTERN int sg_httpauth_deny(struct sg_httpauth *auth, const char *reason,
                               const char *content_type);
 
SG_EXTERN int sg_httpauth_cancel(struct sg_httpauth *auth);
 
SG_EXTERN const char *sg_httpauth_usr(struct sg_httpauth *auth);
 
SG_EXTERN const char *sg_httpauth_pwd(struct sg_httpauth *auth);
 
SG_EXTERN int sg_httpuplds_iter(struct sg_httpupld *uplds,
                                sg_httpuplds_iter_cb cb, void *cls);
 
SG_EXTERN int sg_httpuplds_next(struct sg_httpupld **upld);
 
SG_EXTERN unsigned int sg_httpuplds_count(struct sg_httpupld *uplds);
 
SG_EXTERN void *sg_httpupld_handle(struct sg_httpupld *upld);
 
SG_EXTERN const char *sg_httpupld_dir(struct sg_httpupld *upld);
 
SG_EXTERN const char *sg_httpupld_field(struct sg_httpupld *upld);
 
SG_EXTERN const char *sg_httpupld_name(struct sg_httpupld *upld);
 
SG_EXTERN const char *sg_httpupld_mime(struct sg_httpupld *upld);
 
SG_EXTERN const char *sg_httpupld_encoding(struct sg_httpupld *upld);
 
SG_EXTERN uint64_t sg_httpupld_size(struct sg_httpupld *upld);
 
SG_EXTERN int sg_httpupld_save(struct sg_httpupld *upld, bool overwritten);
 
SG_EXTERN int sg_httpupld_save_as(struct sg_httpupld *upld, const char *path,
                                  bool overwritten);
 
SG_EXTERN struct sg_httpsrv *sg_httpreq_srv(struct sg_httpreq *req);
 
SG_EXTERN struct sg_strmap **sg_httpreq_headers(struct sg_httpreq *req);
 
SG_EXTERN struct sg_strmap **sg_httpreq_cookies(struct sg_httpreq *req);
 
SG_EXTERN struct sg_strmap **sg_httpreq_params(struct sg_httpreq *req);
 
SG_EXTERN struct sg_strmap **sg_httpreq_fields(struct sg_httpreq *req);
 
SG_EXTERN const char *sg_httpreq_version(struct sg_httpreq *req);
 
SG_EXTERN const char *sg_httpreq_method(struct sg_httpreq *req);
 
SG_EXTERN const char *sg_httpreq_path(struct sg_httpreq *req);
 
SG_EXTERN struct sg_str *sg_httpreq_payload(struct sg_httpreq *req);
 
SG_EXTERN bool sg_httpreq_is_uploading(struct sg_httpreq *req);
 
SG_EXTERN struct sg_httpupld *sg_httpreq_uploads(struct sg_httpreq *req);
 
SG_EXTERN const void *sg_httpreq_client(struct sg_httpreq *req);
 
#ifdef SG_HTTPS_SUPPORT
 
SG_EXTERN void *sg_httpreq_tls_session(struct sg_httpreq *req);
 
#endif /* SG_HTTPS_SUPPORT */
 
SG_EXTERN int sg_httpreq_isolate(struct sg_httpreq *req, sg_httpreq_cb cb,
                                 void *cls);
 
SG_EXTERN int sg_httpreq_set_user_data(struct sg_httpreq *req, void *data);
 
SG_EXTERN void *sg_httpreq_user_data(struct sg_httpreq *req);
 
SG_EXTERN struct sg_strmap **sg_httpres_headers(struct sg_httpres *res);
 
SG_EXTERN int sg_httpres_set_cookie(struct sg_httpres *res, const char *name,
                                    const char *val);
 
#define sg_httpres_send(res, val, content_type, status)                        \
  sg_httpres_sendbinary((res), (void *) (val),                                 \
                        (((val) != NULL) ? strlen((val)) : 0), (content_type), \
                        (status))
 
SG_EXTERN int sg_httpres_sendbinary(struct sg_httpres *res, void *buf,
                                    size_t size, const char *content_type,
                                    unsigned int status);
 
#define sg_httpres_download(res, filename, status)                             \
  sg_httpres_sendfile2((res), 0, 0, 0, (filename), "attachment", (status))
 
#define sg_httpres_render(res, filename, status)                               \
  sg_httpres_sendfile2((res), 0, 0, 0, (filename), "inline", (status))
 
SG_EXTERN int sg_httpres_sendfile2(struct sg_httpres *res, uint64_t size,
                                   uint64_t max_size, uint64_t offset,
                                   const char *filename,
                                   const char *disposition,
                                   unsigned int status);
 
SG_EXTERN int sg_httpres_sendfile(struct sg_httpres *res, uint64_t size,
                                  uint64_t max_size, uint64_t offset,
                                  const char *filename, bool downloaded,
                                  unsigned int status);
 
SG_EXTERN int sg_httpres_sendstream(struct sg_httpres *res, uint64_t size,
                                    sg_read_cb read_cb, void *handle,
                                    sg_free_cb free_cb, unsigned int status);
 
#ifdef SG_HTTP_COMPRESSION
 
#define sg_httpres_zsend(res, val, content_type, status)                       \
  sg_httpres_zsendbinary((res), (void *) (val),                                \
                         (((val) != NULL) ? strlen((val)) : 0),                \
                         (content_type), (status))
 
SG_EXTERN int sg_httpres_zsendbinary2(struct sg_httpres *res, int level,
                                      void *buf, size_t size,
                                      const char *content_type,
                                      unsigned int status);
 
SG_EXTERN int sg_httpres_zsendbinary(struct sg_httpres *res, void *buf,
                                     size_t size, const char *content_type,
                                     unsigned int status);
 
SG_EXTERN int sg_httpres_zsendstream2(struct sg_httpres *res, int level,
                                      uint64_t size, sg_read_cb read_cb,
                                      void *handle, sg_free_cb free_cb,
                                      unsigned int status);
 
SG_EXTERN int sg_httpres_zsendstream(struct sg_httpres *res, sg_read_cb read_cb,
                                     void *handle, sg_free_cb free_cb,
                                     unsigned int status);
 
#define sg_httpres_zdownload(res, filename, status)                            \
  sg_httpres_zsendfile2((res), 1, 0, 0, 0, (filename), "attachment", (status))
 
#define sg_httpres_zrender(res, filename, status)                              \
  sg_httpres_zsendfile2((res), 1, 0, 0, 0, (filename), "inline", (status))
 
SG_EXTERN int sg_httpres_zsendfile2(struct sg_httpres *res, int level,
                                    uint64_t size, uint64_t max_size,
                                    uint64_t offset, const char *filename,
                                    const char *disposition,
                                    unsigned int status);
 
SG_EXTERN int sg_httpres_zsendfile(struct sg_httpres *res, uint64_t size,
                                   uint64_t max_size, uint64_t offset,
                                   const char *filename, bool downloaded,
                                   unsigned int status);
 
#endif /* SG_HTTP_COMPRESSION */
 
SG_EXTERN int sg_httpres_reset(struct sg_httpres *res);
 
SG_EXTERN int sg_httpres_clear(struct sg_httpres *res);
 
SG_EXTERN bool sg_httpres_is_empty(struct sg_httpres *res);
 
SG_EXTERN struct sg_httpsrv *sg_httpsrv_new2(sg_httpauth_cb auth_cb,
                                             sg_httpreq_cb req_cb,
                                             sg_err_cb err_cb,
                                             void *cls) __SG_MALLOC;
 
SG_EXTERN struct sg_httpsrv *sg_httpsrv_new(sg_httpreq_cb cb,
                                            void *cls) __SG_MALLOC;
 
SG_EXTERN void sg_httpsrv_free(struct sg_httpsrv *srv);
 
#ifdef SG_HTTPS_SUPPORT
 
SG_EXTERN bool sg_httpsrv_tls_listen4(struct sg_httpsrv *srv, const char *key,
                                      const char *pwd, const char *cert,
                                      const char *trust, const char *dhparams,
                                      const char *priorities,
                                      const char *hostname, uint16_t port,
                                      uint32_t backlog, bool threaded);
 
SG_EXTERN bool sg_httpsrv_tls_listen3(struct sg_httpsrv *srv, const char *key,
                                      const char *pwd, const char *cert,
                                      const char *trust, const char *dhparams,
                                      const char *priorities, uint16_t port,
                                      bool threaded);
 
SG_EXTERN bool sg_httpsrv_tls_listen2(struct sg_httpsrv *srv, const char *key,
                                      const char *pwd, const char *cert,
                                      const char *trust, const char *dhparams,
                                      uint16_t port, bool threaded);
 
SG_EXTERN bool sg_httpsrv_tls_listen(struct sg_httpsrv *srv, const char *key,
                                     const char *cert, uint16_t port,
                                     bool threaded);
 
#endif /* SG_HTTPS_SUPPORT */
 
SG_EXTERN bool sg_httpsrv_listen2(struct sg_httpsrv *srv, const char *hostname,
                                  uint16_t port, uint32_t backlog,
                                  bool threaded);
 
SG_EXTERN bool sg_httpsrv_listen(struct sg_httpsrv *srv, uint16_t port,
                                 bool threaded);
 
SG_EXTERN int sg_httpsrv_shutdown(struct sg_httpsrv *srv);
 
SG_EXTERN uint16_t sg_httpsrv_port(struct sg_httpsrv *srv);
 
SG_EXTERN bool sg_httpsrv_is_threaded(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_cli_cb(struct sg_httpsrv *srv,
                                    sg_httpsrv_cli_cb cb, void *cls);
 
SG_EXTERN int sg_httpsrv_set_upld_cbs(struct sg_httpsrv *srv, sg_httpupld_cb cb,
                                      void *cls, sg_write_cb write_cb,
                                      sg_free_cb free_cb, sg_save_cb save_cb,
                                      sg_save_as_cb save_as_cb);
 
SG_EXTERN int sg_httpsrv_set_upld_dir(struct sg_httpsrv *srv, const char *dir);
 
SG_EXTERN const char *sg_httpsrv_upld_dir(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_post_buf_size(struct sg_httpsrv *srv, size_t size);
 
SG_EXTERN size_t sg_httpsrv_post_buf_size(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_payld_limit(struct sg_httpsrv *srv, size_t limit);
 
SG_EXTERN size_t sg_httpsrv_payld_limit(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_uplds_limit(struct sg_httpsrv *srv,
                                         uint64_t limit);
 
SG_EXTERN uint64_t sg_httpsrv_uplds_limit(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_thr_pool_size(struct sg_httpsrv *srv,
                                           unsigned int size);
 
SG_EXTERN unsigned int sg_httpsrv_thr_pool_size(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_con_timeout(struct sg_httpsrv *srv,
                                         unsigned int timeout);
 
SG_EXTERN unsigned int sg_httpsrv_con_timeout(struct sg_httpsrv *srv);
 
SG_EXTERN int sg_httpsrv_set_con_limit(struct sg_httpsrv *srv,
                                       unsigned int limit);
 
SG_EXTERN unsigned int sg_httpsrv_con_limit(struct sg_httpsrv *srv);
 
SG_EXTERN void *sg_httpsrv_handle(struct sg_httpsrv *srv);
 
#ifdef SG_PATH_ROUTING
 
struct sg_entrypoint;
 
SG_EXTERN const char *sg_entrypoint_name(struct sg_entrypoint *entrypoint);
 
SG_EXTERN int sg_entrypoint_set_user_data(struct sg_entrypoint *entrypoint,
                                          void *data);
 
SG_EXTERN void *sg_entrypoint_user_data(struct sg_entrypoint *entrypoint);
 
struct sg_entrypoints;
 
typedef int (*sg_entrypoints_iter_cb)(void *cls,
                                      struct sg_entrypoint *entrypoint);
 
SG_EXTERN struct sg_entrypoints *sg_entrypoints_new(void) __SG_MALLOC;
 
SG_EXTERN void sg_entrypoints_free(struct sg_entrypoints *entrypoints);
 
SG_EXTERN int sg_entrypoints_add(struct sg_entrypoints *entrypoints,
                                 const char *path, void *user_data);
 
SG_EXTERN int sg_entrypoints_rm(struct sg_entrypoints *entrypoints,
                                const char *path);
 
SG_EXTERN int sg_entrypoints_iter(struct sg_entrypoints *entrypoints,
                                  sg_entrypoints_iter_cb cb, void *cls);
 
SG_EXTERN int sg_entrypoints_clear(struct sg_entrypoints *entrypoints);
 
SG_EXTERN int sg_entrypoints_find(struct sg_entrypoints *entrypoints,
                                  struct sg_entrypoint **entrypoint,
                                  const char *path);
 
struct sg_route;
 
typedef int (*sg_segments_iter_cb)(void *cls, unsigned int index,
                                   const char *segment);
 
typedef int (*sg_vars_iter_cb)(void *cls, const char *name, const char *val);
 
typedef void (*sg_route_cb)(void *cls, struct sg_route *route);
 
typedef int (*sg_routes_iter_cb)(void *cls, struct sg_route *route);
 
SG_EXTERN void *sg_route_handle(struct sg_route *route);
 
SG_EXTERN void *sg_route_match(struct sg_route *route);
 
SG_EXTERN const char *sg_route_rawpattern(struct sg_route *route);
 
SG_EXTERN char *sg_route_pattern(struct sg_route *route) __SG_MALLOC;
 
SG_EXTERN const char *sg_route_path(struct sg_route *route);
 
SG_EXTERN int sg_route_segments_iter(struct sg_route *route,
                                     sg_segments_iter_cb cb, void *cls);
 
SG_EXTERN int sg_route_vars_iter(struct sg_route *route, sg_vars_iter_cb cb,
                                 void *cls);
 
SG_EXTERN void *sg_route_user_data(struct sg_route *route);
 
SG_EXTERN int sg_routes_add2(struct sg_route **routes, struct sg_route **route,
                             const char *pattern, char *errmsg, size_t errlen,
                             sg_route_cb cb, void *cls);
 
SG_EXTERN bool sg_routes_add(struct sg_route **routes, const char *pattern,
                             sg_route_cb cb, void *cls);
 
SG_EXTERN int sg_routes_rm(struct sg_route **routes, const char *pattern);
 
SG_EXTERN int sg_routes_iter(struct sg_route *routes, sg_routes_iter_cb cb,
                             void *cls);
 
SG_EXTERN int sg_routes_next(struct sg_route **route);
 
SG_EXTERN unsigned int sg_routes_count(struct sg_route *routes);
 
SG_EXTERN int sg_routes_cleanup(struct sg_route **routes);
 
struct sg_router;
 
typedef int (*sg_router_dispatch_cb)(void *cls, const char *path,
                                     struct sg_route *route);
 
typedef int (*sg_router_match_cb)(void *cls, struct sg_route *route);
 
SG_EXTERN struct sg_router *sg_router_new(struct sg_route *routes) __SG_MALLOC;
 
SG_EXTERN void sg_router_free(struct sg_router *router);
 
SG_EXTERN int sg_router_dispatch2(struct sg_router *router, const char *path,
                                  void *user_data,
                                  sg_router_dispatch_cb dispatch_cb, void *cls,
                                  sg_router_match_cb match_cb);
 
SG_EXTERN int sg_router_dispatch(struct sg_router *router, const char *path,
                                 void *user_data);
 
#endif /* SG_PATH_ROUTING */
 
#ifdef SG_MATH_EXPR_EVAL
 
struct sg_expr;
 
enum sg_expr_err_type {
  SG_EXPR_ERR_UNKNOWN,
  SG_EXPR_ERR_UNEXPECTED_NUMBER,
  SG_EXPR_ERR_UNEXPECTED_WORD,
  SG_EXPR_ERR_UNEXPECTED_PARENS,
  SG_EXPR_ERR_MISSING_OPERAND,
  SG_EXPR_ERR_UNKNOWN_OPERATOR,
  SG_EXPR_ERR_INVALID_FUNC_NAME,
  SG_EXPR_ERR_BAD_PARENS,
  SG_EXPR_ERR_TOO_FEW_FUNC_ARGS,
  SG_EXPR_ERR_FIRST_ARG_IS_NOT_VAR,
  SG_EXPR_ERR_BAD_VARIABLE_NAME,
  SG_EXPR_ERR_BAD_ASSIGNMENT
};
 
struct sg_expr_argument;
 
typedef double (*sg_expr_func)(void *cls, struct sg_expr_argument *args,
                               const char *identifier);
 
struct sg_expr_extension {
  sg_expr_func func;
  const char *identifier;
  void *cls;
};
 
SG_EXTERN struct sg_expr *sg_expr_new(void) __SG_MALLOC;
 
SG_EXTERN void sg_expr_free(struct sg_expr *expr);
 
SG_EXTERN int sg_expr_compile(struct sg_expr *expr, const char *str, size_t len,
                              struct sg_expr_extension *extensions);
 
SG_EXTERN int sg_expr_clear(struct sg_expr *expr);
 
SG_EXTERN double sg_expr_eval(struct sg_expr *expr);
 
SG_EXTERN double sg_expr_var(struct sg_expr *expr, const char *name,
                             size_t len);
 
SG_EXTERN int sg_expr_set_var(struct sg_expr *expr, const char *name,
                              size_t len, double val);
 
SG_EXTERN double sg_expr_arg(struct sg_expr_argument *args, int index);
 
SG_EXTERN int sg_expr_near(struct sg_expr *expr);
 
SG_EXTERN enum sg_expr_err_type sg_expr_err(struct sg_expr *expr);
 
SG_EXTERN const char *sg_expr_strerror(struct sg_expr *expr);
 
SG_EXTERN double sg_expr_calc(const char *str, size_t len);
 
#endif /* SG_MATH_EXPR_EVAL */
 
#ifdef __cplusplus
}
#endif
 
#endif /* SAGUI_H */