zutil/yaz-ccl.c

   1 /*
   2  * Copyright (c) 1996-1998, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: yaz-ccl.c,v $
   7  * Revision 1.2  1999-06-16 12:00:08  adam
   8  * Added proximity.
   9  *
  10  * Revision 1.1  1999/06/08 10:12:43  adam
  11  * Moved file to be part of zutil (instead of util).
  12  *
  13  * Revision 1.13  1998/03/31 15:13:20  adam
  14  * Development towards compiled ASN.1.
  15  *
  16  * Revision 1.12  1998/02/11 11:53:36  adam
  17  * Changed code so that it compiles as C++.
  18  *
  19  * Revision 1.11  1997/11/24 11:33:57  adam
  20  * Using function odr_nullval() instead of global ODR_NULLVAL when
  21  * appropriate.
  22  *
  23  * Revision 1.10  1997/09/29 08:58:25  adam
  24  * Fixed conversion of trees so that true copy is made.
  25  *
  26  * Revision 1.9  1997/06/23 10:31:25  adam
  27  * Added ODR argument to ccl_rpn_query and ccl_scan_query.
  28  *
  29  * Revision 1.8  1996/10/29 13:36:27  adam
  30  * Added header.
  31  *
  32  */
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <assert.h>
  38
  39 #include <yaz-ccl.h>
  40
  41 static Z_RPNStructure *ccl_rpn_structure (ODR o, struct ccl_rpn_node *p);
  42
  43 static Z_AttributesPlusTerm *ccl_rpn_term (ODR o, struct ccl_rpn_node *p)
  44 {
  45     struct ccl_rpn_attr *attr;
  46     int num = 0;
  47     Z_AttributesPlusTerm *zapt;
  48     Odr_oct *term_octet;
  49     Z_Term *term;
  50     Z_AttributeElement **elements;
  51
  52     zapt = (Z_AttributesPlusTerm *)odr_malloc (o, sizeof(*zapt));
  53     assert (zapt);
  54
  55     term_octet = (Odr_oct *)odr_malloc (o, sizeof(*term_octet));
  56     assert (term_octet);
  57
  58     term = (Z_Term *)odr_malloc (o, sizeof(*term));
  59     assert(term);
  60
  61     for (attr = p->u.t.attr_list; attr; attr = attr->next)
  62         num++;
  63     if (!num)
  64         elements = (Z_AttributeElement**)odr_nullval();
  65     else
  66     {
  67         int i = 0;
  68         elements = (Z_AttributeElement **)
  69             odr_malloc (o, num*sizeof(*elements));
  70         for (attr = p->u.t.attr_list; attr; attr = attr->next, i++)
  71         {
  72             elements[i] = (Z_AttributeElement *)
  73                 odr_malloc (o, sizeof(**elements));
  74             assert (elements[i]);
  75             elements[i]->attributeType =
  76                 (int *)odr_malloc(o, sizeof(int));
  77             *elements[i]->attributeType = attr->type;
  78             elements[i]->attributeSet = 0;
  79             elements[i]->which = Z_AttributeValue_numeric;
  80             elements[i]->value.numeric =
  81                 (int *)odr_malloc (o, sizeof(int));
  82             *elements[i]->value.numeric = attr->value;
  83         }
  84     }
  85 #ifdef ASN_COMPILED
  86     zapt->attributes = (Z_AttributeList *)
  87         odr_malloc (o, sizeof(*zapt->attributes));
  88     zapt->attributes->num_attributes = num;
  89     zapt->attributes->attributes = elements;
  90 #else
  91     zapt->num_attributes = num;
  92     zapt->attributeList = elements;
  93 #endif
  94     zapt->term = term;
  95     term->which = Z_Term_general;
  96     term->u.general = term_octet;
  97     term_octet->len = term_octet->size = strlen (p->u.t.term);
  98     term_octet->buf = (unsigned char *)odr_malloc (o, term_octet->len+1);
  99     strcpy ((char*) term_octet->buf, p->u.t.term);
 100     return zapt;
 101 }
 102
 103 static Z_Operand *ccl_rpn_simple (ODR o, struct ccl_rpn_node *p)
 104 {
 105     Z_Operand *zo;
 106
 107     zo = (Z_Operand *)odr_malloc (o, sizeof(*zo));
 108     assert (zo);
 109
 110     switch (p->kind)
 111     {
 112     case CCL_RPN_TERM:
 113         zo->which = Z_Operand_APT;
 114         zo->u.attributesPlusTerm = ccl_rpn_term (o, p);
 115         break;
 116     case CCL_RPN_SET:
 117         zo->which = Z_Operand_resultSetId;
 118         zo->u.resultSetId = p->u.setname;
 119         break;
 120     default:
 121         assert (0);
 122     }
 123     return zo;
 124 }
 125
 126 static Z_Complex *ccl_rpn_complex (ODR o, struct ccl_rpn_node *p)
 127 {
 128     Z_Complex *zc;
 129     Z_Operator *zo;
 130
 131     zc = (Z_Complex *)odr_malloc (o, sizeof(*zc));
 132     assert (zc);
 133     zo = (Z_Operator *)odr_malloc (o, sizeof(*zo));
 134     assert (zo);
 135
 136     zc->roperator = zo;
 137     switch (p->kind)
 138     {
 139     case CCL_RPN_AND:
 140         zo->which = Z_Operator_and;
 141         zo->u.and = odr_nullval();
 142         break;
 143     case CCL_RPN_OR:
 144         zo->which = Z_Operator_or;
 145         zo->u.and = odr_nullval();
 146         break;
 147     case CCL_RPN_NOT:
 148         zo->which = Z_Operator_and_not;
 149         zo->u.and = odr_nullval();
 150         break;
 151     case CCL_RPN_PROX:
 152         zo->which = Z_Operator_prox;
 153         zo->u.prox = (Z_ProximityOperator *)
 154             odr_malloc (o, sizeof(*zo->u.prox));
 155         zo->u.prox->exclusion = 0;
 156
 157         zo->u.prox->distance = (int *)
 158             odr_malloc (o, sizeof(*zo->u.prox->distance));
 159         *zo->u.prox->distance = 2;
 160
 161         zo->u.prox->ordered = (bool_t *)
 162             odr_malloc (o, sizeof(*zo->u.prox->ordered));
 163         *zo->u.prox->ordered = 0;
 164
 165         zo->u.prox->relationType = (int *)
 166             odr_malloc (o, sizeof(*zo->u.prox->relationType));
 167 #ifdef ASN_COMPILED
 168         *zo->u.prox->relationType = Z_ProximityOperator_Prox_lessThan;
 169         zo->u.prox->which = Z_ProximityOperator_known;
 170         zo->u.prox->u.known =
 171             odr_malloc (o, sizeof(*zo->u.prox->u.known));
 172         *zo->u.prox->u.known = Z_ProxUnit_word;
 173 #else
 174         *zo->u.prox->relationType = Z_Prox_lessThan;
 175         zo->u.prox->which = Z_ProxCode_known;
 176         zo->u.prox->proximityUnitCode = (int*)
 177             odr_malloc (o, sizeof(*zo->u.prox->proximityUnitCode));
 178         *zo->u.prox->proximityUnitCode = Z_ProxUnit_word;
 179 #endif
 180         break;
 181     default:
 182         assert (0);
 183     }
 184     zc->s1 = ccl_rpn_structure (o, p->u.p[0]);
 185     zc->s2 = ccl_rpn_structure (o, p->u.p[1]);
 186     return zc;
 187 }
 188
 189 static Z_RPNStructure *ccl_rpn_structure (ODR o, struct ccl_rpn_node *p)
 190 {
 191     Z_RPNStructure *zs;
 192
 193     zs = (Z_RPNStructure *)odr_malloc (o, sizeof(*zs));
 194     assert (zs);
 195     switch (p->kind)
 196     {
 197     case CCL_RPN_AND:
 198     case CCL_RPN_OR:
 199     case CCL_RPN_NOT:
 200     case CCL_RPN_PROX:
 201         zs->which = Z_RPNStructure_complex;
 202         zs->u.complex = ccl_rpn_complex (o, p);
 203         break;
 204     case CCL_RPN_TERM:
 205     case CCL_RPN_SET:
 206         zs->which = Z_RPNStructure_simple;
 207         zs->u.simple = ccl_rpn_simple (o, p);
 208         break;
 209     default:
 210         assert (0);
 211     }
 212     return zs;
 213 }
 214
 215 Z_RPNQuery *ccl_rpn_query (ODR o, struct ccl_rpn_node *p)
 216 {
 217     Z_RPNQuery *zq;
 218
 219     zq = (Z_RPNQuery *)odr_malloc (o, sizeof(*zq));
 220     assert (zq);
 221     zq->attributeSetId = NULL;
 222     zq->RPNStructure = ccl_rpn_structure (o, p);
 223     return zq;
 224 }
 225
 226 Z_AttributesPlusTerm *ccl_scan_query (ODR o, struct ccl_rpn_node *p)
 227 {
 228     if (p->kind != CCL_RPN_TERM)
 229         return NULL;
 230     return ccl_rpn_term (o, p);
 231 }