sushivision/xml.c

   1 /*
   2  *
   3  *     sushivision copyright (C) 2006-2007 Monty <monty@xiph.org>
   4  *
   5  *  sushivision is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  sushivision is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with sushivision; see the file COPYING.  If not, write to the
  17  *  Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <errno.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <math.h>
  27 #include "internal.h"
  28
  29 /* a few helpers to make specific libxml2 call patterns more concise */
  30
  31 xmlNodePtr _xmlGetChildSPreserve(xmlNodePtr n, char *name,char *prop, char *val){
  32   xmlNodePtr child = (n?n->xmlChildrenNode:NULL);
  33   while(child){
  34     // is this the child we want?
  35     if (child->type == XML_ELEMENT_NODE && !xmlStrcmp(child->name, (const xmlChar *)name)) {
  36       // does the desired attribut match?
  37       xmlChar *test = (prop?xmlGetProp(child, (const xmlChar *)prop):NULL);
  38       if(!prop || test){
  39         if (!prop || !xmlStrcmp(test, (const xmlChar *)val)) {
  40           if(test)
  41             xmlFree(test);
  42
  43           // return it
  44           return child;
  45         }
  46         if(test)
  47           xmlFree(test);
  48       }
  49     }
  50     child = child->next;
  51   }
  52   return NULL;
  53 }
  54
  55 xmlNodePtr _xmlGetChildS(xmlNodePtr n, char *name,char *prop, char *val){
  56   xmlNodePtr child = (n?_xmlGetChildSPreserve(n,name,prop,val):NULL);
  57   if(child){
  58     // this is what we want
  59     // remove it from the tree
  60     xmlUnlinkNode(child);
  61   }
  62
  63   return child;
  64 }
  65
  66 xmlNodePtr _xmlGetChildI(xmlNodePtr n, char *name,char *prop, int val){
  67   char buffer[80];
  68   snprintf(buffer,sizeof(buffer),"%d",val);
  69   return _xmlGetChildS(n, name, prop, buffer);
  70 }
  71
  72 xmlNodePtr _xmlGetChildIPreserve(xmlNodePtr n, char *name,char *prop, int val){
  73   char buffer[80];
  74   snprintf(buffer,sizeof(buffer),"%d",val);
  75   return _xmlGetChildSPreserve(n, name, prop, buffer);
  76 }
  77
  78 void _xmlNewMapProp(xmlNodePtr n, char *name, _sv_propmap_t **map, int val){
  79   _sv_propmap_t *m = *map++;
  80   while(m){
  81     if(m->value == val){
  82       xmlNewProp(n, (xmlChar *)name, (xmlChar *)m->left);
  83       break;
  84     }
  85     m = *map++;
  86   }
  87 }
  88
  89 void _xmlNewPropF(xmlNodePtr n, char *name, double val){
  90   char buffer[80];
  91   snprintf(buffer,sizeof(buffer),"%.20g",val);
  92   xmlNewProp(n, (xmlChar *) name, (xmlChar *)buffer);
  93 }
  94
  95 void _xmlNewPropI(xmlNodePtr n, char *name, int val){
  96   char buffer[80];
  97   snprintf(buffer,sizeof(buffer),"%d",val);
  98   xmlNewProp(n, (xmlChar *) name, (xmlChar *)buffer);
  99 }
 100
 101 void _xmlNewPropS(xmlNodePtr n, char *name, char *val){
 102   if(val)
 103     xmlNewProp(n, (xmlChar *) name, (xmlChar *)val);
 104 }
 105
 106 void _xmlGetPropS(xmlNodePtr n, char *name, char **value){
 107   char *ret = (char *)(n?xmlGetProp(n, (xmlChar *)name):NULL);
 108   if(ret) *value=ret;
 109 }
 110
 111 void _xmlGetPropF(xmlNodePtr n, char *name, double *val){
 112   xmlChar *v = (n?xmlGetProp(n, (xmlChar *)name):NULL);
 113   if(v){
 114     *val = atof((char *)v);
 115     xmlFree(v);
 116   }
 117 }
 118
 119 void _xmlCheckPropS(xmlNodePtr n, char *prop, char *val, char *msg, int num, int *warn){
 120   char *testval = NULL;
 121   _xmlGetPropS(n, prop, &testval);
 122   if(testval){
 123     if(strcmp(val,testval)){
 124       _sv_first_load_warning(warn);
 125       fprintf(stderr,msg, num);
 126       fprintf(stderr,"\n\t(found %s, should be %s).\n", testval, val);
 127     }
 128     xmlFree(testval);
 129   }else{
 130     _sv_first_load_warning(warn);
 131     fprintf(stderr,msg, num);
 132     fprintf(stderr,"\n\t(null found, should be %s).\n", val);
 133   }
 134 }
 135
 136 void _xmlCheckMap(xmlNodePtr n, char *prop, _sv_propmap_t **map, int val, char *msg, int num, int *warn){
 137   char *name = NULL;
 138   char *testname = NULL;
 139   _xmlGetPropS(n, prop, &testname);
 140
 141   // look up our desired value
 142   _sv_propmap_t *m = *map++;
 143   while(m){
 144     if(m->value == val){
 145       name = m->left;
 146       break;
 147     }
 148     m = *map++;
 149   }
 150
 151   if(testname){
 152     if(name){
 153       if(strcmp(name,testname)){
 154         _sv_first_load_warning(warn);
 155         fprintf(stderr,msg, num);
 156         fprintf(stderr,"\n\t(found %s, should be %s).\n", testname, name);
 157       }
 158     }else{
 159       _sv_first_load_warning(warn);
 160       fprintf(stderr,msg, num);
 161       fprintf(stderr,"\n\t(found %s, should be null).\n", testname);
 162     }
 163     xmlFree(testname);
 164   }else{
 165     if(name){
 166       _sv_first_load_warning(warn);
 167       fprintf(stderr,msg, num);
 168       fprintf(stderr,"\n\t(null found, should be %s).\n", name);
 169     }
 170   }
 171 }
 172
 173 static void _xmlGetMapVal(xmlNodePtr n, char *key, _sv_propmap_t **map, int *out){
 174   char *valname = (char *)(n?xmlGetProp(n, (xmlChar *)key):NULL);
 175   if(!valname) return;
 176
 177   _sv_propmap_t *m = *map++;
 178   while(m){
 179     if(!strcmp(m->left,valname)){
 180       xmlFree(valname);
 181       *out = m->value;
 182       return;
 183     }
 184     m = *map++;
 185   }
 186   xmlFree(valname);
 187 }
 188
 189 static void _xmlGetChildMap_i(xmlNodePtr in, char *prop, char *key, _sv_propmap_t **map, int *out,
 190                              char *msg, int num, int *warn, int pres){
 191   xmlNodePtr n = (pres ?
 192                   (in?_xmlGetChildSPreserve(in, prop, NULL, NULL):NULL):
 193                   (in?_xmlGetChildS(in, prop, NULL, NULL):NULL));
 194   if(!n)return;
 195
 196   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 197   if(!val){
 198     if(!pres) xmlFreeNode(n);
 199     return;
 200   }
 201
 202   int ret = -1;
 203   _xmlGetMapVal(n,key,map,&ret);
 204   if(ret == -1){
 205     if(msg){
 206       _sv_first_load_warning(warn);
 207       fprintf(stderr,msg,num);
 208       fprintf(stderr," (%s).\n", val);
 209     }
 210   }else
 211     *out = ret;
 212
 213   xmlFree(val);
 214   if(!pres) xmlFreeNode(n);
 215 }
 216
 217 void _xmlGetChildMap(xmlNodePtr in, char *prop, char *key, _sv_propmap_t **map, int *out,
 218                     char *msg, int num, int *warn){
 219   _xmlGetChildMap_i(in, prop, key, map, out, msg, num, warn, 0);
 220 }
 221
 222 void _xmlGetChildMapPreserve(xmlNodePtr in, char *prop, char *key, _sv_propmap_t **map, int *out,
 223                     char *msg, int num, int *warn){
 224   _xmlGetChildMap_i(in, prop, key, map, out, msg, num, warn, 1);
 225 }
 226
 227 void _xmlGetChildPropS(xmlNodePtr in, char *prop, char *key, char **out){
 228   xmlNodePtr n = (in?_xmlGetChildS(in, prop, NULL, NULL):NULL);
 229   if(!n)return;
 230   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 231   xmlFreeNode(n);
 232   if(val) *out = val;
 233 }
 234
 235 void _xmlGetChildPropSPreserve(xmlNodePtr in, char *prop, char *key, char **out){
 236   xmlNodePtr n = (in?_xmlGetChildSPreserve(in, prop, NULL, NULL):NULL);
 237   if(!n)return;
 238   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 239   if(val) *out = val;
 240 }
 241
 242 void _xmlGetChildPropF(xmlNodePtr in, char *prop, char *key, double *out){
 243   xmlNodePtr n = (in?_xmlGetChildS(in, prop, NULL, NULL):NULL);
 244   if(!n)return;
 245   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 246   xmlFreeNode(n);
 247   if(val) *out = atof(val);
 248   xmlFree(val);
 249 }
 250
 251 void _xmlGetChildPropFPreserve(xmlNodePtr in, char *prop, char *key, double *out){
 252   xmlNodePtr n = (in?_xmlGetChildSPreserve(in, prop, NULL, NULL):NULL);
 253   if(!n)return;
 254   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 255   if(val) *out = atof(val);
 256   xmlFree(val);
 257 }
 258
 259 void _xmlGetChildPropI(xmlNodePtr in, char *prop, char *key, int *out){
 260   xmlNodePtr n = (in?_xmlGetChildS(in, prop, NULL, NULL):NULL);
 261   if(!n)return;
 262   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 263   xmlFreeNode(n);
 264   if(val) *out = atoi(val);
 265   xmlFree(val);
 266 }
 267
 268 void _xmlGetChildPropIPreserve(xmlNodePtr in, char *prop, char *key, int *out){
 269   xmlNodePtr n = (in?_xmlGetChildSPreserve(in, prop, NULL, NULL):NULL);
 270   if(!n)return;
 271   char *val = (char *)xmlGetProp(n, (xmlChar *)key);
 272   if(val) *out = atoi(val);
 273   xmlFree(val);
 274 }
 275
 276 /* convenience helpers for wielding property maps */
 277 int _sv_propmap_pos(_sv_propmap_t **map, int val){
 278   int i=0;
 279   _sv_propmap_t *m = *map++;
 280   while(m){
 281     if(m->value == val)
 282       return i;
 283     i++;
 284     m = *map++;
 285   }
 286   return 0;
 287 }
 288
 289 int _sv_propmap_last(_sv_propmap_t **map){
 290   int i=0;
 291   _sv_propmap_t *m = *map++;
 292   while(m){
 293     i++;
 294     m = *map++;
 295   }
 296   return i-1;
 297 }
 298
 299 int _sv_propmap_label_pos(_sv_propmap_t **map, char *label){
 300   int i=0;
 301   _sv_propmap_t *m = *map++;
 302   while(m){
 303     if(!strcmp(m->left,label))
 304       return i;
 305     i++;
 306     m = *map++;
 307   }
 308   return 0;
 309 }