chaine 3.13.1__cp312-cp312-musllinux_1_2_x86_64.whl

chaine/_core/crfsuite/lib/crf/src/json.h

@@ -0,0 +1,120 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef CCAN_JSON_H
+#define CCAN_JSON_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum
+{
+	JSON_NULL,
+	JSON_BOOL,
+	JSON_STRING,
+	JSON_NUMBER,
+	JSON_ARRAY,
+	JSON_OBJECT,
+} JsonTag;
+
+typedef struct JsonNode JsonNode;
+
+struct JsonNode
+{
+	/* only if parent is an object or array (NULL otherwise) */
+	JsonNode *parent;
+	JsonNode *prev, *next;
+
+	/* only if parent is an object (NULL otherwise) */
+	char *key; /* Must be valid UTF-8. */
+
+	JsonTag tag;
+	union
+	{
+		/* JSON_BOOL */
+		bool bool_;
+
+		/* JSON_STRING */
+		char *string_; /* Must be valid UTF-8. */
+
+		/* JSON_NUMBER */
+		double number_;
+
+		/* JSON_ARRAY */
+		/* JSON_OBJECT */
+		struct
+		{
+			JsonNode *head, *tail;
+		} children;
+	};
+};
+
+/*** Encoding, decoding, and validation ***/
+
+JsonNode *json_decode(const char *json);
+char *json_encode(const JsonNode *node);
+char *json_encode_string(const char *str);
+char *json_stringify(const JsonNode *node, const char *space);
+void json_delete(JsonNode *node);
+
+bool json_validate(const char *json);
+
+/*** Lookup and traversal ***/
+
+JsonNode *json_find_element(JsonNode *array, int index);
+JsonNode *json_find_member(JsonNode *object, const char *name);
+
+JsonNode *json_first_child(const JsonNode *node);
+
+#define json_foreach(i, object_or_array)          \
+	for ((i) = json_first_child(object_or_array); \
+		 (i) != NULL;                             \
+		 (i) = (i)->next)
+
+/*** Construction and manipulation ***/
+
+JsonNode *json_mknull(void);
+JsonNode *json_mkbool(bool b);
+JsonNode *json_mkstring(const char *s);
+JsonNode *json_mknumber(double n);
+JsonNode *json_mkarray(void);
+JsonNode *json_mkobject(void);
+
+void json_append_element(JsonNode *array, JsonNode *element);
+void json_prepend_element(JsonNode *array, JsonNode *element);
+void json_append_member(JsonNode *object, const char *key, JsonNode *value);
+void json_prepend_member(JsonNode *object, const char *key, JsonNode *value);
+
+void json_remove_from_parent(JsonNode *node);
+
+/*** Debugging ***/
+
+/*
+ * Look for structure and encoding problems in a JsonNode or its descendents.
+ *
+ * If a problem is detected, return false, writing a description of the problem
+ * to errmsg (unless errmsg is NULL).
+ */
+bool json_check(const JsonNode *node, char errmsg[256]);
+
+#endif

chaine/_core/crfsuite/lib/crf/src/logging.c

@@ -0,0 +1,85 @@
+/*
+ *      Logging utility.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#include <os.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <crfsuite.h>
+#include "logging.h"
+
+void logging(logging_t *lg, const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+
+    if (lg != NULL && lg->func != NULL)
+    {
+        lg->func(lg->instance, format, args);
+    }
+}
+
+void logging_timestamp(logging_t *lg, const char *format)
+{
+    time_t ts;
+    char timestamp[80];
+
+    time(&ts);
+    strftime(
+        timestamp, sizeof(timestamp),
+        "%Y-%m-%dT%H:%M:%SZ",
+        gmtime(&ts));
+    logging(lg, format, timestamp);
+}
+
+void logging_progress(logging_t *lg, int percent)
+{
+    while (lg->percent < percent)
+    {
+        ++lg->percent;
+        if (lg->percent % 2 == 0)
+        {
+            if (lg->percent % 10 == 0)
+            {
+                logging(lg, "Processed %d%% of the training data", lg->percent);
+            }
+        }
+    }
+}
+
+void logging_progress_end(logging_t *lg)
+{
+    logging_progress(lg, 100);
+}

chaine/_core/crfsuite/lib/crf/src/logging.h

@@ -0,0 +1,49 @@
+/*
+ *      Logging utility.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef __LOGGING_H__
+#define __LOGGING_H__
+
+typedef struct
+{
+    void *instance;
+    crfsuite_logging_callback func;
+    int percent;
+} logging_t;
+
+void logging(logging_t *lg, const char *format, ...);
+void logging_timestamp(logging_t *lg, const char *format);
+void logging_progress_start(logging_t *lg);
+void logging_progress(logging_t *lg, int percent);
+void logging_progress_end(logging_t *lg);
+
+#endif /*__LOGGING_H__*/

