parsley.c

#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>

//tycho added
#include "json/json_tokener.h"
#include "json/json_tokener.c"
#include "xml2json.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;
  }
}

// start tycho's new functions

parsedParsleyPtr parsley_parse_html_string_simple(parsleyPtr parsley, char* string) {
  xmlSetGenericErrorFunc(NULL , parsleyXsltError);
  //char * encoding = flags & PARSLEY_OPTIONS_FORCE_UTF8 ? "UTF-8" : NULL;
  //char * encoding = NULL;
  char * encoding = "UTF-8";
  htmlDocPtr html = htmlParseDoc(string, encoding);
  if(html == NULL) return parse_error("Couldn't parse string");
  parsedParsleyPtr out = parsley_parse_doc(parsley, html, 0);
  xmlFreeDoc(html);
  if(out->error != NULL) {
    fprintf(stderr, "Parsing failed: %s\n", out->error);
    exit(1);
  }
  return out;
}

parsedParsleyPtr parsley_parse_both(char* parselet, char* html) {
  parsleyPtr compiled = parsley_compile(parselet, "");
  if(compiled->error != NULL) {
    fprintf(stderr, "%s\n", compiled->error);
    exit(1);
  }
  return parsley_parse_html_string_simple(compiled, html);
}

char* parsley_to_json(parsedParsleyPtr ptr) {
  struct json_object *json = xml2json(ptr->xml->children->children);
  if(json == NULL) {
    fprintf(stderr, "xml2json unknown error");
    exit(1);
  }
  char * json_string = json_object_to_json_string(json);
  return json_string;
}

char* strings_to_json(char* parselet, char* html) {
  return parsley_to_json(parsley_parse_both(parselet, html));
}

char* compiled_to_json(parsleyPtr parsley, char* html) {
  return parsley_to_json(parsley_parse_html_string_simple(parsley, html));
}

// end tycho's new functions

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_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;
}