util/xpath.c

   1 /* $Id: xpath.c,v 1.3 2003-03-01 22:45:38 adam Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
   3    Index Data Aps
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <assert.h>
  27 #include <ctype.h>
  28 #include <yaz/nmem.h>
  29 #include <zebra_xpath.h>
  30
  31 static char *get_xp_part (char **strs, NMEM mem, int *literal)
  32 {
  33     char *cp = *strs;
  34     char *str = 0;
  35     char *res = 0;
  36
  37     *literal = 0;
  38     while (*cp == ' ')
  39         cp++;
  40     str = cp;
  41     if (strchr("()", *cp))
  42         cp++;
  43     else if (strchr("><=", *cp))
  44     {
  45         while (strchr("><=", *cp))
  46             cp++;
  47     }
  48     else if (*cp == '"' || *cp == '\'')
  49     {
  50         int sep = *cp;
  51         str++;
  52         cp++;
  53         while (*cp && *cp != sep)
  54             cp++;
  55         res = nmem_malloc(mem, cp - str + 1);
  56         if ((cp - str))
  57             memcpy (res, str, (cp-str));
  58         res[cp-str] = '\0';
  59         if (*cp)
  60             cp++;
  61         *literal = 1;
  62     }
  63     else
  64     {
  65         while (*cp && !strchr("><=()]\" ", *cp))
  66             cp++;
  67     }
  68     if (!res)
  69     {
  70         res = nmem_malloc(mem, cp - str + 1);
  71         if ((cp - str))
  72             memcpy (res, str, (cp-str));
  73         res[cp-str] = '\0';
  74     }
  75     *strs = cp;
  76     return res;
  77 }
  78
  79 static struct xpath_predicate *get_xpath_boolean(char **pr, NMEM mem,
  80                                                  char **look, int *literal);
  81
  82 static struct xpath_predicate *get_xpath_relation(char **pr, NMEM mem,
  83                                                   char **look, int *literal)
  84 {
  85     struct xpath_predicate *res = 0;
  86     if (!*literal && !strcmp(*look, "("))
  87     {
  88         *look = get_xp_part(pr, mem, literal);
  89         res = get_xpath_boolean(pr, mem, look, literal);
  90         if (!strcmp(*look, ")"))
  91             *look = get_xp_part(pr, mem, literal);
  92         else
  93             res = 0; /* error */
  94     }
  95     else
  96     {
  97         res=nmem_malloc(mem, sizeof(struct xpath_predicate));
  98         res->which = XPATH_PREDICATE_RELATION;
  99         res->u.relation.name = *look;
 100
 101         *look = get_xp_part(pr, mem, literal);
 102         if (*look && !*literal && strchr("><=", **look))
 103         {
 104             res->u.relation.op = *look;
 105
 106             *look = get_xp_part(pr, mem, literal);
 107             if (!*look)
 108                 return 0;  /* error */
 109             res->u.relation.value = *look;
 110             *look = get_xp_part(pr, mem, literal);
 111         }
 112         else
 113         {
 114             res->u.relation.op = "";
 115             res->u.relation.value = "";
 116         }
 117     }
 118     return res;
 119 }
 120
 121 static struct xpath_predicate *get_xpath_boolean(char **pr, NMEM mem,
 122                                                  char **look, int *literal)
 123 {
 124     struct xpath_predicate *left = 0;
 125
 126     left = get_xpath_relation(pr, mem, look, literal);
 127     if (!left)
 128         return 0;
 129
 130     while (*look && !*literal &&
 131            (!strcmp(*look, "and") || !strcmp(*look, "or") ||
 132             !strcmp(*look, "not")))
 133     {
 134         struct xpath_predicate *res, *right;
 135
 136         res = nmem_malloc(mem, sizeof(struct xpath_predicate));
 137         res->which = XPATH_PREDICATE_BOOLEAN;
 138         res->u.boolean.op = *look;
 139         res->u.boolean.left = left;
 140
 141         *look = get_xp_part(pr, mem, literal); /* skip the boolean name */
 142         right = get_xpath_relation(pr, mem, look, literal);
 143
 144         res->u.boolean.right = right;
 145
 146         left = res;
 147     }
 148     return left;
 149 }
 150
 151 static struct xpath_predicate *get_xpath_predicate(char *predicate, NMEM mem)
 152 {
 153     int literal;
 154     char **pr = &predicate;
 155     char *look = get_xp_part(pr, mem, &literal);
 156
 157     if (!look)
 158         return 0;
 159     return get_xpath_boolean(pr, mem, &look, &literal);
 160 }
 161
 162 int zebra_parse_xpath_str(const char *xpath_string,
 163                           struct xpath_location_step *xpath, int max, NMEM mem)
 164 {
 165     const char *cp;
 166     char *a;
 167
 168     int no = 0;
 169
 170     if (!xpath_string || *xpath_string != '/')
 171         return -1;
 172     cp = xpath_string;
 173
 174     while (*cp && no < max)
 175     {
 176         int i = 0;
 177         while (*cp && !strchr("/[",*cp))
 178         {
 179             i++;
 180             cp++;
 181         }
 182         xpath[no].predicate = 0;
 183         xpath[no].part = nmem_malloc (mem, i+1);
 184         if (i)
 185             memcpy (xpath[no].part,  cp - i, i);
 186         xpath[no].part[i] = 0;
 187
 188         if (*cp == '[')
 189         {
 190             cp++;
 191             while (*cp == ' ')
 192                 cp++;
 193
 194             a = (char *)cp;
 195             xpath[no].predicate = get_xpath_predicate(a, mem);
 196             while(*cp && *cp != ']') {
 197               cp++;
 198             }
 199             if (*cp == ']')
 200                 cp++;
 201         } /* end of ] predicate */
 202         no++;
 203         if (*cp != '/')
 204             break;
 205         cp++;
 206     }
 207
 208 /* for debugging .. */
 209 #if 0
 210     dump_xp_steps(xpath, no);
 211 #endif
 212
 213     return no;
 214 }
 215
 216 void dump_xp_predicate (struct xpath_predicate *p)
 217 {
 218     if (p) {
 219         if (p->which == XPATH_PREDICATE_RELATION &&
 220             p->u.relation.name[0]) {
 221             fprintf (stderr, "%s,%s,%s",
 222                      p->u.relation.name,
 223                      p->u.relation.op,
 224                      p->u.relation.value);
 225         } else {
 226             fprintf (stderr, "(");
 227             dump_xp_predicate(p->u.boolean.left);
 228             fprintf (stderr, ") %s (", p->u.boolean.op);
 229             dump_xp_predicate(p->u.boolean.right);
 230             fprintf (stderr, ")");
 231         }
 232     }
 233 }
 234
 235 void dump_xp_steps (struct xpath_location_step *xpath, int no)
 236 {
 237     int i;
 238     for (i=0; i<no; i++) {
 239         fprintf (stderr, "Step %d: %s   ",i,xpath[i].part);
 240         dump_xp_predicate(xpath[i].predicate);
 241         fprintf (stderr, "\n");
 242     }
 243 }
 244