etc/spotlight/slmod_rdf_parser.y

   1 %{
   2   #include <atalk/standards.h>
   3
   4   #include <stdbool.h>
   5   #include <stdio.h>
   6   #include <string.h>
   7   #include <time.h>
   8
   9   #include <gio/gio.h>
  10
  11   #include <atalk/talloc.h>
  12   #include <atalk/logger.h>
  13   #include <atalk/errchk.h>
  14   #include <atalk/spotlight.h>
  15
  16   #include "slmod_rdf_map.h"
  17
  18   struct yy_buffer_state;
  19   typedef struct yy_buffer_state *YY_BUFFER_STATE;
  20   extern int yylex (void);
  21   extern void yyerror (char const *);
  22   extern void *yyterminate(void);
  23   extern YY_BUFFER_STATE yy_scan_string( const char *str);
  24   extern void yy_delete_buffer ( YY_BUFFER_STATE buffer );
  25
  26   /* forward declarations */
  27   static const char *map_expr(const char *attr, char op, const char *val);
  28   static const char *map_daterange(const char *dateattr, time_t date1, time_t date2);
  29   static time_t isodate2unix(const char *s);
  30
  31  /* global vars, eg needed by the lexer */
  32   slq_t *srp_slq;
  33
  34   /* local vars */
  35   static gchar *ssp_result;
  36 %}
  37
  38 %code provides {
  39   #define SPRAW_TIME_OFFSET 978307200
  40   extern int map_spotlight_to_rdf_query(slq_t *slq, gchar **sparql_result);
  41   extern slq_t *srp_slq;
  42 }
  43
  44 %union {
  45     int ival;
  46     const char *sval;
  47     bool bval;
  48     time_t tval;
  49 }
  50
  51 %expect 5
  52 %error-verbose
  53
  54 %type <sval> match expr line function
  55 %type <tval> date
  56
  57 %token <sval> WORD
  58 %token <bval> BOOL
  59 %token FUNC_INRANGE
  60 %token DATE_ISO
  61 %token OBRACE CBRACE EQUAL UNEQUAL GT LT COMMA QUOTE
  62 %left AND
  63 %left OR
  64 %%
  65
  66 input:
  67 /* empty */
  68 | input line
  69 ;
  70
  71 line:
  72 expr                           {
  73     ssp_result = talloc_asprintf(srp_slq,
  74                                  "<rdfq:Condition>"
  75                                  "  <rdfq:and>"
  76                                  "    <rdfq:startsWith>"
  77                                  "      <rdfq:Property name=\"File:Path\" />"
  78                                  "      <rdf:String>%s</rdf:String>"
  79                                  "    </rdfq:startsWith>"
  80                                  "    %s"
  81                                  "  </rdfq:and>"
  82                                  "</rdfq:Condition>",
  83                                  srp_slq->slq_vol->v_path, $1);
  84     $$ = ssp_result;
  85 }
  86 ;
  87
  88 expr:
  89 BOOL                             {
  90     if ($1 == false)
  91         YYACCEPT;
  92     else
  93         YYABORT;
  94 }
  95 | match OR match                 {
  96     if (strcmp($1, $3) != 0)
  97         $$ = talloc_asprintf(srp_slq, "{ %s } UNION { %s }", $1, $3);
  98     else
  99         $$ = talloc_asprintf(srp_slq, "%s", $1);
 100 }
 101 | match                        {$$ = $1; if ($$ == NULL) YYABORT;}
 102 | function                     {$$ = $1;}
 103 | OBRACE expr CBRACE           {$$ = talloc_asprintf(srp_slq, "%s", $2);}
 104 | expr AND expr                {$$ = talloc_asprintf(srp_slq, "%s . %s", $1, $3);}
 105 | expr OR expr                 {
 106     if (strcmp($1, $3) != 0)
 107         $$ = talloc_asprintf(srp_slq, "{ %s } UNION { %s }", $1, $3);
 108     else
 109         $$ = talloc_asprintf(srp_slq, "%s", $1);
 110 }
 111 ;
 112
 113 match:
 114 WORD EQUAL QUOTE WORD QUOTE     {$$ = map_expr($1, '=', $4);}
 115 | WORD UNEQUAL QUOTE WORD QUOTE {$$ = map_expr($1, '!', $4);}
 116 | WORD LT QUOTE WORD QUOTE      {$$ = map_expr($1, '<', $4);}
 117 | WORD GT QUOTE WORD QUOTE      {$$ = map_expr($1, '>', $4);}
 118 | WORD EQUAL QUOTE WORD QUOTE WORD    {$$ = map_expr($1, '=', $4);}
 119 | WORD UNEQUAL QUOTE WORD QUOTE WORD {$$ = map_expr($1, '!', $4);}
 120 | WORD LT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '<', $4);}
 121 | WORD GT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '>', $4);}
 122 ;
 123
 124 function:
 125 FUNC_INRANGE OBRACE WORD COMMA date COMMA date CBRACE {$$ = map_daterange($3, $5, $7);}
 126 ;
 127
 128 date:
 129 DATE_ISO OBRACE WORD CBRACE    {$$ = isodate2unix($3);}
 130 | WORD                         {$$ = atoi($1) + SPRAW_TIME_OFFSET;}
 131 ;
 132
 133 %%
 134
 135 static time_t isodate2unix(const char *s)
 136 {
 137     struct tm tm;
 138
 139     if (strptime(s, "%Y-%m-%dT%H:%M:%SZ", &tm) == NULL)
 140         return (time_t)-1;
 141     return mktime(&tm);
 142 }
 143
 144 const char *map_daterange(const char *dateattr, time_t date1, time_t date2)
 145 {
 146     EC_INIT;
 147     char *result = NULL;
 148     struct spotlight_rdf_map *p;
 149     struct tm *tmp;
 150     char buf1[64], buf2[64];
 151
 152     EC_NULL_LOG( tmp = localtime(&date1) );
 153     strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 154     EC_NULL_LOG( tmp = localtime(&date2) );
 155     strftime(buf2, sizeof(buf2), "%Y-%m-%dT%H:%M:%SZ", tmp);
 156
 157     for (p = spotlight_rdf_map; p->srm_spotlight_attr; p++) {
 158         if (strcmp(dateattr, p->srm_spotlight_attr) == 0) {
 159             /* do something */
 160             break;
 161         }
 162     }
 163
 164 EC_CLEANUP:
 165     if (ret != 0)
 166         return NULL;
 167     return result;
 168 }
 169
 170 const char *map_expr(const char *attr, char op, const char *val)
 171 {
 172     EC_INIT;
 173     char *result = NULL;
 174     struct spotlight_rdf_map *p;
 175     time_t t;
 176     struct tm *tmp;
 177     char buf1[64];
 178     bstring q = NULL, search = NULL, replace = NULL;
 179
 180     for (p = spotlight_rdf_map; p->srm_spotlight_attr; p++) {
 181         if (p->srm_rdf_attr && strcmp(p->srm_spotlight_attr, attr) == 0) {
 182             switch (p->srm_type) {
 183             case srmt_bool:
 184                 /* do something */
 185                 break;
 186             case srmt_num:
 187                 /* do something */
 188                 break;
 189             case srmt_str:
 190                 q = bformat("^%s$", val);
 191                 search = bfromcstr("*");
 192                 replace = bfromcstr(".*");
 193                 bfindreplace(q, search, replace, 0);
 194                 /* do something */
 195                 break;
 196             case srmt_fts:
 197                 /* do something */
 198                 break;
 199             case srmt_date:
 200                 t = atoi(val) + SPRAW_TIME_OFFSET;
 201                 EC_NULL( tmp = localtime(&t) );
 202                 strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 203                 /* do something */
 204                 break;
 205             default:
 206                 yyerror("unknown Spotlight attribute type");
 207                 EC_FAIL;
 208             }
 209             break;
 210         }
 211     }
 212
 213 EC_CLEANUP:
 214     if (q)
 215         bdestroy(q);
 216     if (search)
 217         bdestroy(search);
 218     if (replace)
 219         bdestroy(replace);
 220     return result;
 221 }
 222
 223 void yyerror(const char *str)
 224 {
 225 #ifdef MAIN
 226     printf("yyerror: %s\n", str);
 227 #else
 228     LOG(log_error, logtype_sl, "yyerror: %s", str);
 229 #endif
 230 }
 231
 232 int yywrap()
 233 {
 234     return 1;
 235 }
 236
 237 /**
 238  * Map a Spotlight RAW query string to a SPARQL query string
 239  *
 240  * @param[in]     slq            Spotlight query handle
 241  * @param[out]    sparql_result  Mapped SPARQL query, string is allocated in
 242  *                               talloc context of slq
 243  * @return        0 on success, -1 on error
 244  **/
 245 int map_spotlight_to_sparql_query(slq_t *slq, gchar **sparql_result)
 246 {
 247     EC_INIT;
 248     YY_BUFFER_STATE s = NULL;
 249     ssp_result = NULL;
 250
 251     srp_slq = slq;
 252     s = yy_scan_string(slq->slq_qstring);
 253
 254     EC_ZERO( yyparse() );
 255
 256 EC_CLEANUP:
 257     if (s)
 258         yy_delete_buffer(s);
 259     if (ret == 0)
 260         *sparql_result = ssp_result;
 261     else
 262         *sparql_result = NULL;
 263     EC_EXIT;
 264 }
 265
 266 #ifdef MAIN
 267 int main(int argc, char **argv)
 268 {
 269     int ret;
 270     YY_BUFFER_STATE s;
 271
 272     if (argc != 2) {
 273         printf("usage: %s QUERY\n", argv[0]);
 274         return 1;
 275     }
 276
 277     srp_slq = talloc_zero(NULL, slq_t);
 278     struct vol *vol = talloc_zero(srp_slq, struct vol);
 279     vol->v_path = "/Volumes/test";
 280     srp_slq->slq_vol = vol;
 281
 282     s = yy_scan_string(argv[1]);
 283
 284     ret = yyparse();
 285
 286     yy_delete_buffer(s);
 287
 288     if (ret == 0)
 289         printf("SPARQL: %s\n", ssp_result ? ssp_result : "(empty)");
 290
 291     return 0;
 292 }
 293 #endif