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