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

   1 /* -*- mode: C -*-
   2  *
   3  *       File:         rec-fex.c
   4  *       Date:         Sun Apr 11 21:31:32 2010
   5  *
   6  *       GNU recutils - Field Expressions
   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 <stdlib.h>
  29 #include <string.h>
  30 #include <gettext.h>
  31 #define _(str) dgettext (PACKAGE, str)
  32
  33 #include <rec-utils.h>
  34 #include <rec.h>
  35
  36 /*
  37  * Data types.
  38  */
  39
  40 struct rec_fex_elem_s
  41 {
  42   char *str;
  43
  44   char *field_name;
  45   char *rewrite_to;
  46   int max;
  47   int min;
  48
  49   char *function_name;
  50   void *function_data;
  51 };
  52
  53 #define REC_FEX_MAX_ELEMS 256
  54
  55 struct rec_fex_s
  56 {
  57   int num_elems;
  58   char *str;
  59   rec_fex_elem_t elems[REC_FEX_MAX_ELEMS];
  60 };
  61
  62 /*
  63  * Static function declarations.
  64  */
  65
  66 static void rec_fex_init (rec_fex_t fex);
  67
  68 static bool rec_fex_parse_str_simple     (rec_fex_t new,       const char *str, const char *sep);
  69 static bool rec_fex_parse_str_subscripts (rec_fex_t new,       const char *str);
  70 static bool rec_fex_parse_elem           (rec_fex_elem_t elem, const char *str);
  71
  72 /*
  73  * Public functions.
  74  */
  75
  76 rec_fex_t
  77 rec_fex_new (const char *str,
  78              enum rec_fex_kind_e kind)
  79 {
  80   rec_fex_t new;
  81   int i;
  82
  83   new = malloc (sizeof (struct rec_fex_s));
  84   if (new)
  85     {
  86       rec_fex_init (new);
  87
  88       new->num_elems = 0;
  89       new->str = NULL;
  90       for (i = 0; i < REC_FEX_MAX_ELEMS; i++)
  91         {
  92           new->elems[i] = 0;
  93         }
  94
  95       if (str != NULL)
  96         {
  97           /* Parse the string, using the proper parsing routine
  98              depending on the kind of field expression requested by
  99              the user.  */
 100
 101           if (kind == REC_FEX_SUBSCRIPTS)
 102             {
 103               if (!rec_fex_parse_str_subscripts (new, str))
 104                 {
 105                   /* Out of memory or parse error.  */
 106                   free (new);
 107                   return NULL;
 108                 }
 109             }
 110           else if (kind == REC_FEX_SIMPLE)
 111             {
 112               if (!rec_fex_parse_str_simple (new, str, " \t\n"))
 113                 {
 114                   /* Out of memory or parse error.  */
 115                   free (new);
 116                   return NULL;
 117                 }
 118             }
 119           else /* REC_FEX_CSV */
 120             {
 121               if (!rec_fex_parse_str_simple (new, str, ","))
 122                 {
 123                   /* Out of memory or parse error.  */
 124                   free (new);
 125                   return NULL;
 126                 }
 127             }
 128         }
 129     }
 130
 131   return new;
 132 }
 133
 134 void
 135 rec_fex_destroy (rec_fex_t fex)
 136 {
 137   int i;
 138
 139   if (fex)
 140     {
 141       for (i = 0; i < fex->num_elems; i++)
 142         {
 143           free (fex->elems[i]->rewrite_to);
 144           free (fex->elems[i]->field_name);
 145           free (fex->elems[i]->str);
 146           free (fex->elems[i]);
 147         }
 148
 149       free (fex->str);
 150       free (fex);
 151     }
 152 }
 153
 154 rec_fex_t
 155 rec_fex_dup (rec_fex_t fex)
 156 {
 157   rec_fex_t copy = NULL;
 158   size_t i = 0;
 159
 160   copy = malloc (sizeof (struct rec_fex_s));
 161   if (copy)
 162     {
 163       rec_fex_init (copy);
 164
 165       copy->num_elems = fex->num_elems;
 166       copy->str = strdup (fex->str);
 167       if (!copy->str)
 168         {
 169           /* Out of memory.  */
 170           rec_fex_destroy (copy);
 171           return NULL;
 172         }
 173
 174       for (i = 0; i < fex->num_elems; i++)
 175         {
 176           if (fex->elems[i] == NULL)
 177             {
 178               copy->elems[i] = NULL;
 179               continue;
 180             }
 181
 182           copy->elems[i] = malloc (sizeof (struct rec_fex_elem_s));
 183           if (!copy->elems[i])
 184             {
 185               /* Out of memory.  */
 186               rec_fex_destroy (copy);
 187               return NULL;
 188             }
 189
 190           copy->elems[i]->max = fex->elems[i]->max;
 191           copy->elems[i]->min = fex->elems[i]->min;
 192
 193 #define REC_COPY_STR_MAYBE_RETURN(FNAME)                                \
 194           do                                                            \
 195             {                                                           \
 196                if (!fex->elems[i]->FNAME)                               \
 197                  {                                                      \
 198                    copy->elems[i]->FNAME = NULL;                        \
 199                  }                                                      \
 200                else                                                     \
 201                  {                                                      \
 202                    copy->elems[i]->FNAME = strdup (fex->elems[i]->FNAME); \
 203                    if (!copy->elems[i]->FNAME)                          \
 204                      {                                                  \
 205                        /* Out of memory.  */                            \
 206                        rec_fex_destroy (copy);                          \
 207                        return NULL;                                     \
 208                      }                                                  \
 209                  }                                                      \
 210             } while (0)
 211
 212           REC_COPY_STR_MAYBE_RETURN (str);
 213           REC_COPY_STR_MAYBE_RETURN (field_name);
 214           REC_COPY_STR_MAYBE_RETURN (rewrite_to);
 215           REC_COPY_STR_MAYBE_RETURN (function_name);
 216         }
 217     }
 218
 219   return copy;
 220 }
 221
 222 bool
 223 rec_fex_check (const char *str, enum rec_fex_kind_e kind)
 224 {
 225   char *regexp_str;
 226
 227   switch (kind)
 228     {
 229     case REC_FEX_SIMPLE:
 230       {
 231         regexp_str = "^" REC_FNAME_LIST_RE "$";
 232         break;
 233       }
 234     case REC_FEX_CSV:
 235       {
 236         regexp_str = "^" REC_FNAME_LIST_CS_RE "$";
 237         break;
 238       }
 239     case REC_FEX_SUBSCRIPTS:
 240       {
 241         regexp_str = "^" REC_FNAME_LIST_SUB_RE "$";
 242         break;
 243       }
 244     default:
 245       {
 246         regexp_str = NULL;
 247         break;
 248       }
 249     }
 250
 251   return rec_match (str, regexp_str);
 252 }
 253
 254 size_t
 255 rec_fex_size (rec_fex_t fex)
 256 {
 257   return fex->num_elems;
 258 }
 259
 260 rec_fex_elem_t
 261 rec_fex_get (rec_fex_t fex,
 262              size_t position)
 263 {
 264   if ((position < 0) || (position >= fex->num_elems))
 265     {
 266       return NULL;
 267     }
 268
 269   return fex->elems[position];
 270 }
 271
 272 const char *
 273 rec_fex_elem_field_name (rec_fex_elem_t elem)
 274 {
 275   return elem->field_name;
 276 }
 277
 278 bool
 279 rec_fex_elem_set_field_name (rec_fex_elem_t elem,
 280                              const char *fname)
 281 {
 282   free (elem->field_name);
 283   elem->field_name = strdup (fname);
 284   return (elem->field_name != NULL);
 285 }
 286
 287 int
 288 rec_fex_elem_min (rec_fex_elem_t elem)
 289 {
 290   return elem->min;
 291 }
 292
 293 int
 294 rec_fex_elem_max (rec_fex_elem_t elem)
 295 {
 296   return elem->max;
 297 }
 298
 299 const char *
 300 rec_fex_elem_rewrite_to (rec_fex_elem_t elem)
 301 {
 302   return elem->rewrite_to;
 303 }
 304
 305 void
 306 rec_fex_sort (rec_fex_t fex)
 307 {
 308   bool done;
 309   rec_fex_elem_t aux;
 310   int i, j;
 311
 312   /* XXX: this code only works when 'max' is not specified.  */
 313
 314   for (i = 1; i < fex->num_elems; i++)
 315     {
 316       aux = fex->elems[i];
 317       j = i - 1;
 318       done = false;
 319
 320       while (!done)
 321        {
 322          /* If elems[j] > aux  */
 323          if ((fex->elems[j]->min == -1) || (fex->elems[j]->min > aux->min))
 324            {
 325              fex->elems[j + 1] = fex->elems[j];
 326              j = j - 1;
 327              if (j < 0)
 328                {
 329                  done = true;
 330                }
 331            }
 332          else
 333            {
 334              done = true;
 335            }
 336        }
 337
 338       fex->elems[j + 1] = aux;
 339     }
 340 }
 341
 342 char *
 343 rec_fex_str (rec_fex_t fex,
 344              enum rec_fex_kind_e kind)
 345 {
 346   char *result;
 347   size_t result_size;
 348   rec_buf_t buf;
 349   size_t i;
 350   char *tmp;
 351
 352   result = NULL;
 353   buf = rec_buf_new (&result, &result_size);
 354   if (buf)
 355     {
 356       char *field_str = NULL;
 357
 358       for (i = 0; i < fex->num_elems; i++)
 359         {
 360           if (i != 0)
 361             {
 362               if (kind == REC_FEX_SIMPLE)
 363                 {
 364                   rec_buf_putc (' ', buf);
 365                 }
 366               else
 367                 {
 368                   rec_buf_putc (',', buf);
 369                 }
 370             }
 371
 372           field_str = strdup (fex->elems[i]->field_name);
 373           if (!field_str)
 374             {
 375               rec_buf_close (buf);
 376               free (result);
 377               return NULL;
 378             }
 379
 380           rec_buf_puts (field_str, buf);
 381           free (field_str);
 382
 383           if (kind == REC_FEX_SUBSCRIPTS)
 384             {
 385               if ((fex->elems[i]->min != -1)
 386                   || (fex->elems[i]->max != -1))
 387                 {
 388                   rec_buf_putc ('[', buf);
 389                   if (fex->elems[i]->min != -1)
 390                     {
 391                       if (asprintf (&tmp, "%d", fex->elems[i]->min) != -1)
 392                         {
 393                           rec_buf_puts (tmp, buf);
 394                           free (tmp);
 395                         }
 396                     }
 397                   if (fex->elems[i]->max != -1)
 398                     {
 399                       if (asprintf (&tmp, "-%d", fex->elems[i]->max) != -1)
 400                         {
 401                           rec_buf_puts (tmp, buf);
 402                           free (tmp);
 403                         }
 404                     }
 405
 406                   rec_buf_putc (']', buf);
 407                 }
 408             }
 409         }
 410     }
 411
 412   rec_buf_close (buf);
 413
 414   return result;
 415 }
 416
 417 bool
 418 rec_fex_member_p (rec_fex_t fex,
 419                   const char *fname,
 420                   int min,
 421                   int max)
 422 {
 423   bool res = false;
 424   int i;
 425
 426   for (i = 0; i < fex->num_elems; i++)
 427     {
 428       if (rec_field_name_equal_p (fname,
 429                                   fex->elems[i]->field_name)
 430           && ((min == -1) || (fex->elems[i]->min == min))
 431           && ((max == -1) || (fex->elems[i]->max == max)))
 432         {
 433           res = true;
 434           break;
 435         }
 436     }
 437
 438   return res;
 439 }
 440
 441 rec_fex_elem_t
 442 rec_fex_append (rec_fex_t fex,
 443                 const char *fname,
 444                 int min,
 445                 int max)
 446 {
 447   rec_fex_elem_t new_elem;
 448
 449   if (fex->num_elems >= REC_FEX_MAX_ELEMS)
 450     {
 451       fprintf (stderr, _("internal error: REC_FEX_MAX_ELEMS exceeded.  Please report this.\n"));
 452       return NULL;
 453     }
 454
 455   new_elem = malloc (sizeof (struct rec_fex_elem_s));
 456   if (new_elem)
 457     {
 458       memset (new_elem, 0, sizeof (*new_elem));
 459       new_elem->field_name = strdup (fname);
 460       if (!new_elem->field_name)
 461         {
 462           /* Out of memory.  */
 463           free (new_elem);
 464           return NULL;
 465         }
 466
 467       new_elem->str = strdup (fname);
 468       if (!new_elem->str)
 469         {
 470           /* Out of memory.  */
 471           free (new_elem->field_name);
 472           free (new_elem);
 473           return NULL;
 474         }
 475
 476       new_elem->min = min;
 477       new_elem->max = max;
 478       fex->elems[fex->num_elems++] = new_elem;
 479     }
 480
 481   return new_elem;
 482 }
 483
 484 const char *
 485 rec_fex_elem_function_name (rec_fex_elem_t elem)
 486 {
 487   return elem->function_name;
 488 }
 489
 490 void **
 491 rec_fex_elem_function_data (rec_fex_elem_t elem)
 492 {
 493   return elem->function_data;
 494 }
 495
 496 bool
 497 rec_fex_all_calls_p (rec_fex_t fex)
 498 {
 499   bool result = true;
 500   size_t i = 0;
 501
 502   for (i = 0; i < fex->num_elems; i++)
 503     {
 504       if (fex->elems[i]->function_name == NULL)
 505         {
 506           result = false;
 507           break;
 508         }
 509     }
 510
 511   return result;
 512 }
 513
 514 /*
 515  * Private functions.
 516  */
 517
 518 static void
 519 rec_fex_init (rec_fex_t fex)
 520 {
 521   /* Initialize the field expression structure so it can be safely
 522      passed to rec_fex_destroy even if its contents are not completely
 523      initialized with real values.  */
 524
 525   memset (fex, 0 /* NULL */, sizeof (struct rec_fex_s));
 526 }
 527
 528 static bool
 529 rec_fex_parse_str_simple (rec_fex_t new,
 530                           const char *str,
 531                           const char *sep)
 532 {
 533   bool res;
 534   rec_fex_elem_t elem;
 535   char *fex_str, *fex_str_orig;
 536   char *elem_str;
 537   size_t i;
 538
 539   if (!str)
 540     {
 541       return false;
 542     }
 543
 544   fex_str = strdup (str);
 545   if (!fex_str)
 546     {
 547       return false;
 548     }
 549   fex_str_orig = fex_str;
 550
 551   res = true;
 552
 553   elem_str = strsep (&fex_str, sep);
 554   do
 555     {
 556       if (strlen (elem_str) > 0)
 557         {
 558           if ((elem = malloc (sizeof (struct rec_fex_elem_s))))
 559             {
 560               const char *p = elem_str;
 561
 562               /* Get the field name.  */
 563
 564               if (!rec_parse_regexp (&p,
 565                                      "^" REC_FNAME_RE,
 566                                      &(elem->field_name)))
 567                 {
 568                   /* Parse error. */
 569                   free (elem);
 570                   res = false;
 571                   break;
 572                 }
 573
 574               /* Get the subname, if any, and modify the name
 575                  accordingly.  */
 576
 577               if (*p == '.')
 578                 {
 579                   char *subname = NULL;
 580
 581                   p++;
 582                   if (!rec_parse_regexp (&p,
 583                                          "^" REC_FNAME_RE,
 584                                          &subname))
 585                     {
 586                       /* Parse error.  */
 587                       free (elem->field_name);
 588                       free (elem);
 589                       res = false;
 590                       break;
 591                     }
 592
 593                   /* Concatenate the field name and the subname.  */
 594                   elem->field_name = rec_concat_strings (elem->field_name, "_", subname);
 595                 }
 596
 597               /* Check that there are no extra stuff at the end of the
 598                  string.  */
 599
 600               if (*p != '\0')
 601                 {
 602                   free (elem->field_name);
 603                   free (elem);
 604                   res = false;
 605                   break;
 606                 }
 607
 608               /* Initialize other attributes of the fex entry.  */
 609
 610               elem->function_name = NULL;
 611               elem->function_data = NULL;
 612               elem->rewrite_to = NULL;
 613               elem->str = strdup (elem_str);
 614               elem->min = -1;
 615               elem->max = -1;
 616               new->elems[new->num_elems++] = elem;
 617             }
 618           else
 619             {
 620               res = false;
 621               break;
 622             }
 623         }
 624     }
 625   while ((elem_str = strsep (&fex_str, sep)));
 626
 627   if (new->num_elems == 0)
 628     {
 629       /* No elements were recognized.  */
 630       res = false;
 631     }
 632
 633   if (res)
 634     {
 635       new->str = strdup (str);
 636     }
 637   else
 638     {
 639       /* Destroy parsed elements.  */
 640       for (i = 0; i < new->num_elems; i++)
 641         {
 642           free (new->elems[i]->rewrite_to);
 643           free (new->elems[i]->field_name);
 644           free (new->elems[i]->str);
 645           free (new->elems[i]);
 646         }
 647     }
 648
 649   free (fex_str_orig);
 650   return res;
 651 }
 652
 653 static bool
 654 rec_fex_parse_str_subscripts (rec_fex_t new,
 655                               const char *str)
 656 {
 657   bool res;
 658   char *elem_str;
 659   char *fex_str, *fex_str_orig;
 660   rec_fex_elem_t elem;
 661   int i;
 662
 663   res = true;
 664
 665   fex_str = strdup (str);
 666   if (!fex_str)
 667     {
 668       return false;
 669     }
 670   fex_str_orig = fex_str;
 671
 672   elem_str = strsep (&fex_str, ",");
 673   do
 674     {
 675       elem = malloc (sizeof (struct rec_fex_elem_s));
 676       if (!elem)
 677         {
 678           /* Out of memory.  */
 679           res = false;
 680           break;
 681         }
 682
 683       if (!rec_fex_parse_elem (elem, elem_str))
 684         {
 685           /* Parse error.  */
 686           for (i = 0; i < new->num_elems; i++)
 687             {
 688               free (new->elems[i]->field_name);
 689               free (new->elems[i]->str);
 690               free (new->elems[i]);
 691             }
 692
 693           free (elem);
 694           res = false;
 695           break;
 696         }
 697
 698       /* Add the elem to the FEX.  */
 699       new->elems[new->num_elems++] = elem;
 700     }
 701   while ((elem_str = strsep (&fex_str, ",")));
 702
 703   if (res)
 704     {
 705       new->str = strdup (str);
 706     }
 707
 708   free (fex_str_orig);
 709   return res;
 710 }
 711
 712 static bool
 713 rec_fex_parse_elem (rec_fex_elem_t elem,
 714                     const char *str)
 715 {
 716   bool ret;
 717   const char *p;
 718
 719   ret = true;
 720   p = str;
 721
 722   /* 'Empty' part.  */
 723   elem->field_name = NULL;
 724   elem->function_name = NULL;
 725   elem->function_data = NULL;
 726   elem->str = NULL;
 727   elem->rewrite_to = NULL;
 728   elem->min = -1;
 729   elem->max = -1;
 730
 731   /* The 'str' field keeps a copy of the textual entry.  */
 732
 733   elem->str = strdup (str);
 734
 735   /* Each FEX element can be either a function call or a field name
 736      with an optional subscript.  */
 737
 738   if (rec_match (p, "^" REC_FEX_CALL))
 739     {
 740       /* Get the function name and the field argument and store them
 741          in the FEX element.  */
 742
 743       if (!rec_parse_regexp (&p,
 744                              "^" REC_FEX_FUNCTION_NAME,
 745                              &(elem->function_name)))
 746         {
 747           /* Parse error.  */
 748           free (elem->str);
 749           return false;
 750         }
 751
 752       p++; /* Skip the ( */
 753     }
 754
 755   /* Get the field name.  */
 756
 757   if (!rec_parse_regexp (&p,
 758                          "^" REC_FNAME_RE,
 759                          &(elem->field_name)))
 760     {
 761       /* Parse error.  */
 762       free (elem->str);
 763       return false;
 764     }
 765
 766   /* Get the subname and modify the name accordingly, if it
 767      exists.  */
 768
 769   if (*p == '.')
 770     {
 771       char *subname = NULL;
 772
 773       p++;
 774       if (!rec_parse_regexp (&p,
 775                              "^" REC_FNAME_RE,
 776                              &subname))
 777         {
 778           /* Parse error.  */
 779           free (elem->str);
 780           return false;
 781         }
 782
 783       /* Concatenate the field_name and the subname.  */
 784       elem->field_name = rec_concat_strings (elem->field_name, "_", subname);
 785     }
 786
 787   /* Get the subscripts if they are present.  */
 788   if (*p == '[')
 789     {
 790       p++;
 791       /* First subscript in range.  */
 792       if (!rec_parse_int (&p, &(elem->min)))
 793         {
 794           /* Parse error.  */
 795           free (elem->str);
 796           free (elem->field_name);
 797           return false;
 798         }
 799
 800       if (*p == '-')
 801         {
 802           p++;
 803           /* Second subscript in range.  */
 804           if (!rec_parse_int (&p, &(elem->max)))
 805             {
 806               /* Parse error.  */
 807               free (elem->str);
 808               free (elem->field_name);
 809               return false;
 810             }
 811         }
 812
 813       if (*p != ']')
 814         {
 815           /* Parse error.  */
 816           free (elem->str);
 817           free (elem->field_name);
 818           return false;
 819         }
 820       p++; /* Skip the ]  */
 821     }
 822
 823   if (elem->function_name)
 824     {
 825       p++; /* Skip the ) */
 826     }
 827
 828   /* Get the rewrite rule if it is present.  */
 829   if (*p == ':')
 830     {
 831       p++;
 832       if (!rec_parse_regexp (&p,
 833                              "^" REC_FNAME_RE,
 834                              &(elem->rewrite_to)))
 835         {
 836           /* Parse error.  */
 837           free (elem->str);
 838           free (elem->field_name);
 839           return false;
 840         }
 841     }
 842
 843   if (*p != '\0')
 844     {
 845       free (elem->str);
 846       free (elem->field_name);
 847       free (elem->rewrite_to);
 848       return false;
 849     }
 850
 851   return ret;
 852 }
 853
 854 /* End of rec-fex.c */