src/cql.y

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2011 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /* bison parser for CQL grammar. */
   6 %{
   7 /**
   8  * \file cql.c
   9  * \brief Implements CQL parser.
  10  *
  11  * This is a YACC parser, but since it must be reentrant, Bison is required.
  12  * The original source file is cql.y.
  13  */
  14 #if HAVE_CONFIG_H
  15 #include <config.h>
  16 #endif
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <yaz/yaz-iconv.h>
  21 #include <yaz/xmalloc.h>
  22 #include <yaz/nmem.h>
  23 #include <yaz/cql.h>
  24
  25     /** Node in the LALR parse tree. */
  26     typedef struct {
  27         /** Inhereted attribute: relation */
  28         struct cql_node *rel;
  29         /** Synthesized attribute: CQL node */
  30         struct cql_node *cql;
  31         /** string buffer with token */
  32         char *buf;
  33         /** length of token */
  34         size_t len;
  35         /** size of buffer (len <= size) */
  36         size_t size;
  37     } token;
  38
  39     struct cql_parser {
  40         int (*getbyte)(void *client_data);
  41         void (*ungetbyte)(int b, void *client_data);
  42         void *client_data;
  43         int last_error;
  44         int last_pos;
  45         struct cql_node *top;
  46         NMEM nmem;
  47     };
  48
  49 #define YYSTYPE token
  50
  51 #define YYPARSE_PARAM parm
  52 #define YYLEX_PARAM parm
  53
  54     int yylex(YYSTYPE *lval, void *vp);
  55     int yyerror(char *s);
  56 %}
  57
  58 %pure_parser
  59 %token DOTTERM TERM AND OR NOT PROX GE LE NE EXACT SORTBY
  60
  61 %%
  62
  63 top: {
  64     $$.rel = cql_node_mk_sc(((CQL_parser) parm)->nmem,
  65                             "cql.serverChoice", "=", 0);
  66     ((CQL_parser) parm)->top = 0;
  67 } cqlQuery1 sortby {
  68     cql_node_destroy($$.rel);
  69     if ($3.cql)
  70     {
  71         $3.cql->u.sort.search = $2.cql;
  72         ((CQL_parser) parm)->top = $3.cql;
  73     } else {
  74         ((CQL_parser) parm)->top = $2.cql;
  75     }
  76 }
  77 ;
  78
  79 sortby: /* empty */
  80   { $$.cql = 0; }
  81 | SORTBY sortSpec {
  82     $$.cql = $2.cql;
  83  };
  84
  85 sortSpec: sortSpec singleSpec {
  86     $$.cql = $1.cql;
  87     $$.cql->u.sort.next = $2.cql;
  88  }
  89 | singleSpec
  90 {
  91     $$.cql = $1.cql;
  92 };
  93
  94 singleSpec: index modifiers {
  95     $$.cql = cql_node_mk_sort(((CQL_parser) parm)->nmem, $1.buf, $2.cql);
  96  }
  97 ;
  98
  99 cqlQuery1: cqlQuery
 100 | cqlQuery error {
 101     cql_node_destroy($1.cql);
 102     $$.cql = 0;
 103 }
 104 ;
 105
 106 cqlQuery:
 107   scopedClause
 108  |
 109   '>' searchTerm '=' searchTerm {
 110     $$.rel = $0.rel;
 111   } cqlQuery {
 112     $$.cql = cql_apply_prefix(((CQL_parser) parm)->nmem,
 113                               $6.cql, $2.buf, $4.buf);
 114   }
 115 | '>' searchTerm {
 116       $$.rel = $0.rel;
 117   } cqlQuery {
 118     $$.cql = cql_apply_prefix(((CQL_parser) parm)->nmem,
 119                               $4.cql, 0, $2.buf);
 120    }
 121 ;
 122
 123 scopedClause:
 124   searchClause
 125 |
 126   scopedClause boolean modifiers {
 127       $$.rel = $0.rel;
 128   } searchClause {
 129       struct cql_node *cn = cql_node_mk_boolean(((CQL_parser) parm)->nmem,
 130                                                 $2.buf);
 131
 132       cn->u.boolean.modifiers = $3.cql;
 133       cn->u.boolean.left = $1.cql;
 134       cn->u.boolean.right = $5.cql;
 135
 136       $$.cql = cn;
 137   }
 138 ;
 139
 140 searchClause:
 141   '(' {
 142       $$.rel = $0.rel;
 143
 144   } cqlQuery ')' {
 145       $$.cql = $3.cql;
 146   }
 147 |
 148 searchTerm extraTerms {
 149       struct cql_node *st = cql_node_dup(((CQL_parser) parm)->nmem, $0.rel);
 150       st->u.st.extra_terms = $2.cql;
 151       st->u.st.term = nmem_strdup(((CQL_parser)parm)->nmem, $1.buf);
 152       $$.cql = st;
 153   }
 154 |
 155   index relation modifiers {
 156       $$.rel = cql_node_mk_sc(((CQL_parser) parm)->nmem, $1.buf, $2.buf, 0);
 157       $$.rel->u.st.modifiers = $3.cql;
 158   } searchClause {
 159       $$.cql = $5.cql;
 160       cql_node_destroy($4.rel);
 161   }
 162 ;
 163
 164 extraTerms:
 165 extraTerms TERM {
 166     struct cql_node *st = cql_node_mk_sc(((CQL_parser) parm)->nmem,
 167                                          /* index */ 0, /* rel */ 0, $2.buf);
 168     st->u.st.extra_terms = $1.cql;
 169     $$.cql = st;
 170 }
 171 |
 172 { $$.cql = 0; }
 173 ;
 174
 175
 176 /* unary NOT search TERM here .. */
 177
 178 boolean:
 179   AND | OR | NOT | PROX ;
 180
 181 modifiers: modifiers '/' searchTerm
 182 {
 183     struct cql_node *mod = cql_node_mk_sc(((CQL_parser)parm)->nmem,
 184                                           $3.buf, 0, 0);
 185
 186     mod->u.st.modifiers = $1.cql;
 187     $$.cql = mod;
 188 }
 189 |
 190 modifiers '/' searchTerm mrelation searchTerm
 191 {
 192     struct cql_node *mod = cql_node_mk_sc(((CQL_parser)parm)->nmem,
 193                                           $3.buf, $4.buf, $5.buf);
 194
 195     mod->u.st.modifiers = $1.cql;
 196     $$.cql = mod;
 197 }
 198 |
 199 {
 200     $$.cql = 0;
 201 }
 202 ;
 203
 204 mrelation:
 205   '='
 206 | '>'
 207 | '<'
 208 | GE
 209 | LE
 210 | NE
 211 | EXACT
 212 ;
 213
 214 relation:
 215   '='
 216 | '>'
 217 | '<'
 218 | GE
 219 | LE
 220 | NE
 221 | EXACT
 222 | DOTTERM
 223 ;
 224
 225 index:
 226   searchTerm;
 227
 228 searchTerm:
 229   TERM
 230 | DOTTERM
 231 | AND
 232 | OR
 233 | NOT
 234 | PROX
 235 | SORTBY
 236 ;
 237
 238 %%
 239
 240 int yyerror(char *s)
 241 {
 242     return 0;
 243 }
 244
 245 /**
 246  * putb is a utility that puts one character to the string
 247  * in current lexical token. This routine deallocates as
 248  * necessary using NMEM.
 249  */
 250
 251 static void putb(YYSTYPE *lval, CQL_parser cp, int c)
 252 {
 253     if (lval->len+1 >= lval->size)
 254     {
 255         char *nb = (char *)
 256             nmem_malloc(cp->nmem, (lval->size = lval->len * 2 + 20));
 257         memcpy (nb, lval->buf, lval->len);
 258         lval->buf = nb;
 259     }
 260     if (c)
 261         lval->buf[lval->len++] = c;
 262     lval->buf[lval->len] = '\0';
 263 }
 264
 265
 266 /**
 267  * yylex returns next token for Bison to be read. In this
 268  * case one of the CQL terminals are returned.
 269  */
 270 int yylex(YYSTYPE *lval, void *vp)
 271 {
 272     CQL_parser cp = (CQL_parser) vp;
 273     int c;
 274     lval->cql = 0;
 275     lval->rel = 0;
 276     lval->len = 0;
 277     lval->size = 10;
 278     lval->buf = (char *) nmem_malloc(cp->nmem, lval->size);
 279     lval->buf[0] = '\0';
 280     do
 281     {
 282         c = cp->getbyte(cp->client_data);
 283         if (c == 0)
 284             return 0;
 285         if (c == '\n')
 286             return 0;
 287     } while (yaz_isspace(c));
 288     if (strchr("()=></", c))
 289     {
 290         int c1;
 291         putb(lval, cp, c);
 292         if (c == '=')
 293         {
 294             c1 = cp->getbyte(cp->client_data);
 295             if (c1 == '=')
 296             {
 297                 putb(lval, cp, c1);
 298                 return EXACT;
 299             }
 300             else
 301                 cp->ungetbyte(c1, cp->client_data);
 302         }
 303         else if (c == '>')
 304         {
 305             c1 = cp->getbyte(cp->client_data);
 306             if (c1 == '=')
 307             {
 308                 putb(lval, cp, c1);
 309                 return GE;
 310             }
 311             else
 312                 cp->ungetbyte(c1, cp->client_data);
 313         }
 314         else if (c == '<')
 315         {
 316             c1 = cp->getbyte(cp->client_data);
 317             if (c1 == '=')
 318             {
 319                 putb(lval, cp, c1);
 320                 return LE;
 321             }
 322             else if (c1 == '>')
 323             {
 324                 putb(lval, cp, c1);
 325                 return NE;
 326             }
 327             else
 328                 cp->ungetbyte(c1, cp->client_data);
 329         }
 330         return c;
 331     }
 332     if (c == '"')
 333     {
 334         while ((c = cp->getbyte(cp->client_data)) != 0 && c != '"')
 335         {
 336             if (c == '\\')
 337             {
 338                 putb(lval, cp, c);
 339                 c = cp->getbyte(cp->client_data);
 340                 if (!c)
 341                     break;
 342             }
 343             putb(lval, cp, c);
 344         }
 345         putb(lval, cp, 0);
 346         return TERM;
 347     }
 348     else
 349     {
 350         int relation_like = 0;
 351         while (c != 0 && !strchr(" \n()=<>/", c))
 352         {
 353             if (c == '.')
 354                 relation_like = 1;
 355             if (c == '\\')
 356             {
 357                 putb(lval, cp, c);
 358                 c = cp->getbyte(cp->client_data);
 359                 if (!c)
 360                     break;
 361             }
 362             putb(lval, cp, c);
 363             c = cp->getbyte(cp->client_data);
 364         }
 365         putb(lval, cp, 0);
 366 #if YYDEBUG
 367         printf ("got %s\n", lval->buf);
 368 #endif
 369         if (c != 0)
 370             cp->ungetbyte(c, cp->client_data);
 371         if (!cql_strcmp(lval->buf, "and"))
 372         {
 373             lval->buf = "and";
 374             return AND;
 375         }
 376         if (!cql_strcmp(lval->buf, "or"))
 377         {
 378             lval->buf = "or";
 379             return OR;
 380         }
 381         if (!cql_strcmp(lval->buf, "not"))
 382         {
 383             lval->buf = "not";
 384             return NOT;
 385         }
 386         if (!cql_strcmp(lval->buf, "prox"))
 387         {
 388             lval->buf = "prox";
 389             return PROX;
 390         }
 391         if (!cql_strcmp(lval->buf, "sortby"))
 392         {
 393             lval->buf = "sortby";
 394             return SORTBY;
 395         }
 396         if (!cql_strcmp(lval->buf, "all"))
 397             relation_like = 1;
 398         if (!cql_strcmp(lval->buf, "any"))
 399             relation_like = 1;
 400         if (relation_like)
 401             return DOTTERM;
 402     }
 403     return TERM;
 404 }
 405
 406
 407 int cql_parser_stream(CQL_parser cp,
 408                       int (*getbyte)(void *client_data),
 409                       void (*ungetbyte)(int b, void *client_data),
 410                       void *client_data)
 411 {
 412     nmem_reset(cp->nmem);
 413     cp->getbyte = getbyte;
 414     cp->ungetbyte = ungetbyte;
 415     cp->client_data = client_data;
 416     cql_node_destroy(cp->top);
 417     cql_parse(cp);
 418     if (cp->top)
 419         return 0;
 420     return -1;
 421 }
 422
 423 CQL_parser cql_parser_create(void)
 424 {
 425     CQL_parser cp = (CQL_parser) xmalloc (sizeof(*cp));
 426
 427     cp->top = 0;
 428     cp->getbyte = 0;
 429     cp->ungetbyte = 0;
 430     cp->client_data = 0;
 431     cp->last_error = 0;
 432     cp->last_pos = 0;
 433     cp->nmem = nmem_create();
 434     return cp;
 435 }
 436
 437 void cql_parser_destroy(CQL_parser cp)
 438 {
 439     cql_node_destroy(cp->top);
 440     nmem_destroy(cp->nmem);
 441     xfree (cp);
 442 }
 443
 444 struct cql_node *cql_parser_result(CQL_parser cp)
 445 {
 446     return cp->top;
 447 }
 448
 449 /*
 450  * Local variables:
 451  * c-basic-offset: 4
 452  * c-file-style: "Stroustrup"
 453  * indent-tabs-mode: nil
 454  * End:
 455  * vim: shiftwidth=4 tabstop=8 expandtab
 456  */