src/cql.y

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