Initial commit

diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644 (file)
index 0000000..9b2fd50
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 2.6)
+
+PROJECT(jsonpath C)
+ADD_DEFINITIONS(-Os -Wall -Werror --std=gnu99 -Wmissing-declarations)
+
+SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+
+IF(APPLE)
+  INCLUDE_DIRECTORIES(/opt/local/include)
+  LINK_DIRECTORIES(/opt/local/lib)
+ENDIF()
+
+find_library(json NAMES json-c json)
+
+IF(DEBUG)
+  ADD_DEFINITIONS(-DDEBUG -g3)
+ENDIF()
+
+INCLUDE(FindPkgConfig)
+PKG_CHECK_MODULES(JSONC json-c json)
+IF(JSONC_FOUND)
+  ADD_DEFINITIONS(-DJSONC)
+  INCLUDE_DIRECTORIES(${JSONC_INCLUDE_DIRS})
+ENDIF()
+
+FIND_PACKAGE(BISON REQUIRED)
+IF(BISON_FOUND)
+    ADD_CUSTOM_COMMAND(
+      OUTPUT parser.c
+      COMMAND ${BISON_EXECUTABLE} parser.y
+      COMMENT "Generating parser.c"
+    )
+ENDIF()
+
+FIND_PACKAGE(FLEX REQUIRED)
+IF(FLEX_FOUND)
+    ADD_CUSTOM_COMMAND(
+      OUTPUT lexer.c
+      COMMAND ${FLEX_EXECUTABLE} lexer.l
+      COMMENT "Generating lexer.c"
+    )
+ENDIF()
+
+ADD_EXECUTABLE(jsonpath main.c lexer.c parser.c matcher.c)
+TARGET_LINK_LIBRARIES(jsonpath ubox ${json})
+
+INSTALL(TARGETS jsonpath RUNTIME DESTINATION bin)