chaine/_core/crfsuite/lib/crf/src/params.c

@@ -0,0 +1,370 @@
+/*
+ *      Parameter exchange.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#include <os.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <crfsuite.h>
+#include "quark.h"
+
+enum
+{
+    PT_NONE = 0,
+    PT_INT,
+    PT_FLOAT,
+    PT_STRING,
+};
+
+typedef struct
+{
+    char *name;
+    int type;
+    int val_i;
+    floatval_t val_f;
+    char *val_s;
+    char *help;
+} param_t;
+
+typedef struct
+{
+    int num_params;
+    param_t *params;
+} params_t;
+
+static char *mystrdup(const char *src)
+{
+    char *dst = (char *)malloc(strlen(src) + 1);
+    if (dst != NULL)
+    {
+        strcpy(dst, src);
+    }
+    return dst;
+}
+
+static int params_addref(crfsuite_params_t *params)
+{
+    return crfsuite_interlocked_increment(&params->nref);
+}
+
+static int params_release(crfsuite_params_t *params)
+{
+    int count = crfsuite_interlocked_decrement(&params->nref);
+    if (count == 0)
+    {
+        int i;
+        params_t *pars = (params_t *)params->internal;
+        for (i = 0; i < pars->num_params; ++i)
+        {
+            free(pars->params[i].name);
+            free(pars->params[i].val_s);
+            free(pars->params[i].help);
+        }
+        free(pars->params);
+        free(pars);
+        free(params);
+    }
+    return count;
+}
+
+static param_t *find_param(params_t *pars, const char *name)
+{
+    int i;
+
+    for (i = 0; i < pars->num_params; ++i)
+    {
+        if (strcmp(pars->params[i].name, name) == 0)
+        {
+            return &pars->params[i];
+        }
+    }
+
+    return NULL;
+}
+
+static int params_num(crfsuite_params_t *params)
+{
+    params_t *pars = (params_t *)params->internal;
+    return pars->num_params;
+}
+
+static int params_name(crfsuite_params_t *params, int i, char **ptr_name)
+{
+    params_t *pars = (params_t *)params->internal;
+    *ptr_name = mystrdup(pars->params[i].name);
+    return 0;
+}
+
+static int params_set(crfsuite_params_t *params, const char *name, const char *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    switch (par->type)
+    {
+    case PT_INT:
+        par->val_i = (value != NULL) ? atoi(value) : 0;
+        break;
+    case PT_FLOAT:
+        par->val_f = (value != NULL) ? (floatval_t)atof(value) : 0;
+        break;
+    case PT_STRING:
+        free(par->val_s);
+        par->val_s = (value != NULL) ? mystrdup(value) : mystrdup("");
+    }
+    return 0;
+}
+
+static int params_get(crfsuite_params_t *params, const char *name, char **value)
+{
+    char buffer[1024];
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    switch (par->type)
+    {
+    case PT_INT:
+        snprintf(buffer, sizeof(buffer) - 1, "%d", par->val_i);
+        *value = mystrdup(buffer);
+        break;
+    case PT_FLOAT:
+        snprintf(buffer, sizeof(buffer) - 1, "%f", par->val_f);
+        *value = mystrdup(buffer);
+        break;
+    case PT_STRING:
+        *value = mystrdup(par->val_s);
+    }
+    return 0;
+}
+
+static void params_free(crfsuite_params_t *params, const char *value)
+{
+    free((char *)value);
+}
+
+static int params_set_int(crfsuite_params_t *params, const char *name, int value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_INT)
+        return -1;
+    par->val_i = value;
+    return 0;
+}
+
+static int params_set_float(crfsuite_params_t *params, const char *name, floatval_t value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_FLOAT)
+        return -1;
+    par->val_f = value;
+    return 0;
+}
+
+static int params_set_string(crfsuite_params_t *params, const char *name, const char *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_STRING)
+        return -1;
+    free(par->val_s);
+    par->val_s = mystrdup(value);
+    return 0;
+}
+
+static int params_get_int(crfsuite_params_t *params, const char *name, int *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_INT)
+        return -1;
+    *value = par->val_i;
+    return 0;
+}
+
+static int params_get_float(crfsuite_params_t *params, const char *name, floatval_t *value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_FLOAT)
+        return -1;
+    *value = par->val_f;
+    return 0;
+}
+
+static int params_get_string(crfsuite_params_t *params, const char *name, char **value)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (par->type != PT_STRING)
+        return -1;
+    *value = par->val_s;
+    return 0;
+}
+
+static int params_help(crfsuite_params_t *params, const char *name, char **ptr_type, char **ptr_help)
+{
+    params_t *pars = (params_t *)params->internal;
+    param_t *par = find_param(pars, name);
+    if (par == NULL)
+        return -1;
+    if (ptr_type != NULL)
+    {
+        switch (par->type)
+        {
+        case PT_INT:
+            *ptr_type = mystrdup("int");
+            break;
+        case PT_FLOAT:
+            *ptr_type = mystrdup("float");
+            break;
+        case PT_STRING:
+            *ptr_type = mystrdup("string");
+            break;
+        default:
+            *ptr_type = mystrdup("unknown");
+        }
+    }
+    if (ptr_help != NULL)
+    {
+        *ptr_help = mystrdup(par->help);
+    }
+    return 0;
+}
+
+crfsuite_params_t *params_create_instance()
+{
+    crfsuite_params_t *params = (crfsuite_params_t *)calloc(1, sizeof(crfsuite_params_t));
+
+    if (params != NULL)
+    {
+        /* Construct the internal data. */
+        params->internal = (params_t *)calloc(1, sizeof(params_t));
+        if (params->internal == NULL)
+        {
+            free(params);
+            return NULL;
+        }
+
+        /* Set member functions. */
+        params->nref = 1;
+        params->addref = params_addref;
+        params->release = params_release;
+        params->num = params_num;
+        params->name = params_name;
+        params->set = params_set;
+        params->get = params_get;
+        params->free = params_free;
+        params->set_int = params_set_int;
+        params->set_float = params_set_float;
+        params->set_string = params_set_string;
+        params->get_int = params_get_int;
+        params->get_float = params_get_float;
+        params->get_string = params_get_string;
+        params->help = params_help;
+    }
+
+    return params;
+}
+
+int params_add_int(crfsuite_params_t *params, const char *name, int value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_INT;
+    par->val_i = value;
+    par->help = mystrdup(help);
+    return 0;
+}
+
+int params_add_float(crfsuite_params_t *params, const char *name, floatval_t value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_FLOAT;
+    par->val_f = value;
+    par->help = mystrdup(help);
+    return 0;
+}
+
+int params_add_string(crfsuite_params_t *params, const char *name, const char *value, const char *help)
+{
+    param_t *par = NULL;
+    params_t *pars = (params_t *)params->internal;
+    pars->params = (param_t *)realloc(pars->params, (pars->num_params + 1) * sizeof(param_t));
+    if (pars->params == NULL)
+    {
+        return -1;
+    }
+
+    par = &pars->params[pars->num_params++];
+    memset(par, 0, sizeof(*par));
+    par->name = mystrdup(name);
+    par->type = PT_STRING;
+    par->val_s = mystrdup(value);
+    par->help = mystrdup(help);
+    return 0;
+}

