cql/cqlutil.c

   1 /* $Id: cqlutil.c,v 1.3 2003-03-03 19:57:35 adam Exp $
   2    Copyright (C) 2002-2003
   3    Index Data Aps
   4
   5 This file is part of the YAZ toolkit.
   6
   7 See the file LICENSE.
   8 */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include <yaz/cql.h>
  14
  15 void cql_fputs(const char *buf, void *client_data)
  16 {
  17     FILE *f = (FILE *) client_data;
  18     fputs(buf, f);
  19 }
  20
  21 struct cql_node *cql_node_dup (struct cql_node *cp)
  22 {
  23     struct cql_node *cn = 0;
  24
  25     if (!cp)
  26         return 0;
  27     switch (cp->which)
  28     {
  29     case CQL_NODE_ST:
  30         cn = cql_node_mk_sc(cp->u.st.index,
  31                             cp->u.st.relation,
  32                             cp->u.st.term);
  33         cn->u.st.modifiers = cql_node_dup(cp->u.st.modifiers);
  34         cn->u.st.prefixes = cql_node_dup(cp->u.st.prefixes);
  35         break;
  36     case CQL_NODE_MOD:
  37         cn = cql_node_mk_mod(cp->u.mod.name,
  38                              cp->u.mod.value);
  39         cn->u.mod.next = cql_node_dup(cp->u.mod.next);
  40         break;
  41     case CQL_NODE_BOOL:
  42         cn = cql_node_mk_boolean(cp->u.boolean.value);
  43         cn->u.boolean.left = cql_node_dup(cp->u.boolean.left);
  44         cn->u.boolean.right = cql_node_dup(cp->u.boolean.right);
  45         cn->u.boolean.prefixes = cql_node_dup(cp->u.boolean.prefixes);
  46     }
  47     return cn;
  48 }
  49
  50 struct cql_node *cql_node_mk_sc(const char *index,
  51                                 const char *relation,
  52                                 const char *term)
  53 {
  54     struct cql_node *p = (struct cql_node *) malloc(sizeof(*p));
  55     p->which = CQL_NODE_ST;
  56     p->u.st.index = 0;
  57     if (index)
  58         p->u.st.index = strdup(index);
  59     p->u.st.term = 0;
  60     if (term)
  61         p->u.st.term = strdup(term);
  62     p->u.st.relation = 0;
  63     if (relation)
  64         p->u.st.relation = strdup(relation);
  65     p->u.st.modifiers = 0;
  66     p->u.st.prefixes = 0;
  67     return p;
  68 }
  69
  70 struct cql_node *cql_node_mk_mod(const char *name,
  71                                  const char *value)
  72 {
  73     struct cql_node *p = (struct cql_node *) malloc(sizeof(*p));
  74     p->which = CQL_NODE_MOD;
  75
  76     p->u.mod.name = 0;
  77     if (name)
  78         p->u.mod.name = strdup(name);
  79     p->u.mod.value = 0;
  80     if (value)
  81         p->u.mod.value = strdup(value);
  82     p->u.mod.next = 0;
  83     return p;
  84 }
  85
  86 struct cql_node *cql_node_mk_boolean(const char *op)
  87 {
  88     struct cql_node *p = (struct cql_node *) malloc(sizeof(*p));
  89     p->which = CQL_NODE_BOOL;
  90     p->u.boolean.value = 0;
  91     if (op)
  92         p->u.boolean.value = strdup(op);
  93     p->u.boolean.left = 0;
  94     p->u.boolean.right = 0;
  95     p->u.boolean.modifiers = 0;
  96     p->u.boolean.prefixes = 0;
  97     return p;
  98 }
  99
 100 struct cql_node *cql_node_prefix(struct cql_node *n, const char *prefix,
 101                                  const char *uri)
 102 {
 103     struct cql_node **cpp = 0;
 104     if (n->which == CQL_NODE_ST)
 105     {
 106         cpp = &n->u.st.prefixes;
 107     }
 108     else if (n->which == CQL_NODE_BOOL)
 109     {
 110         cpp = &n->u.boolean.prefixes;
 111     }
 112     if (cpp)
 113     {
 114         struct cql_node *cp = cql_node_mk_mod(prefix, uri);
 115         cp->u.mod.next = *cpp;
 116         *cpp = cp;
 117     }
 118     return n;
 119 }
 120
 121 struct cql_node *cql_node_mk_proxargs(const char *relation,
 122                                       const char *distance,
 123                                       const char *unit,
 124                                       const char *ordering)
 125 {
 126     struct cql_node *m = 0, *m1;
 127
 128     if (ordering && *ordering)
 129         m = cql_node_mk_mod("ordering", ordering);
 130     if (unit && *unit)
 131     {
 132         m1 = cql_node_mk_mod("unit", unit);
 133         m1->u.mod.next = m;
 134         m = m1;
 135     }
 136     if (distance && *distance)
 137     {
 138         m1 = cql_node_mk_mod("distance", distance);
 139         m1->u.mod.next = m;
 140         m = m1;
 141     }
 142     if (relation && *relation)
 143     {
 144         m1 = cql_node_mk_mod("relation", relation);
 145         m1->u.mod.next = m;
 146         m = m1;
 147     }
 148     return m;
 149 }
 150
 151 void cql_node_destroy(struct cql_node *cn)
 152 {
 153     if (!cn)
 154         return;
 155     switch (cn->which)
 156     {
 157     case CQL_NODE_ST:
 158         free (cn->u.st.index);
 159         free (cn->u.st.relation);
 160         free (cn->u.st.term);
 161         cql_node_destroy(cn->u.st.modifiers);
 162         cql_node_destroy(cn->u.st.prefixes);
 163         break;
 164     case CQL_NODE_MOD:
 165         free (cn->u.mod.name);
 166         free (cn->u.mod.value);
 167         cql_node_destroy(cn->u.mod.next);
 168         break;
 169     case CQL_NODE_BOOL:
 170         free (cn->u.boolean.value);
 171         cql_node_destroy(cn->u.boolean.left);
 172         cql_node_destroy(cn->u.boolean.right);
 173         cql_node_destroy(cn->u.boolean.prefixes);
 174     }
 175     free (cn);
 176 }
 177