devspec.en_US/project/recutils/src/rec-utils.c

   1 /* -*- mode: C -*-
   2  *
   3  *       File:         rec-utils.c
   4  *       Date:         Fri Apr  9 19:45:00 2010
   5  *
   6  *       GNU recutils - Miscellanea utilities
   7  *
   8  */
   9
  10 /* Copyright (C) 2010-2019 Jose E. Marchesi */
  11
  12 /* This program is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation, either version 3 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <regex.h>
  29 #include <stdlib.h>
  30 #include <gettext.h>
  31 #define _(str) dgettext (PACKAGE, str)
  32 #include <string.h>
  33 #include <locale.h>
  34
  35 #include <rec-utils.h>
  36
  37 bool
  38 rec_atoi (const char *str,
  39           int *number)
  40 {
  41   bool res;
  42   long int li;
  43   char *end;
  44   int base = 0;
  45
  46   res = false;
  47
  48   li = strtol (str, &end, base);
  49   if ((*str != '\0') && (*end == '\0'))
  50     {
  51       /* The entire string is valid.  */
  52       res = true;
  53       *number = (int) li;
  54     }
  55
  56   return res;
  57 }
  58
  59 bool
  60 rec_atod (const char *str,
  61           double *number)
  62 {
  63   bool res;
  64   char *end;
  65
  66   res = false;
  67
  68   setlocale (LC_NUMERIC, "C"); /* We want the dot to always be the
  69                                   decimal separator. */
  70   *number = strtod (str, &end);
  71   setlocale (LC_NUMERIC, ""); /* Restore the locale from the
  72                                  environment.  */
  73
  74   if ((*str != '\0') && (*end == '\0'))
  75     {
  76       /* The entire string is valid.  */
  77       res = true;
  78     }
  79
  80   return res;
  81 }
  82
  83 char *
  84 rec_extract_file (const char *str)
  85 {
  86   regex_t regexp;
  87   regmatch_t matches;
  88   char *rec_file = NULL;
  89   size_t rec_file_length = 0;
  90
  91   if (regcomp (&regexp, "[ \n\t]" REC_FILE_REGEXP, REG_EXTENDED) != 0)
  92     {
  93       fprintf (stderr, _("internal error: rec_int_rec_extract_file: error compiling regexp.\n"));
  94       return NULL;
  95     }
  96
  97   if ((regexec (&regexp, str, 1, &matches, 0) == 0)
  98       && (matches.rm_so != -1))
  99     {
 100       /* Get the match.  */
 101       rec_file_length = matches.rm_eo - matches.rm_so;
 102       rec_file = malloc (rec_file_length + 1);
 103       memcpy (rec_file, str + matches.rm_so + 1, rec_file_length - 1);
 104       rec_file[rec_file_length - 1] = '\0';
 105     }
 106
 107   regfree (&regexp);
 108   return rec_file;
 109 }
 110
 111 char *
 112 rec_extract_url (const char *str)
 113 {
 114   regex_t regexp;
 115   regmatch_t matches;
 116   char *rec_url = NULL;
 117   size_t rec_url_length = 0;
 118
 119   if (regcomp (&regexp, REC_URL_REGEXP, REG_EXTENDED) != 0)
 120     {
 121       fprintf (stderr, _("internal error: rec_int_rec_extract_url: error compiling regexp.\n"));
 122       return NULL;
 123     }
 124
 125   if ((regexec (&regexp, str, 1, &matches, 0) == 0)
 126       && (matches.rm_so != -1))
 127     {
 128       /* Get the match.  */
 129       rec_url_length = matches.rm_eo - matches.rm_so;
 130       rec_url = malloc (rec_url_length + 1);
 131       memcpy (rec_url, str + matches.rm_so, rec_url_length);
 132       rec_url[rec_url_length] = '\0';
 133     }
 134
 135   regfree (&regexp);
 136   return rec_url;
 137 }
 138
 139 char *
 140 rec_extract_type (const char *str)
 141 {
 142   regex_t regexp;
 143   regmatch_t matches;
 144   char *rec_type = NULL;
 145   size_t rec_type_length = 0;
 146
 147   /* TODO: use a REC_TYPE_NAME_RE  */
 148   if (regcomp (&regexp, REC_FNAME_RE, REG_EXTENDED) != 0)
 149     {
 150       fprintf (stderr, _("internal error: rec_int_rec_extract_url: error compiling regexp.\n"));
 151       return NULL;
 152     }
 153
 154   if ((regexec (&regexp, str, 1, &matches, 0) == 0)
 155       && (matches.rm_so != -1))
 156     {
 157       /* Get the match.  */
 158       rec_type_length = matches.rm_eo - matches.rm_so;
 159       rec_type = malloc (rec_type_length + 1);
 160       memcpy (rec_type, str + matches.rm_so, rec_type_length);
 161       rec_type[rec_type_length] = '\0';
 162     }
 163
 164   regfree (&regexp);
 165   return rec_type;
 166 }
 167
 168 bool
 169 rec_parse_int (const char **str, int *num)
 170 {
 171   bool ret;
 172   const char *p, *b;
 173   char number[30];
 174
 175   ret = true;
 176   p = *str;
 177
 178   b = p;
 179   while (rec_digit_p (*p)
 180          || ((p == b) && (*p == '-'))
 181          || ((*p >= 'a') && (*p <= 'f'))
 182          || ((*p >= 'A') && (*p <= 'F'))
 183          || (*p == 'x')
 184          || (*p == 'X'))
 185     {
 186       number[p - b] = *p;
 187       p++;
 188     }
 189   number[p - b] = '\0';
 190
 191   if (!rec_atoi (number, num))
 192     {
 193       ret = false;
 194     }
 195
 196   if (ret)
 197     {
 198       *str = p;
 199     }
 200
 201   return ret;
 202 }
 203
 204 bool
 205 rec_parse_regexp (const char **str, const char *re, char **result)
 206 {
 207   bool ret;
 208   const char *p;
 209   regex_t regexp;
 210   regmatch_t pm;
 211
 212   ret = true;
 213   p = *str;
 214
 215   /* Compile the regexp.  */
 216   if (regcomp (&regexp, re, REG_EXTENDED) != 0)
 217     {
 218       ret = false;
 219     }
 220
 221   if (ret)
 222     {
 223       /* Try to match the regexp.  */
 224       if (regexec (&regexp, p, 1, &pm, 0) == 0)
 225         {
 226           if (result)
 227             {
 228               /* Get the match into 'result'.  Note that
 229                  since the pattern starts with a ^ rm_so shall be 0 and we
 230                  can use rm_eo relative to *p.  */
 231               *result = malloc (pm.rm_eo + 1);
 232               memcpy (*result, p, pm.rm_eo);
 233               (*result)[pm.rm_eo] = '\0';
 234             }
 235
 236           /* Advance 'p'.  */
 237           p = p + pm.rm_eo;
 238         }
 239       else
 240         {
 241           ret = false;
 242           if (result)
 243             {
 244               *result = NULL;
 245             }
 246         }
 247
 248       regfree (&regexp);
 249     }
 250
 251   if (ret)
 252     {
 253       *str = p;
 254     }
 255
 256   return ret;
 257 }
 258
 259 void
 260 rec_skip_blanks (const char **str)
 261 {
 262   const char *p;
 263
 264   p = *str;
 265   while (rec_blank_p (*p))
 266     {
 267       p++;
 268     }
 269
 270   *str = p;
 271 }
 272
 273 bool
 274 rec_blank_p (char c)
 275 {
 276   return ((c == ' ')
 277           || (c == '\n')
 278           || (c == '\t'));
 279 }
 280
 281 bool
 282 rec_digit_p (char c)
 283 {
 284   return ((c >= '0') && (c <= '9'));
 285 }
 286
 287 bool
 288 rec_letter_p (char c)
 289 {
 290   return (((c >= 'a') && (c <= 'z'))
 291           || ((c >= 'A') && (c <= 'Z')));
 292 }
 293
 294 static bool
 295 rec_match_int (const char *str,
 296                const char *reg,
 297                int flags)
 298 {
 299   bool ret;
 300   regex_t regexp;
 301
 302   if (regcomp (&regexp, reg, flags) != 0)
 303     {
 304       fprintf (stderr, _("internal error: rec_match: error compiling regexp.\n"));
 305       return false;
 306     }
 307
 308   ret = (regexec (&regexp, str, 0, NULL, 0) == 0);
 309   regfree (&regexp);
 310
 311   return ret;
 312 }
 313
 314 bool
 315 rec_match (const char *str,
 316            const char *reg)
 317 {
 318   return rec_match_int (str, reg, REG_EXTENDED);
 319 }
 320
 321 bool
 322 rec_match_insensitive (const char *str,
 323                        const char *reg)
 324 {
 325   return rec_match_int (str, reg, REG_EXTENDED | REG_ICASE);
 326 }
 327
 328 size_t
 329 rec_extract_size (const char *str)
 330 {
 331   const char *p;
 332   char *condition_str;
 333   int res;
 334
 335   if (!rec_match (str, REC_INT_SIZE_RE))
 336     {
 337       return 0;
 338     }
 339
 340   p = str;
 341   rec_skip_blanks (&p);
 342   rec_parse_regexp (&p, "^[><]=?", &condition_str);
 343   rec_skip_blanks (&p);
 344   rec_parse_int (&p, &res);
 345
 346   return (size_t) res;
 347 }
 348
 349 enum rec_size_condition_e
 350 rec_extract_size_condition (const char *str)
 351 {
 352   const char *p;
 353   char *condition_str = NULL;
 354   enum rec_size_condition_e condition;
 355
 356   if (!rec_match (str, REC_INT_SIZE_RE))
 357     {
 358       return SIZE_COND_E;
 359     }
 360
 361   p = str;
 362   rec_skip_blanks (&p);
 363   rec_parse_regexp (&p, "^[><]=?", &condition_str);
 364
 365   if (condition_str)
 366     {
 367       if (strcmp (condition_str, ">") == 0)
 368         {
 369           condition = SIZE_COND_G;
 370         }
 371       else if (strcmp (condition_str, ">=") == 0)
 372         {
 373           condition = SIZE_COND_GE;
 374         }
 375       else if (strcmp (condition_str, "<") == 0)
 376         {
 377           condition = SIZE_COND_L;
 378         }
 379       else if (strcmp (condition_str, "<=") == 0)
 380         {
 381           condition = SIZE_COND_LE;
 382         }
 383       else
 384         {
 385           fprintf (stderr, "internal error: rec_extract_size_condition: invalid condition.\n");
 386           return SIZE_COND_E;
 387         }
 388
 389       free (condition_str);
 390     }
 391   else
 392     {
 393       condition = SIZE_COND_E;
 394     }
 395
 396   return condition;
 397 }
 398
 399 int
 400 rec_timespec_subtract (struct timespec *result,
 401                        struct timespec *x,
 402                        struct timespec *y)
 403 {
 404   result->tv_sec = x->tv_sec - y->tv_sec;
 405   result->tv_nsec = x->tv_nsec - y->tv_nsec;
 406   if (result->tv_nsec < 0)
 407     {
 408       /* Overflow.  Subtract one second.  */
 409       result->tv_sec--;
 410       result->tv_nsec += 1000000000;
 411     }
 412
 413   /* Return whether there is an overflow in the 'tv_sec' field.  */
 414   return (result->tv_sec < 0);
 415 }
 416
 417 uint32_t
 418 rec_endian_swap (uint32_t number)
 419 {
 420   uint32_t res;
 421
 422   res = (number >> 24)
 423     | ((number << 8) & 0x00FF0000)
 424     | ((number >> 8) & 0x0000FF00)
 425     | (number << 24);
 426
 427   return res;
 428 }
 429
 430 char *
 431 rec_concat_strings (const char *str1,
 432                     const char *str2,
 433                     const char *str3)
 434 {
 435   char *res = malloc (strlen (str1) + strlen (str2) + strlen (str3) + 1);
 436
 437   if (res)
 438     {
 439       memcpy (res, str1, strlen (str1));
 440       memcpy (res + strlen (str1), str2, strlen (str2));
 441       memcpy (res + strlen (str1) + strlen (str2), str3, strlen (str3) + 1);
 442     }
 443
 444   return res;
 445 }
 446
 447 /* End of rec-utils.c */