chaine/_core/crfsuite/lib/crf/src/params.h

@@ -0,0 +1,84 @@
+/*
+ *      Parameter exchange.
+ *
+ * Copyright (c) 2007-2010, Naoaki Okazaki
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the names of the authors nor the names of its contributors
+ *       may be used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef __PARAMS_H__
+#define __PARAMS_H__
+
+crfsuite_params_t *params_create_instance();
+int params_add_int(crfsuite_params_t *params, const char *name, int value, const char *help);
+int params_add_float(crfsuite_params_t *params, const char *name, floatval_t value, const char *help);
+int params_add_string(crfsuite_params_t *params, const char *name, const char *value, const char *help);
+
+enum
+{
+    PARAMS_READ = -1,
+    PARAMS_INIT = 0,
+    PARAMS_WRITE = 1,
+};
+
+#define BEGIN_PARAM_MAP(params, mode) \
+    do                                \
+    {                                 \
+        int __ret = 0;                \
+        int __mode = mode;            \
+        crfsuite_params_t *__params = params;
+
+#define END_PARAM_MAP() \
+    }                   \
+    while (0)           \
+        ;
+
+#define DDX_PARAM_INT(name, var, defval, help)           \
+    if (__mode < 0)                                      \
+        __ret = __params->get_int(__params, name, &var); \
+    else if (__mode > 0)                                 \
+        __ret = __params->set_int(__params, name, var);  \
+    else                                                 \
+        __ret = params_add_int(__params, name, defval, help);
+
+#define DDX_PARAM_FLOAT(name, var, defval, help)           \
+    if (__mode < 0)                                        \
+        __ret = __params->get_float(__params, name, &var); \
+    else if (__mode > 0)                                   \
+        __ret = __params->set_float(__params, name, var);  \
+    else                                                   \
+        __ret = params_add_float(__params, name, defval, help);
+
+#define DDX_PARAM_STRING(name, var, defval, help)           \
+    if (__mode < 0)                                         \
+        __ret = __params->get_string(__params, name, &var); \
+    else if (__mode > 0)                                    \
+        __ret = __params->set_string(__params, name, var);  \
+    else                                                    \
+        __ret = params_add_string(__params, name, defval, help);
+
+#endif /*__PARAMS_H__*/