1 | /*
|
---|
2 | * Copyright (c) 1996-2000, Index Data.
|
---|
3 | * See the file LICENSE for details.
|
---|
4 | * Sebastian Hammer, Adam Dickmeiss
|
---|
5 | *
|
---|
6 | * $Log$
|
---|
7 | * Revision 1.1 2000/08/03 03:12:39 johnmcp
|
---|
8 | * Added the YAZ toolkit source to the packages directory (for z39.50 stuff)
|
---|
9 | *
|
---|
10 | * Revision 1.6 2000/02/02 15:13:23 adam
|
---|
11 | * Minor change.
|
---|
12 | *
|
---|
13 | * Revision 1.5 2000/01/31 13:15:22 adam
|
---|
14 | * Removed uses of assert(3). Cleanup of ODR. CCL parser update so
|
---|
15 | * that some characters are not surrounded by spaces in resulting term.
|
---|
16 | * ILL-code updates.
|
---|
17 | *
|
---|
18 | * Revision 1.4 1999/12/20 15:20:13 adam
|
---|
19 | * Implemented ccl_pquery to convert from CCL tree to prefix query.
|
---|
20 | *
|
---|
21 | * Revision 1.3 1999/11/30 13:47:12 adam
|
---|
22 | * Improved installation. Moved header files to include/yaz.
|
---|
23 | *
|
---|
24 | * Revision 1.2 1999/06/16 12:00:08 adam
|
---|
25 | * Added proximity.
|
---|
26 | *
|
---|
27 | * Revision 1.1 1999/06/08 10:12:43 adam
|
---|
28 | * Moved file to be part of zutil (instead of util).
|
---|
29 | *
|
---|
30 | * Revision 1.13 1998/03/31 15:13:20 adam
|
---|
31 | * Development towards compiled ASN.1.
|
---|
32 | *
|
---|
33 | * Revision 1.12 1998/02/11 11:53:36 adam
|
---|
34 | * Changed code so that it compiles as C++.
|
---|
35 | *
|
---|
36 | * Revision 1.11 1997/11/24 11:33:57 adam
|
---|
37 | * Using function odr_nullval() instead of global ODR_NULLVAL when
|
---|
38 | * appropriate.
|
---|
39 | *
|
---|
40 | * Revision 1.10 1997/09/29 08:58:25 adam
|
---|
41 | * Fixed conversion of trees so that true copy is made.
|
---|
42 | *
|
---|
43 | * Revision 1.9 1997/06/23 10:31:25 adam
|
---|
44 | * Added ODR argument to ccl_rpn_query and ccl_scan_query.
|
---|
45 | *
|
---|
46 | * Revision 1.8 1996/10/29 13:36:27 adam
|
---|
47 | * Added header.
|
---|
48 | *
|
---|
49 | */
|
---|
50 |
|
---|
51 | #include <stdio.h>
|
---|
52 | #include <stdlib.h>
|
---|
53 | #include <string.h>
|
---|
54 |
|
---|
55 | #include <yaz/yaz-ccl.h>
|
---|
56 |
|
---|
57 | static Z_RPNStructure *ccl_rpn_structure (ODR o, struct ccl_rpn_node *p);
|
---|
58 |
|
---|
59 | static Z_AttributesPlusTerm *ccl_rpn_term (ODR o, struct ccl_rpn_node *p)
|
---|
60 | {
|
---|
61 | struct ccl_rpn_attr *attr;
|
---|
62 | int num = 0;
|
---|
63 | Z_AttributesPlusTerm *zapt;
|
---|
64 | Odr_oct *term_octet;
|
---|
65 | Z_Term *term;
|
---|
66 | Z_AttributeElement **elements;
|
---|
67 |
|
---|
68 | zapt = (Z_AttributesPlusTerm *)odr_malloc (o, sizeof(*zapt));
|
---|
69 |
|
---|
70 | term_octet = (Odr_oct *)odr_malloc (o, sizeof(*term_octet));
|
---|
71 |
|
---|
72 | term = (Z_Term *)odr_malloc (o, sizeof(*term));
|
---|
73 |
|
---|
74 | for (attr = p->u.t.attr_list; attr; attr = attr->next)
|
---|
75 | num++;
|
---|
76 | if (!num)
|
---|
77 | elements = (Z_AttributeElement**)odr_nullval();
|
---|
78 | else
|
---|
79 | {
|
---|
80 | int i = 0;
|
---|
81 | elements = (Z_AttributeElement **)
|
---|
82 | odr_malloc (o, num*sizeof(*elements));
|
---|
83 | for (attr = p->u.t.attr_list; attr; attr = attr->next, i++)
|
---|
84 | {
|
---|
85 | elements[i] = (Z_AttributeElement *)
|
---|
86 | odr_malloc (o, sizeof(**elements));
|
---|
87 | elements[i]->attributeType =
|
---|
88 | (int *)odr_malloc(o, sizeof(int));
|
---|
89 | *elements[i]->attributeType = attr->type;
|
---|
90 | elements[i]->attributeSet = 0;
|
---|
91 | elements[i]->which = Z_AttributeValue_numeric;
|
---|
92 | elements[i]->value.numeric =
|
---|
93 | (int *)odr_malloc (o, sizeof(int));
|
---|
94 | *elements[i]->value.numeric = attr->value;
|
---|
95 | }
|
---|
96 | }
|
---|
97 | #ifdef ASN_COMPILED
|
---|
98 | zapt->attributes = (Z_AttributeList *)
|
---|
99 | odr_malloc (o, sizeof(*zapt->attributes));
|
---|
100 | zapt->attributes->num_attributes = num;
|
---|
101 | zapt->attributes->attributes = elements;
|
---|
102 | #else
|
---|
103 | zapt->num_attributes = num;
|
---|
104 | zapt->attributeList = elements;
|
---|
105 | #endif
|
---|
106 | zapt->term = term;
|
---|
107 | term->which = Z_Term_general;
|
---|
108 | term->u.general = term_octet;
|
---|
109 | term_octet->len = term_octet->size = strlen (p->u.t.term);
|
---|
110 | term_octet->buf = (unsigned char *)odr_malloc (o, term_octet->len+1);
|
---|
111 | strcpy ((char*) term_octet->buf, p->u.t.term);
|
---|
112 | return zapt;
|
---|
113 | }
|
---|
114 |
|
---|
115 | static Z_Operand *ccl_rpn_simple (ODR o, struct ccl_rpn_node *p)
|
---|
116 | {
|
---|
117 | Z_Operand *zo;
|
---|
118 |
|
---|
119 | zo = (Z_Operand *)odr_malloc (o, sizeof(*zo));
|
---|
120 |
|
---|
121 | switch (p->kind)
|
---|
122 | {
|
---|
123 | case CCL_RPN_TERM:
|
---|
124 | zo->which = Z_Operand_APT;
|
---|
125 | zo->u.attributesPlusTerm = ccl_rpn_term (o, p);
|
---|
126 | break;
|
---|
127 | case CCL_RPN_SET:
|
---|
128 | zo->which = Z_Operand_resultSetId;
|
---|
129 | zo->u.resultSetId = p->u.setname;
|
---|
130 | break;
|
---|
131 | default:
|
---|
132 | return 0;
|
---|
133 | }
|
---|
134 | return zo;
|
---|
135 | }
|
---|
136 |
|
---|
137 | static Z_Complex *ccl_rpn_complex (ODR o, struct ccl_rpn_node *p)
|
---|
138 | {
|
---|
139 | Z_Complex *zc;
|
---|
140 | Z_Operator *zo;
|
---|
141 |
|
---|
142 | zc = (Z_Complex *)odr_malloc (o, sizeof(*zc));
|
---|
143 | zo = (Z_Operator *)odr_malloc (o, sizeof(*zo));
|
---|
144 |
|
---|
145 | zc->roperator = zo;
|
---|
146 | switch (p->kind)
|
---|
147 | {
|
---|
148 | case CCL_RPN_AND:
|
---|
149 | zo->which = Z_Operator_and;
|
---|
150 | zo->u.and = odr_nullval();
|
---|
151 | break;
|
---|
152 | case CCL_RPN_OR:
|
---|
153 | zo->which = Z_Operator_or;
|
---|
154 | zo->u.and = odr_nullval();
|
---|
155 | break;
|
---|
156 | case CCL_RPN_NOT:
|
---|
157 | zo->which = Z_Operator_and_not;
|
---|
158 | zo->u.and = odr_nullval();
|
---|
159 | break;
|
---|
160 | case CCL_RPN_PROX:
|
---|
161 | zo->which = Z_Operator_prox;
|
---|
162 | zo->u.prox = (Z_ProximityOperator *)
|
---|
163 | odr_malloc (o, sizeof(*zo->u.prox));
|
---|
164 | zo->u.prox->exclusion = 0;
|
---|
165 |
|
---|
166 | zo->u.prox->distance = (int *)
|
---|
167 | odr_malloc (o, sizeof(*zo->u.prox->distance));
|
---|
168 | *zo->u.prox->distance = 2;
|
---|
169 |
|
---|
170 | zo->u.prox->ordered = (bool_t *)
|
---|
171 | odr_malloc (o, sizeof(*zo->u.prox->ordered));
|
---|
172 | *zo->u.prox->ordered = 0;
|
---|
173 |
|
---|
174 | zo->u.prox->relationType = (int *)
|
---|
175 | odr_malloc (o, sizeof(*zo->u.prox->relationType));
|
---|
176 | #ifdef ASN_COMPILED
|
---|
177 | *zo->u.prox->relationType = Z_ProximityOperator_Prox_lessThan;
|
---|
178 | zo->u.prox->which = Z_ProximityOperator_known;
|
---|
179 | zo->u.prox->u.known =
|
---|
180 | odr_malloc (o, sizeof(*zo->u.prox->u.known));
|
---|
181 | *zo->u.prox->u.known = Z_ProxUnit_word;
|
---|
182 | #else
|
---|
183 | *zo->u.prox->relationType = Z_Prox_lessThan;
|
---|
184 | zo->u.prox->which = Z_ProxCode_known;
|
---|
185 | zo->u.prox->proximityUnitCode = (int*)
|
---|
186 | odr_malloc (o, sizeof(*zo->u.prox->proximityUnitCode));
|
---|
187 | *zo->u.prox->proximityUnitCode = Z_ProxUnit_word;
|
---|
188 | #endif
|
---|
189 | break;
|
---|
190 | default:
|
---|
191 | return 0;
|
---|
192 | }
|
---|
193 | zc->s1 = ccl_rpn_structure (o, p->u.p[0]);
|
---|
194 | zc->s2 = ccl_rpn_structure (o, p->u.p[1]);
|
---|
195 | return zc;
|
---|
196 | }
|
---|
197 |
|
---|
198 | static Z_RPNStructure *ccl_rpn_structure (ODR o, struct ccl_rpn_node *p)
|
---|
199 | {
|
---|
200 | Z_RPNStructure *zs;
|
---|
201 |
|
---|
202 | zs = (Z_RPNStructure *)odr_malloc (o, sizeof(*zs));
|
---|
203 | switch (p->kind)
|
---|
204 | {
|
---|
205 | case CCL_RPN_AND:
|
---|
206 | case CCL_RPN_OR:
|
---|
207 | case CCL_RPN_NOT:
|
---|
208 | case CCL_RPN_PROX:
|
---|
209 | zs->which = Z_RPNStructure_complex;
|
---|
210 | zs->u.complex = ccl_rpn_complex (o, p);
|
---|
211 | break;
|
---|
212 | case CCL_RPN_TERM:
|
---|
213 | case CCL_RPN_SET:
|
---|
214 | zs->which = Z_RPNStructure_simple;
|
---|
215 | zs->u.simple = ccl_rpn_simple (o, p);
|
---|
216 | break;
|
---|
217 | default:
|
---|
218 | return 0;
|
---|
219 | }
|
---|
220 | return zs;
|
---|
221 | }
|
---|
222 |
|
---|
223 | Z_RPNQuery *ccl_rpn_query (ODR o, struct ccl_rpn_node *p)
|
---|
224 | {
|
---|
225 | Z_RPNQuery *zq;
|
---|
226 |
|
---|
227 | zq = (Z_RPNQuery *)odr_malloc (o, sizeof(*zq));
|
---|
228 | zq->attributeSetId = NULL;
|
---|
229 | zq->RPNStructure = ccl_rpn_structure (o, p);
|
---|
230 | return zq;
|
---|
231 | }
|
---|
232 |
|
---|
233 | Z_AttributesPlusTerm *ccl_scan_query (ODR o, struct ccl_rpn_node *p)
|
---|
234 | {
|
---|
235 | if (p->kind != CCL_RPN_TERM)
|
---|
236 | return NULL;
|
---|
237 | return ccl_rpn_term (o, p);
|
---|
238 | }
|
---|
239 |
|
---|
240 | static void ccl_pquery_complex (WRBUF w, struct ccl_rpn_node *p)
|
---|
241 | {
|
---|
242 | switch (p->kind)
|
---|
243 | {
|
---|
244 | case CCL_RPN_AND:
|
---|
245 | wrbuf_puts (w, "@and ");
|
---|
246 | break;
|
---|
247 | case CCL_RPN_OR:
|
---|
248 | wrbuf_puts(w, "@or ");
|
---|
249 | break;
|
---|
250 | case CCL_RPN_NOT:
|
---|
251 | wrbuf_puts(w, "@not ");
|
---|
252 | break;
|
---|
253 | case CCL_RPN_PROX:
|
---|
254 | wrbuf_puts(w, "@prox 0 2 0 1 known 2 ");
|
---|
255 | break;
|
---|
256 | default:
|
---|
257 | wrbuf_puts(w, "@ bad op (unknown) ");
|
---|
258 | };
|
---|
259 | ccl_pquery(w, p->u.p[0]);
|
---|
260 | ccl_pquery(w, p->u.p[1]);
|
---|
261 | }
|
---|
262 |
|
---|
263 | void ccl_pquery (WRBUF w, struct ccl_rpn_node *p)
|
---|
264 | {
|
---|
265 | struct ccl_rpn_attr *att;
|
---|
266 |
|
---|
267 | switch (p->kind)
|
---|
268 | {
|
---|
269 | case CCL_RPN_AND:
|
---|
270 | case CCL_RPN_OR:
|
---|
271 | case CCL_RPN_NOT:
|
---|
272 | case CCL_RPN_PROX:
|
---|
273 | ccl_pquery_complex (w, p);
|
---|
274 | break;
|
---|
275 | case CCL_RPN_SET:
|
---|
276 | wrbuf_puts (w, "@set ");
|
---|
277 | wrbuf_puts (w, p->u.setname);
|
---|
278 | wrbuf_puts (w, " ");
|
---|
279 | break;
|
---|
280 | case CCL_RPN_TERM:
|
---|
281 | for (att = p->u.t.attr_list; att; att = att->next)
|
---|
282 | {
|
---|
283 | char tmpattr[128];
|
---|
284 | sprintf(tmpattr, "@attr %d=%d ", att->type, att->value);
|
---|
285 | wrbuf_puts (w, tmpattr);
|
---|
286 | }
|
---|
287 | wrbuf_puts (w, "{");
|
---|
288 | wrbuf_puts (w, p->u.t.term);
|
---|
289 | wrbuf_puts (w, "} ");
|
---|
290 | break;
|
---|
291 | }
|
---|
292 | }
|
---|