util/yaz-ccl.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <assert.h>
   5
   6 #include <yaz-ccl.h>
   7
   8 static Z_RPNStructure *ccl_rpn_structure (struct ccl_rpn_node *p);
   9
  10 static Z_AttributesPlusTerm *ccl_rpn_term (struct ccl_rpn_node *p)
  11 {
  12     struct ccl_rpn_attr *attr;
  13     int num = 0;
  14     Z_AttributesPlusTerm *zapt;
  15     Odr_oct *term_octet;
  16     Z_Term *term;
  17
  18     zapt = malloc (sizeof(*zapt));
  19     assert (zapt);
  20
  21     term_octet = malloc (sizeof(*term_octet));
  22     assert (term_octet);
  23
  24     term = malloc(sizeof(*term));
  25     assert(term);
  26
  27     for (attr = p->u.t.attr_list; attr; attr = attr->next)
  28         num++;
  29     zapt->num_attributes = num;
  30     if (num)
  31     {
  32         int i = 0;
  33         zapt->attributeList = malloc (num*sizeof(*zapt->attributeList));
  34         assert (zapt->attributeList);
  35         for (attr = p->u.t.attr_list; attr; attr = attr->next, i++)
  36         {
  37             zapt->attributeList[i] = malloc (sizeof(**zapt->attributeList));
  38             assert (zapt->attributeList[i]);
  39             zapt->attributeList[i]->attributeType =
  40                 &attr->type;
  41             zapt->attributeList[i]->attributeValue =
  42                 &attr->value;
  43         }
  44     }
  45     else
  46         zapt->attributeList = ODR_NULLVAL;
  47
  48     zapt->term = term;
  49     term->which = Z_Term_general;
  50     term->u.general = term_octet;
  51     term_octet->buf = (unsigned char*) p->u.t.term;
  52     term_octet->len = term_octet->size = strlen (p->u.t.term);
  53     return zapt;
  54 }
  55
  56 static Z_Operand *ccl_rpn_simple (struct ccl_rpn_node *p)
  57 {
  58     Z_Operand *zo;
  59
  60     zo = malloc (sizeof(*zo));
  61     assert (zo);
  62
  63     switch (p->kind)
  64     {
  65     case CCL_RPN_TERM:
  66         zo->which = Z_Operand_APT;
  67         zo->u.attributesPlusTerm = ccl_rpn_term (p);
  68         break;
  69     case CCL_RPN_SET:
  70         zo->which = Z_Operand_resultSetId;
  71         zo->u.resultSetId = p->u.setname;
  72         break;
  73     default:
  74         assert (0);
  75     }
  76     return zo;
  77 }
  78
  79 static Z_Complex *ccl_rpn_complex (struct ccl_rpn_node *p)
  80 {
  81     Z_Complex *zc;
  82     Z_Operator *zo;
  83
  84     zc = malloc (sizeof(*zc));
  85     assert (zc);
  86     zo = malloc (sizeof(*zo));
  87     assert (zo);
  88
  89     zc->operator = zo;
  90     switch (p->kind)
  91     {
  92     case CCL_RPN_AND:
  93         zo->which = Z_Operator_and;
  94         zo->u.and = ODR_NULLVAL;
  95         break;
  96     case CCL_RPN_OR:
  97         zo->which = Z_Operator_or;
  98         zo->u.and = ODR_NULLVAL;
  99         break;
 100     case CCL_RPN_NOT:
 101         zo->which = Z_Operator_and_not;
 102         zo->u.and = ODR_NULLVAL;
 103         break;
 104     default:
 105         assert (0);
 106     }
 107     zc->s1 = ccl_rpn_structure (p->u.p[0]);
 108     zc->s2 = ccl_rpn_structure (p->u.p[1]);
 109     return zc;
 110 }
 111
 112 static Z_RPNStructure *ccl_rpn_structure (struct ccl_rpn_node *p)
 113 {
 114     Z_RPNStructure *zs;
 115
 116     zs = malloc (sizeof(*zs));
 117     assert (zs);
 118     switch (p->kind)
 119     {
 120     case CCL_RPN_AND:
 121     case CCL_RPN_OR:
 122     case CCL_RPN_NOT:
 123     case CCL_RPN_PROX:
 124         zs->which = Z_RPNStructure_complex;
 125         zs->u.complex = ccl_rpn_complex (p);
 126         break;
 127     case CCL_RPN_TERM:
 128     case CCL_RPN_SET:
 129         zs->which = Z_RPNStructure_simple;
 130         zs->u.simple = ccl_rpn_simple (p);
 131         break;
 132     default:
 133         assert (0);
 134     }
 135     return zs;
 136 }
 137
 138 Z_RPNQuery *ccl_rpn_query (struct ccl_rpn_node *p)
 139 {
 140     Z_RPNQuery *zq;
 141
 142     zq = malloc (sizeof(*zq));
 143     assert (zq);
 144     zq->attributeSetId = NULL;
 145     zq->RPNStructure = ccl_rpn_structure (p);
 146     return zq;
 147 }
 148
 149 Z_AttributesPlusTerm *ccl_scan_query (struct ccl_rpn_node *p)
 150 {
 151     if (p->kind != CCL_RPN_TERM)
 152         return NULL;
 153     return ccl_rpn_term (p);
 154 }