#if 0
gcc -s -O2 -c smallxrm.c
exit
#endif

/*
  Small XRM (X Resource Manager) in C.
  Public domain.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "smallxrm.h"

typedef struct xrm_pair {
  xrm_quark k;
  xrm_db*x;
} xrm_pair;

typedef struct xrm_map {
  int n;
  xrm_pair*p;
} xrm_map;

typedef struct xrm_db {
  xrm_map l;
  xrm_map t;
  char*v;
} xrm_db;

#define BUFINC 1024

static char anyq_name[2]="?";
static void*(*my_realloc)(void*,size_t);
static int nquarks;
static xrm_quark*quarklook;
static char**quarknames;
static xrm_quark keyquark=0;
static const char*keyname;
static char*inbuf;
static int inbufsize;
static int staticquarks;

static void*cb_get_resource(xrm_db*db,void*usr) {
  return db->v;
}

static int db_compar(const void*a,const void*b) {
  const xrm_pair*x=a;
  const xrm_pair*y=b;
  return x->k<y->k?-1:x->k==y->k?0:1;
}

static char*my_strdup(const char*p) {
  char*s=my_realloc(0,strlen(p)+1);
  if(!s) return 0;
  strcpy(s,p);
  return s;
}

static int quarklook_compar(const void*a,const void*b) {
  xrm_quark x=*(const xrm_quark*)a;
  xrm_quark y=*(const xrm_quark*)b;
  return strcmp(x?quarknames[x-1]?:"":keyname,y?quarknames[y-1]?:"":keyname);
}

void xrm_annihilate(void) {
  int i;
  if(!my_realloc) return;
  for(i=staticquarks;i<nquarks;i++) my_realloc(quarknames[i],0);
  my_realloc(quarknames,0);
  nquarks=0;
  quarklook=0;
  quarknames=0;
  my_realloc(inbuf,0);
  inbuf=0;
  inbufsize=0;
  my_realloc=0;
}

xrm_db*xrm_create(void) {
  xrm_db*db=my_realloc(0,sizeof(xrm_db));
  if(!db) return 0;
  db->l.n=0;
  db->l.p=0;
  db->t.n=0;
  db->t.p=0;
  db->v=0;
  return db;
}

void xrm_destroy(xrm_db*db) {
  int i;
  if(!db) return;
  my_realloc(db->v,0);
  for(i=0;i<db->l.n;i++) xrm_destroy(db->l.p[i].x);
  my_realloc(db->l.p,0);
  for(i=0;i<db->t.n;i++) xrm_destroy(db->t.p[i].x);
  my_realloc(db->t.p,0);
  my_realloc(db,0);
}

void*xrm_enumerate(xrm_db*db,void*(*cb)(xrm_db*,void*,int,xrm_quark),void*usr) {
  int i;
  void*r;
  if(!db) return 0;
  for(i=0;i<db->t.n;i++) if(r=cb(db,usr,0,db->t.p[i].k)) return r;
  for(i=0;i<db->l.n;i++) if(r=cb(db,usr,1,db->l.p[i].k)) return r;
  return 0;
}

const char*xrm_get(xrm_db*db) {
  return db?db->v:0;
}

const char*xrm_get_resource(xrm_db*db,const xrm_quark*ns,const xrm_quark*cs,int len) {
  if(!db) return 0;
  return xrm_search(db,ns,cs,len,cb_get_resource,0);
}

int xrm_init(void*(*f)(void*,size_t)) {
  if(my_realloc || !f) return -1;
  my_realloc=f;
  nquarks=1;
  quarknames=my_realloc(0,sizeof(char*));
  if(!quarknames) goto bad;
  quarklook=my_realloc(0,sizeof(xrm_quark));
  if(!quarklook) {
    my_realloc(quarknames,0);
    quarknames=0;
    goto bad;
  }
  *quarklook=xrm_anyq;
  *quarknames=anyq_name;
  inbuf=0;
  inbufsize=0;
  staticquarks=1;
  return 0;
bad:
  my_realloc=0;
  return -1;
}

int xrm_init_quarks(const char*const*list) {
  void*mem;
  int i=0;
  if(!my_realloc || !list || nquarks!=1 || staticquarks!=1) return -1;
  while(list[i]) i++;
  mem=my_realloc(quarknames,(i+1)*sizeof(char*));
  if(!mem) return -1;
  quarknames=mem;
  mem=my_realloc(quarklook,(i+1)*sizeof(xrm_quark));
  if(!mem) return -1;
  quarklook=mem;
  nquarks=staticquarks=i+1;
  for(i=0;list[i];i++) {
    quarknames[i+1]=(char*)(list[i]);
    quarklook[i+1]=i+2;
  }
  qsort(quarklook,nquarks,sizeof(xrm_quark),quarklook_compar);
  return 0;
}

int xrm_link(xrm_db*db,int loose,xrm_quark q,xrm_db*ins) {
  xrm_map*m;
  xrm_pair*p;
  xrm_pair k={q,ins};
  if(!db || !q) return 0;
  m=loose?&db->l:&db->t;
  if(m->n) {
    p=bsearch(&k,m->p,m->n,sizeof(xrm_pair),db_compar);
    if(p) {
      *p=k;
      return 0;
    }
  }
  p=my_realloc(m->p,(m->n+1)*sizeof(xrm_pair));
  if(!p) return -1;
  p[m->n]=k;
  qsort(p,++m->n,sizeof(xrm_pair),db_compar);
  m->p=p;
  return 0;
}

int xrm_load(xrm_db*db,FILE*fp,int o) {
  int bs,c,n,x;
  if(!inbuf) {
    inbuf=my_realloc(0,BUFINC+2);
    if(!inbuf) return -1;
    inbufsize=BUFINC;
  }
  if(!db || !fp) return -1;
  for(c=0;c!=EOF;) {
    for(x=bs=0;(c=fgetc(fp))!=EOF;) {
      if(c=='\r') continue;
      if(c=='\\') {
        bs^=1;
      } else if(c=='\n') {
        if(bs--) x--; else break;
      } else {
        bs=0;
      }
      inbuf[x++]=c;
      if(x>=inbufsize) {
        char*buf=my_realloc(inbuf,inbufsize+BUFINC+2);
        if(!buf) return -1;
        inbuf=buf;
        inbufsize+=BUFINC;
      }
    }
    inbuf[x]=0;
    xrm_load_line(db,inbuf,o);
  }
  return 0;
}

int xrm_load_line(xrm_db*db,const char*s,int o) {
  int c;
  int loose=0;
  char*p;
  char*q=0;
  char*r;
  if(!s) return -1;
  if(!*s || *s=='!') return 0;
  if(*s=='#') return -1;
  if(s!=inbuf) {
    int i=strlen(s)+1;
    if(i>=inbufsize) {
      char*buf=my_realloc(inbuf,i+2);
      if(!buf) return -1;
      inbuf=buf;
      inbufsize=i;
    }
    strcpy(inbuf,s);
  }
  p=inbuf;
  while(*p==' ' || *p=='\t') s++;
  if(!*p) return 0;
  while(c=*p++) {
    if(c=='.' || c=='*' || c==':') {
      if(q) {
        r=p-1;
        *r--=0;
        while(r>q && (*r==' ' || *r=='\t')) *r--=0;
        db=xrm_sub(db,loose,xrm_make_quark(q,1));
        if(!db) return -1;
        loose=0;
        q=0;
      }
      if(c=='*') loose=1;
      if(c==':') break;
    } else if(c!=' ' && c!='\t' && !q) {
      q=p-1;
    }
  }
  if(!c) return -1;
  if(db->v && !o) return 0;
  while(*p==' ' || *p=='\t') p++;
  q=p;
  while(c=*p++) {
    if(c=='\\') {
      if(p[0]>='0' && p[0]<'8' && p[1]>='0' && p[1]<'8' && p[2]>='0' && p[2]<'8') {
        r=p+2;
        *r=((p[0]-'0')<<6)|((p[1]-'0')<<3)|(p[2]-'0');
        while(*r) r[-3]=*r,++r;
        r[-3]=0;
      } else {
        if(*p=='n') *p='\n';
        r=p;
        while(*r) r[-1]=*r,++r;
        r[-1]=0;
      }
    } else if(c=='\r' || c=='\n') {
      break;
    }
  }
  *p=0;
  return xrm_put(db,q,1);
}

xrm_quark xrm_make_quark(const char*name,int addnew) {
  xrm_quark*q;
  if(name && !*name) return 0;
  keyname=name;
  if(!name) {
    if(!addnew) return 0;
    q=0;
  } else {
    q=bsearch(&keyquark,quarklook,nquarks,sizeof(xrm_quark),quarklook_compar);
  }
  if(addnew && !q) {
    xrm_quark*ql=my_realloc(quarklook,(nquarks+1)*sizeof(xrm_quark));
    char**qn=my_realloc(quarknames,(nquarks+1)*sizeof(char*));
    if(ql) quarklook=ql;
    if(qn) quarknames=qn;
    if(!ql || !qn) return 0;
    if(name) {
      qn[nquarks]=my_strdup(name);
      if(!qn[nquarks]) return 0;
    } else {
      qn[nquarks]=0;
    }
    ql[nquarks]=++nquarks;
    qsort(quarklook,nquarks,sizeof(xrm_quark),quarklook_compar);
    return nquarks;
  } else {
    return q?*q:0;
  }
}

int xrm_merge(xrm_db*to,xrm_db*from,int o) {
  int i;
  if(!from) return 0;
  if(!to) return -1;
  if(xrm_put(to,from->v,o)) return -1;
  for(i=0;i<from->t.n;i++) if(xrm_merge(xrm_sub(to,0,from->t.p[i].k),from->t.p[i].x,o)) return -1;
  for(i=0;i<from->l.n;i++) if(xrm_merge(xrm_sub(to,1,from->l.p[i].k),from->l.p[i].x,o)) return -1;
  return 0;
}

const char*xrm_name(xrm_quark n) {
  if(!n || n>nquarks) return 0;
  return quarknames[n-1];
}

int xrm_put(xrm_db*db,const char*v,int o) {
  char*s;
  if(!db) return -1;
  if(db->v && !o) return 0;
  if(v) {
    s=my_strdup(v);
    if(!s) return -1;
    my_realloc(db->v,0);
    db->v=s;
  } else {
    my_realloc(db->v,0);
    db->v=0;
  }
  return 0;
}

int xrm_put_resource(xrm_db*db,const xrm_quark*q,const char*b,const char*v,int o) {
  while(*b) {
    if(*b!='.' && *b!='*') return -1;
    db=xrm_sub(db,*b=='*',*q);
    q++; b++;
  }
  return xrm_put(db,v,o);
}

void*xrm_search(xrm_db*db,const xrm_quark*ns,const xrm_quark*cs,int len,void*(*cb)(xrm_db*,void*),void*usr) {
  xrm_db*p;
  void*r;
  if(!len) return cb(db,usr);
  if((p=xrm_sub(db,0,*ns)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
  if(ns!=cs && (p=xrm_sub(db,0,*cs)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
  if((p=xrm_sub(db,0,xrm_anyq)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
again:
  if((p=xrm_sub(db,1,*ns)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
  if(ns!=cs && (p=xrm_sub(db,1,*cs)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
  if((p=xrm_sub(db,1,xrm_anyq)) && (r=xrm_search(p,ns+1,cs+1,len-1,cb,usr))) return r;
  ns++; cs++;
  if(--len) goto again;
  return 0;
}

xrm_db*xrm_sub(xrm_db*db,int loose,xrm_quark q) {
  xrm_map*m;
  xrm_pair*p;
  xrm_pair k={q,0};
  if(!db || !q) return 0;
  m=loose?&db->l:&db->t;
  if(m->n) {
    p=bsearch(&k,m->p,m->n,sizeof(xrm_pair),db_compar);
    if(p) return p->x;
  }
  k.x=xrm_create();
  if(!k.x) return 0;
  p=my_realloc(m->p,(m->n+1)*sizeof(xrm_pair));
  if(!p) {
    my_realloc(k.x,0);
    return 0;
  }
  p[m->n]=k;
  qsort(p,++m->n,sizeof(xrm_pair),db_compar);
  m->p=p;
  return k.x;
}