LCOV - code coverage report
Current view: top level - third_party/heimdal/lib/roken - rtbl.c (source / functions) Hit Total Coverage
Test: coverage report for master 2f515e9b Lines: 0 268 0.0 %
Date: 2024-04-21 15:09:00 Functions: 0 25 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2000, 2002, 2004 Kungliga Tekniska Högskolan
       3             :  * (Royal Institute of Technology, Stockholm, Sweden).
       4             :  * All rights reserved.
       5             :  *
       6             :  * Redistribution and use in source and binary forms, with or without
       7             :  * modification, are permitted provided that the following conditions
       8             :  * are met:
       9             :  *
      10             :  * 1. Redistributions of source code must retain the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer.
      12             :  *
      13             :  * 2. Redistributions in binary form must reproduce the above copyright
      14             :  *    notice, this list of conditions and the following disclaimer in the
      15             :  *    documentation and/or other materials provided with the distribution.
      16             :  *
      17             :  * 3. Neither the name of the Institute nor the names of its contributors
      18             :  *    may be used to endorse or promote products derived from this software
      19             :  *    without specific prior written permission.
      20             :  *
      21             :  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
      22             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
      25             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      26             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      27             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      28             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      31             :  * SUCH DAMAGE.
      32             :  */
      33             : 
      34             : #include <config.h>
      35             : 
      36             : #include "roken.h"
      37             : #include <ctype.h>
      38             : #include "rtbl.h"
      39             : 
      40             : struct column_entry {
      41             :     char *data;
      42             : };
      43             : 
      44             : struct column_data {
      45             :     char *header;
      46             :     char *prefix;
      47             :     int width;
      48             :     unsigned flags;
      49             :     size_t num_rows;
      50             :     struct column_entry *rows;
      51             :     unsigned int column_id;
      52             :     char *suffix;
      53             : };
      54             : 
      55             : struct rtbl_data {
      56             :     char *column_prefix;
      57             :     size_t num_columns;
      58             :     struct column_data **columns;
      59             :     unsigned int flags;
      60             :     char *column_separator;
      61             : };
      62             : 
      63             : ROKEN_LIB_FUNCTION rtbl_t ROKEN_LIB_CALL
      64           0 : rtbl_create (void)
      65             : {
      66           0 :     return calloc (1, sizeof (struct rtbl_data));
      67             : }
      68             : 
      69             : ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
      70           0 : rtbl_set_flags (rtbl_t table, unsigned int flags)
      71             : {
      72           0 :     table->flags = flags;
      73           0 : }
      74             : 
      75             : ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL
      76           0 : rtbl_get_flags (rtbl_t table)
      77             : {
      78           0 :     return table->flags;
      79             : }
      80             : 
      81             : static struct column_data *
      82           0 : rtbl_get_column_by_id (rtbl_t table, unsigned int id)
      83             : {
      84           0 :     size_t i;
      85           0 :     for(i = 0; i < table->num_columns; i++)
      86           0 :         if(table->columns[i]->column_id == id)
      87           0 :             return table->columns[i];
      88           0 :     return NULL;
      89             : }
      90             : 
      91             : static struct column_data *
      92           0 : rtbl_get_column (rtbl_t table, const char *column)
      93             : {
      94           0 :     size_t i;
      95           0 :     for(i = 0; i < table->num_columns; i++)
      96           0 :         if(strcmp(table->columns[i]->header, column) == 0)
      97           0 :             return table->columns[i];
      98           0 :     return NULL;
      99             : }
     100             : 
     101             : ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
     102           0 : rtbl_destroy (rtbl_t table)
     103             : {
     104           0 :     size_t i, j;
     105             : 
     106           0 :     for (i = 0; i < table->num_columns; i++) {
     107           0 :         struct column_data *c = table->columns[i];
     108             : 
     109           0 :         for (j = 0; j < c->num_rows; j++)
     110           0 :             free (c->rows[j].data);
     111           0 :         free (c->rows);
     112           0 :         free (c->header);
     113           0 :         free (c->prefix);
     114           0 :         free (c->suffix);
     115           0 :         free (c);
     116             :     }
     117           0 :     free (table->column_prefix);
     118           0 :     free (table->column_separator);
     119           0 :     free (table->columns);
     120           0 :     free (table);
     121           0 : }
     122             : 
     123             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     124           0 : rtbl_add_column_by_id (rtbl_t table, unsigned int id,
     125             :                        const char *header, unsigned int flags)
     126             : {
     127           0 :     struct column_data *col, **tmp;
     128             : 
     129           0 :     tmp = realloc (table->columns, (table->num_columns + 1) * sizeof (*tmp));
     130           0 :     if (tmp == NULL)
     131           0 :         return ENOMEM;
     132           0 :     table->columns = tmp;
     133           0 :     col = malloc (sizeof (*col));
     134           0 :     if (col == NULL)
     135           0 :         return ENOMEM;
     136           0 :     col->header = strdup (header);
     137           0 :     if (col->header == NULL) {
     138           0 :         free (col);
     139           0 :         return ENOMEM;
     140             :     }
     141           0 :     col->prefix = NULL;
     142           0 :     col->width = 0;
     143           0 :     col->flags = flags;
     144           0 :     col->num_rows = 0;
     145           0 :     col->rows = NULL;
     146           0 :     col->column_id = id;
     147           0 :     col->suffix = NULL;
     148           0 :     table->columns[table->num_columns++] = col;
     149           0 :     return 0;
     150             : }
     151             : 
     152             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     153           0 : rtbl_add_column (rtbl_t table, const char *header, unsigned int flags)
     154             : {
     155           0 :     return rtbl_add_column_by_id(table, 0, header, flags);
     156             : }
     157             : 
     158             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     159           0 : rtbl_new_row(rtbl_t table)
     160             : {
     161           0 :     size_t max_rows = 0;
     162           0 :     size_t c;
     163           0 :     for (c = 0; c < table->num_columns; c++)
     164           0 :         if(table->columns[c]->num_rows > max_rows)
     165           0 :             max_rows = table->columns[c]->num_rows;
     166           0 :     for (c = 0; c < table->num_columns; c++) {
     167           0 :         struct column_entry *tmp;
     168             : 
     169           0 :         if(table->columns[c]->num_rows == max_rows)
     170           0 :             continue;
     171           0 :         tmp = realloc(table->columns[c]->rows,
     172             :                       max_rows * sizeof(table->columns[c]->rows[0]));
     173           0 :         if(tmp == NULL)
     174           0 :             return ENOMEM;
     175           0 :         table->columns[c]->rows = tmp;
     176           0 :         while(table->columns[c]->num_rows < max_rows) {
     177           0 :             if((tmp[table->columns[c]->num_rows++].data = strdup("")) == NULL)
     178           0 :                 return ENOMEM;
     179             :         }
     180             :     }
     181           0 :     return 0;
     182             : }
     183             : 
     184             : static void
     185           0 : column_compute_width (rtbl_t table, struct column_data *column)
     186             : {
     187           0 :     size_t i;
     188             : 
     189           0 :     if(table->flags & RTBL_HEADER_STYLE_NONE)
     190           0 :         column->width = 0;
     191             :     else
     192           0 :         column->width = (int)strlen (column->header);
     193           0 :     for (i = 0; i < column->num_rows; i++)
     194           0 :         column->width = max (column->width, (int) strlen (column->rows[i].data));
     195           0 : }
     196             : 
     197             : /* DEPRECATED */
     198             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     199           0 : rtbl_set_prefix (rtbl_t table, const char *prefix)
     200             : {
     201           0 :     if (table->column_prefix)
     202           0 :         free (table->column_prefix);
     203           0 :     table->column_prefix = strdup (prefix);
     204           0 :     if (table->column_prefix == NULL)
     205           0 :         return ENOMEM;
     206           0 :     return 0;
     207             : }
     208             : 
     209             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     210           0 : rtbl_set_separator (rtbl_t table, const char *separator)
     211             : {
     212           0 :     if (table->column_separator)
     213           0 :         free (table->column_separator);
     214           0 :     table->column_separator = strdup (separator);
     215           0 :     if (table->column_separator == NULL)
     216           0 :         return ENOMEM;
     217           0 :     return 0;
     218             : }
     219             : 
     220             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     221           0 : rtbl_set_column_prefix (rtbl_t table, const char *column,
     222             :                         const char *prefix)
     223             : {
     224           0 :     struct column_data *c = rtbl_get_column (table, column);
     225             : 
     226           0 :     if (c == NULL)
     227           0 :         return -1;
     228           0 :     if (c->prefix)
     229           0 :         free (c->prefix);
     230           0 :     c->prefix = strdup (prefix);
     231           0 :     if (c->prefix == NULL)
     232           0 :         return ENOMEM;
     233           0 :     return 0;
     234             : }
     235             : 
     236             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     237           0 : rtbl_set_column_affix_by_id(rtbl_t table, unsigned int id,
     238             :                             const char *prefix, const char *suffix)
     239             : {
     240           0 :     struct column_data *c = rtbl_get_column_by_id (table, id);
     241             : 
     242           0 :     if (c == NULL)
     243           0 :         return -1;
     244           0 :     if (c->prefix)
     245           0 :         free (c->prefix);
     246           0 :     if(prefix == NULL)
     247           0 :         c->prefix = NULL;
     248             :     else {
     249           0 :         c->prefix = strdup (prefix);
     250           0 :         if (c->prefix == NULL)
     251           0 :             return ENOMEM;
     252             :     }
     253             : 
     254           0 :     if (c->suffix)
     255           0 :         free (c->suffix);
     256           0 :     if(suffix == NULL)
     257           0 :         c->suffix = NULL;
     258             :     else {
     259           0 :         c->suffix = strdup (suffix);
     260           0 :         if (c->suffix == NULL)
     261           0 :             return ENOMEM;
     262             :     }
     263           0 :     return 0;
     264             : }
     265             : 
     266             : 
     267             : static const char *
     268           0 : get_column_prefix (rtbl_t table, struct column_data *c)
     269             : {
     270           0 :     if (c == NULL)
     271           0 :         return "";
     272           0 :     if (c->prefix)
     273           0 :         return c->prefix;
     274           0 :     if (table->column_prefix)
     275           0 :         return table->column_prefix;
     276           0 :     return "";
     277             : }
     278             : 
     279             : static const char *
     280           0 : get_column_suffix (rtbl_t table, struct column_data *c)
     281             : {
     282           0 :     if (c && c->suffix)
     283           0 :         return c->suffix;
     284           0 :     return "";
     285             : }
     286             : 
     287             : static int
     288           0 : add_column_entry (struct column_data *c, const char *data)
     289             : {
     290           0 :     struct column_entry row, *tmp;
     291             : 
     292           0 :     row.data = strdup (data);
     293           0 :     if (row.data == NULL)
     294           0 :         return ENOMEM;
     295           0 :     tmp = realloc (c->rows, (c->num_rows + 1) * sizeof (*tmp));
     296           0 :     if (tmp == NULL) {
     297           0 :         free (row.data);
     298           0 :         return ENOMEM;
     299             :     }
     300           0 :     c->rows = tmp;
     301           0 :     c->rows[c->num_rows++] = row;
     302           0 :     return 0;
     303             : }
     304             : 
     305             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     306           0 : rtbl_add_column_entry_by_id (rtbl_t table, unsigned int id, const char *data)
     307             : {
     308           0 :     struct column_data *c = rtbl_get_column_by_id (table, id);
     309             : 
     310           0 :     if (c == NULL)
     311           0 :         return -1;
     312             : 
     313           0 :     return add_column_entry(c, data);
     314             : }
     315             : 
     316             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     317           0 : rtbl_add_column_entryv_by_id (rtbl_t table, unsigned int id,
     318             :                               const char *fmt, ...)
     319             : {
     320           0 :     va_list ap;
     321           0 :     char *str;
     322           0 :     int ret;
     323             : 
     324           0 :     va_start(ap, fmt);
     325           0 :     ret = vasprintf(&str, fmt, ap);
     326           0 :     va_end(ap);
     327           0 :     if (ret == -1)
     328           0 :         return -1;
     329           0 :     ret = rtbl_add_column_entry_by_id(table, id, str);
     330           0 :     free(str);
     331           0 :     return ret;
     332             : }
     333             : 
     334             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     335           0 : rtbl_add_column_entry (rtbl_t table, const char *column, const char *data)
     336             : {
     337           0 :     struct column_data *c = rtbl_get_column (table, column);
     338             : 
     339           0 :     if (c == NULL)
     340           0 :         return -1;
     341             : 
     342           0 :     return add_column_entry(c, data);
     343             : }
     344             : 
     345             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     346           0 : rtbl_add_column_entryv (rtbl_t table, const char *column, const char *fmt, ...)
     347             : {
     348           0 :     va_list ap;
     349           0 :     char *str;
     350           0 :     int ret;
     351             : 
     352           0 :     va_start(ap, fmt);
     353           0 :     ret = vasprintf(&str, fmt, ap);
     354           0 :     va_end(ap);
     355           0 :     if (ret == -1)
     356           0 :         return -1;
     357           0 :     ret = rtbl_add_column_entry(table, column, str);
     358           0 :     free(str);
     359           0 :     return ret;
     360             : }
     361             : 
     362             : 
     363             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     364           0 : rtbl_format (rtbl_t table, FILE * f)
     365             : {
     366           0 :     char *str = rtbl_format_str(table);
     367           0 :     if (str == NULL)
     368           0 :         return ENOMEM;
     369           0 :     fprintf(f, "%s", str);
     370           0 :     free(str);
     371           0 :     return 0;
     372             : }
     373             : 
     374             : static char *
     375           0 : rtbl_format_pretty(rtbl_t table)
     376             : {
     377           0 :     struct rk_strpool *p = NULL;
     378           0 :     size_t i, j;
     379             : 
     380           0 :     for (i = 0; i < table->num_columns; i++)
     381           0 :         column_compute_width (table, table->columns[i]);
     382           0 :     if((table->flags & RTBL_HEADER_STYLE_NONE) == 0) {
     383           0 :         for (i = 0; i < table->num_columns; i++) {
     384           0 :             struct column_data *c = table->columns[i];
     385             : 
     386           0 :             if(table->column_separator != NULL && i > 0)
     387           0 :                 p = rk_strpoolprintf(p, "%s", table->column_separator);
     388           0 :             p = rk_strpoolprintf(p, "%s", get_column_prefix (table, c));
     389           0 :             if (c == NULL) {
     390             :                 /* do nothing if no column */
     391           0 :             } else if(i == table->num_columns - 1 && c->suffix == NULL)
     392             :                 /* last column, so no need to pad with spaces */
     393           0 :                 p = rk_strpoolprintf(p, "%-*s", 0, c->header);
     394             :             else
     395           0 :                 p = rk_strpoolprintf(p, "%-*s", (int)c->width, c->header);
     396           0 :             p = rk_strpoolprintf(p, "%s", get_column_suffix (table, c));
     397             :         }
     398           0 :         p = rk_strpoolprintf(p, "\n");
     399             :     }
     400             : 
     401           0 :     for (j = 0;; j++) {
     402           0 :         int flag = 0;
     403             : 
     404             :         /* are there any more rows left? */
     405           0 :         for (i = 0; flag == 0 && i < table->num_columns; ++i) {
     406           0 :             struct column_data *c = table->columns[i];
     407             : 
     408           0 :             if (c->num_rows > j) {
     409           0 :                 ++flag;
     410           0 :                 break;
     411             :             }
     412             :         }
     413           0 :         if (flag == 0)
     414           0 :             break;
     415             : 
     416           0 :         for (i = 0; i < table->num_columns; i++) {
     417           0 :             int w;
     418           0 :             struct column_data *c = table->columns[i];
     419             : 
     420           0 :             if(table->column_separator != NULL && i > 0)
     421           0 :                 p = rk_strpoolprintf(p, "%s", table->column_separator);
     422             : 
     423           0 :             w = c->width;
     424             : 
     425           0 :             if ((c->flags & RTBL_ALIGN_RIGHT) == 0) {
     426           0 :                 if(i == table->num_columns - 1 && c->suffix == NULL)
     427             :                     /* last column, so no need to pad with spaces */
     428           0 :                     w = 0;
     429             :                 else
     430           0 :                     w = -w;
     431             :             }
     432           0 :             p = rk_strpoolprintf(p, "%s", get_column_prefix (table, c));
     433           0 :             if (c->num_rows <= j)
     434           0 :                 p = rk_strpoolprintf(p, "%*s", w, "");
     435             :             else
     436           0 :                 p = rk_strpoolprintf(p, "%*s", w, c->rows[j].data);
     437           0 :             p = rk_strpoolprintf(p, "%s", get_column_suffix (table, c));
     438             :         }
     439           0 :         p = rk_strpoolprintf(p, "\n");
     440             :     }
     441             : 
     442           0 :     return rk_strpoolcollect(p);
     443             : }
     444             : 
     445             : static char *
     446           0 : rtbl_format_json(rtbl_t table)
     447             : {
     448           0 :     struct rk_strpool *p = NULL;
     449           0 :     size_t i, j;
     450           0 :     int comma;
     451             : 
     452           0 :     p = rk_strpoolprintf(p, "[");
     453           0 :     for (j = 0;; j++) {
     454           0 :         int flag = 0;
     455             : 
     456             :         /* are there any more rows left? */
     457           0 :         for (i = 0; flag == 0 && i < table->num_columns; ++i) {
     458           0 :             struct column_data *c = table->columns[i];
     459             : 
     460           0 :             if (c->num_rows > j) {
     461           0 :                 ++flag;
     462           0 :                 break;
     463             :             }
     464             :         }
     465           0 :         if (flag == 0)
     466           0 :             break;
     467             : 
     468           0 :         p = rk_strpoolprintf(p, "%s{", j > 0 ? "," : "");
     469             : 
     470           0 :         comma = 0;
     471           0 :         for (i = 0; i < table->num_columns; i++) {
     472           0 :             struct column_data *c = table->columns[i];
     473             : 
     474           0 :             if (c->num_rows > j) {
     475           0 :                 char *header = c->header;
     476           0 :                 while (isspace((unsigned char)header[0])) /* trim off prefixed whitespace */
     477           0 :                     header++;
     478           0 :                 p = rk_strpoolprintf(p, "%s\"%s\" : \"%s\"",
     479             :                                      comma ? "," : "", header,
     480           0 :                                      c->rows[j].data);
     481           0 :                 comma = 1;
     482             :             }
     483             :         }
     484           0 :         p = rk_strpoolprintf(p, "}");
     485             :     }
     486           0 :     p = rk_strpoolprintf(p, "]");
     487             : 
     488           0 :     return rk_strpoolcollect(p);
     489             : }
     490             : 
     491             : ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
     492           0 : rtbl_format_str (rtbl_t table)
     493             : {
     494           0 :     if (table->flags & RTBL_JSON)
     495           0 :         return rtbl_format_json(table);
     496             : 
     497           0 :     return rtbl_format_pretty(table);
     498             : }
     499             : 
     500             : #ifdef TEST
     501             : int
     502             : main (int argc, char **argv)
     503             : {
     504             :     rtbl_t table;
     505             : 
     506             :     table = rtbl_create ();
     507             :     rtbl_add_column_by_id (table, 0, "Issued", 0);
     508             :     rtbl_add_column_by_id (table, 1, "Expires", 0);
     509             :     rtbl_add_column_by_id (table, 2, "Foo", RTBL_ALIGN_RIGHT);
     510             :     rtbl_add_column_by_id (table, 3, "Principal", 0);
     511             : 
     512             :     rtbl_add_column_entry_by_id (table, 0, "Jul  7 21:19:29");
     513             :     rtbl_add_column_entry_by_id (table, 1, "Jul  8 07:19:29");
     514             :     rtbl_add_column_entry_by_id (table, 2, "73");
     515             :     rtbl_add_column_entry_by_id (table, 2, "0");
     516             :     rtbl_add_column_entry_by_id (table, 2, "-2000");
     517             :     rtbl_add_column_entry_by_id (table, 3, "krbtgt/NADA.KTH.SE@NADA.KTH.SE");
     518             : 
     519             :     rtbl_add_column_entry_by_id (table, 0, "Jul  7 21:19:29");
     520             :     rtbl_add_column_entry_by_id (table, 1, "Jul  8 07:19:29");
     521             :     rtbl_add_column_entry_by_id (table, 3, "afs/pdc.kth.se@NADA.KTH.SE");
     522             : 
     523             :     rtbl_add_column_entry_by_id (table, 0, "Jul  7 21:19:29");
     524             :     rtbl_add_column_entry_by_id (table, 1, "Jul  8 07:19:29");
     525             :     rtbl_add_column_entry_by_id (table, 3, "afs@NADA.KTH.SE");
     526             : 
     527             :     rtbl_set_separator (table, "  ");
     528             : 
     529             :     rtbl_format (table, stdout);
     530             : 
     531             :     rtbl_destroy (table);
     532             : 
     533             :     printf("\n");
     534             : 
     535             :     table = rtbl_create ();
     536             :     rtbl_add_column_by_id (table, 0, "Column A", 0);
     537             :     rtbl_set_column_affix_by_id (table, 0, "<", ">");
     538             :     rtbl_add_column_by_id (table, 1, "Column B", 0);
     539             :     rtbl_set_column_affix_by_id (table, 1, "[", "]");
     540             :     rtbl_add_column_by_id (table, 2, "Column C", 0);
     541             :     rtbl_set_column_affix_by_id (table, 2, "(", ")");
     542             : 
     543             :     rtbl_add_column_entry_by_id (table, 0, "1");
     544             :     rtbl_new_row(table);
     545             :     rtbl_add_column_entry_by_id (table, 1, "2");
     546             :     rtbl_new_row(table);
     547             :     rtbl_add_column_entry_by_id (table, 2, "3");
     548             :     rtbl_new_row(table);
     549             : 
     550             :     rtbl_set_separator (table, "  ");
     551             :     rtbl_format (table, stdout);
     552             : 
     553             :     rtbl_destroy (table);
     554             : 
     555             :     return 0;
     556             : }
     557             : 
     558             : #endif

Generated by: LCOV version 1.14