diff --git a/lexer.h b/lexer.h
new file mode 100644 (file)
index 0000000..c8b5bed
--- /dev/null
+++ b/lexer.h
@@ -0,0 +1,336 @@
+#ifndef yyHEADER_H
+#define yyHEADER_H 1
+#define yyIN_HEADER 1
+
+#line 6 "lexer.h"
+
+#line 8 "lexer.h"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 35
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+#ifdef __cplusplus
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else  /* ! __cplusplus */
+
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
+
+#define YY_USE_CONST
+
+#endif /* defined (__STDC__) */
+#endif /* ! __cplusplus */
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+extern int yyleng;
+
+extern FILE *yyin, *yyout;
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+       {
+       FILE *yy_input_file;
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       int yy_n_chars;
+
+       /* Whether we "own" the buffer - i.e., we know we created it,
+        * and can realloc() it to grow it, and should free() it to
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
+
+       int yy_buffer_status;
+
+       };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart (FILE *input_file  );
+void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
+void yy_delete_buffer (YY_BUFFER_STATE b  );
+void yy_flush_buffer (YY_BUFFER_STATE b  );
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state (void );
+
+YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
+
+void *yyalloc (yy_size_t  );
+void *yyrealloc (void *,yy_size_t  );
+void yyfree (void *  );
+
+/* Begin user sect3 */
+
+#define yywrap(n) 1
+#define YY_SKIP_YYWRAP
+
+extern int yylineno;
+
+extern char *yytext;
+#define yytext_ptr yytext
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define STRING 1
+
+#endif
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy (void );
+
+int yyget_debug (void );
+
+void yyset_debug (int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra (void );
+
+void yyset_extra (YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in (void );
+
+void yyset_in  (FILE * in_str  );
+
+FILE *yyget_out (void );
+
+void yyset_out  (FILE * out_str  );
+
+int yyget_leng (void );
+
+char *yyget_text (void );
+
+int yyget_lineno (void );
+
+void yyset_lineno (int line_number  );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap (void );
+#else
+extern int yywrap (void );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * );
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#line 172 "lexer.l"
+
+
+#line 335 "lexer.h"
+#undef yyIN_HEADER
+#endif /* yyHEADER_H */

diff --git a/lexer.l b/lexer.l
new file mode 100644 (file)
index 0000000..e3467bc
--- /dev/null
+++ b/lexer.l
@@ -0,0 +1,172 @@
+%{
+/*
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <ctype.h>
+
+#include "parser.h"
+
+static char *str_ptr;
+static char str_buf[128];
+
+static void
+str_put(char c)
+{
+       if ((str_ptr - str_buf + 1) < sizeof(str_buf))
+               *str_ptr++ = c;
+}
+
+static void
+str_decode(const char *input, int base)
+{
+       int code;
+       char *end;
+
+       code = strtoul(input, &end, base);
+
+       if (end == input || *end)
+               return;
+
+       if (code > 0 && code <= 0x7F)
+       {
+               str_put(code);
+       }
+       else if (code > 0 && code <= 0x7FF)
+       {
+               str_put(((code >>  6) & 0x1F) | 0xC0);
+               str_put(( code        & 0x3F) | 0x80);
+       }
+       else if (code > 0 && code <= 0xFFFF)
+       {
+               str_put(((code >> 12) & 0x0F) | 0xE0);
+               str_put(((code >>  6) & 0x3F) | 0x80);
+               str_put(( code        & 0x3F) | 0x80);
+       }
+       else if (code > 0 && code <= 0x10FFFF)
+       {
+               str_put(((code >> 18) & 0x07) | 0xF0);
+               str_put(((code >> 12) & 0x3F) | 0x80);
+               str_put(((code >>  6) & 0x3F) | 0x80);
+               str_put(( code        & 0x3F) | 0x80);
+       }
+}
+
+%}
+
+%option outfile="lexer.c" header-file="lexer.h"
+%option noyywrap nounput noinput
+
+DOT                    "."
+LABEL          [a-zA-Z_][a-zA-Z0-9_]*
+
+BROPEN         "["
+BRCLOSE                "]"
+POPEN          "("
+PCLOSE         ")"
+
+ROOT           "$"
+THIS           "@"
+
+LT                     "<"
+LE                     "<="
+GT                     ">"
+GE                     ">="
+NE                     "!="
+EQ                     "="
+NOT                    "!"
+AND                    "&&"
+OR                     "||"
+
+NUMBER         -?[0-9]+
+WILDCARD       "*"
+BOOL           (true|false)
+
+WS                     [ \t\n]*
+
+%x                     STRING
+
+%%
+
+\" {
+       str_ptr = str_buf;
+       memset(str_buf, 0, sizeof(str_buf));
+       BEGIN(STRING);
+}
+
+<STRING>{
+       \" {
+               BEGIN(INITIAL);
+               yylval.op = jp_alloc_op(T_STRING, 0, str_buf);
+               return T_STRING;
+       }
+
+       \\([0-3][0-7]{1,2}|[0-7]{0,2})  { str_decode(yytext + 1, 8); }
+       \\x[A-Fa-f0-9]{2}                               { str_decode(yytext + 2, 16); }
+       \\u[A-Fa-f0-9]{4}                               { str_decode(yytext + 2, 16); }
+       \\a                                                             { str_put('\a'); }
+       \\b                                                             { str_put('\b'); }
+       \\e                                                             { str_put('\e'); }
+       \\f                                                             { str_put('\f'); }
+       \\n                                                             { str_put('\n'); }
+       \\r                                                             { str_put('\r'); }
+       \\t                                                             { str_put('\t'); }
+       \\v                                                             { str_put('\v'); }
+       \\.                                                             { str_put(*yytext); }
+       [^\\"]+                                                 { while (*yytext) str_put(*yytext++); }
+}
+
+{BOOL} {
+       yylval.op = jp_alloc_op(T_BOOL, (*yytext == 't'), NULL);
+       return T_BOOL;
+}
+
+{NUMBER} {
+       yylval.op = jp_alloc_op(T_NUMBER, atoi(yytext), NULL);
+       return T_NUMBER;
+}
+
+{LABEL} {
+       yylval.op = jp_alloc_op(T_LABEL, 0, yytext);
+       return T_LABEL;
+}
+
+{WILDCARD} {
+       yylval.op = jp_alloc_op(T_WILDCARD, 0, NULL);
+       return T_WILDCARD;
+}
+
+{DOT}          { return T_DOT; }
+{BROPEN}       { return T_BROPEN; }
+{BRCLOSE}      { return T_BRCLOSE; }
+{POPEN}                { return T_POPEN; }
+{PCLOSE}       { return T_PCLOSE; }
+
+{ROOT}         { return T_ROOT; }
+{THIS}         { return T_THIS; }
+
+{LT}           { return T_LT; }
+{LE}           { return T_LE; }
+{GT}           { return T_GT; }
+{GE}           { return T_GE; }
+{EQ}           { return T_EQ; }
+{NE}           { return T_NE; }
+{NOT}          { return T_NOT; }
+{AND}          { return T_AND; }
+{OR}           { return T_OR; }
+
+{WS}           { }
+
+%%

diff --git a/main.c b/main.c
new file mode 100644 (file)
index 0000000..7a19091
--- /dev/null
+++ b/main.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+
+#ifdef JSONC
+       #include <json.h>
+#else
+       #include <json-c/json.h>
+#endif
+
+#include "lexer.h"
+#include "parser.h"
+#include "matcher.h"
+
+static struct json_object *
+parse_json(FILE *fd)
+{
+       int len;
+       char buf[256];
+       struct json_object *obj = NULL;
+       struct json_tokener *tok = json_tokener_new();
+       enum json_tokener_error err = json_tokener_continue;
+
+       if (!tok)
+               return NULL;
+
+       while ((len = fread(buf, 1, sizeof(buf), fd)) > 0)
+       {
+               obj = json_tokener_parse_ex(tok, buf, len);
+               err = json_tokener_get_error(tok);
+
+               if (!err || err != json_tokener_continue)
+                       break;
+       }
+
+       json_tokener_free(tok);
+
+       return err ? NULL : obj;
+}
+
+static void
+print_string(const char *s)
+{
+       const char *p;
+
+       printf("'");
+
+       for (p = s; *p; p++)
+       {
+               if (*p == '\'')
+                       printf("'\"'\"'");
+               else
+                       printf("%c", *p);
+       }
+
+       printf("'");
+}
+
+static void
+export_json(struct json_object *jsobj, char *expr)
+{
+       bool first;
+       struct jp_opcode *tree;
+       struct json_object *res;
+       const char *error, *prefix;
+
+       tree = jp_parse(expr, &error);
+
+       if (error)
+       {
+               fprintf(stderr, "In expression '%s': %s\n", expr, error);
+               return;
+       }
+
+       res = jp_match(tree, jsobj);
+
+       if (tree->type == T_LABEL)
+       {
+               prefix = tree->str;
+
+               switch (json_object_get_type(res))
+               {
+               case json_type_object:
+                       printf("export %s_TYPE=object; ", prefix);
+
+                       first = true;
+                       printf("export %s_KEYS=", prefix);
+                       json_object_object_foreach(res, key, val)
+                       {
+                               if (!val)
+                                       continue;
+
+                               if (!first)
+                                       printf("\\ ");
+
+                               print_string(key);
+                               first = false;
+                       }
+                       printf("; ");
+
+                       //printf("export %s=", prefix);
+                       //print_string(json_object_to_json_string(res));
+                       //printf("; ");
+
+                       break;
+
+               case json_type_array:
+                       printf("export %s_TYPE=array; ", prefix);
+                       printf("export %s_LENGTH=%d; ",
+                              prefix, json_object_array_length(res));
+
+                       //printf("export %s=", prefix);
+                       //print_string(json_object_to_json_string(res));
+                       //printf("; ");
+                       break;
+
+               case json_type_boolean:
+                       printf("export %s_TYPE=bool; ", prefix);
+                       printf("export %s=%d; ", prefix, json_object_get_boolean(res));
+                       break;
+
+               case json_type_int:
+                       printf("export %s_TYPE=int; ", prefix);
+                       printf("export %s=%d; ", prefix, json_object_get_int(res));
+                       break;
+
+               case json_type_double:
+                       printf("export %s_TYPE=double; ", prefix);
+                       printf("export %s=%f; ", prefix, json_object_get_double(res));
+                       break;
+
+               case json_type_string:
+                       printf("export %s_TYPE=string; ", prefix);
+                       printf("export %s=", prefix);
+                       print_string(json_object_get_string(res));
+                       printf("; ");
+                       break;
+
+               case json_type_null:
+                       printf("unset %s %s_TYPE %s_LENGTH %s_KEYS; ",
+                                  prefix, prefix, prefix, prefix);
+                       break;
+               }
+       }
+       else
+       {
+               printf("%s\n", json_object_to_json_string(res));
+       }
+
+       jp_free();
+}
+
+int main(int argc, char **argv)
+{
+       int opt;
+       FILE *input = stdin;
+       struct json_object *jsobj = NULL;
+
+       while ((opt = getopt(argc, argv, "i:e:")) != -1)
+       {
+               switch (opt)
+               {
+               case 'i':
+                       input = fopen(optarg, "r");
+
+                       if (!input)
+                       {
+                               fprintf(stderr, "Failed to open %s: %s\n",
+                                               optarg, strerror(errno));
+
+                               exit(1);
+                       }
+
+                       break;
+
+               case 'e':
+                       if (!jsobj)
+                       {
+                               jsobj = parse_json(input);
+
+                               if (!jsobj)
+                               {
+                                       fprintf(stderr, "Failed to parse json data\n");
+                                       exit(2);
+                               }
+                       }
+
+                       export_json(jsobj, optarg);
+                       break;
+               }
+       }
+
+       if (jsobj)
+               json_object_put(jsobj);
+
+       fclose(input);
+
+       return 0;
+}

diff --git a/matcher.c b/matcher.c
new file mode 100644 (file)
index 0000000..1a4a57d
--- /dev/null
+++ b/matcher.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "matcher.h"
+
+static struct json_object *
+jp_match_next(struct jp_opcode *ptr,
+              struct json_object *root, struct json_object *cur);
+
+static bool
+jp_json_to_op(struct json_object *obj, struct jp_opcode *op)
+{
+       switch (json_object_get_type(obj))
+       {
+       case json_type_boolean:
+               op->type = T_BOOL;
+               op->num = json_object_get_boolean(obj);
+               return true;
+
+       case json_type_int:
+               op->type = T_NUMBER;
+               op->num = json_object_get_int(obj);
+               return true;
+
+       case json_type_string:
+               op->type = T_STRING;
+               op->str = (char *)json_object_get_string(obj);
+               return true;
+
+       default:
+               return false;
+       }
+}
+
+static bool
+jp_resolve(struct json_object *root, struct json_object *cur,
+           struct jp_opcode *op, struct jp_opcode *res)
+{
+       struct json_object *val;
+
+       switch (op->type)
+       {
+       case T_THIS:
+               val = jp_match(op, cur);
+
+               if (val)
+                       return jp_json_to_op(val, res);
+
+               return false;
+
+       case T_ROOT:
+               val = jp_match(op, root);
+
+               if (val)
+                       return jp_json_to_op(val, res);
+
+               return false;
+
+       default:
+               *res = *op;
+               return true;
+       }
+}
+
+static bool
+jp_cmp(struct jp_opcode *op, struct json_object *root, struct json_object *cur)
+{
+       int delta;
+       struct jp_opcode left, right;
+
+       if (!jp_resolve(root, cur, op->down, &left) ||
+        !jp_resolve(root, cur, op->down->sibling, &right))
+               return false;
+
+       if (left.type != right.type)
+               return false;
+
+       switch (left.type)
+       {
+       case T_BOOL:
+       case T_NUMBER:
+               delta = left.num - right.num;
+               break;
+
+       case T_STRING:
+               delta = strcmp(left.str, right.str);
+               break;
+
+       default:
+               return false;
+       }
+
+       switch (op->type)
+       {
+       case T_EQ:
+               return (delta == 0);
+
+       case T_LT:
+               return (delta < 0);
+
+       case T_LE:
+               return (delta <= 0);
+
+       case T_GT:
+               return (delta > 0);
+
+       case T_GE:
+               return (delta >= 0);
+
+       case T_NE:
+               return (delta != 0);
+
+       default:
+               return false;
+       }
+}
+
+static bool
+jp_expr(struct jp_opcode *op, struct json_object *root, struct json_object *cur)
+{
+       struct jp_opcode *sop;
+
+       switch (op->type)
+       {
+       case T_WILDCARD:
+               return true;
+
+       case T_EQ:
+       case T_NE:
+       case T_LT:
+       case T_LE:
+       case T_GT:
+       case T_GE:
+               return jp_cmp(op, root, cur);
+
+       case T_ROOT:
+               return !!jp_match(op, root);
+
+       case T_THIS:
+               return !!jp_match(op, cur);
+
+       case T_NOT:
+               return !jp_expr(op->down, root, cur);
+
+       case T_AND:
+               for (sop = op->down; sop; sop = sop->sibling)
+                       if (!jp_expr(sop, root, cur))
+                               return false;
+               return true;
+
+       case T_OR:
+               for (sop = op->down; sop; sop = sop->sibling)
+                       if (jp_expr(sop, root, cur))
+                               return true;
+               return false;
+
+       default:
+               return false;
+       }
+}
+
+static struct json_object *
+jp_match_expr(struct jp_opcode *ptr,
+              struct json_object *root, struct json_object *cur)
+{
+       int idx, len;
+       struct json_object *tmp, *res = NULL;
+
+       switch (json_object_get_type(cur))
+       {
+       case json_type_object:
+               ; /* a label can only be part of a statement and a declaration is not a statement */
+               json_object_object_foreach(cur, key, val)
+               {
+                       if (!key)
+                               continue;
+
+                       if (jp_expr(ptr, root, val))
+                       {
+                               tmp = jp_match_next(ptr->sibling, root, val);
+
+                               if (tmp && !res)
+                                       res = tmp;
+                       }
+               }
+
+               break;
+
+       case json_type_array:
+               len = json_object_array_length(cur);
+
+               for (idx = 0; idx < len; idx++)
+               {
+                       tmp = json_object_array_get_idx(cur, idx);
+
+                       if (jp_expr(ptr, root, tmp))
+                       {
+                               tmp = jp_match_next(ptr->sibling, root, tmp);
+
+                               if (tmp && !res)
+                                       res = tmp;
+                       }
+               }
+
+               break;
+
+       default:
+               break;
+       }
+
+       return res;
+}
+
+static struct json_object *
+jp_match_next(struct jp_opcode *ptr,
+              struct json_object *root, struct json_object *cur)
+{
+       struct json_object *next;
+
+       if (!ptr)
+               return cur;
+
+       switch (ptr->type)
+       {
+       case T_STRING:
+       case T_LABEL:
+               if (json_object_object_get_ex(cur, ptr->str, &next))
+                       return jp_match_next(ptr->sibling, root, next);
+
+               break;
+
+       case T_NUMBER:
+               next = json_object_array_get_idx(cur, ptr->num);
+
+               if (next)
+                       return jp_match_next(ptr->sibling, root, next);
+
+               break;
+
+       default:
+               return jp_match_expr(ptr, root, cur);
+       }
+
+       return NULL;
+}
+
+struct json_object *
+jp_match(struct jp_opcode *path, json_object *jsobj)
+{
+       if (path->type == T_LABEL)
+               path = path->down;
+
+       return jp_match_next(path->down, jsobj, jsobj);
+}

diff --git a/matcher.h b/matcher.h
new file mode 100644 (file)
index 0000000..4187241
--- /dev/null
+++ b/matcher.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef __MATCHER_H_
+#define __MATCHER_H_
+
+#include <string.h>
+#include <stdbool.h>
+
+#ifdef JSONC
+       #include <json.h>
+#else
+       #include <json-c/json.h>
+#endif
+
+#include "parser.h"
+
+struct json_object *
+jp_match(struct jp_opcode *path, struct json_object *jsobj);
+
+#endif

diff --git a/parser.h b/parser.h
new file mode 100644 (file)
index 0000000..a50bd50
--- /dev/null
+++ b/parser.h
@@ -0,0 +1,116 @@
+/* A Bison parser, made by GNU Bison 2.5.  */
+
+/* Bison interface for Yacc-like parsers in C
+   
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+   
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     T_ROOT = 258,
+     T_THIS = 259,
+     T_DOT = 260,
+     T_BROPEN = 261,
+     T_BRCLOSE = 262,
+     T_OR = 263,
+     T_AND = 264,
+     T_LT = 265,
+     T_LE = 266,
+     T_GT = 267,
+     T_GE = 268,
+     T_EQ = 269,
+     T_NE = 270,
+     T_POPEN = 271,
+     T_PCLOSE = 272,
+     T_NOT = 273,
+     T_BOOL = 274,
+     T_NUMBER = 275,
+     T_STRING = 276,
+     T_LABEL = 277,
+     T_WILDCARD = 278
+   };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 2068 of yacc.c  */
+#line 60 "parser.y"
+
+       struct jp_opcode *op;
+
+
+
+/* Line 2068 of yacc.c  */
+#line 79 "parser.h"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+extern YYSTYPE yylval;
+
+
+/* "%code provides" blocks.  */
+
+/* Line 2068 of yacc.c  */
+#line 38 "parser.y"
+
+
+#ifndef JP_OPCODE
+# define JP_OPCODE
+       struct jp_opcode {
+               int type;
+               struct jp_opcode *next;
+               struct jp_opcode *down;
+               struct jp_opcode *sibling;
+               char *str;
+               int num;
+       };
+#endif
+
+struct jp_opcode *_jp_alloc_op(int type, int num, char *str, ...);
+#define jp_alloc_op(type, num, str, ...) _jp_alloc_op(type, num, str, ##__VA_ARGS__, NULL)
+
+struct jp_opcode *jp_parse(const char *expr, const char **error);
+void jp_free(void);
+
+
+
+
+/* Line 2068 of yacc.c  */
+#line 117 "parser.h"

diff --git a/parser.y b/parser.y
new file mode 100644 (file)
index 0000000..40b25f5
--- /dev/null
+++ b/parser.y
@@ -0,0 +1,231 @@
+%{
+/*
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdarg.h>
+#include <libubox/utils.h>
+
+#include "lexer.h"
+#include "parser.h"
+
+static struct jp_opcode *op_pool = NULL;
+static struct jp_opcode *append_op(struct jp_opcode *a, struct jp_opcode *b);
+
+int yyparse(struct jp_opcode **tree, const char **error);
+void yyerror(struct jp_opcode **expr, const char **error, const char *msg);
+
+%}
+
+%output  "parser.c"
+%defines "parser.h"
+
+%parse-param { struct jp_opcode **expr }
+%parse-param { const char **error }
+
+%code provides {
+
+#ifndef JP_OPCODE
+# define JP_OPCODE
+       struct jp_opcode {
+               int type;
+               struct jp_opcode *next;
+               struct jp_opcode *down;
+               struct jp_opcode *sibling;
+               char *str;
+               int num;
+       };
+#endif
+
+struct jp_opcode *_jp_alloc_op(int type, int num, char *str, ...);
+#define jp_alloc_op(type, num, str, ...) _jp_alloc_op(type, num, str, ##__VA_ARGS__, NULL)
+
+struct jp_opcode *jp_parse(const char *expr, const char **error);
+void jp_free(void);
+
+}
+
+%union {
+       struct jp_opcode *op;
+}
+
+
+%token T_ROOT T_THIS T_DOT T_BROPEN T_BRCLOSE
+%token T_OR T_AND T_LT T_LE T_GT T_GE T_EQ T_NE T_POPEN T_PCLOSE T_NOT
+
+%token <op> T_BOOL T_NUMBER T_STRING T_LABEL T_WILDCARD
+
+%type <op> expr path segments segment or_exps or_exp and_exps and_exp cmp_exp unary_exp
+
+%error-verbose
+
+%%
+
+input
+       : expr                                                  { *expr = $1; }
+       ;
+
+expr
+       : T_LABEL T_EQ path                             { $1->down = $3; $$ = $1; }
+       | path                                                  { $$ = $1; }
+       ;
+
+path
+       : T_ROOT segments                               { $$ = jp_alloc_op(T_ROOT, 0, NULL, $2); }
+       | T_THIS segments                               { $$ = jp_alloc_op(T_THIS, 0, NULL, $2); }
+       ;
+
+segments
+       : segments segment                              { $$ = append_op($1, $2); }
+       | segment                                               { $$ = $1; }
+       ;
+
+segment
+       : T_DOT T_LABEL                                 { $$ = $2; }
+       | T_DOT T_WILDCARD                              { $$ = $2; }
+       | T_BROPEN or_exps T_BRCLOSE    { $$ = $2; }
+       ;
+
+or_exps
+       : or_exp                                                { $$ = $1->sibling ? jp_alloc_op(T_OR, 0, NULL, $1) : $1; }
+       ;
+
+or_exp
+       : or_exp T_OR and_exps                  { $$ = append_op($1, $3); }
+       | and_exps                                              { $$ = $1; }
+       ;
+
+and_exps
+       : and_exp                                               { $$ = $1->sibling ? jp_alloc_op(T_AND, 0, NULL, $1) : $1; }
+       ;
+
+and_exp
+       : and_exp T_AND cmp_exp                 { $$ = append_op($1, $3); }
+       | cmp_exp                                               { $$ = $1; }
+       ;
+
+cmp_exp
+       : unary_exp T_LT unary_exp              { $$ = jp_alloc_op(T_LT, 0, NULL, $1, $3); }
+       | unary_exp T_LE unary_exp              { $$ = jp_alloc_op(T_LE, 0, NULL, $1, $3); }
+       | unary_exp T_GT unary_exp              { $$ = jp_alloc_op(T_GT, 0, NULL, $1, $3); }
+       | unary_exp T_GE unary_exp              { $$ = jp_alloc_op(T_GE, 0, NULL, $1, $3); }
+       | unary_exp T_EQ unary_exp              { $$ = jp_alloc_op(T_EQ, 0, NULL, $1, $3); }
+       | unary_exp T_NE unary_exp              { $$ = jp_alloc_op(T_NE, 0, NULL, $1, $3); }
+       | unary_exp                                             { $$ = $1; }
+       ;
+
+unary_exp
+       : T_BOOL                                                { $$ = $1; }
+       | T_NUMBER                                              { $$ = $1; }
+       | T_STRING                                              { $$ = $1; }
+       | T_WILDCARD                                    { $$ = $1; }
+       | T_POPEN or_exps T_PCLOSE              { $$ = $2; }
+       | T_NOT unary_exp                               { $$ = jp_alloc_op(T_NOT, 0, NULL, $2); }
+       | path                                                  { $$ = $1; }
+       ;
+
+%%
+
+void
+yyerror(struct jp_opcode **expr, const char **error, const char *msg)
+{
+       *error = msg;
+       jp_free();
+}
+
+static struct jp_opcode *
+append_op(struct jp_opcode *a, struct jp_opcode *b)
+{
+       struct jp_opcode *tail = a;
+
+       while (tail->sibling)
+               tail = tail->sibling;
+
+       tail->sibling = b;
+
+       return a;
+}
+
+struct jp_opcode *
+_jp_alloc_op(int type, int num, char *str, ...)
+{
+       va_list ap;
+       char *ptr;
+       struct jp_opcode *newop, *child;
+
+       newop = calloc_a(sizeof(*newop),
+                        str ? &ptr : NULL, str ? strlen(str) + 1 : 0);
+
+       if (!newop)
+       {
+               fprintf(stderr, "Out of memory\n");
+               exit(1);
+       }
+
+       newop->type = type;
+       newop->num = num;
+
+       if (str)
+               newop->str = strcpy(ptr, str);
+
+       va_start(ap, str);
+
+       while ((child = va_arg(ap, void *)) != NULL)
+               if (!newop->down)
+                       newop->down = child;
+               else
+                       append_op(newop->down, child);
+
+       va_end(ap);
+
+       newop->next = op_pool;
+       op_pool = newop;
+
+       return newop;
+}
+
+struct jp_opcode *
+jp_parse(const char *expr, const char **error)
+{
+       void *buf;
+       struct jp_opcode *tree;
+
+       buf = yy_scan_string(expr);
+
+       if (yyparse(&tree, error))
+               tree = NULL;
+       else
+               *error = NULL;
+
+       yy_delete_buffer(buf);
+       yylex_destroy();
+
+       return tree;
+}
+
+void
+jp_free(void)
+{
+       struct jp_opcode *op, *tmp;
+
+       for (op = op_pool; op;)
+       {
+               tmp = op->next;
+               free(op);
+               op = tmp;
+       }
+
+       op_pool = NULL;
+}