src/cclptree.c

   1 /*
   2  * Copyright (c) 1995, the EUROPAGATE consortium (see below).
   3  *
   4  * The EUROPAGATE consortium members are:
   5  *
   6  *    University College Dublin
   7  *    Danmarks Teknologiske Videnscenter
   8  *    An Chomhairle Leabharlanna
   9  *    Consejo Superior de Investigaciones Cientificas
  10  *
  11  * Permission to use, copy, modify, distribute, and sell this software and
  12  * its documentation, in whole or in part, for any purpose, is hereby granted,
  13  * provided that:
  14  *
  15  * 1. This copyright and permission notice appear in all copies of the
  16  * software and its documentation. Notices of copyright or attribution
  17  * which appear at the beginning of any file must remain unchanged.
  18  *
  19  * 2. The names of EUROPAGATE or the project partners may not be used to
  20  * endorse or promote products derived from this software without specific
  21  * prior written permission.
  22  *
  23  * 3. Users of this software (implementors and gateway operators) agree to
  24  * inform the EUROPAGATE consortium of their use of the software. This
  25  * information will be used to evaluate the EUROPAGATE project and the
  26  * software, and to plan further developments. The consortium may use
  27  * the information in later publications.
  28  *
  29  * 4. Users of this software agree to make their best efforts, when
  30  * documenting their use of the software, to acknowledge the EUROPAGATE
  31  * consortium, and the role played by the software in their work.
  32  *
  33  * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
  34  * EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  35  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  36  * IN NO EVENT SHALL THE EUROPAGATE CONSORTIUM OR ITS MEMBERS BE LIABLE
  37  * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF
  38  * ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
  39  * OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND
  40  * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  41  * USE OR PERFORMANCE OF THIS SOFTWARE.
  42  *
  43  */
  44
  45 /**
  46  * \file cclptree.c
  47  * \brief Implements CCL parse tree printing
  48  *
  49  * This source file implements functions to parse and print
  50  * a CCL node tree (as a result of parsing).
  51  */
  52
  53 /* CCL print rpn tree - infix notation
  54  * Europagate, 1995
  55  *
  56  * $Id: cclptree.c,v 1.4 2004-12-30 00:22:25 adam Exp $
  57  *
  58  * Old Europagate Log:
  59  *
  60  * Revision 1.6  1995/05/16  09:39:26  adam
  61  * LICENSE.
  62  *
  63  * Revision 1.5  1995/02/23  08:31:59  adam
  64  * Changed header.
  65  *
  66  * Revision 1.3  1995/02/15  17:42:16  adam
  67  * Minor changes of the api of this module. FILE* argument added
  68  * to ccl_pr_tree.
  69  *
  70  * Revision 1.2  1995/02/14  19:55:11  adam
  71  * Header files ccl.h/cclp.h are gone! They have been merged an
  72  * moved to ../include/ccl.h.
  73  * Node kind(s) in ccl_rpn_node have changed names.
  74  *
  75  * Revision 1.1  1995/02/14  10:25:56  adam
  76  * The constructions 'qualifier rel term ...' implemented.
  77  *
  78  */
  79
  80 #include <stdio.h>
  81 #include <string.h>
  82 #include <ctype.h>
  83
  84 #include <yaz/ccl.h>
  85
  86 void fprintSpaces(int indent,FILE * fd_out)
  87 {
  88         char buf[100];
  89         sprintf(buf,"%%%d.s",indent);
  90         fprintf(fd_out,buf," ");
  91 }
  92
  93 void ccl_pr_tree_as_qrpn(struct ccl_rpn_node *rpn, FILE *fd_out, int indent)
  94 {
  95         if(indent>0) fprintSpaces(indent,fd_out);
  96     switch (rpn->kind)
  97     {
  98     case CCL_RPN_TERM:
  99         if (rpn->u.t.attr_list)
 100         {
 101             struct ccl_rpn_attr *attr;
 102             for (attr = rpn->u.t.attr_list; attr; attr = attr->next)
 103                         {
 104                                 if (attr->set)
 105                                         fprintf(fd_out, "@attr %s ", attr->set);
 106                                 else
 107                                         fprintf(fd_out, "@attr ");
 108                                 switch(attr->kind)
 109                                 {
 110                                 case CCL_RPN_ATTR_NUMERIC:
 111                     fprintf (fd_out, "%d=%d ", attr->type,
 112                              attr->value.numeric);
 113                                         break;
 114                                 case CCL_RPN_ATTR_STRING:
 115                     fprintf (fd_out, "%d=%s ", attr->type,
 116                                                          attr->value.str);
 117                                 }
 118                         }
 119         }
 120                 fprintf (fd_out, "\"%s\"\n", rpn->u.t.term);
 121         break;
 122     case CCL_RPN_AND:
 123         fprintf (fd_out, "@and \n");
 124         ccl_pr_tree_as_qrpn (rpn->u.p[0], fd_out,indent+2);
 125         ccl_pr_tree_as_qrpn (rpn->u.p[1], fd_out,indent+2);
 126         break;
 127     case CCL_RPN_OR:
 128         fprintf (fd_out, "@or \n");
 129         ccl_pr_tree_as_qrpn (rpn->u.p[0], fd_out,indent+2);
 130         ccl_pr_tree_as_qrpn (rpn->u.p[1], fd_out,indent+2);
 131         break;
 132     case CCL_RPN_NOT:
 133         fprintf (fd_out, "@not ");
 134         ccl_pr_tree_as_qrpn (rpn->u.p[0], fd_out,indent+2);
 135         ccl_pr_tree_as_qrpn (rpn->u.p[1], fd_out,indent+2);
 136         break;
 137     case CCL_RPN_SET:
 138         fprintf (fd_out, "set=%s ", rpn->u.setname);
 139         break;
 140     case CCL_RPN_PROX:
 141         if (rpn->u.p[2] && rpn->u.p[2]->kind == CCL_RPN_TERM)
 142         {
 143             const char *cp = rpn->u.p[2]->u.t.term;
 144             /* exlusion distance ordered relation which-code unit-code */
 145             if (*cp == '!')
 146             {
 147                 /* word order specified */
 148                 if (isdigit(((const unsigned char *) cp)[1]))
 149                     fprintf(fd_out, "@prox 0 %s 1 2 known 2", cp+1);
 150                 else
 151                     fprintf(fd_out, "@prox 0 1 1 2 known 2");
 152             }
 153             else if (*cp == '%')
 154             {
 155                 /* word order not specified */
 156                 if (isdigit(((const unsigned char *) cp)[1]))
 157                     fprintf(fd_out, "@prox 0 %s 0 2 known 2", cp+1);
 158                 else
 159                     fprintf(fd_out, "@prox 0 1 0 2 known 2");
 160             }
 161         }
 162         ccl_pr_tree_as_qrpn (rpn->u.p[0], fd_out,indent+2);
 163         ccl_pr_tree_as_qrpn (rpn->u.p[1], fd_out,indent+2);
 164         break;
 165     default:
 166                 fprintf(stderr,"Internal Error Unknown ccl_rpn node type %d\n",rpn->kind);
 167     }
 168 }
 169
 170
 171 void ccl_pr_tree (struct ccl_rpn_node *rpn, FILE *fd_out)
 172 {
 173         ccl_pr_tree_as_qrpn(rpn,fd_out,0);
 174 }
 175
 176
 177 static void ccl_pquery_complex (WRBUF w, struct ccl_rpn_node *p)
 178 {
 179     switch (p->kind)
 180     {
 181     case CCL_RPN_AND:
 182         wrbuf_puts(w, "@and ");
 183                 break;
 184     case CCL_RPN_OR:
 185         wrbuf_puts(w, "@or ");
 186                 break;
 187     case CCL_RPN_NOT:
 188         wrbuf_puts(w, "@not ");
 189                 break;
 190     case CCL_RPN_PROX:
 191         if (p->u.p[2] && p->u.p[2]->kind == CCL_RPN_TERM)
 192         {
 193             const char *cp = p->u.p[2]->u.t.term;
 194             /* exlusion distance ordered relation which-code unit-code */
 195             if (*cp == '!')
 196             {
 197                 /* word order specified */
 198                 if (isdigit(((const unsigned char *) cp)[1]))
 199                     wrbuf_printf(w, "@prox 0 %s 1 2 k 2 ", cp+1);
 200                 else
 201                     wrbuf_printf(w, "@prox 0 1 1 2 k 2 ");
 202             }
 203             else if (*cp == '%')
 204             {
 205                 /* word order not specified */
 206                 if (isdigit(((const unsigned char *) cp)[1]))
 207                     wrbuf_printf(w, "@prox 0 %s 0 2 k 2 ", cp+1);
 208                 else
 209                     wrbuf_printf(w, "@prox 0 1 0 2 k 2 ");
 210             }
 211         }
 212         else
 213             wrbuf_puts(w, "@prox 0 2 0 1 k 2 ");
 214                 break;
 215     default:
 216                 wrbuf_puts(w, "@ bad op (unknown) ");
 217     }
 218     ccl_pquery(w, p->u.p[0]);
 219     ccl_pquery(w, p->u.p[1]);
 220 }
 221
 222 void ccl_pquery (WRBUF w, struct ccl_rpn_node *p)
 223 {
 224     struct ccl_rpn_attr *att;
 225     const char *cp;
 226
 227     switch (p->kind)
 228     {
 229     case CCL_RPN_AND:
 230     case CCL_RPN_OR:
 231     case CCL_RPN_NOT:
 232     case CCL_RPN_PROX:
 233         ccl_pquery_complex (w, p);
 234                 break;
 235     case CCL_RPN_SET:
 236                 wrbuf_puts (w, "@set ");
 237                 wrbuf_puts (w, p->u.setname);
 238                 wrbuf_puts (w, " ");
 239                 break;
 240     case CCL_RPN_TERM:
 241         for (att = p->u.t.attr_list; att; att = att->next)
 242                 {
 243                         char tmpattr[128];
 244                         wrbuf_puts (w, "@attr ");
 245                         if (att->set)
 246                         {
 247                                 wrbuf_puts (w, att->set);
 248                                 wrbuf_puts (w, " ");
 249                         }
 250                         switch(att->kind)
 251                         {
 252                         case CCL_RPN_ATTR_NUMERIC:
 253                                 sprintf(tmpattr, "%d=%d ", att->type, att->value.numeric);
 254                                 wrbuf_puts (w, tmpattr);
 255                                 break;
 256                         case CCL_RPN_ATTR_STRING:
 257                                 sprintf(tmpattr, "%d=", att->type);
 258                                 wrbuf_puts (w, tmpattr);
 259                                 wrbuf_puts(w, att->value.str);
 260                                 wrbuf_puts (w, " ");
 261                                 break;
 262                         }
 263                 }
 264                 for (cp = p->u.t.term; *cp; cp++)
 265                 {
 266                         if (*cp == ' ' || *cp == '\\')
 267                                 wrbuf_putc (w, '\\');
 268                         wrbuf_putc (w, *cp);
 269                 }
 270                 wrbuf_puts (w, " ");
 271                 break;
 272     }
 273 }
 274
 275 /*
 276  * Local variables:
 277  * tab-width: 8
 278  * c-basic-offset: 4
 279  * End:
 280  */