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

   1 /* -*- mode: C -*-
   2  *
   3  *       File:         rec-writer.c
   4  *       Date:         Sat Dec 26 22:47:16 2009
   5  *
   6  *       GNU recutils - Writer
   7  *
   8  */
   9
  10 /* Copyright (C) 2009-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 <rec.h>
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <rec.h>
  34 #include <rec-utils.h>
  35
  36 /*
  37  * Static functions defined in this file
  38  */
  39 static bool rec_writer_putc (rec_writer_t writer, char c);
  40 static bool rec_writer_puts (rec_writer_t writer, const char *s);
  41
  42 /* Writer Data Structure
  43  *
  44  */
  45 struct rec_writer_s
  46 {
  47   FILE *file_out;    /* File stream used by the writer. */
  48   rec_buf_t buf_out; /* Growable buffer used by the writer. */
  49
  50   bool eof;
  51   int line;  /* Current line number. */
  52
  53   /* The following flags and options can be accesssed using the
  54      corresponding rec_writer_(get/set)_FLAG function.  */
  55
  56   bool collapse_p;        /* If true the writer won't introduce
  57                              separators between records.  */
  58   bool skip_comments_p;   /* If true the writer won't print out
  59                              comments.  */
  60   enum rec_writer_mode_e mode; /* The mode in which the writer operates.
  61                                   See the definition of the enumerated type
  62                                   in rec.h for a list of allowed modes.  */
  63
  64 };
  65
  66 static void
  67 rec_writer_new_common (rec_writer_t writer)
  68 {
  69   writer->file_out = NULL;
  70   writer->buf_out = NULL;
  71   writer->line = 1;
  72   writer->eof = false;
  73   writer->collapse_p = false;
  74   writer->skip_comments_p = false;
  75   writer->mode = REC_WRITER_NORMAL;
  76 }
  77
  78 rec_writer_t
  79 rec_writer_new (FILE *file_out)
  80 {
  81   rec_writer_t new;
  82
  83   new = malloc (sizeof(struct rec_writer_s));
  84   if (new)
  85     {
  86       rec_writer_new_common (new);
  87       new->file_out = file_out;
  88     }
  89
  90   return new;
  91 }
  92
  93 rec_writer_t
  94 rec_writer_new_str (char **str, size_t *str_size)
  95 {
  96   rec_writer_t new;
  97
  98   new = malloc (sizeof(struct rec_writer_s));
  99   if (new)
 100     {
 101       rec_writer_new_common (new);
 102       new->buf_out = rec_buf_new (str, str_size);
 103     }
 104
 105   return new;
 106 }
 107
 108 void
 109 rec_writer_destroy (rec_writer_t writer)
 110 {
 111   if (writer)
 112     {
 113       if (writer->file_out)
 114         {
 115           fflush (writer->file_out);
 116         }
 117       if (writer->buf_out)
 118         {
 119           rec_buf_close (writer->buf_out);
 120         }
 121
 122       free (writer);
 123     }
 124 }
 125
 126 bool
 127 rec_write_comment (rec_writer_t writer,
 128                    rec_comment_t comment)
 129 {
 130   char *line;
 131   char *str;
 132   char *orig_str;
 133   size_t i;
 134
 135   if (writer->mode == REC_WRITER_SEXP)
 136     {
 137       if (!rec_writer_puts (writer, "(comment "))
 138         {
 139           return false;
 140         }
 141       if (!rec_writer_putc (writer, '"'))
 142         {
 143           return false;
 144         }
 145
 146       str = rec_comment_text (comment);
 147       for (i = 0; i < strlen (str); i++)
 148         {
 149           if (str[i] == '\n')
 150             {
 151               if (!rec_writer_puts (writer, "\\n"))
 152                 {
 153                   return false;
 154                 }
 155             }
 156           else
 157             {
 158               if (!rec_writer_putc (writer, str[i]))
 159                 {
 160                   return false;
 161                 }
 162             }
 163         }
 164
 165       if (!rec_writer_puts (writer, "\")"))
 166         {
 167           return false;
 168         }
 169     }
 170   else
 171     {
 172       /* Every line in the comment is written preceded by a '#'
 173          character.  The lines composing the comments are separated by
 174          newline characters.  */
 175
 176       bool first = true;
 177
 178       str = strdup (rec_comment_text (comment));
 179       orig_str = str; /* Save a pointer to str to deallocate it later,
 180                          since strsep will modify the str
 181                          variable.  */
 182       line = strsep (&str, "\n");
 183       do
 184         {
 185           if (!first)
 186             {
 187               if (!rec_writer_putc (writer, '\n'))
 188                 {
 189                   return false;
 190                 }
 191             }
 192
 193           if (!rec_writer_putc (writer, '#')
 194               || !rec_writer_puts (writer, line))
 195             {
 196               return false;
 197             }
 198
 199           first = false;
 200         }
 201       while ((line = strsep (&str, "\n")));
 202
 203       free (orig_str);
 204     }
 205
 206   return true;
 207 }
 208
 209 bool
 210 rec_write_field (rec_writer_t writer,
 211                  rec_field_t field)
 212 {
 213   size_t pos;
 214   const char *fname;
 215   const char *fvalue;
 216   enum rec_writer_mode_e mode = writer->mode;
 217
 218   if (mode == REC_WRITER_SEXP)
 219     {
 220       if (!rec_writer_puts (writer, "(field "))
 221         {
 222           return false;
 223         }
 224       if (!rec_writer_puts (writer, rec_field_char_location_str (field)))
 225         {
 226           return false;
 227         }
 228       if (!rec_writer_putc (writer, ' '))
 229         {
 230           return false;
 231         }
 232     }
 233
 234   if ((mode != REC_WRITER_VALUES) && (mode != REC_WRITER_VALUES_ROW))
 235     {
 236       fname = rec_field_name (field);
 237       if (!rec_write_field_name (writer, fname))
 238         {
 239           return false;
 240         }
 241     }
 242
 243   /* Write the field value */
 244   if (mode == REC_WRITER_SEXP)
 245     {
 246       if (!rec_writer_putc (writer, ' '))
 247         {
 248           return false;
 249         }
 250
 251       if (!rec_writer_putc (writer, '"'))
 252         {
 253           return false;
 254         }
 255     }
 256
 257   fvalue = rec_field_value (field);
 258
 259   if ((strlen (fvalue) > 0) && (mode == REC_WRITER_NORMAL))
 260     {
 261       if (!rec_writer_putc (writer, ' '))
 262         {
 263           return false;
 264         }
 265     }
 266
 267   for (pos = 0; pos < strlen (fvalue); pos++)
 268     {
 269       if (fvalue[pos] == '\n')
 270         {
 271           if (mode == REC_WRITER_SEXP)
 272             {
 273               if (!rec_writer_puts (writer, "\\n"))
 274                 {
 275                   return false;
 276                 }
 277             }
 278           else if (mode == REC_WRITER_NORMAL)
 279             {
 280               if (!rec_writer_puts (writer, "\n+ "))
 281                 {
 282                   return false;
 283                 }
 284             }
 285           else
 286             {
 287               if (!rec_writer_putc (writer, '\n'))
 288                 {
 289                   return false;
 290                 }
 291             }
 292         }
 293       else if (((fvalue[pos] == '"') || (fvalue[pos] == '\\')) && (mode == REC_WRITER_SEXP))
 294         {
 295           if ((!rec_writer_putc (writer, '\\'))
 296               || (!rec_writer_putc (writer, fvalue[pos])))
 297             {
 298               return false;
 299             }
 300         }
 301       else
 302         {
 303           if (!rec_writer_putc (writer, fvalue[pos]))
 304             {
 305               /* EOF on output */
 306               return false;
 307             }
 308         }
 309     }
 310
 311   if (mode == REC_WRITER_SEXP)
 312     {
 313       if (!rec_writer_putc (writer, '"'))
 314         {
 315           return false;
 316         }
 317     }
 318
 319   if (mode == REC_WRITER_SEXP)
 320     {
 321       if (!rec_writer_puts (writer, ")"))
 322         {
 323           return false;
 324         }
 325     }
 326
 327   return true;
 328 }
 329
 330 bool
 331 rec_write_field_name (rec_writer_t writer,
 332                       const char *field_name)
 333 {
 334   /* Field names can be written in several formats, according to the
 335    * desired mode:
 336    *
 337    * REC_WRITER_NORMAL
 338    *    The field name is written in rec format. i.e. NP:
 339    * REC_WRITER_SEXP
 340    *    The field name is a string: "NP"
 341    */
 342
 343   enum rec_writer_mode_e mode = writer->mode;
 344
 345   if (mode == REC_WRITER_SEXP)
 346     {
 347       if (!rec_writer_putc (writer, '"'))
 348         {
 349           return false;
 350         }
 351     }
 352
 353   if (!rec_writer_puts (writer, field_name))
 354     {
 355       return false;
 356     }
 357
 358   if (mode == REC_WRITER_SEXP)
 359     {
 360       if (!rec_writer_putc (writer, '"'))
 361         {
 362           return false;
 363         }
 364     }
 365   else
 366     {
 367       if (!rec_writer_putc (writer, ':'))
 368         {
 369           return false;
 370         }
 371     }
 372
 373   return true;
 374 }
 375
 376 bool
 377 rec_write_record (rec_writer_t writer,
 378                   rec_record_t record)
 379 {
 380   bool ret;
 381   rec_mset_iterator_t iter;
 382   rec_mset_elem_t elem;
 383   char *data;
 384   size_t num_field, num_elem, num_fields, num_elems;
 385   enum rec_writer_mode_e mode = writer->mode;
 386
 387   ret = true;
 388
 389   if (mode == REC_WRITER_SEXP)
 390     {
 391       if (!rec_writer_puts (writer, "(record "))
 392         return false;
 393       if (!rec_writer_puts (writer, rec_record_char_location_str (record)))
 394         return false;
 395       if (!rec_writer_puts (writer, " (\n"))
 396         return false;
 397     }
 398
 399   num_elems = rec_record_num_elems (record);
 400   num_fields = rec_record_num_fields (record);
 401   num_field = 0;
 402   num_elem = 0;
 403   iter = rec_mset_iterator (rec_record_mset (record));
 404   while (rec_mset_iterator_next (&iter, MSET_ANY, (const void **) &data, &elem))
 405     {
 406       if (rec_mset_elem_type (elem) == MSET_FIELD)
 407         {
 408           /* Write a field.  */
 409           rec_field_t field = (rec_field_t) data;
 410
 411           if (!rec_write_field (writer, field))
 412             {
 413               ret = false;
 414               break;
 415             }
 416
 417           /* Include a field separator.  */
 418
 419           if ((mode == REC_WRITER_VALUES_ROW)
 420               && (num_field != (num_fields - 1)))
 421             {
 422               if(mode == REC_WRITER_VALUES_ROW)
 423                 {
 424                   if (!rec_writer_putc (writer, ' '))
 425                     return false;
 426                 }
 427             }
 428           else if ((writer->skip_comments_p && (num_field != (num_fields - 1)))
 429                    || (!writer->skip_comments_p && (num_elem != (num_elems - 1))))
 430             {
 431               if (!rec_writer_putc (writer, '\n'))
 432                 return false;
 433             }
 434
 435           num_field++;
 436         }
 437       else if (!writer->skip_comments_p)
 438         {
 439           /* Write a comment.  */
 440
 441           rec_comment_t comment = (rec_comment_t) data;
 442
 443           if ((mode != REC_WRITER_VALUES) && (mode != REC_WRITER_VALUES_ROW))
 444             {
 445               if (!rec_write_comment (writer, comment))
 446                 {
 447                   ret = false;
 448                   break;
 449                 }
 450
 451               if (num_elem != (num_elems - 1))
 452                 {
 453                   if (!rec_writer_putc (writer, '\n'))
 454                     return false;
 455                 }
 456             }
 457         }
 458
 459       num_elem++;
 460     }
 461
 462   rec_mset_iterator_free (&iter);
 463
 464   if (mode == REC_WRITER_SEXP)
 465     {
 466       if (!rec_writer_puts (writer, "))"))
 467         {
 468           return false;
 469         }
 470     }
 471
 472   return ret;
 473 }
 474
 475 bool
 476 rec_write_rset (rec_writer_t writer,
 477                 rec_rset_t rset)
 478 {
 479   bool ret;
 480   rec_record_t descriptor;
 481   bool wrote_descriptor;
 482   size_t position;
 483   size_t descriptor_pos;
 484   rec_mset_iterator_t iter;
 485   rec_mset_elem_t elem;
 486   void *data;
 487   enum rec_writer_mode_e mode = writer->mode;
 488
 489   ret = true;
 490   wrote_descriptor = false;
 491   position = 0;
 492   descriptor_pos = rec_rset_descriptor_pos (rset);
 493   descriptor = rec_rset_descriptor (rset);
 494
 495   /* Special case: record set containing just the record
 496      descriptor.  */
 497   if ((rec_rset_num_elems (rset) == 0) && descriptor)
 498     {
 499       rec_write_record (writer,
 500                         rec_rset_descriptor (rset));
 501       rec_writer_putc (writer, '\n');
 502
 503       return true;
 504     }
 505
 506   iter = rec_mset_iterator (rec_rset_mset (rset));
 507   while (rec_mset_iterator_next (&iter, MSET_ANY, (const void **) &data, &elem))
 508     {
 509       if (position != 0)
 510         {
 511           if (!rec_writer_putc (writer, '\n'))
 512             {
 513               ret = false;
 514             }
 515         }
 516
 517       if (position == descriptor_pos)
 518         {
 519           if (descriptor
 520               && (!(wrote_descriptor = rec_write_record (writer,
 521                                                          rec_rset_descriptor (rset)))))
 522             {
 523               ret = false;
 524             }
 525           else
 526             {
 527               if (wrote_descriptor)
 528                 {
 529                   if (!rec_writer_puts (writer, "\n\n"))
 530                     {
 531                       ret = false;
 532                     }
 533                 }
 534             }
 535         }
 536
 537       if (rec_mset_elem_type (elem) == MSET_RECORD)
 538         {
 539           ret = rec_write_record (writer, (rec_record_t) data);
 540         }
 541       else if (!writer->skip_comments_p)
 542         {
 543           ret = rec_write_comment (writer, (rec_comment_t) data);
 544         }
 545
 546       if (!writer->collapse_p || (position == (rec_rset_num_elems (rset) - 1)))
 547         {
 548           if (!rec_writer_putc (writer, '\n'))
 549             {
 550               ret = false;
 551             }
 552         }
 553
 554       if (!ret)
 555         {
 556           break;
 557         }
 558
 559       position++;
 560     }
 561
 562   rec_mset_iterator_free (&iter);
 563
 564   /* Special case:
 565    *
 566    * # comment 1
 567    *
 568    * # comment 2
 569    * ...
 570    * %rec: foo
 571    */
 572   if (!wrote_descriptor
 573       && (descriptor_pos >= rec_rset_num_elems (rset))
 574       && rec_rset_descriptor (rset))
 575     {
 576       if (!rec_writer_putc (writer, '\n'))
 577         {
 578           ret = false;
 579         }
 580       if (!rec_write_record (writer, rec_rset_descriptor (rset)))
 581         {
 582           ret = false;
 583         }
 584       if (!rec_writer_putc (writer, '\n'))
 585         {
 586           ret = false;
 587         }
 588     }
 589
 590   return ret;
 591 }
 592
 593 bool
 594 rec_write_db (rec_writer_t writer,
 595               rec_db_t db)
 596 {
 597   bool ret;
 598   int i;
 599
 600   ret = true;
 601   for (i = 0; i < rec_db_size (db); i++)
 602     {
 603       rec_rset_t rset = rec_db_get_rset (db, i);
 604
 605       if (i != 0)
 606         {
 607           if (!rec_writer_putc (writer, '\n'))
 608             {
 609               ret = false;
 610               break;
 611             }
 612         }
 613
 614       if (!rec_write_rset (writer, rset))
 615         {
 616           ret = false;
 617           break;
 618         }
 619     }
 620
 621   return ret;
 622 }
 623
 624 char *
 625 rec_write_field_str (rec_field_t field,
 626                      rec_writer_mode_t mode)
 627 {
 628   rec_writer_t writer;
 629   char *result;
 630   size_t result_size;
 631
 632   result = NULL;
 633   writer = rec_writer_new_str (&result, &result_size);
 634   if (writer)
 635     {
 636       rec_writer_set_mode (writer, mode);
 637       rec_write_field (writer, field);
 638       rec_writer_destroy (writer);
 639     }
 640
 641   return result;
 642 }
 643
 644 char *
 645 rec_write_field_name_str (const char *field_name,
 646                           rec_writer_mode_t mode)
 647 {
 648   rec_writer_t writer;
 649   char *result;
 650   size_t result_size;
 651
 652   result = NULL;
 653   writer = rec_writer_new_str (&result, &result_size);
 654   if (writer)
 655     {
 656       rec_writer_set_mode (writer, mode);
 657       rec_write_field_name (writer, field_name);
 658       rec_writer_destroy (writer);
 659     }
 660
 661   return result;
 662 }
 663
 664 char *
 665 rec_write_comment_str (rec_comment_t comment,
 666                        rec_writer_mode_t mode)
 667 {
 668   rec_writer_t writer;
 669   char *result;
 670   size_t result_size;
 671
 672   result = NULL;
 673   writer = rec_writer_new_str (&result, &result_size);
 674   if (writer)
 675     {
 676       rec_writer_set_mode (writer, mode);
 677       rec_write_comment (writer, comment);
 678       rec_writer_destroy (writer);
 679     }
 680
 681   return result;
 682 }
 683
 684 bool
 685 rec_write_string (rec_writer_t writer,
 686                   const char *str)
 687 {
 688   return rec_writer_puts (writer, str);
 689 }
 690
 691 void
 692 rec_writer_set_collapse (rec_writer_t writer,
 693                          bool value)
 694 {
 695   writer->collapse_p = value;
 696 }
 697
 698 void
 699 rec_writer_set_skip_comments (rec_writer_t writer,
 700                               bool value)
 701 {
 702   writer->skip_comments_p = value;
 703 }
 704
 705 void
 706 rec_writer_set_mode (rec_writer_t writer,
 707                      enum rec_writer_mode_e mode)
 708 {
 709   writer->mode = mode;
 710 }
 711
 712 /*
 713  * Private functions
 714  */
 715
 716 static bool
 717 rec_writer_putc (rec_writer_t writer, char c)
 718 {
 719   bool ret;
 720
 721   ret = false;
 722   if (writer->file_out)
 723     {
 724       ret = (fputc (c, writer->file_out) != EOF);
 725     }
 726   if (writer->buf_out)
 727     {
 728       ret = (rec_buf_putc (c, writer->buf_out) != EOF);
 729     }
 730
 731   return ret;
 732 }
 733
 734 static bool
 735 rec_writer_puts (rec_writer_t writer, const char *s)
 736 {
 737   bool ret;
 738
 739   ret = false;
 740   if (writer->file_out)
 741     {
 742       ret = (fputs (s, writer->file_out) != EOF);
 743     }
 744   if (writer->buf_out)
 745     {
 746       ret = (rec_buf_puts (s, writer->buf_out) != EOF);
 747     }
 748
 749   return ret;
 750 }
 751
 752 /* End of rec-writer.c */