opener-opinion-detector-basic 1.0.0

data/core/vendor/src/crfsuite/lib/crf/src/params.c

@@ -0,0 +1,335 @@
+/*
+ *      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);
+    }
+    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;
+}

data/core/vendor/src/crfsuite/lib/crf/src/params.h

@@ -0,0 +1,80 @@
+/*
+ *      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__*/

data/core/vendor/src/crfsuite/lib/crf/src/quark.c

@@ -0,0 +1,172 @@
+/*
+ *      Quark object.
+ *
+ * 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 "rumavl.h"
+#include "quark.h"
+
+typedef struct {
+    char *str;
+    int qid;
+} record_t;
+
+struct tag_quark {
+    int num;
+    int max;
+    RUMAVL* string_to_id;
+    char **id_to_string;
+};
+
+static int keycmp(const void *_x, const void *_y, size_t n, void *udata)
+{
+    const record_t* x = (const record_t*)_x;
+    const record_t* y = (const record_t*)_y;
+    return strcmp(x->str, y->str);
+}
+
+static int owcb(RUMAVL *tree, RUMAVL_NODE *n, void *_x, const void *_y, void *udata)
+{
+    record_t* x = (record_t*)_x;
+    free(x->str);
+    return 0;
+}
+
+static int delcb(RUMAVL *tree, RUMAVL_NODE *n, void *_record, void *udata)
+{
+    record_t* record = (record_t*)_record;
+    free(record->str);
+    return 0;
+}
+
+quark_t* quark_new()
+{
+    quark_t* qrk = (quark_t*)malloc(sizeof(quark_t));
+    if (qrk != NULL) {
+        qrk->num = 0;
+        qrk->max = 0;
+        qrk->string_to_id = rumavl_new(sizeof(record_t), keycmp, NULL, NULL);
+        if (qrk->string_to_id != NULL) {
+            *rumavl_delcb(qrk->string_to_id) = delcb;
+            *rumavl_owcb(qrk->string_to_id) = owcb;
+        }
+        qrk->id_to_string = NULL;
+    }
+    return qrk;
+}
+
+void quark_delete(quark_t* qrk)
+{
+    if (qrk != NULL) {
+        rumavl_destroy(qrk->string_to_id);
+        free(qrk->id_to_string);
+        free(qrk);
+    }
+}
+
+int quark_get(quark_t* qrk, const char *str)
+{
+    record_t key, *record = NULL;
+
+    key.str = (char *)str;
+    record = (record_t*)rumavl_find(qrk->string_to_id, &key);
+    if (record == NULL) {
+        char *newstr = (char*)malloc(strlen(str)+1);
+        if (newstr != NULL) {
+            strcpy(newstr, str);
+        }
+
+        if (qrk->max <= qrk->num) {
+            qrk->max = (qrk->max + 1) * 2;
+            qrk->id_to_string = (char **)realloc(qrk->id_to_string, sizeof(char *) * qrk->max);
+        }
+
+        qrk->id_to_string[qrk->num] = newstr;
+        key.str = newstr;
+        key.qid = qrk->num;
+        rumavl_insert(qrk->string_to_id, &key);
+
+        ++qrk->num;
+        return key.qid;
+    } else {
+        return record->qid;
+    }    
+}
+
+int quark_to_id(quark_t* qrk, const char *str)
+{
+    record_t key, *record = NULL;
+
+    key.str = (char *)str;
+    record = (record_t*)rumavl_find(qrk->string_to_id, &key);
+    return (record != NULL) ? record->qid : -1;
+}
+
+const char *quark_to_string(quark_t* qrk, int qid)
+{
+    return (qid < qrk->num) ? qrk->id_to_string[qid] : NULL;
+}
+
+int quark_num(quark_t* qrk)
+{
+    return qrk->num;
+}
+
+
+
+#if 0
+int main(int argc, char *argv[])
+{
+    quark_t *qrk = quark_new();
+    int qid = 0;
+
+    qid = quark_get(qrk, "zero");
+    qid = quark_get(qrk, "one");
+    qid = quark_get(qrk, "zero");
+    qid = quark_to_id(qrk, "three");
+    qid = quark_get(qrk, "two");
+    qid = quark_get(qrk, "three");
+    qid = quark_to_id(qrk, "three");
+    qid = quark_get(qrk, "zero");
+    qid = quark_get(qrk, "one");
+
+    printf("%s\n", quark_to_string(qrk, 0));
+    printf("%s\n", quark_to_string(qrk, 1));
+    printf("%s\n", quark_to_string(qrk, 2));
+    printf("%s\n", quark_to_string(qrk, 3));
+
+    quark_delete(qrk);
+    
+    return 0;
+}
+#endif