Fixed warnings. Updated headers
[yaz-moved-to-github.git] / 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