parse.c

   1 /* fswebcam - FireStorm.cx's webcam generator                */
   2 /*===========================================================*/
   3 /* Copyright (C)2005-2006 Philip Heron <phil@firestorm.cx>   */
   4 /*                                                           */
   5 /* This program is distributed under the terms of the GNU    */
   6 /* General Public License, version 2. You may use, modify,   */
   7 /* and redistribute it under the terms of this license. A    */
   8 /* copy should be included with this source.                 */
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include "config.h"
  12 #endif
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <errno.h>
  18 #include "parse.h"
  19
  20 #define ARG_EOS (-1) /* End of string   */
  21 #define ARG_EOA (-2) /* End of argument */
  22
  23 typedef struct {
  24
  25         char *s;
  26         char *sep;
  27         char opts;
  28
  29         char quote;
  30
  31 } arg_t;
  32
  33 int arggetc(arg_t *arg)
  34 {
  35         if(*arg->s == '\0') return(ARG_EOS);
  36
  37         if((!(arg->opts & ARG_NO_ESCAPE) && *arg->s == '\\') &&
  38             !(arg->quote && *(arg->s + 1) != '"'))
  39         {
  40                 if(*(++arg->s) == '\0') return(ARG_EOS);
  41                 return((int) *(arg->s++));
  42         }
  43
  44         if(!(arg->opts & ARG_NO_QUOTE) && *arg->s == '"')
  45         {
  46                 arg->s++;
  47                 arg->quote = !arg->quote;
  48
  49                 return(arggetc(arg));
  50         }
  51
  52         if(arg->quote) return((int) *(arg->s++));
  53
  54         if(strchr(arg->sep, *arg->s))
  55         {
  56                 arg->s++;
  57                 return(ARG_EOA);
  58         }
  59
  60         return((int) *(arg->s++));
  61 }
  62
  63 int argopts(arg_t *arg, char *src, char *sep, int opts)
  64 {
  65         memset(arg, 0, sizeof(arg_t));
  66         arg->s    = src;
  67         arg->sep  = sep;
  68         arg->opts = opts;
  69         return(0);
  70 }
  71
  72 int argncpy(char *dst, size_t n, char *src, char *sep, int arg, int opt)
  73 {
  74         arg_t s;
  75         char *d;
  76         size_t l;
  77         int r;
  78
  79         argopts(&s, src, sep, opt);
  80
  81         d = dst;
  82         *d = '\0';
  83         l = 0;
  84
  85         while((r = arggetc(&s)) != ARG_EOS)
  86         {
  87                 if(r == ARG_EOA)
  88                 {
  89                         if(!(opt & ARG_NO_TRIM) && !l) continue;
  90                         if(!arg--) return(0);
  91
  92                         d = dst;
  93                         *d = '\0';
  94                         l = 0;
  95
  96                         continue;
  97                 }
  98
  99                 if(n > l)
 100                 {
 101                         *(d++) = r;
 102                         *d = '\0';
 103                         l++;
 104                 }
 105         }
 106
 107         if(!arg && !(!(opt & ARG_NO_TRIM) && !l)) return(0);
 108
 109         return(-1);
 110 }
 111
 112 int arglen(char *src, char *sep, int arg, int opt)
 113 {
 114         arg_t s;
 115         size_t l;
 116         int r;
 117
 118         argopts(&s, src, sep, opt);
 119
 120         l = 0;
 121
 122         while((r = arggetc(&s)) != ARG_EOS)
 123         {
 124                 if(r == ARG_EOA)
 125                 {
 126                         if(!(opt & ARG_NO_TRIM) && !l) continue;
 127                         if(!arg--) return(l);
 128
 129                         l = 0;
 130
 131                         continue;
 132                 }
 133
 134                 l++;
 135         }
 136
 137         if(!arg && !(!(opt & ARG_NO_TRIM) && !l)) return(l);
 138
 139         return(-1);
 140 }
 141
 142 char *argdup(char *src, char *sep, int arg, int opt)
 143 {
 144         char *dst;
 145         int l;
 146
 147         l = arglen(src, sep, arg, opt);
 148         if(l < 0) return(NULL);
 149
 150         dst = malloc(++l);
 151         if(!dst) return(NULL);
 152
 153         argncpy(dst, l, src, sep, arg, opt);
 154
 155         return(dst);
 156 }
 157
 158 int argcount(char *src, char *sep, int opt)
 159 {
 160         int count = 0;
 161
 162         while(arglen(src, sep, count, opt) >= 0)
 163                 count++;
 164
 165         return(count);
 166 }
 167
 168 long argtol(char *src, char *sep, int arg, int opt, int base)
 169 {
 170         char *str;
 171         long val;
 172
 173         str = argdup(src, sep, arg, opt);
 174         if(!str) return(-1);
 175
 176         /* Catch any errors. */
 177         errno = 0;
 178
 179         val = strtol(str, NULL, base);
 180         if(errno) val = -1;
 181         free(str);
 182
 183         return(val);
 184 }
 185
 186 int parse_font(char *src, char **font, int *fontsize)
 187 {
 188         char  *p;
 189         size_t l;
 190
 191         if(!src || !font || !fontsize) return(-1);
 192
 193         p = strchr(src, ':');
 194
 195         if(p) l = p - src;
 196         else  l = strlen(src);
 197
 198         if(l)
 199         {
 200                 *font = (char *) calloc(l + 1, 1);
 201                 if(!*font) return(-1);
 202                 strncpy(*font, src, l);
 203         }
 204
 205         if(p)
 206         {
 207                 p++;
 208                 if(*p) *fontsize = atoi(p);
 209         }
 210
 211         return(0);
 212 }
 213
 214 char *strtrim(char *str, char *ws)
 215 {
 216         char *s = str;
 217
 218         str += strspn(str, ws);
 219
 220         while(*str != '\0' && strspn(str, ws) != strlen(str))
 221                 *(s++) = *(str++);
 222
 223         *s = '\0';
 224
 225         return(str);
 226 }
 227