gtl-parsley-ruby 0.5.0

data/ext/parsley/parsley.c

@@ -0,0 +1,793 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <argp.h>
+#include <stdarg.h>
+#include <json/json.h>
+#include "parsley.h"
+#include "y.tab.h"
+#include <json/printbuf.h>
+#include "functions.h"
+#include "util.h"
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/debugXML.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/xmlwriter.h>
+#include <libxml/xmlerror.h>
+#include <libxml/debugXML.h>
+#include <libexslt/exslt.h>
+
+int yywrap(void){
+  return 1;
+}
+
+struct ll {
+  xmlChar *name;
+  struct ll *next;
+};
+
+static char* 
+arepl(char* orig, char* old, char* new) {
+	// printf("y\n");
+	char* ptr = strdup(orig);
+	int nlen = strlen(new);
+	int olen = strlen(old);
+	char* i;
+	struct printbuf * buf = printbuf_new();
+	while((i = strstr(ptr, old)) != NULL) {
+		printbuf_memappend(buf, ptr, i - ptr);
+		printbuf_memappend(buf, new, nlen);
+		ptr = i + olen;
+	}
+	printbuf_memappend(buf, ptr, strlen(ptr));
+	ptr = strdup(buf->buf);
+	printbuf_free(buf);
+	return ptr;
+}
+
+static char *
+full_key_name(contextPtr c) {  
+  if(c == NULL || c->parent == NULL) return strdup("/");
+  static struct ll * last = NULL;
+  while(c->parent != NULL) {
+    if(c->tag != NULL) {
+      struct ll * ptr = calloc(sizeof(struct ll), 1);
+      ptr->name = c->tag;
+      ptr->next = last;
+      last = ptr;
+    }
+    c = c->parent;
+  }
+  struct printbuf *buf = printbuf_new();
+  while(last != NULL) {
+    sprintbuf(buf, "/%s", last->name);
+    last = last->next;
+  }
+  char *out = strdup(buf->buf);
+  printbuf_free(buf);
+  return out;
+}
+
+void parsed_parsley_free(parsedParsleyPtr ptr) {
+  if(ptr->xml != NULL) xmlFree(ptr->xml);
+  if(ptr->error != NULL) free(ptr->error);
+  free(ptr);
+}
+
+static parsedParsleyPtr parse_error(char* format, ...) {
+  parsedParsleyPtr ptr = (parsedParsleyPtr) calloc(sizeof(parsed_parsley), 1);
+  ptr->xml = NULL;
+	va_list args;
+	va_start(args, format);
+  vasprintf(&ptr->error, format, args);
+	va_end(args);
+  return ptr;
+}
+
+parsedParsleyPtr parsley_parse_file(parsleyPtr parsley, char* file, int flags) {
+  xmlSetGenericErrorFunc(NULL , parsleyXsltError);
+	bool html = flags & PARSLEY_OPTIONS_HTML;
+  char * encoding = flags & PARSLEY_OPTIONS_FORCE_UTF8 ? "UTF-8" : NULL;
+	if(html) {
+		htmlParserCtxtPtr htmlCtxt = htmlNewParserCtxt();
+  	htmlDocPtr html = htmlCtxtReadFile(htmlCtxt, file, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
+    htmlFreeParserCtxt(htmlCtxt);
+    if(html == NULL) return parse_error("Couldn't parse file: %s\n", file);
+    parsedParsleyPtr out = parsley_parse_doc(parsley, html, flags);
+    xmlFreeDoc(html);
+    return out;
+	} else {
+		xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+		xmlDocPtr xml = xmlCtxtReadFile(ctxt, file, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
+		xmlFreeParserCtxt(ctxt);
+		if(xml == NULL) return parse_error("Couldn't parse file: %s\n", file);
+    parsedParsleyPtr out = parsley_parse_doc(parsley, xml, flags);
+    xmlFreeDoc(xml);
+    return out;
+	}
+}
+
+parsedParsleyPtr parsley_parse_string(parsleyPtr parsley, char* string, size_t size, char* base_uri, int flags) {
+  xmlSetGenericErrorFunc(NULL , parsleyXsltError);
+	bool html = flags & PARSLEY_OPTIONS_HTML;
+  char * encoding = flags & PARSLEY_OPTIONS_FORCE_UTF8 ? "UTF-8" : NULL;
+	if(base_uri == NULL) base_uri = "http://parselets.com/in-memory-string";
+	if(html) {
+		htmlParserCtxtPtr htmlCtxt = htmlNewParserCtxt();
+  	htmlDocPtr html = htmlCtxtReadMemory(htmlCtxt, string, size, base_uri, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
+    if(html == NULL) return parse_error("Couldn't parse string");
+    parsedParsleyPtr out = parsley_parse_doc(parsley, html, flags);
+    xmlFreeDoc(html);
+    return out;
+	} else {
+		xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+ 		xmlDocPtr xml = xmlCtxtReadMemory(ctxt, string, size, base_uri, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
+		if(xml == NULL) return parse_error("Couldn't parse string");
+    parsedParsleyPtr out = parsley_parse_doc(parsley, xml, flags);
+    xmlFreeDoc(xml);
+    return out;
+	}
+}
+
+static char *
+xpath_of(xmlNodePtr node) {
+  if(node == NULL || node->name == NULL || node->parent == NULL) return strdup("/");
+  
+  struct ll * ptr = (struct ll *) calloc(sizeof(struct ll), 1);
+  
+  while(node->name != NULL && node->parent != NULL) {
+    if(node->ns == NULL) {
+      struct ll * tmp = (struct ll *) calloc(sizeof(struct ll), 1);
+      tmp->name = node->name;
+      tmp->next = ptr;
+      ptr = tmp;
+    }
+    node = node->parent;
+  }
+  
+  struct printbuf *buf = printbuf_new();
+  sprintbuf(buf, "");
+  while(ptr->name != NULL) {
+    sprintbuf(buf, "/%s", ptr->name);
+    struct ll * last = ptr;
+    ptr = ptr->next;
+    free(last);
+  }
+  free(ptr);
+  
+  char *str = strdup(strlen(buf->buf) ? buf->buf : "/");
+  printbuf_free(buf);
+  return str;
+}
+
+static bool
+is_root(xmlNodePtr node) {
+  return node != NULL && node->ns != NULL && !strcmp(node->ns->prefix, "parsley") && !strcmp(node->name, "root");
+}
+
+int compare_pos (const void * a, const void * b)
+{
+	char* as = xmlGetProp(*(xmlNodePtr*)a, "position");
+	char* bs = xmlGetProp(*(xmlNodePtr*)b, "position");
+	return atoi(as) - atoi(bs);
+}
+
+static void 
+_xmlAddChild(xmlNodePtr parent, xmlNodePtr child) {
+	xmlNodePtr node = parent->children;
+	if(node == NULL) {
+		parent->children = child;
+		return;
+	}
+	while(node->next != NULL){
+		node = node->next;
+	}
+	node->next = child;
+}
+
+static int 
+_xmlChildElementCount(xmlNodePtr n) {
+  xmlNodePtr child = n->children;
+  int i = 0;
+  while(child != NULL) {
+    i++;
+    child = child->next;
+  }
+  return i;
+}
+
+static bool
+xml_empty(xmlNodePtr xml) { 
+  // fprintf(stderr, "%s\n", xml->name);
+  xmlNodePtr child = xml->children;
+  while(child != NULL) {
+    if(child->type != XML_TEXT_NODE) return false;
+    if(strlen(child->content)) return false;
+    child = child->next;
+  }
+  // printf("hello!\n");
+  return true;
+}
+
+static void 
+collate(xmlNodePtr xml) { 
+	if(xml == NULL) return ;
+  if(xml->type != XML_ELEMENT_NODE) return;
+  if(xml->ns != NULL && !strcmp(xml->ns->prefix, "parsley") && !strcmp(xml->name, "zipped")){
+    xmlNodePtr parent = xml->parent;
+    xmlNodePtr child = xml->children;
+    if(child == NULL) return;
+    int n = _xmlChildElementCount(xml);
+    
+    xmlNodePtr* name_nodes = calloc(n, sizeof(xmlNodePtr));
+    xmlNodePtr* lists = calloc(n, sizeof(xmlNodePtr));
+    bool* empty = calloc(n, sizeof(bool));
+    bool* multi = calloc(n, sizeof(bool));
+    bool* optional = calloc(n, sizeof(bool));
+    
+		int len = 0;
+    for(int i = 0; i < n; i++) {
+      name_nodes[i] = child;
+      if(child->children == NULL) {
+        lists[i] = NULL;
+      } else {
+        lists[i] = child->children;
+  			multi[i] = false;
+        optional[i] = xmlGetProp(name_nodes[i], "optional") != NULL;
+        if(lists[i] != NULL && !strcmp(lists[i]->name, "groups")) {
+          lists[i] = lists[i]->children;
+          multi[i] = true;
+        }
+  			if(lists[i] != NULL) {
+  			  lists[i]->parent->extra = i;
+  			  len += _xmlChildElementCount(lists[i]->parent);
+			  }
+
+        child->children = NULL;
+      }
+      child = child->next;
+    }
+    xml->children = NULL;
+
+		xmlNodePtr* sortable = malloc(len * sizeof(xmlNodePtr));
+		int j = 0;
+		
+		for(int i = 0; i < n; i++) {
+			xmlNodePtr node = lists[i];
+			while(node != NULL){
+				sortable[j++] = node;
+				// printf("%d/%d: %d/%d\n", i, n, j, len);
+				node = node->next;
+			}
+		}
+		
+		for(int i = 0; i < len; i++) {
+			sortable[i]->next = NULL;
+		}
+		
+		qsort(sortable, len, sizeof(xmlNodePtr), compare_pos);
+		
+		xmlNodePtr groups = xml->parent;
+		groups->children = NULL;
+		xmlNodePtr group;
+		xmlNodePtr* targets = calloc(sizeof(xmlNodePtr), n);
+		
+		for(j = 0; j < len; j++) {
+			int i = sortable[j]->parent->extra;
+			if (j == 0 || (!empty[i] && !multi[i] && !optional[i])) { // first or full
+				xmlNodePtr group = xmlNewChild(groups, xml->ns, "group", NULL); //new group
+				xmlSetProp(group, "optional", "true");
+				for(int k = 0; k < n; k++) {
+					empty[k] = true;
+					targets[k] = xmlCopyNode(name_nodes[k], 2);
+					_xmlAddChild(group, targets[k]);
+					if(multi[k]) targets[k] = xmlNewChild(targets[k], xml->ns, "groups", NULL);
+				}
+			}
+			
+			if(!multi[i]) sortable[j] = sortable[j]->children;
+			if(empty[i] || multi[i]) _xmlAddChild(targets[i], sortable[j]);
+			empty[i] = false;
+		}
+		
+    free(targets);
+    free(name_nodes);
+    free(lists);
+    free(optional);
+    free(empty);
+    free(multi);
+    free(sortable);
+    
+    collate(groups);
+  } else {
+    xmlNodePtr child = xml->children;
+    while(child != NULL){
+      collate(child);
+      child = child->next;
+    }
+  }
+}
+
+void
+parsley_set_user_agent(char const * agent) {
+  _parsley_set_user_agent(agent);
+}
+
+static void
+unlink(xmlNodePtr parent, xmlNodePtr child) {
+  if(child == NULL || parent == NULL) return;
+  xmlNodePtr ptr = parent->children;
+  
+  if(ptr == child) {
+    parent->children = child->next;
+    if(child->next != NULL) {
+      child->next->prev = NULL;
+    }
+  } else {
+    while(ptr != NULL) {
+      if(ptr->next == child) {
+        ptr->next = child->next;
+        if(child->next) child->next->prev = ptr;
+      }
+      ptr = ptr->next;
+    }
+  }  
+  child->next = NULL;
+  child->prev = NULL;
+  child->parent = NULL;
+}
+
+static void
+visit(parsedParsleyPtr ptr, xmlNodePtr xml, char* err);
+
+static void 
+prune(parsedParsleyPtr ptr, xmlNodePtr xml, char* err) {   
+	if(xml == NULL || is_root(xml)) return;
+  bool optional = xmlGetProp(xml, "optional") != NULL;
+  if(optional) {
+    xmlNodePtr parent = xml->parent;
+    unlink(parent, xml);
+    free(err);
+    err = NULL;
+    visit(ptr, parent, err);
+    return;
+  } else {
+    if(err == NULL) asprintf(&err, "%s was empty", xpath_of(xml));
+    if(!is_root(xml->parent)) {
+      // fprintf(stderr, "prune up: %s\n", xml->parent->name);
+      prune(ptr, xml->parent, err);
+    } else {
+      // fprintf(stderr, "error out\n");
+      ptr->error = err;
+    }
+  }
+}
+
+static void
+visit(parsedParsleyPtr ptr, xmlNodePtr xml, char* err) { 
+  if(xml == NULL) return;
+  // printf("trying to visit:      %s\n", xml->name);
+  if(xml->type != XML_ELEMENT_NODE) return;
+  xmlNodePtr child = xml->children;
+  xmlNodePtr parent = xml->parent;
+  if(parent == NULL) return;
+  
+  // printf("passed guard clause:      %s\n", xml->name);
+  
+  if(xml_empty(xml)) {
+    if(err == NULL) asprintf(&err, "%s was empty", xpath_of(xml));
+    
+    prune(ptr, xml, err);
+  } else if(err != NULL) {
+    free(err);
+  }  
+  while(err == NULL && child != NULL){
+		child->parent = xml;
+    visit(ptr, child, err);
+    child = child->next;
+  }
+}
+
+static parsedParsleyPtr current_ptr = NULL;
+
+void 
+parsleyXsltError(void * ctx, const char * msg, ...) {
+	if(current_ptr == NULL) return;
+  va_list ap;
+  va_start(ap, msg);
+  if(current_ptr->error == NULL) {
+    char *tmp;
+    char *tmp2;
+    vasprintf(&tmp, msg, ap);
+    tmp2 = arepl(tmp, "xmlXPathCompOpEval: ", "");
+    current_ptr->error = arepl(tmp2, "\n", "");
+    
+    free(tmp);
+    free(tmp2);
+  }
+  va_end(ap);
+}
+
+static bool
+hasDefaultNS(xmlDocPtr doc) {
+	return xmlSearchNs(doc, doc->children, NULL) != NULL;
+}
+
+static void 
+_killDefaultNS(xmlNodePtr node) {
+	if(node == NULL) return;
+
+	xmlNsPtr ns = node->nsDef;
+	if(ns != NULL) {
+		if(ns->prefix == NULL) node->nsDef = ns->next;
+		xmlNsPtr prev = ns;
+		while(ns = ns->next) {
+			if(ns->prefix == NULL) prev->next = ns->next;
+		}
+	}
+	
+	ns = node->ns;
+	if(ns != NULL) {
+		if(ns->prefix == NULL) node->ns = ns->next;
+		xmlNsPtr prev = ns;
+		while(ns = ns->next) {
+			if(ns->prefix == NULL) prev->next = ns->next;
+		}
+	}
+	
+	_killDefaultNS(node->children);
+	_killDefaultNS(node->next);
+}
+
+void 
+killDefaultNS(xmlDocPtr doc) {
+	if(hasDefaultNS(doc)) {
+		_killDefaultNS(doc->children);
+	}
+}
+
+parsedParsleyPtr parsley_parse_doc(parsleyPtr parsley, xmlDocPtr doc, int flags) {
+	killDefaultNS(doc);
+	
+  parsedParsleyPtr ptr = (parsedParsleyPtr) calloc(sizeof(parsed_parsley), 1);
+  ptr->error = NULL;
+  ptr->parsley = parsley;
+  
+  parsley_io_set_mode(flags);
+  xsltTransformContextPtr ctxt = xsltNewTransformContext(parsley->stylesheet, doc);
+  xmlSetGenericErrorFunc(ctxt, parsleyXsltError);
+  current_ptr = ptr;
+  
+  if(flags & PARSLEY_OPTIONS_SGWRAP) { 
+    doc = parsley_apply_span_wrap(doc);
+  }
+  ptr->xml = xsltApplyStylesheetUser(parsley->stylesheet, doc, NULL, NULL, NULL, ctxt);
+  xsltFreeTransformContext(ctxt);
+  current_ptr = NULL;
+  
+  if(ptr->error == NULL) {
+    if(ptr->xml != NULL && ptr->error == NULL) {
+      if(flags & PARSLEY_OPTIONS_COLLATE) collate(ptr->xml->children);
+      if(flags & PARSLEY_OPTIONS_PRUNE) visit(ptr, ptr->xml->children, NULL);
+    }
+    if(ptr->xml == NULL && ptr->error == NULL) { // == NULL
+      ptr->error = strdup("Internal runtime error");
+    }
+  }
+	return ptr;
+}
+
+static bool 
+json_invalid_object(parsleyPtr ptr, struct json_object *json) {
+	json_object_object_foreach(json, key, val) {
+		if(val==NULL) ptr->error = strdup("Parselets can only be made up of strings, arrays, and objects.");
+		
+		switch(json_object_get_type(val)) {
+		case json_type_string:
+			break;
+		case json_type_array:
+			if(json_object_array_length(val) != 1) {
+				ptr->error = strdup("Parselet arrays should have length 1.");
+				return true;
+			}
+			struct json_object * inner = json_object_array_get_idx(val, 0);
+			switch(json_object_get_type(inner)) {
+			case json_type_string:
+				break;
+			case json_type_object:
+				if(json_invalid_object(ptr, inner)) return true;
+				break;
+			default:
+				ptr->error = strdup("Arrays may contain either a single string or an object.");
+				return true;
+			}
+			break;
+		case json_type_object:
+			if(json_invalid_object(ptr, val)) {
+				return true;
+			}
+			break;
+		default:
+			ptr->error = strdup("Parselets can only be made up of strings, arrays, and objects.");
+		}
+    if(val == NULL || !json_object_is_type(val, json_type_string)) return false;
+  }
+	return false;
+}
+
+static bool 
+json_invalid(parsleyPtr ptr, struct json_object *json) {
+	if(!json_object_is_type(json, json_type_object)) {
+		ptr->error = strdup("The parselet root must be an object");
+		return true;
+	}
+	return json_invalid_object(ptr, json);
+}
+
+static void free_context(contextPtr c) {
+  if(c == NULL) return;
+  if(c->tag != NULL) free(c->tag);
+  if(c->filter != NULL) pxpath_free(c->filter);
+  if(c->expr != NULL) pxpath_free(c->expr);
+  
+  if(c->parent != NULL && c->parent->child != NULL) {
+    if(c->parent->child == c) {
+      c->parent->child = NULL;
+    } else {
+      contextPtr ptr = c->parent->child;
+      while(ptr->next != NULL) {
+        if(ptr->next == c) {
+          ptr->next = NULL;
+        } else {
+          ptr = ptr->next;
+        }
+      }
+    }
+  }
+  if(c->next != NULL) free_context(c->next);
+  if(c->child != NULL) free_context(c->child);
+  free(c);
+}
+
+static contextPtr 
+new_context(struct json_object * json, xmlNodePtr node) {
+	contextPtr c = calloc(sizeof(parsley_context), 1);
+	c->node = node;
+	c->ns = node->ns;
+  c->tag = strdup("root");
+	c->expr = pxpath_new_path(1, "/");
+	c->json = json;
+	return c;
+}
+
+parsleyPtr parsley_compile(char* parsley_str, char* incl) {
+	parsleyPtr parsley = (parsleyPtr) calloc(sizeof(compiled_parsley), 1);
+	
+	if(last_parsley_error != NULL) {
+		free(last_parsley_error);
+		last_parsley_error = NULL;
+	}
+	
+  registerEXSLT();
+	
+  // struct json_tokener *tok = json_tokener_new();
+  //  struct json_object *json = json_tokener_parse_ex(tok, parsley_str);
+  //  
+	struct json_tokener *tok = json_tokener_new();
+  struct json_object *json = json_tokener_parse_ex(tok, parsley_str, -1);
+  int error_offset = tok->char_offset;
+  if(tok->err != json_tokener_success)
+    json = error_ptr(-tok->err);
+  json_tokener_free(tok);
+  
+	if(is_error(json)) {
+		asprintf(&(parsley->error), "Your parselet is not valid json: %s at char:%d", json_tokener_errors[-(unsigned long) json], error_offset);
+		return parsley;
+	}
+	
+	if(json_invalid(parsley, json)) {
+		// fprintf(stderr, "Invalid parselet structure: %s\n", parsley->error);
+		return parsley;
+	}
+
+	xmlNodePtr node = new_stylesheet_skeleton(incl);
+		
+	contextPtr context = new_context(json, node);
+	__parsley_recurse(context);
+	
+	json_object_put(json); // frees json
+	parsley->error = last_parsley_error;
+	
+	if(parsley->error == NULL) {
+		parsley->stylesheet = xsltParseStylesheetDoc(node->doc);
+	}
+	
+  free_context(context);
+	return parsley;
+}
+
+contextPtr deeper_context(contextPtr context, char* key, struct json_object * val) {
+	contextPtr c = (contextPtr) calloc(sizeof(parsley_context), 1);
+	c->node = context->node;
+	c->ns = context->ns;
+	c->parent = context;
+	c->tag = parsley_key_tag(key);
+  c->flags = parsley_key_flags(key);
+	parsley_parsing_context = c;
+	c->array = val != NULL && json_object_is_type(val, json_type_array);
+	c->json = c->array ? json_object_array_get_idx(val, 0) : val;
+	c->string = val != NULL && json_object_is_type(c->json, json_type_string);
+	c->filter = parsley_key_filter(key);
+	c->magic = context->array && context->filter == NULL;
+	c->expr = c->string ? myparse(json_object_get_string(c->json)) : NULL;
+	if(context->child == NULL) {
+		context->child = c;
+	} else {
+		contextPtr tmp = context->child;
+		while(tmp->next != NULL) tmp = tmp->next;
+		tmp->next = c;
+	}
+  // printf(stderr, "json:    %s\ntag:    %s\nexpr:   %s\nfilter: %s\n\n", json_object_get_string(c->json), c->tag, pxpath_to_string(c->expr), pxpath_to_string(c->filter));
+	return c;
+}
+
+void parsley_free(parsleyPtr ptr) {
+	if(ptr->error != NULL) 						
+			free(ptr->error);
+	if(ptr->stylesheet != NULL) 			
+			xsltFreeStylesheet(ptr->stylesheet);
+	free(ptr);
+}
+
+void yyerror(const char * s) {
+	struct printbuf *buf = printbuf_new();
+	if(last_parsley_error !=NULL) sprintbuf(buf, "%s\n", last_parsley_error);
+  sprintbuf(buf, "%s in key: %s", s, full_key_name(parsley_parsing_context));
+	last_parsley_error = strdup(buf->buf);
+	printbuf_free(buf);
+}
+
+static bool 
+all_strings(struct json_object * json) {  
+	json_object_object_foreach(json, key, val) {
+    if(val == NULL || !json_object_is_type(val, json_type_string)) return false;
+  }
+  return true;
+}
+
+static char *
+inner_path(pxpathPtr p) {
+  if(p == NULL) return NULL;
+  if(p->type == PXPATH_PATH) return pxpath_to_string(p);
+  char *tmp = NULL;
+  pxpathPtr ptr = p->child;
+  while(ptr != NULL) {
+    tmp = inner_path(p->child);
+    if(tmp != NULL) return tmp;
+    ptr = ptr->next;
+  }
+  return NULL;
+}
+
+//TODO: tree-based replace, instead of naive string-based
+static char *
+inner_path_to_dot(pxpathPtr p) {
+  char *outer = pxpath_to_string(p);
+  char *inner = inner_path(p);
+  char *repl = NULL; 
+  if(inner != NULL) {
+    repl = arepl(outer, inner, ".");
+    free(inner);
+  }
+  free(outer);
+  return repl;
+}
+
+static bool
+inner_path_transform(contextPtr c) {
+  return c->filter == NULL && c->expr != NULL && inner_path(c->expr) != NULL;
+}
+
+static char * 
+resolve_filter(contextPtr c) {
+  return inner_path_transform(c) ? inner_path(c->expr) : pxpath_to_string(c->filter);
+}
+
+static char * 
+resolve_expr(contextPtr c) {  
+  return inner_path_transform(c) ? inner_path_to_dot(c->expr) : pxpath_to_string(c->expr);
+}
+
+static void
+render(contextPtr c) {  
+  char *filter = resolve_filter(c);
+  char *expr = resolve_expr(c);
+  char *scope = filter == NULL ? expr : filter;
+  bool magic_children = c->array && filter == NULL;
+  bool simple_array = c->array && filter != NULL;
+  bool filtered = filter != NULL;
+  bool multiple = (c->array || c->magic) && !magic_children;
+
+	// printf("node %s\n", c->node->name);
+	xmlNsPtr parsley = c->ns;
+	xmlNsPtr xsl = xmlDocGetRootElement(c->node->doc)->ns;
+  
+	if(c->array)                c->node = xmlNewChild(c->node, parsley, "groups", NULL);
+  if(filtered) {
+															c->node = xmlNewChild(c->node, xsl, "for-each", NULL);
+															xmlSetProp(c->node, "select", filter);
+	}
+  if(filtered && !multiple) {
+															c->node = xmlNewChild(c->node, xsl, "if", NULL);
+															xmlSetProp(c->node, "test", "position() = 1");
+  }
+  if(multiple) {
+	               							c->node = xmlNewChild(c->node, parsley, "group", NULL);
+															if (!(c->flags & PARSLEY_BANG)) xmlSetProp(c->node, "optional", "true");
+	}
+	xmlNodePtr attr = xmlNewChild(c->node, xsl, "attribute", NULL);
+	xmlSetProp(attr, "name", "position");
+	xmlNodePtr counter = xmlNewChild(attr, xsl, "value-of", NULL);
+	xmlSetProp(counter, "select", "count(preceding::*) + count(ancestor::*)");
+  
+  if(c->string) {
+		c->node = xmlNewChild(c->node, xsl, "value-of", NULL);
+		xmlSetProp(c->node, "select", expr);
+  } else {
+    if(magic_children)        c->node = xmlNewChild(c->node, parsley, "zipped", NULL);
+    __parsley_recurse(c);
+  }
+  
+  if(filter !=NULL) free(filter);
+  if(expr !=NULL)   free(expr);
+}
+
+void __parsley_recurse(contextPtr context) {
+	contextPtr c;
+	if(context->json == NULL) return;
+	// printf(stderr, "<%s> %s\n", context->tag, context->node->name);
+	json_object_object_foreach(context->json, key, val) {
+		c = deeper_context(context, key, val);
+		// printf(stderr, "<%s>\n", c->tag);
+		c->node = xmlAddChild(c->node, xmlNewNode(NULL, c->tag));
+		if (c->flags & PARSLEY_OPTIONAL) xmlSetProp(c->node, "optional", "true");
+    render(c);
+	}  
+}
+
+
+// static char* full_expr(contextPtr context, char* expr) {
+// 	if(expr == NULL) return context->full_expr;
+// 	char* merged = arepl(expr, ".", context->full_expr);
+// 	return arepl(merged, "///", "//");
+// }
+static char* 
+inner_key_each(struct json_object * json);
+
+static char* inner_key_of(struct json_object * json) {
+	switch(json_object_get_type(json)) {
+		case json_type_string: 
+			return json_object_get_string(json);
+		case json_type_array:
+			return NULL;
+		case json_type_object:
+			return inner_key_each(json);
+	}
+}
+
+static char* 
+inner_key_each(struct json_object * json) {
+	json_object_object_foreach(json, key, val) {
+		char* inner = inner_key_of(val);
+		if(inner != NULL) return inner;
+	}
+	return NULL;
+}