vfs_fruit: checks wrong AAPL config state and so always uses readdirattr
[samba.git] / source3 / rpc_server / mdssvc / sparql_parser.c
1 /* A Bison parser, made by GNU Bison 3.0.4.  */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5    Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6
7    This program is free software: you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation, either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 /* As a special exception, you may create a larger work that contains
21    part or all of the Bison parser skeleton and distribute that work
22    under terms of your choice, so long as that work isn't itself a
23    parser generator using the skeleton or a modified version thereof
24    as a parser skeleton.  Alternatively, if you modify or redistribute
25    the parser skeleton itself, you may (at your option) remove this
26    special exception, which will cause the skeleton and the resulting
27    Bison output files to be licensed under the GNU General Public
28    License without this special exception.
29
30    This special exception was added by the Free Software Foundation in
31    version 2.2 of Bison.  */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34    simplifying the original so-called "semantic" parser.  */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37    infringing on user name space.  This should be done even for local
38    variables, as they might otherwise be expanded by user macros.
39    There are some unavoidable exceptions within include files to
40    define necessary library symbols; they are noted "INFRINGES ON
41    USER NAME SPACE" below.  */
42
43 /* Identify Bison output.  */
44 #define YYBISON 1
45
46 /* Bison version.  */
47 #define YYBISON_VERSION "3.0.4"
48
49 /* Skeleton name.  */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers.  */
53 #define YYPURE 0
54
55 /* Push parsers.  */
56 #define YYPUSH 0
57
58 /* Pull parsers.  */
59 #define YYPULL 1
60
61
62 /* Substitute the variable and function names.  */
63 #define yyparse         mdsyyparse
64 #define yylex           mdsyylex
65 #define yyerror         mdsyyerror
66 #define yydebug         mdsyydebug
67 #define yynerrs         mdsyynerrs
68
69 #define yylval          mdsyylval
70 #define yychar          mdsyychar
71
72 /* Copy the first part of user declarations.  */
73 #line 21 "sparql_parser.y" /* yacc.c:339  */
74
75         #include "includes.h"
76         #include "mdssvc.h"
77         #include "sparql_parser.h"
78         #include "sparql_mapping.h"
79
80         #define YYMALLOC SMB_MALLOC
81         #define YYREALLOC SMB_REALLOC
82
83         struct yy_buffer_state;
84         typedef struct yy_buffer_state *YY_BUFFER_STATE;
85         extern int mdsyylex (void);
86         extern void mdsyyerror (char const *);
87         extern void *mdsyyterminate(void);
88         extern YY_BUFFER_STATE mdsyy_scan_string( const char *str);
89         extern void mdsyy_delete_buffer ( YY_BUFFER_STATE buffer );
90
91         /* forward declarations */
92         static const char *map_expr(const char *attr, char op, const char *val);
93         static const char *map_daterange(const char *dateattr,
94                                          time_t date1, time_t date2);
95         static time_t isodate2unix(const char *s);
96
97         /* global vars, eg needed by the lexer */
98         struct sparql_parser_state {
99                 TALLOC_CTX *frame;
100                 YY_BUFFER_STATE s;
101                 char var;
102                 const char *result;
103         } *global_sparql_parser_state;
104
105 #line 106 "sparql_parser.c" /* yacc.c:339  */
106
107 # ifndef YY_NULLPTR
108 #  if defined __cplusplus && 201103L <= __cplusplus
109 #   define YY_NULLPTR nullptr
110 #  else
111 #   define YY_NULLPTR 0
112 #  endif
113 # endif
114
115 /* Enabling verbose error messages.  */
116 #ifdef YYERROR_VERBOSE
117 # undef YYERROR_VERBOSE
118 # define YYERROR_VERBOSE 1
119 #else
120 # define YYERROR_VERBOSE 1
121 #endif
122
123 /* In a future release of Bison, this section will be replaced
124    by #include "sparql_parser.h".  */
125 #ifndef YY_MDSYY_SPARQL_PARSER_H_INCLUDED
126 # define YY_MDSYY_SPARQL_PARSER_H_INCLUDED
127 /* Debug traces.  */
128 #ifndef YYDEBUG
129 # define YYDEBUG 0
130 #endif
131 #if YYDEBUG
132 extern int mdsyydebug;
133 #endif
134
135 /* Token type.  */
136 #ifndef YYTOKENTYPE
137 # define YYTOKENTYPE
138   enum yytokentype
139   {
140     WORD = 258,
141     BOOL = 259,
142     FUNC_INRANGE = 260,
143     DATE_ISO = 261,
144     OBRACE = 262,
145     CBRACE = 263,
146     EQUAL = 264,
147     UNEQUAL = 265,
148     GT = 266,
149     LT = 267,
150     COMMA = 268,
151     QUOTE = 269,
152     AND = 270,
153     OR = 271
154   };
155 #endif
156
157 /* Value type.  */
158 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
159
160 union YYSTYPE
161 {
162 #line 61 "sparql_parser.y" /* yacc.c:355  */
163
164         int ival;
165         const char *sval;
166         bool bval;
167         time_t tval;
168
169 #line 170 "sparql_parser.c" /* yacc.c:355  */
170 };
171
172 typedef union YYSTYPE YYSTYPE;
173 # define YYSTYPE_IS_TRIVIAL 1
174 # define YYSTYPE_IS_DECLARED 1
175 #endif
176
177
178 extern YYSTYPE mdsyylval;
179
180 int mdsyyparse (void);
181 /* "%code provides" blocks.  */
182 #line 53 "sparql_parser.y" /* yacc.c:355  */
183
184         #include <stdbool.h>
185         #include "mdssvc.h"
186         #define SPRAW_TIME_OFFSET 978307200
187         extern int mdsyywrap(void);
188         extern bool map_spotlight_to_sparql_query(struct sl_query *slq);
189
190 #line 191 "sparql_parser.c" /* yacc.c:355  */
191
192 #endif /* !YY_MDSYY_SPARQL_PARSER_H_INCLUDED  */
193
194 /* Copy the second part of user declarations.  */
195
196 #line 197 "sparql_parser.c" /* yacc.c:358  */
197
198 #ifdef short
199 # undef short
200 #endif
201
202 #ifdef YYTYPE_UINT8
203 typedef YYTYPE_UINT8 yytype_uint8;
204 #else
205 typedef unsigned char yytype_uint8;
206 #endif
207
208 #ifdef YYTYPE_INT8
209 typedef YYTYPE_INT8 yytype_int8;
210 #else
211 typedef signed char yytype_int8;
212 #endif
213
214 #ifdef YYTYPE_UINT16
215 typedef YYTYPE_UINT16 yytype_uint16;
216 #else
217 typedef unsigned short int yytype_uint16;
218 #endif
219
220 #ifdef YYTYPE_INT16
221 typedef YYTYPE_INT16 yytype_int16;
222 #else
223 typedef short int yytype_int16;
224 #endif
225
226 #ifndef YYSIZE_T
227 # ifdef __SIZE_TYPE__
228 #  define YYSIZE_T __SIZE_TYPE__
229 # elif defined size_t
230 #  define YYSIZE_T size_t
231 # elif ! defined YYSIZE_T
232 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
233 #  define YYSIZE_T size_t
234 # else
235 #  define YYSIZE_T unsigned int
236 # endif
237 #endif
238
239 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
240
241 #ifndef YY_
242 # if defined YYENABLE_NLS && YYENABLE_NLS
243 #  if ENABLE_NLS
244 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
245 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
246 #  endif
247 # endif
248 # ifndef YY_
249 #  define YY_(Msgid) Msgid
250 # endif
251 #endif
252
253 #ifndef YY_ATTRIBUTE
254 # if (defined __GNUC__                                               \
255       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
256      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
257 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
258 # else
259 #  define YY_ATTRIBUTE(Spec) /* empty */
260 # endif
261 #endif
262
263 #ifndef YY_ATTRIBUTE_PURE
264 # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
265 #endif
266
267 #ifndef YY_ATTRIBUTE_UNUSED
268 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
269 #endif
270
271 #if !defined _Noreturn \
272      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
273 # if defined _MSC_VER && 1200 <= _MSC_VER
274 #  define _Noreturn __declspec (noreturn)
275 # else
276 #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
277 # endif
278 #endif
279
280 /* Suppress unused-variable warnings by "using" E.  */
281 #if ! defined lint || defined __GNUC__
282 # define YYUSE(E) ((void) (E))
283 #else
284 # define YYUSE(E) /* empty */
285 #endif
286
287 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
288 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
289 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
290     _Pragma ("GCC diagnostic push") \
291     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
292     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
293 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
294     _Pragma ("GCC diagnostic pop")
295 #else
296 # define YY_INITIAL_VALUE(Value) Value
297 #endif
298 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
299 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
300 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
301 #endif
302 #ifndef YY_INITIAL_VALUE
303 # define YY_INITIAL_VALUE(Value) /* Nothing. */
304 #endif
305
306
307 #if ! defined yyoverflow || YYERROR_VERBOSE
308
309 /* The parser invokes alloca or malloc; define the necessary symbols.  */
310
311 # ifdef YYSTACK_USE_ALLOCA
312 #  if YYSTACK_USE_ALLOCA
313 #   ifdef __GNUC__
314 #    define YYSTACK_ALLOC __builtin_alloca
315 #   elif defined __BUILTIN_VA_ARG_INCR
316 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
317 #   elif defined _AIX
318 #    define YYSTACK_ALLOC __alloca
319 #   elif defined _MSC_VER
320 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
321 #    define alloca _alloca
322 #   else
323 #    define YYSTACK_ALLOC alloca
324 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
325 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
326       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
327 #     ifndef EXIT_SUCCESS
328 #      define EXIT_SUCCESS 0
329 #     endif
330 #    endif
331 #   endif
332 #  endif
333 # endif
334
335 # ifdef YYSTACK_ALLOC
336    /* Pacify GCC's 'empty if-body' warning.  */
337 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
338 #  ifndef YYSTACK_ALLOC_MAXIMUM
339     /* The OS might guarantee only one guard page at the bottom of the stack,
340        and a page size can be as small as 4096 bytes.  So we cannot safely
341        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
342        to allow for a few compiler-allocated temporary stack slots.  */
343 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
344 #  endif
345 # else
346 #  define YYSTACK_ALLOC YYMALLOC
347 #  define YYSTACK_FREE YYFREE
348 #  ifndef YYSTACK_ALLOC_MAXIMUM
349 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
350 #  endif
351 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
352        && ! ((defined YYMALLOC || defined malloc) \
353              && (defined YYFREE || defined free)))
354 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
355 #   ifndef EXIT_SUCCESS
356 #    define EXIT_SUCCESS 0
357 #   endif
358 #  endif
359 #  ifndef YYMALLOC
360 #   define YYMALLOC malloc
361 #   if ! defined malloc && ! defined EXIT_SUCCESS
362 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
363 #   endif
364 #  endif
365 #  ifndef YYFREE
366 #   define YYFREE free
367 #   if ! defined free && ! defined EXIT_SUCCESS
368 void free (void *); /* INFRINGES ON USER NAME SPACE */
369 #   endif
370 #  endif
371 # endif
372 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
373
374
375 #if (! defined yyoverflow \
376      && (! defined __cplusplus \
377          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
378
379 /* A type that is properly aligned for any stack member.  */
380 union yyalloc
381 {
382   yytype_int16 yyss_alloc;
383   YYSTYPE yyvs_alloc;
384 };
385
386 /* The size of the maximum gap between one aligned stack and the next.  */
387 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
388
389 /* The size of an array large to enough to hold all stacks, each with
390    N elements.  */
391 # define YYSTACK_BYTES(N) \
392      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
393       + YYSTACK_GAP_MAXIMUM)
394
395 # define YYCOPY_NEEDED 1
396
397 /* Relocate STACK from its old location to the new one.  The
398    local variables YYSIZE and YYSTACKSIZE give the old and new number of
399    elements in the stack, and YYPTR gives the new location of the
400    stack.  Advance YYPTR to a properly aligned location for the next
401    stack.  */
402 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
403     do                                                                  \
404       {                                                                 \
405         YYSIZE_T yynewbytes;                                            \
406         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
407         Stack = &yyptr->Stack_alloc;                                    \
408         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
409         yyptr += yynewbytes / sizeof (*yyptr);                          \
410       }                                                                 \
411     while (0)
412
413 #endif
414
415 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
416 /* Copy COUNT objects from SRC to DST.  The source and destination do
417    not overlap.  */
418 # ifndef YYCOPY
419 #  if defined __GNUC__ && 1 < __GNUC__
420 #   define YYCOPY(Dst, Src, Count) \
421       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
422 #  else
423 #   define YYCOPY(Dst, Src, Count)              \
424       do                                        \
425         {                                       \
426           YYSIZE_T yyi;                         \
427           for (yyi = 0; yyi < (Count); yyi++)   \
428             (Dst)[yyi] = (Src)[yyi];            \
429         }                                       \
430       while (0)
431 #  endif
432 # endif
433 #endif /* !YYCOPY_NEEDED */
434
435 /* YYFINAL -- State number of the termination state.  */
436 #define YYFINAL  2
437 /* YYLAST -- Last index in YYTABLE.  */
438 #define YYLAST   52
439
440 /* YYNTOKENS -- Number of terminals.  */
441 #define YYNTOKENS  17
442 /* YYNNTS -- Number of nonterminals.  */
443 #define YYNNTS  7
444 /* YYNRULES -- Number of rules.  */
445 #define YYNRULES  22
446 /* YYNSTATES -- Number of states.  */
447 #define YYNSTATES  51
448
449 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
450    by yylex, with out-of-bounds checking.  */
451 #define YYUNDEFTOK  2
452 #define YYMAXUTOK   271
453
454 #define YYTRANSLATE(YYX)                                                \
455   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
456
457 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
458    as returned by yylex, without out-of-bounds checking.  */
459 static const yytype_uint8 yytranslate[] =
460 {
461        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
462        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
463        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
464        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
465        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
466        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
467        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
468        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
469        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
470        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
471        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
472        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
473        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
474        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
475        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
476        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
477        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
478        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
479        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
480        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
481        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
482        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
483        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
484        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
485        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
486        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
487        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
488       15,    16
489 };
490
491 #if YYDEBUG
492   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
493 static const yytype_uint8 yyrline[] =
494 {
495        0,    84,    84,    86,    90,    96,   119,   126,   129,   132,
496      135,   138,   148,   152,   156,   160,   164,   168,   172,   176,
497      183,   190,   191
498 };
499 #endif
500
501 #if YYDEBUG || YYERROR_VERBOSE || 1
502 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
503    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
504 static const char *const yytname[] =
505 {
506   "$end", "error", "$undefined", "WORD", "BOOL", "FUNC_INRANGE",
507   "DATE_ISO", "OBRACE", "CBRACE", "EQUAL", "UNEQUAL", "GT", "LT", "COMMA",
508   "QUOTE", "AND", "OR", "$accept", "input", "line", "expr", "match",
509   "function", "date", YY_NULLPTR
510 };
511 #endif
512
513 # ifdef YYPRINT
514 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
515    (internal) symbol number NUM (which must be that of a token).  */
516 static const yytype_uint16 yytoknum[] =
517 {
518        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
519      265,   266,   267,   268,   269,   270,   271
520 };
521 # endif
522
523 #define YYPACT_NINF -10
524
525 #define yypact_value_is_default(Yystate) \
526   (!!((Yystate) == (-10)))
527
528 #define YYTABLE_NINF -1
529
530 #define yytable_value_is_error(Yytable_value) \
531   0
532
533   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
534      STATE-NUM.  */
535 static const yytype_int8 yypact[] =
536 {
537      -10,    10,   -10,     9,   -10,    -2,    -1,   -10,     8,    -9,
538      -10,     2,    12,    13,    14,    26,    -7,    -1,    -1,    27,
539       28,    29,    30,    31,    22,   -10,    20,   -10,   -10,    23,
540       24,    25,    32,    19,    37,    38,    39,    40,   -10,    41,
541       34,   -10,   -10,   -10,   -10,    42,    19,    36,    43,   -10,
542      -10
543 };
544
545   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
546      Performed when YYTABLE does not specify something else to do.  Zero
547      means the default is an error.  */
548 static const yytype_uint8 yydefact[] =
549 {
550        2,     0,     1,     0,     5,     0,     0,     3,     4,     7,
551        8,     0,     0,     0,     0,     0,     0,     0,     0,     0,
552        0,     0,     0,     0,     0,     9,    10,    11,     6,     0,
553        0,     0,     0,     0,    12,    13,    15,    14,    22,     0,
554        0,    16,    17,    19,    18,     0,     0,     0,     0,    21,
555       20
556 };
557
558   /* YYPGOTO[NTERM-NUM].  */
559 static const yytype_int8 yypgoto[] =
560 {
561      -10,   -10,   -10,    -6,    33,   -10,     3
562 };
563
564   /* YYDEFGOTO[NTERM-NUM].  */
565 static const yytype_int8 yydefgoto[] =
566 {
567       -1,     1,     7,     8,     9,    10,    40
568 };
569
570   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
571      positive, shift that token.  If negative, reduce the rule whose
572      number is the opposite.  If YYTABLE_NINF, syntax error.  */
573 static const yytype_uint8 yytable[] =
574 {
575       16,    25,     3,     4,     5,    15,     6,    19,    17,    18,
576        2,    26,    27,     3,     4,     5,    20,     6,    11,    12,
577       13,    14,    38,    17,    18,    39,    21,    22,    23,    24,
578        3,    29,    30,    31,    32,    33,    18,    34,    35,    36,
579       41,    42,    43,    44,    49,    47,    37,    46,    45,    48,
580        0,    50,    28
581 };
582
583 static const yytype_int8 yycheck[] =
584 {
585        6,     8,     3,     4,     5,     7,     7,    16,    15,    16,
586        0,    17,    18,     3,     4,     5,    14,     7,     9,    10,
587       11,    12,     3,    15,    16,     6,    14,    14,    14,     3,
588        3,     3,     3,     3,     3,    13,    16,    14,    14,    14,
589        3,     3,     3,     3,     8,     3,    14,    13,     7,    46,
590       -1,     8,    19
591 };
592
593   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
594      symbol of state STATE-NUM.  */
595 static const yytype_uint8 yystos[] =
596 {
597        0,    18,     0,     3,     4,     5,     7,    19,    20,    21,
598       22,     9,    10,    11,    12,     7,    20,    15,    16,    16,
599       14,    14,    14,    14,     3,     8,    20,    20,    21,     3,
600        3,     3,     3,    13,    14,    14,    14,    14,     3,     6,
601       23,     3,     3,     3,     3,     7,    13,     3,    23,     8,
602        8
603 };
604
605   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
606 static const yytype_uint8 yyr1[] =
607 {
608        0,    17,    18,    18,    19,    20,    20,    20,    20,    20,
609       20,    20,    21,    21,    21,    21,    21,    21,    21,    21,
610       22,    23,    23
611 };
612
613   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
614 static const yytype_uint8 yyr2[] =
615 {
616        0,     2,     0,     2,     1,     1,     3,     1,     1,     3,
617        3,     3,     5,     5,     5,     5,     6,     6,     6,     6,
618        8,     4,     1
619 };
620
621
622 #define yyerrok         (yyerrstatus = 0)
623 #define yyclearin       (yychar = YYEMPTY)
624 #define YYEMPTY         (-2)
625 #define YYEOF           0
626
627 #define YYACCEPT        goto yyacceptlab
628 #define YYABORT         goto yyabortlab
629 #define YYERROR         goto yyerrorlab
630
631
632 #define YYRECOVERING()  (!!yyerrstatus)
633
634 #define YYBACKUP(Token, Value)                                  \
635 do                                                              \
636   if (yychar == YYEMPTY)                                        \
637     {                                                           \
638       yychar = (Token);                                         \
639       yylval = (Value);                                         \
640       YYPOPSTACK (yylen);                                       \
641       yystate = *yyssp;                                         \
642       goto yybackup;                                            \
643     }                                                           \
644   else                                                          \
645     {                                                           \
646       yyerror (YY_("syntax error: cannot back up")); \
647       YYERROR;                                                  \
648     }                                                           \
649 while (0)
650
651 /* Error token number */
652 #define YYTERROR        1
653 #define YYERRCODE       256
654
655
656
657 /* Enable debugging if requested.  */
658 #if YYDEBUG
659
660 # ifndef YYFPRINTF
661 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
662 #  define YYFPRINTF fprintf
663 # endif
664
665 # define YYDPRINTF(Args)                        \
666 do {                                            \
667   if (yydebug)                                  \
668     YYFPRINTF Args;                             \
669 } while (0)
670
671 /* This macro is provided for backward compatibility. */
672 #ifndef YY_LOCATION_PRINT
673 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
674 #endif
675
676
677 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
678 do {                                                                      \
679   if (yydebug)                                                            \
680     {                                                                     \
681       YYFPRINTF (stderr, "%s ", Title);                                   \
682       yy_symbol_print (stderr,                                            \
683                   Type, Value); \
684       YYFPRINTF (stderr, "\n");                                           \
685     }                                                                     \
686 } while (0)
687
688
689 /*----------------------------------------.
690 | Print this symbol's value on YYOUTPUT.  |
691 `----------------------------------------*/
692
693 static void
694 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
695 {
696   FILE *yyo = yyoutput;
697   YYUSE (yyo);
698   if (!yyvaluep)
699     return;
700 # ifdef YYPRINT
701   if (yytype < YYNTOKENS)
702     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
703 # endif
704   YYUSE (yytype);
705 }
706
707
708 /*--------------------------------.
709 | Print this symbol on YYOUTPUT.  |
710 `--------------------------------*/
711
712 static void
713 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
714 {
715   YYFPRINTF (yyoutput, "%s %s (",
716              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
717
718   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
719   YYFPRINTF (yyoutput, ")");
720 }
721
722 /*------------------------------------------------------------------.
723 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
724 | TOP (included).                                                   |
725 `------------------------------------------------------------------*/
726
727 static void
728 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
729 {
730   YYFPRINTF (stderr, "Stack now");
731   for (; yybottom <= yytop; yybottom++)
732     {
733       int yybot = *yybottom;
734       YYFPRINTF (stderr, " %d", yybot);
735     }
736   YYFPRINTF (stderr, "\n");
737 }
738
739 # define YY_STACK_PRINT(Bottom, Top)                            \
740 do {                                                            \
741   if (yydebug)                                                  \
742     yy_stack_print ((Bottom), (Top));                           \
743 } while (0)
744
745
746 /*------------------------------------------------.
747 | Report that the YYRULE is going to be reduced.  |
748 `------------------------------------------------*/
749
750 static void
751 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
752 {
753   unsigned long int yylno = yyrline[yyrule];
754   int yynrhs = yyr2[yyrule];
755   int yyi;
756   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
757              yyrule - 1, yylno);
758   /* The symbols being reduced.  */
759   for (yyi = 0; yyi < yynrhs; yyi++)
760     {
761       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
762       yy_symbol_print (stderr,
763                        yystos[yyssp[yyi + 1 - yynrhs]],
764                        &(yyvsp[(yyi + 1) - (yynrhs)])
765                                               );
766       YYFPRINTF (stderr, "\n");
767     }
768 }
769
770 # define YY_REDUCE_PRINT(Rule)          \
771 do {                                    \
772   if (yydebug)                          \
773     yy_reduce_print (yyssp, yyvsp, Rule); \
774 } while (0)
775
776 /* Nonzero means print parse trace.  It is left uninitialized so that
777    multiple parsers can coexist.  */
778 int yydebug;
779 #else /* !YYDEBUG */
780 # define YYDPRINTF(Args)
781 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
782 # define YY_STACK_PRINT(Bottom, Top)
783 # define YY_REDUCE_PRINT(Rule)
784 #endif /* !YYDEBUG */
785
786
787 /* YYINITDEPTH -- initial size of the parser's stacks.  */
788 #ifndef YYINITDEPTH
789 # define YYINITDEPTH 200
790 #endif
791
792 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
793    if the built-in stack extension method is used).
794
795    Do not make this value too large; the results are undefined if
796    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
797    evaluated with infinite-precision integer arithmetic.  */
798
799 #ifndef YYMAXDEPTH
800 # define YYMAXDEPTH 10000
801 #endif
802
803
804 #if YYERROR_VERBOSE
805
806 # ifndef yystrlen
807 #  if defined __GLIBC__ && defined _STRING_H
808 #   define yystrlen strlen
809 #  else
810 /* Return the length of YYSTR.  */
811 static YYSIZE_T
812 yystrlen (const char *yystr)
813 {
814   YYSIZE_T yylen;
815   for (yylen = 0; yystr[yylen]; yylen++)
816     continue;
817   return yylen;
818 }
819 #  endif
820 # endif
821
822 # ifndef yystpcpy
823 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
824 #   define yystpcpy stpcpy
825 #  else
826 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
827    YYDEST.  */
828 static char *
829 yystpcpy (char *yydest, const char *yysrc)
830 {
831   char *yyd = yydest;
832   const char *yys = yysrc;
833
834   while ((*yyd++ = *yys++) != '\0')
835     continue;
836
837   return yyd - 1;
838 }
839 #  endif
840 # endif
841
842 # ifndef yytnamerr
843 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
844    quotes and backslashes, so that it's suitable for yyerror.  The
845    heuristic is that double-quoting is unnecessary unless the string
846    contains an apostrophe, a comma, or backslash (other than
847    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
848    null, do not copy; instead, return the length of what the result
849    would have been.  */
850 static YYSIZE_T
851 yytnamerr (char *yyres, const char *yystr)
852 {
853   if (*yystr == '"')
854     {
855       YYSIZE_T yyn = 0;
856       char const *yyp = yystr;
857
858       for (;;)
859         switch (*++yyp)
860           {
861           case '\'':
862           case ',':
863             goto do_not_strip_quotes;
864
865           case '\\':
866             if (*++yyp != '\\')
867               goto do_not_strip_quotes;
868             /* Fall through.  */
869           default:
870             if (yyres)
871               yyres[yyn] = *yyp;
872             yyn++;
873             break;
874
875           case '"':
876             if (yyres)
877               yyres[yyn] = '\0';
878             return yyn;
879           }
880     do_not_strip_quotes: ;
881     }
882
883   if (! yyres)
884     return yystrlen (yystr);
885
886   return yystpcpy (yyres, yystr) - yyres;
887 }
888 # endif
889
890 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
891    about the unexpected token YYTOKEN for the state stack whose top is
892    YYSSP.
893
894    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
895    not large enough to hold the message.  In that case, also set
896    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
897    required number of bytes is too large to store.  */
898 static int
899 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
900                 yytype_int16 *yyssp, int yytoken)
901 {
902   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
903   YYSIZE_T yysize = yysize0;
904   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
905   /* Internationalized format string. */
906   const char *yyformat = YY_NULLPTR;
907   /* Arguments of yyformat. */
908   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
909   /* Number of reported tokens (one for the "unexpected", one per
910      "expected"). */
911   int yycount = 0;
912
913   /* There are many possibilities here to consider:
914      - If this state is a consistent state with a default action, then
915        the only way this function was invoked is if the default action
916        is an error action.  In that case, don't check for expected
917        tokens because there are none.
918      - The only way there can be no lookahead present (in yychar) is if
919        this state is a consistent state with a default action.  Thus,
920        detecting the absence of a lookahead is sufficient to determine
921        that there is no unexpected or expected token to report.  In that
922        case, just report a simple "syntax error".
923      - Don't assume there isn't a lookahead just because this state is a
924        consistent state with a default action.  There might have been a
925        previous inconsistent state, consistent state with a non-default
926        action, or user semantic action that manipulated yychar.
927      - Of course, the expected token list depends on states to have
928        correct lookahead information, and it depends on the parser not
929        to perform extra reductions after fetching a lookahead from the
930        scanner and before detecting a syntax error.  Thus, state merging
931        (from LALR or IELR) and default reductions corrupt the expected
932        token list.  However, the list is correct for canonical LR with
933        one exception: it will still contain any token that will not be
934        accepted due to an error action in a later state.
935   */
936   if (yytoken != YYEMPTY)
937     {
938       int yyn = yypact[*yyssp];
939       yyarg[yycount++] = yytname[yytoken];
940       if (!yypact_value_is_default (yyn))
941         {
942           /* Start YYX at -YYN if negative to avoid negative indexes in
943              YYCHECK.  In other words, skip the first -YYN actions for
944              this state because they are default actions.  */
945           int yyxbegin = yyn < 0 ? -yyn : 0;
946           /* Stay within bounds of both yycheck and yytname.  */
947           int yychecklim = YYLAST - yyn + 1;
948           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
949           int yyx;
950
951           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
952             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
953                 && !yytable_value_is_error (yytable[yyx + yyn]))
954               {
955                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
956                   {
957                     yycount = 1;
958                     yysize = yysize0;
959                     break;
960                   }
961                 yyarg[yycount++] = yytname[yyx];
962                 {
963                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
964                   if (! (yysize <= yysize1
965                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
966                     return 2;
967                   yysize = yysize1;
968                 }
969               }
970         }
971     }
972
973   switch (yycount)
974     {
975 # define YYCASE_(N, S)                      \
976       case N:                               \
977         yyformat = S;                       \
978       break
979       YYCASE_(0, YY_("syntax error"));
980       YYCASE_(1, YY_("syntax error, unexpected %s"));
981       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
982       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
983       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
984       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
985 # undef YYCASE_
986     }
987
988   {
989     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
990     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
991       return 2;
992     yysize = yysize1;
993   }
994
995   if (*yymsg_alloc < yysize)
996     {
997       *yymsg_alloc = 2 * yysize;
998       if (! (yysize <= *yymsg_alloc
999              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1000         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1001       return 1;
1002     }
1003
1004   /* Avoid sprintf, as that infringes on the user's name space.
1005      Don't have undefined behavior even if the translation
1006      produced a string with the wrong number of "%s"s.  */
1007   {
1008     char *yyp = *yymsg;
1009     int yyi = 0;
1010     while ((*yyp = *yyformat) != '\0')
1011       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1012         {
1013           yyp += yytnamerr (yyp, yyarg[yyi++]);
1014           yyformat += 2;
1015         }
1016       else
1017         {
1018           yyp++;
1019           yyformat++;
1020         }
1021   }
1022   return 0;
1023 }
1024 #endif /* YYERROR_VERBOSE */
1025
1026 /*-----------------------------------------------.
1027 | Release the memory associated to this symbol.  |
1028 `-----------------------------------------------*/
1029
1030 static void
1031 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1032 {
1033   YYUSE (yyvaluep);
1034   if (!yymsg)
1035     yymsg = "Deleting";
1036   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1037
1038   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1039   YYUSE (yytype);
1040   YY_IGNORE_MAYBE_UNINITIALIZED_END
1041 }
1042
1043
1044
1045
1046 /* The lookahead symbol.  */
1047 int yychar;
1048
1049 /* The semantic value of the lookahead symbol.  */
1050 YYSTYPE yylval;
1051 /* Number of syntax errors so far.  */
1052 int yynerrs;
1053
1054
1055 /*----------.
1056 | yyparse.  |
1057 `----------*/
1058
1059 int
1060 yyparse (void)
1061 {
1062     int yystate;
1063     /* Number of tokens to shift before error messages enabled.  */
1064     int yyerrstatus;
1065
1066     /* The stacks and their tools:
1067        'yyss': related to states.
1068        'yyvs': related to semantic values.
1069
1070        Refer to the stacks through separate pointers, to allow yyoverflow
1071        to reallocate them elsewhere.  */
1072
1073     /* The state stack.  */
1074     yytype_int16 yyssa[YYINITDEPTH];
1075     yytype_int16 *yyss;
1076     yytype_int16 *yyssp;
1077
1078     /* The semantic value stack.  */
1079     YYSTYPE yyvsa[YYINITDEPTH];
1080     YYSTYPE *yyvs;
1081     YYSTYPE *yyvsp;
1082
1083     YYSIZE_T yystacksize;
1084
1085   int yyn;
1086   int yyresult;
1087   /* Lookahead token as an internal (translated) token number.  */
1088   int yytoken = 0;
1089   /* The variables used to return semantic value and location from the
1090      action routines.  */
1091   YYSTYPE yyval;
1092
1093 #if YYERROR_VERBOSE
1094   /* Buffer for error messages, and its allocated size.  */
1095   char yymsgbuf[128];
1096   char *yymsg = yymsgbuf;
1097   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1098 #endif
1099
1100 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1101
1102   /* The number of symbols on the RHS of the reduced rule.
1103      Keep to zero when no symbol should be popped.  */
1104   int yylen = 0;
1105
1106   yyssp = yyss = yyssa;
1107   yyvsp = yyvs = yyvsa;
1108   yystacksize = YYINITDEPTH;
1109
1110   YYDPRINTF ((stderr, "Starting parse\n"));
1111
1112   yystate = 0;
1113   yyerrstatus = 0;
1114   yynerrs = 0;
1115   yychar = YYEMPTY; /* Cause a token to be read.  */
1116   goto yysetstate;
1117
1118 /*------------------------------------------------------------.
1119 | yynewstate -- Push a new state, which is found in yystate.  |
1120 `------------------------------------------------------------*/
1121  yynewstate:
1122   /* In all cases, when you get here, the value and location stacks
1123      have just been pushed.  So pushing a state here evens the stacks.  */
1124   yyssp++;
1125
1126  yysetstate:
1127   *yyssp = yystate;
1128
1129   if (yyss + yystacksize - 1 <= yyssp)
1130     {
1131       /* Get the current used size of the three stacks, in elements.  */
1132       YYSIZE_T yysize = yyssp - yyss + 1;
1133
1134 #ifdef yyoverflow
1135       {
1136         /* Give user a chance to reallocate the stack.  Use copies of
1137            these so that the &'s don't force the real ones into
1138            memory.  */
1139         YYSTYPE *yyvs1 = yyvs;
1140         yytype_int16 *yyss1 = yyss;
1141
1142         /* Each stack pointer address is followed by the size of the
1143            data in use in that stack, in bytes.  This used to be a
1144            conditional around just the two extra args, but that might
1145            be undefined if yyoverflow is a macro.  */
1146         yyoverflow (YY_("memory exhausted"),
1147                     &yyss1, yysize * sizeof (*yyssp),
1148                     &yyvs1, yysize * sizeof (*yyvsp),
1149                     &yystacksize);
1150
1151         yyss = yyss1;
1152         yyvs = yyvs1;
1153       }
1154 #else /* no yyoverflow */
1155 # ifndef YYSTACK_RELOCATE
1156       goto yyexhaustedlab;
1157 # else
1158       /* Extend the stack our own way.  */
1159       if (YYMAXDEPTH <= yystacksize)
1160         goto yyexhaustedlab;
1161       yystacksize *= 2;
1162       if (YYMAXDEPTH < yystacksize)
1163         yystacksize = YYMAXDEPTH;
1164
1165       {
1166         yytype_int16 *yyss1 = yyss;
1167         union yyalloc *yyptr =
1168           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1169         if (! yyptr)
1170           goto yyexhaustedlab;
1171         YYSTACK_RELOCATE (yyss_alloc, yyss);
1172         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1173 #  undef YYSTACK_RELOCATE
1174         if (yyss1 != yyssa)
1175           YYSTACK_FREE (yyss1);
1176       }
1177 # endif
1178 #endif /* no yyoverflow */
1179
1180       yyssp = yyss + yysize - 1;
1181       yyvsp = yyvs + yysize - 1;
1182
1183       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1184                   (unsigned long int) yystacksize));
1185
1186       if (yyss + yystacksize - 1 <= yyssp)
1187         YYABORT;
1188     }
1189
1190   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1191
1192   if (yystate == YYFINAL)
1193     YYACCEPT;
1194
1195   goto yybackup;
1196
1197 /*-----------.
1198 | yybackup.  |
1199 `-----------*/
1200 yybackup:
1201
1202   /* Do appropriate processing given the current state.  Read a
1203      lookahead token if we need one and don't already have one.  */
1204
1205   /* First try to decide what to do without reference to lookahead token.  */
1206   yyn = yypact[yystate];
1207   if (yypact_value_is_default (yyn))
1208     goto yydefault;
1209
1210   /* Not known => get a lookahead token if don't already have one.  */
1211
1212   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1213   if (yychar == YYEMPTY)
1214     {
1215       YYDPRINTF ((stderr, "Reading a token: "));
1216       yychar = yylex ();
1217     }
1218
1219   if (yychar <= YYEOF)
1220     {
1221       yychar = yytoken = YYEOF;
1222       YYDPRINTF ((stderr, "Now at end of input.\n"));
1223     }
1224   else
1225     {
1226       yytoken = YYTRANSLATE (yychar);
1227       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1228     }
1229
1230   /* If the proper action on seeing token YYTOKEN is to reduce or to
1231      detect an error, take that action.  */
1232   yyn += yytoken;
1233   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1234     goto yydefault;
1235   yyn = yytable[yyn];
1236   if (yyn <= 0)
1237     {
1238       if (yytable_value_is_error (yyn))
1239         goto yyerrlab;
1240       yyn = -yyn;
1241       goto yyreduce;
1242     }
1243
1244   /* Count tokens shifted since error; after three, turn off error
1245      status.  */
1246   if (yyerrstatus)
1247     yyerrstatus--;
1248
1249   /* Shift the lookahead token.  */
1250   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1251
1252   /* Discard the shifted token.  */
1253   yychar = YYEMPTY;
1254
1255   yystate = yyn;
1256   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1257   *++yyvsp = yylval;
1258   YY_IGNORE_MAYBE_UNINITIALIZED_END
1259
1260   goto yynewstate;
1261
1262
1263 /*-----------------------------------------------------------.
1264 | yydefault -- do the default action for the current state.  |
1265 `-----------------------------------------------------------*/
1266 yydefault:
1267   yyn = yydefact[yystate];
1268   if (yyn == 0)
1269     goto yyerrlab;
1270   goto yyreduce;
1271
1272
1273 /*-----------------------------.
1274 | yyreduce -- Do a reduction.  |
1275 `-----------------------------*/
1276 yyreduce:
1277   /* yyn is the number of a rule to reduce with.  */
1278   yylen = yyr2[yyn];
1279
1280   /* If YYLEN is nonzero, implement the default value of the action:
1281      '$$ = $1'.
1282
1283      Otherwise, the following line sets YYVAL to garbage.
1284      This behavior is undocumented and Bison
1285      users should not rely upon it.  Assigning to YYVAL
1286      unconditionally makes the parser a bit smaller, and it avoids a
1287      GCC warning that YYVAL may be used uninitialized.  */
1288   yyval = yyvsp[1-yylen];
1289
1290
1291   YY_REDUCE_PRINT (yyn);
1292   switch (yyn)
1293     {
1294         case 4:
1295 #line 90 "sparql_parser.y" /* yacc.c:1646  */
1296     {
1297         global_sparql_parser_state->result = (yyvsp[0].sval);
1298 }
1299 #line 1300 "sparql_parser.c" /* yacc.c:1646  */
1300     break;
1301
1302   case 5:
1303 #line 96 "sparql_parser.y" /* yacc.c:1646  */
1304     {
1305         /*
1306          * We can't properly handle these in expressions, fortunately this
1307          * is probably only ever used by OS X as sole element in an
1308          * expression ie "False" (when Finder window selected our share
1309          * but no search string entered yet). Packet traces showed that OS
1310          * X Spotlight server then returns a failure (ie -1) which is what
1311          * we do here too by calling YYABORT.
1312          */
1313         YYABORT;
1314 }
1315 #line 1316 "sparql_parser.c" /* yacc.c:1646  */
1316     break;
1317
1318   case 6:
1319 #line 119 "sparql_parser.y" /* yacc.c:1646  */
1320     {
1321         if (strcmp((yyvsp[-2].sval), (yyvsp[0].sval)) != 0) {
1322                 (yyval.sval) = talloc_asprintf(talloc_tos(), "{ %s } UNION { %s }", (yyvsp[-2].sval), (yyvsp[0].sval));
1323         } else {
1324                 (yyval.sval) = talloc_asprintf(talloc_tos(), "%s", (yyvsp[-2].sval));
1325         }
1326 }
1327 #line 1328 "sparql_parser.c" /* yacc.c:1646  */
1328     break;
1329
1330   case 7:
1331 #line 126 "sparql_parser.y" /* yacc.c:1646  */
1332     {
1333         (yyval.sval) = (yyvsp[0].sval);
1334 }
1335 #line 1336 "sparql_parser.c" /* yacc.c:1646  */
1336     break;
1337
1338   case 8:
1339 #line 129 "sparql_parser.y" /* yacc.c:1646  */
1340     {
1341         (yyval.sval) = (yyvsp[0].sval);
1342 }
1343 #line 1344 "sparql_parser.c" /* yacc.c:1646  */
1344     break;
1345
1346   case 9:
1347 #line 132 "sparql_parser.y" /* yacc.c:1646  */
1348     {
1349         (yyval.sval) = talloc_asprintf(talloc_tos(), "%s", (yyvsp[-1].sval));
1350 }
1351 #line 1352 "sparql_parser.c" /* yacc.c:1646  */
1352     break;
1353
1354   case 10:
1355 #line 135 "sparql_parser.y" /* yacc.c:1646  */
1356     {
1357         (yyval.sval) = talloc_asprintf(talloc_tos(), "%s . %s", (yyvsp[-2].sval), (yyvsp[0].sval));
1358 }
1359 #line 1360 "sparql_parser.c" /* yacc.c:1646  */
1360     break;
1361
1362   case 11:
1363 #line 138 "sparql_parser.y" /* yacc.c:1646  */
1364     {
1365         if (strcmp((yyvsp[-2].sval), (yyvsp[0].sval)) != 0) {
1366                 (yyval.sval) = talloc_asprintf(talloc_tos(), "{ %s } UNION { %s }", (yyvsp[-2].sval), (yyvsp[0].sval));
1367         } else {
1368                 (yyval.sval) = talloc_asprintf(talloc_tos(), "%s", (yyvsp[-2].sval));
1369         }
1370 }
1371 #line 1372 "sparql_parser.c" /* yacc.c:1646  */
1372     break;
1373
1374   case 12:
1375 #line 148 "sparql_parser.y" /* yacc.c:1646  */
1376     {
1377         (yyval.sval) = map_expr((yyvsp[-4].sval), '=', (yyvsp[-1].sval));
1378         if ((yyval.sval) == NULL) YYABORT;
1379 }
1380 #line 1381 "sparql_parser.c" /* yacc.c:1646  */
1381     break;
1382
1383   case 13:
1384 #line 152 "sparql_parser.y" /* yacc.c:1646  */
1385     {
1386         (yyval.sval) = map_expr((yyvsp[-4].sval), '!', (yyvsp[-1].sval));
1387         if ((yyval.sval) == NULL) YYABORT;
1388 }
1389 #line 1390 "sparql_parser.c" /* yacc.c:1646  */
1390     break;
1391
1392   case 14:
1393 #line 156 "sparql_parser.y" /* yacc.c:1646  */
1394     {
1395         (yyval.sval) = map_expr((yyvsp[-4].sval), '<', (yyvsp[-1].sval));
1396         if ((yyval.sval) == NULL) YYABORT;
1397 }
1398 #line 1399 "sparql_parser.c" /* yacc.c:1646  */
1399     break;
1400
1401   case 15:
1402 #line 160 "sparql_parser.y" /* yacc.c:1646  */
1403     {
1404         (yyval.sval) = map_expr((yyvsp[-4].sval), '>', (yyvsp[-1].sval));
1405         if ((yyval.sval) == NULL) YYABORT;
1406 }
1407 #line 1408 "sparql_parser.c" /* yacc.c:1646  */
1408     break;
1409
1410   case 16:
1411 #line 164 "sparql_parser.y" /* yacc.c:1646  */
1412     {
1413         (yyval.sval) = map_expr((yyvsp[-5].sval), '=', (yyvsp[-2].sval));
1414         if ((yyval.sval) == NULL) YYABORT;
1415 }
1416 #line 1417 "sparql_parser.c" /* yacc.c:1646  */
1417     break;
1418
1419   case 17:
1420 #line 168 "sparql_parser.y" /* yacc.c:1646  */
1421     {
1422         (yyval.sval) = map_expr((yyvsp[-5].sval), '!', (yyvsp[-2].sval));
1423         if ((yyval.sval) == NULL) YYABORT;
1424 }
1425 #line 1426 "sparql_parser.c" /* yacc.c:1646  */
1426     break;
1427
1428   case 18:
1429 #line 172 "sparql_parser.y" /* yacc.c:1646  */
1430     {
1431         (yyval.sval) = map_expr((yyvsp[-5].sval), '<', (yyvsp[-2].sval));
1432         if ((yyval.sval) == NULL) YYABORT;
1433 }
1434 #line 1435 "sparql_parser.c" /* yacc.c:1646  */
1435     break;
1436
1437   case 19:
1438 #line 176 "sparql_parser.y" /* yacc.c:1646  */
1439     {
1440         (yyval.sval) = map_expr((yyvsp[-5].sval), '>', (yyvsp[-2].sval));
1441         if ((yyval.sval) == NULL) YYABORT;
1442 }
1443 #line 1444 "sparql_parser.c" /* yacc.c:1646  */
1444     break;
1445
1446   case 20:
1447 #line 183 "sparql_parser.y" /* yacc.c:1646  */
1448     {
1449         (yyval.sval) = map_daterange((yyvsp[-5].sval), (yyvsp[-3].tval), (yyvsp[-1].tval));
1450         if ((yyval.sval) == NULL) YYABORT;
1451 }
1452 #line 1453 "sparql_parser.c" /* yacc.c:1646  */
1453     break;
1454
1455   case 21:
1456 #line 190 "sparql_parser.y" /* yacc.c:1646  */
1457     {(yyval.tval) = isodate2unix((yyvsp[-1].sval));}
1458 #line 1459 "sparql_parser.c" /* yacc.c:1646  */
1459     break;
1460
1461   case 22:
1462 #line 191 "sparql_parser.y" /* yacc.c:1646  */
1463     {(yyval.tval) = atoi((yyvsp[0].sval)) + SPRAW_TIME_OFFSET;}
1464 #line 1465 "sparql_parser.c" /* yacc.c:1646  */
1465     break;
1466
1467
1468 #line 1469 "sparql_parser.c" /* yacc.c:1646  */
1469       default: break;
1470     }
1471   /* User semantic actions sometimes alter yychar, and that requires
1472      that yytoken be updated with the new translation.  We take the
1473      approach of translating immediately before every use of yytoken.
1474      One alternative is translating here after every semantic action,
1475      but that translation would be missed if the semantic action invokes
1476      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1477      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1478      incorrect destructor might then be invoked immediately.  In the
1479      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1480      to an incorrect destructor call or verbose syntax error message
1481      before the lookahead is translated.  */
1482   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1483
1484   YYPOPSTACK (yylen);
1485   yylen = 0;
1486   YY_STACK_PRINT (yyss, yyssp);
1487
1488   *++yyvsp = yyval;
1489
1490   /* Now 'shift' the result of the reduction.  Determine what state
1491      that goes to, based on the state we popped back to and the rule
1492      number reduced by.  */
1493
1494   yyn = yyr1[yyn];
1495
1496   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1497   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1498     yystate = yytable[yystate];
1499   else
1500     yystate = yydefgoto[yyn - YYNTOKENS];
1501
1502   goto yynewstate;
1503
1504
1505 /*--------------------------------------.
1506 | yyerrlab -- here on detecting error.  |
1507 `--------------------------------------*/
1508 yyerrlab:
1509   /* Make sure we have latest lookahead translation.  See comments at
1510      user semantic actions for why this is necessary.  */
1511   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1512
1513   /* If not already recovering from an error, report this error.  */
1514   if (!yyerrstatus)
1515     {
1516       ++yynerrs;
1517 #if ! YYERROR_VERBOSE
1518       yyerror (YY_("syntax error"));
1519 #else
1520 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1521                                         yyssp, yytoken)
1522       {
1523         char const *yymsgp = YY_("syntax error");
1524         int yysyntax_error_status;
1525         yysyntax_error_status = YYSYNTAX_ERROR;
1526         if (yysyntax_error_status == 0)
1527           yymsgp = yymsg;
1528         else if (yysyntax_error_status == 1)
1529           {
1530             if (yymsg != yymsgbuf)
1531               YYSTACK_FREE (yymsg);
1532             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1533             if (!yymsg)
1534               {
1535                 yymsg = yymsgbuf;
1536                 yymsg_alloc = sizeof yymsgbuf;
1537                 yysyntax_error_status = 2;
1538               }
1539             else
1540               {
1541                 yysyntax_error_status = YYSYNTAX_ERROR;
1542                 yymsgp = yymsg;
1543               }
1544           }
1545         yyerror (yymsgp);
1546         if (yysyntax_error_status == 2)
1547           goto yyexhaustedlab;
1548       }
1549 # undef YYSYNTAX_ERROR
1550 #endif
1551     }
1552
1553
1554
1555   if (yyerrstatus == 3)
1556     {
1557       /* If just tried and failed to reuse lookahead token after an
1558          error, discard it.  */
1559
1560       if (yychar <= YYEOF)
1561         {
1562           /* Return failure if at end of input.  */
1563           if (yychar == YYEOF)
1564             YYABORT;
1565         }
1566       else
1567         {
1568           yydestruct ("Error: discarding",
1569                       yytoken, &yylval);
1570           yychar = YYEMPTY;
1571         }
1572     }
1573
1574   /* Else will try to reuse lookahead token after shifting the error
1575      token.  */
1576   goto yyerrlab1;
1577
1578
1579 /*---------------------------------------------------.
1580 | yyerrorlab -- error raised explicitly by YYERROR.  |
1581 `---------------------------------------------------*/
1582 yyerrorlab:
1583
1584   /* Pacify compilers like GCC when the user code never invokes
1585      YYERROR and the label yyerrorlab therefore never appears in user
1586      code.  */
1587   if (/*CONSTCOND*/ 0)
1588      goto yyerrorlab;
1589
1590   /* Do not reclaim the symbols of the rule whose action triggered
1591      this YYERROR.  */
1592   YYPOPSTACK (yylen);
1593   yylen = 0;
1594   YY_STACK_PRINT (yyss, yyssp);
1595   yystate = *yyssp;
1596   goto yyerrlab1;
1597
1598
1599 /*-------------------------------------------------------------.
1600 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1601 `-------------------------------------------------------------*/
1602 yyerrlab1:
1603   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1604
1605   for (;;)
1606     {
1607       yyn = yypact[yystate];
1608       if (!yypact_value_is_default (yyn))
1609         {
1610           yyn += YYTERROR;
1611           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1612             {
1613               yyn = yytable[yyn];
1614               if (0 < yyn)
1615                 break;
1616             }
1617         }
1618
1619       /* Pop the current state because it cannot handle the error token.  */
1620       if (yyssp == yyss)
1621         YYABORT;
1622
1623
1624       yydestruct ("Error: popping",
1625                   yystos[yystate], yyvsp);
1626       YYPOPSTACK (1);
1627       yystate = *yyssp;
1628       YY_STACK_PRINT (yyss, yyssp);
1629     }
1630
1631   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1632   *++yyvsp = yylval;
1633   YY_IGNORE_MAYBE_UNINITIALIZED_END
1634
1635
1636   /* Shift the error token.  */
1637   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1638
1639   yystate = yyn;
1640   goto yynewstate;
1641
1642
1643 /*-------------------------------------.
1644 | yyacceptlab -- YYACCEPT comes here.  |
1645 `-------------------------------------*/
1646 yyacceptlab:
1647   yyresult = 0;
1648   goto yyreturn;
1649
1650 /*-----------------------------------.
1651 | yyabortlab -- YYABORT comes here.  |
1652 `-----------------------------------*/
1653 yyabortlab:
1654   yyresult = 1;
1655   goto yyreturn;
1656
1657 #if !defined yyoverflow || YYERROR_VERBOSE
1658 /*-------------------------------------------------.
1659 | yyexhaustedlab -- memory exhaustion comes here.  |
1660 `-------------------------------------------------*/
1661 yyexhaustedlab:
1662   yyerror (YY_("memory exhausted"));
1663   yyresult = 2;
1664   /* Fall through.  */
1665 #endif
1666
1667 yyreturn:
1668   if (yychar != YYEMPTY)
1669     {
1670       /* Make sure we have latest lookahead translation.  See comments at
1671          user semantic actions for why this is necessary.  */
1672       yytoken = YYTRANSLATE (yychar);
1673       yydestruct ("Cleanup: discarding lookahead",
1674                   yytoken, &yylval);
1675     }
1676   /* Do not reclaim the symbols of the rule whose action triggered
1677      this YYABORT or YYACCEPT.  */
1678   YYPOPSTACK (yylen);
1679   YY_STACK_PRINT (yyss, yyssp);
1680   while (yyssp != yyss)
1681     {
1682       yydestruct ("Cleanup: popping",
1683                   yystos[*yyssp], yyvsp);
1684       YYPOPSTACK (1);
1685     }
1686 #ifndef yyoverflow
1687   if (yyss != yyssa)
1688     YYSTACK_FREE (yyss);
1689 #endif
1690 #if YYERROR_VERBOSE
1691   if (yymsg != yymsgbuf)
1692     YYSTACK_FREE (yymsg);
1693 #endif
1694   return yyresult;
1695 }
1696 #line 194 "sparql_parser.y" /* yacc.c:1906  */
1697
1698
1699 static time_t isodate2unix(const char *s)
1700 {
1701         struct tm tm;
1702         const char *p;
1703
1704         p = strptime(s, "%Y-%m-%dT%H:%M:%SZ", &tm);
1705         if (p == NULL) {
1706                 return (time_t)-1;
1707         }
1708         return mktime(&tm);
1709 }
1710
1711 static const char *map_daterange(const char *dateattr,
1712                                  time_t date1, time_t date2)
1713 {
1714         struct sparql_parser_state *s = global_sparql_parser_state;
1715         int result = 0;
1716         char *sparql = NULL;
1717         const struct sl_attr_map *p;
1718         struct tm *tmp;
1719         char buf1[64], buf2[64];
1720
1721         if (s->var == 'z') {
1722                 return NULL;
1723         }
1724
1725         tmp = localtime(&date1);
1726         if (tmp == NULL) {
1727                 return NULL;
1728         }
1729         result = strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
1730         if (result == 0) {
1731                 return NULL;
1732         }
1733
1734         tmp = localtime(&date2);
1735         if (tmp == NULL) {
1736                 return NULL;
1737         }
1738         result = strftime(buf2, sizeof(buf2), "%Y-%m-%dT%H:%M:%SZ", tmp);
1739         if (result == 0) {
1740                 return NULL;
1741         }
1742
1743         p = sl_attr_map_by_spotlight(dateattr);
1744         if (p == NULL) {
1745                 return NULL;
1746         }
1747
1748         sparql = talloc_asprintf(talloc_tos(),
1749                                  "?obj %s ?%c FILTER (?%c > '%s' && ?%c < '%s')",
1750                                  p->sparql_attr,
1751                                  s->var,
1752                                  s->var,
1753                                  buf1,
1754                                  s->var,
1755                                  buf2);
1756         if (sparql == NULL) {
1757                 return NULL;
1758         }
1759
1760         s->var++;
1761         return sparql;
1762 }
1763
1764 static char *map_type_search(const char *attr, char op, const char *val)
1765 {
1766         char *result = NULL;
1767         const char *sparqlAttr;
1768         const struct sl_type_map *p;
1769
1770         p = sl_type_map_by_spotlight(val);
1771         if (p == NULL) {
1772                 return NULL;
1773         }
1774
1775         switch (p->type) {
1776         case kMDTypeMapRDF:
1777                 sparqlAttr = "rdf:type";
1778                 break;
1779         case kMDTypeMapMime:
1780                 sparqlAttr = "nie:mimeType";
1781                 break;
1782         default:
1783                 return NULL;
1784         }
1785
1786         result = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
1787                                  sparqlAttr,
1788                                  p->sparql_type);
1789         if (result == NULL) {
1790                 return NULL;
1791         }
1792
1793         return result;
1794 }
1795
1796 static const char *map_expr(const char *attr, char op, const char *val)
1797 {
1798         struct sparql_parser_state *s = global_sparql_parser_state;
1799         int result = 0;
1800         char *sparql = NULL;
1801         const struct sl_attr_map *p;
1802         time_t t;
1803         struct tm *tmp;
1804         char buf1[64];
1805         char *q;
1806         const char *start;
1807
1808         if (s->var == 'z') {
1809                 return NULL;
1810         }
1811
1812         p = sl_attr_map_by_spotlight(attr);
1813         if (p == NULL) {
1814                 return NULL;
1815         }
1816
1817         if ((p->type != ssmt_type) && (p->sparql_attr == NULL)) {
1818                 yyerror("unsupported Spotlight attribute");
1819                 return NULL;
1820         }
1821
1822         switch (p->type) {
1823         case ssmt_bool:
1824                 sparql = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
1825                                          p->sparql_attr, val);
1826                 if (sparql == NULL) {
1827                         return NULL;
1828                 }
1829                 break;
1830
1831         case ssmt_num:
1832                 sparql = talloc_asprintf(talloc_tos(),
1833                                          "?obj %s ?%c FILTER(?%c %c%c '%s')",
1834                                          p->sparql_attr,
1835                                          s->var,
1836                                          s->var,
1837                                          op,
1838                                          /* append '=' to '!' */
1839                                          op == '!' ? '=' : ' ',
1840                                          val);
1841                 if (sparql == NULL) {
1842                         return NULL;
1843                 }
1844                 s->var++;
1845                 break;
1846
1847         case ssmt_str:
1848                 q = talloc_strdup(talloc_tos(), "");
1849                 if (q == NULL) {
1850                         return NULL;
1851                 }
1852                 start = val;
1853                 while (*val) {
1854                         if (*val != '*') {
1855                                 val++;
1856                                 continue;
1857                         }
1858                         if (val > start) {
1859                                 q = talloc_strndup_append(q, start, val - start);
1860                                 if (q == NULL) {
1861                                         return NULL;
1862                                 }
1863                         }
1864                         q = talloc_strdup_append(q, ".*");
1865                         if (q == NULL) {
1866                                 return NULL;
1867                         }
1868                         val++;
1869                         start = val;
1870                 }
1871                 if (val > start) {
1872                         q = talloc_strndup_append(q, start, val - start);
1873                         if (q == NULL) {
1874                                 return NULL;
1875                         }
1876                 }
1877                 sparql = talloc_asprintf(talloc_tos(),
1878                                          "?obj %s ?%c "
1879                                          "FILTER(regex(?%c, '^%s$', 'i'))",
1880                                          p->sparql_attr,
1881                                          s->var,
1882                                          s->var,
1883                                          q);
1884                 TALLOC_FREE(q);
1885                 if (sparql == NULL) {
1886                         return NULL;
1887                 }
1888                 s->var++;
1889                 break;
1890
1891         case ssmt_fts:
1892                 sparql = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
1893                                          p->sparql_attr, val);
1894                 if (sparql == NULL) {
1895                         return NULL;
1896                 }
1897                 break;
1898
1899         case ssmt_date:
1900                 t = atoi(val) + SPRAW_TIME_OFFSET;
1901                 tmp = localtime(&t);
1902                 if (tmp == NULL) {
1903                         return NULL;
1904                 }
1905                 result = strftime(buf1, sizeof(buf1),
1906                                   "%Y-%m-%dT%H:%M:%SZ", tmp);
1907                 if (result == 0) {
1908                         return NULL;
1909                 }
1910                 sparql = talloc_asprintf(talloc_tos(),
1911                                          "?obj %s ?%c FILTER(?%c %c '%s')",
1912                                          p->sparql_attr,
1913                                          s->var,
1914                                          s->var,
1915                                          op,
1916                                          buf1);
1917                 if (sparql == NULL) {
1918                         return NULL;
1919                 }
1920                 s->var++;
1921                 break;
1922
1923         case ssmt_type:
1924                 sparql = map_type_search(attr, op, val);
1925                 if (sparql == NULL) {
1926                         return NULL;
1927                 }
1928                 break;
1929
1930         default:
1931                 return NULL;
1932         }
1933
1934         return sparql;
1935 }
1936
1937 void mdsyyerror(const char *str)
1938 {
1939         DEBUG(1, ("mdsyyerror: %s\n", str));
1940 }
1941
1942 int mdsyywrap(void)
1943 {
1944         return 1;
1945 }
1946
1947 /**
1948  * Map a Spotlight RAW query string to a SPARQL query string
1949  **/
1950 bool map_spotlight_to_sparql_query(struct sl_query *slq)
1951 {
1952         struct sparql_parser_state s = {
1953                 .frame = talloc_stackframe(),
1954                 .var = 'a',
1955         };
1956         int result;
1957
1958         s.s = mdsyy_scan_string(slq->query_string);
1959         if (s.s == NULL) {
1960                 TALLOC_FREE(s.frame);
1961                 return false;
1962         }
1963         global_sparql_parser_state = &s;
1964         result = mdsyyparse();
1965         global_sparql_parser_state = NULL;
1966         mdsyy_delete_buffer(s.s);
1967
1968         if (result != 0) {
1969                 TALLOC_FREE(s.frame);
1970                 return false;
1971         }
1972
1973         slq->sparql_query = talloc_asprintf(slq,
1974                 "SELECT ?url WHERE { %s . ?obj nie:url ?url . "
1975                 "FILTER(tracker:uri-is-descendant('file://%s/', ?url)) }",
1976                 s.result, slq->path_scope);
1977         TALLOC_FREE(s.frame);
1978         if (slq->sparql_query == NULL) {
1979                 return false;
1980         }
1981
1982         return true;
1983 }