common: Add support for printing tables

Fetched the library from omapconf
https://github.com/omapconf/omapconf/blob/master/common/autoadjust_table.c

Signed-off-by: Lokesh Vutla <lokeshvutla@ti.com>

diff --git a/Makefile b/Makefile
index 67eb10d2b06701bef2dc5668ea1092b2a6ad4b24..34672c545859a3ea597492ffb7a5fb87778ad3fc 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -64,7 +64,8 @@ COMMONSOURCES=\
                common/sec_proxy.c \
                common/tisci/tisci_core.c \
                common/tisci/tisci_device.c \
-               common/tisci/tisci_clock.c
+               common/tisci/tisci_clock.c \
+               common/autoadjust_table.c
 
 AM65XSOURCES =\
              soc/am65x/am65x_host_info.c \

diff --git a/common/autoadjust_table.c b/common/autoadjust_table.c
new file mode 100644 (file)
index 0000000..1f41acd
--- /dev/null
+++ b/common/autoadjust_table.c
@@ -0,0 +1,417 @@
+/*
+ * Table printing Libraries
+ *
+ * Copyright (C) 2010-2019 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <autoadjust_table.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/* #define AUTOADJUST_TABLE_DEBUG */
+#ifdef AUTOADJUST_TABLE_DEBUG
+#define dprintf(format, ...)    printf(format, ## __VA_ARGS__)
+#else
+#define dprintf(format, ...)
+#endif
+
+
+/* ------------------------------------------------------------------------*//**
+ * @FUNCTION           autoadjust_table_generic_fprint
+ * @BRIEF              print elements into a table which size automatically
+ *                     adjusts.
+ * @RETURNS            0 in case of success
+ *                     -1 in case of incorrect pointer
+ *                     -2 in case of memory allocation error
+ *                     -3 one element of the table is longer than
+ *                     TABLE_MAX_ELT_LEN
+ * @param[in,out]      stream: output file
+ * @param[in]          table: elements to be printed
+ *                     format: table[row][col][string]
+ * @param[in]          row_nbr: number of rows
+ * @param[in]          col_nbr: number of columns
+ * @param[in]          flags: table format flags
+ * @DESCRIPTION                print elements into a table which size automatically
+ *                     adjusts. The printed table depends on the format flags:
+ *
+ *     TABLE_HAS_TITLE:
+ *
+ *     |------------------------------------------------------------------|
+ *     | elements[0][0]                                                   |
+ *     |------------------------------------------------------------------|
+ *     | elements[1][0]     | elements[1][1]     | elements[1][col-1]     |
+ *     | elements[2][0]     | elements[2][1]     | elements[2][col-1]     |
+ *     | elements[row-1][0] | elements[row-1][1] | elements[row-1][col-1] |
+ *     |------------------------------------------------------------------|
+ *
+ *     TABLE_HAS_SUBTITLE:
+ *
+ *     |------------------------------------------------------------------|
+ *     | elements[0][0]     | elements[0][1]     | elements[0][col-1]     |
+ *     |------------------------------------------------------------------|
+ *     | elements[1][0]     | elements[1][1]     | elements[1][col-1]     |
+ *     | elements[2][0]     | elements[2][1]     | elements[2][col-1]     |
+ *     | elements[row-1][0] | elements[row-1][1] | elements[row-1][col-1] |
+ *     |------------------------------------------------------------------|
+ *
+ *     TABLE_HAS_TITLE | TABLE_HAS_SUBTITLE:
+ *
+ *     |------------------------------------------------------------------|
+ *     | elements[0][0]                                                   |
+ *     |------------------------------------------------------------------|
+ *     | elements[1][0]     | elements[1][1]     | elements[1][col-1]     |
+ *     |------------------------------------------------------------------|
+ *     | elements[2][0]     | elements[2][1]     | elements[2][col-1]     |
+ *     | elements[row-1][0] | elements[row-1][1] | elements[row-1][col-1] |
+ *     |------------------------------------------------------------------|
+ *//*------------------------------------------------------------------------ */
+int autoadjust_table_generic_fprint(FILE *stream,
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr, unsigned int flags)
+{
+       int has_title = !!(flags & TABLE_HAS_TITLE);
+       unsigned int max_elt_size[TABLE_MAX_COL];
+       unsigned int total_dash_nbr = 0;
+       unsigned int total_width = 0;
+       char *dash_line = NULL;
+       unsigned int col, row;
+       unsigned int strln;
+       char *title = NULL;
+       char *line = NULL;
+       unsigned int tmp;
+
+       if (stream == NULL) {
+               printf("autoadjust_table_fprint() error: stream == NULL!\n");
+               return -1;
+       }
+       if (table == NULL) {
+               printf("autoadjust_table_fprint() error: table == NULL!\n");
+               return -1;
+       }
+       if (row_nbr > TABLE_MAX_ROW) {
+               printf("autoadjust_table_fprint() error: row_nbr (%d) > "
+                       "TABLE_MAX_ROW (%d)!\n", row_nbr, TABLE_MAX_ROW);
+               return -1;
+       }
+       if (col_nbr > TABLE_MAX_COL) {
+               printf("autoadjust_table_fprint() error: col_nbr (%d) > "
+                       "TABLE_MAX_COL (%d)!\n", col_nbr, TABLE_MAX_COL);
+               return -1;
+       }
+
+       if (has_title)
+               title = table[0][0];
+
+       #ifdef AUTOADJUST_TABLE_DEBUG
+       dprintf("row_nbr = %d, col_nbr = %d\n", row_nbr, col_nbr);
+       for (row = 0; row < row_nbr; row++) {
+               for (col = 0; col < col_nbr; col++)
+                       dprintf("element[%d][%d] = %s\n",
+                               row, col, table[row][col]);
+       }
+       #endif
+
+
+       /* compute width of each column of the table */
+       for (col = 0; col < col_nbr; col++)
+               max_elt_size[col] = 0;
+
+       /* title length will be added to total width later */
+       row = has_title ? 1 : 0;
+
+       for (; row < row_nbr; row++) {
+               tmp = 0;
+               /* Get total length of strings in this line */
+               for (col = 0; col < col_nbr; col++) {
+                       strln = strlen(table[row][col]);
+                       if (strln > TABLE_MAX_ELT_LEN) {
+                               printf("%s(): WARNING: \"%s\" size (%u) > "
+                                       "TABLE_MAX_ELT_LEN (%u)!\n",
+                                       __func__, table[row][col],
+                                       strln, TABLE_MAX_ELT_LEN);
+                               strln = TABLE_MAX_ELT_LEN;
+                       }
+
+                       if (strln > max_elt_size[col]) {
+                               max_elt_size[col] = strln;
+                               dprintf("new max_elt_size[%d] = %d\n",
+                                       col, max_elt_size[col]);
+                       }
+               }
+       }
+
+       /* Compute the total width of the table, and allocate memory for it */
+       for (col = 0; col < col_nbr; col++)
+               total_width += max_elt_size[col];
+       /* Add number of '|' separators per line */
+       total_width += (col_nbr + 1);
+       /* Add number of space character separators (2 per element) */
+       total_width += col_nbr * 2;
+
+       /* Compensate if the title is longer than table width */
+       if (has_title) {
+               unsigned int avail;
+
+               strln = strlen(title);
+               avail = total_width - 4; /* exclude left and right borders */
+               dprintf("title_width=%d\n", strln);
+
+               if (avail < strln) {
+                       /* Number of chars to compensate per column */
+                       tmp = (strln - avail + col_nbr - 1) / col_nbr;
+
+                       total_width = 0;
+                       for (col = 0; col < col_nbr; col++) {
+                               max_elt_size[col] += tmp;
+                               total_width += max_elt_size[col];
+                               dprintf("new max_elt_size[%d] = %d\n",
+                                       col, max_elt_size[col]);
+                       }
+                       /* Add number of separators per line */
+                       total_width += (col_nbr + 1);
+                       total_width += col_nbr * 2;
+               }
+       }
+
+       dprintf("total_width = %d\n", total_width);
+       line  = malloc(sizeof(char) * (total_width + 1));
+       if (line == NULL) {
+               printf("autoadjust_table_fprint(): line malloc error!\n");
+               return -2;
+       }
+       line[0] = '\0';
+       line[total_width] = '\0';
+
+       /*
+        * Compute the total number of dash characters,
+        * used to delimit the table, and allocate memory for it
+        */
+       total_dash_nbr = total_width - 2;
+       dash_line = malloc(sizeof(char) * (total_width + 1));
+       dprintf("total_dash_nbr = %d\n", total_dash_nbr);
+       if (dash_line == NULL) {
+               printf("autoadjust_table_fprint(): dash_line malloc error!\n");
+               return -2;
+       }
+       dash_line[0] = '\0';
+       dash_line[total_width] = '\0';
+
+       dprintf("total_dash_nbr=%d\n", total_dash_nbr);
+       dprintf("total_width=%d\n", total_width);
+
+       /* Print table */
+       dash_line[0] = '|';
+       memset(dash_line + sizeof(char), '-', total_dash_nbr);
+       dash_line[total_dash_nbr + 1] = '|';
+       fprintf(stream, "%s\n", dash_line);
+
+       row = 0;
+       if (has_title) {
+               strcpy(line, "| ");
+               strcat(line, title);
+               tmp = total_width - 4 - strlen(title);
+               while (tmp--)
+                       strcat(line, " ");
+
+               strcat(line, " |");
+               fprintf(stream, "%s\n", line);
+               fprintf(stream, "%s\n", dash_line);
+               row++;
+       }
+
+       for (; row < row_nbr; row++) {
+               strcpy(line, "|");
+               for (col = 0; col < col_nbr; col++) {
+                       strcat(line, " ");
+                       strncat(line, table[row][col], TABLE_MAX_ELT_LEN);
+                       if (strlen(table[row][col]) != TABLE_MAX_ELT_LEN) {
+                               for (tmp = strlen(table[row][col]);
+                                       tmp < max_elt_size[col]; tmp++)
+                                       strcat(line, " ");
+                       }
+                       strcat(line, " |");
+               }
+               fprintf(stream, "%s\n", line);
+               if (flags & TABLE_HAS_SUBTITLE) {
+                       fprintf(stream, "%s\n", dash_line);
+                       flags &= ~TABLE_HAS_SUBTITLE;
+               }
+       }
+       fprintf(stream, "%s\n\n", dash_line);
+
+       free(dash_line);
+       free(line);
+
+       return 0;
+}
+
+/* ------------------------------------------------------------------------*//**
+ * @FUNCTION           autoadjust_table_fprint
+ * @BRIEF              print elements into a table which size automatically
+ *                     adjusts.
+ * @RETURNS            0 in case of success
+ *                     -1 in case of incorrect pointer
+ *                     -2 in case of memory allocation error
+ *                     -3 one element of the table is longer than
+ *                     TABLE_MAX_ELT_LEN
+ * @param[in,out]      stream: output file
+ * @param[in]          table: elements to be printed
+ *                     format: table[row][col][string]
+ * @param[in]          row_nbr: number of rows
+ * @param[in]          col_nbr: number of columns
+ * @DESCRIPTION                print elements into a table which size automatically
+ *                     adjusts. The printed table looks like this:
+ *     |------------------------------------------------------------------|
+ *     | elements[0][0]     | elements[0][1]     | elements[0][col-1]     |
+ *     |------------------------------------------------------------------|
+ *     | elements[1][0]     | elements[1][1]     | elements[1][col-1]     |
+ *     | elements[2][0]     | elements[2][1]     | elements[2][col-1]     |
+ *     | elements[row-1][0] | elements[row-1][1] | elements[row-1][col-1] |
+ *     |------------------------------------------------------------------|
+ *//*------------------------------------------------------------------------ */
+int autoadjust_table_fprint(FILE *stream,
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr)
+{
+       return autoadjust_table_generic_fprint(stream, table, row_nbr, col_nbr,
+                                              TABLE_HAS_SUBTITLE);
+}
+
+
+/* ------------------------------------------------------------------------*//**
+ * @FUNCTION           autoadjust_table_print
+ * @BRIEF              print to console elements into a table which size
+ *                     automatically adjusts.
+ * @RETURNS            0 in case of success
+ *                     -1 in case of incorrect pointer
+ *                     -2 in case of memory allocation error
+ *                     -3 one element of the table is longer than
+ *                     TABLE_MAX_ELT_LEN
+ * @param[in]          table: elements to be printed
+ *                     format: table[row][col][string]
+ * @param[in]          row_nbr: number of rows
+ * @param[in]          col_nbr: number of columns
+ * @DESCRIPTION                print to console elements into a table which size
+ *                     automatically adjusts. The printed table is like this:
+ *     |------------------------------------------------------------------|
+ *     | elements[0][0]     | elements[0][1]     | elements[0][col-1]     |
+ *     |------------------------------------------------------------------|
+ *     | elements[1][0]     | elements[1][1]     | elements[1][col-1]     |
+ *     | elements[2][0]     | elements[2][1]     | elements[2][col-1]     |
+ *     | elements[row-1][0] | elements[row-1][1] | elements[row-1][col-1] |
+ *     |------------------------------------------------------------------|
+ *//*------------------------------------------------------------------------ */
+int autoadjust_table_print(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr)
+{
+       return autoadjust_table_fprint(stdout, table, row_nbr, col_nbr);
+}
+
+
+/* ------------------------------------------------------------------------*//**
+ * @FUNCTION           autoadjust_table_strncpy
+ * @BRIEF              copy string into table element, making sure it can fit.
+ * @RETURNS            0 in case of success
+ *                     -1 in case of incorrect argument(s)
+ *                     -3 one element of the table longer than
+ *                     TABLE_MAX_ELT_LEN
+ * @param[in,out]      table: elements to be printed
+ *                     format: table[row][col][string]
+ * @param[in]          row: number of rows
+ * @param[in]          col: number of columns
+ * @param[in]          s: string to copy
+ * @DESCRIPTION                copy string into table element, making sure it can fit.
+ *//*------------------------------------------------------------------------ */
+int autoadjust_table_strncpy(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row, unsigned int col, char s[TABLE_MAX_ELT_LEN])
+{
+       if (table == NULL) {
+               fprintf(stderr, "%s(): table == NULL!!!\n", __func__);
+               return -1;
+       }
+       if (s == NULL) {
+               fprintf(stderr, "%s(): s == NULL!!!\n", __func__);
+               return -1;
+       }
+       if (row >= TABLE_MAX_ROW) {
+               fprintf(stderr, "%s(): row (%u) >= TABLE_MAX_ROW (%u)\n",
+                       __func__, row, TABLE_MAX_ROW);
+               return -1;
+       }
+       if (col >= TABLE_MAX_COL) {
+               fprintf(stderr, "%s(): col (%u) >= TABLE_MAX_COL (%u)\n",
+                       __func__, col, TABLE_MAX_COL);
+               return -1;
+       }
+       if (strlen(s) >= TABLE_MAX_ELT_LEN) {
+               fprintf(stderr, "%s(): "
+                       "strlen(%s)=%lu >= TABLE_MAX_ELT_LEN (%u)!\n", __func__,
+                       s, strlen(s), TABLE_MAX_ELT_LEN);
+               return -3;
+       }
+
+       strncpy(table[row][col], s, TABLE_MAX_ELT_LEN);
+
+       return 0;
+}
+
+
+/* ------------------------------------------------------------------------*//**
+ * @FUNCTION           autoadjust_table_init
+ * @BRIEF              fill table with empty strings
+ * @RETURNS            0 in case of success
+ *                     -1 in case of incorrect pointer
+ * @param[in,out]      table: table to fill with empty strings
+ * @DESCRIPTION                fill table with empty strings, so that user does not
+ *                     need to fill empty cell(s).
+ *//*------------------------------------------------------------------------ */
+int autoadjust_table_init(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN])
+{
+       unsigned int col, row;
+
+       if (table == NULL) {
+               printf("autoadjust_table_init() error: table == NULL!\n");
+               return -1;
+       }
+
+       for (row = 0; row < TABLE_MAX_ROW; row++)
+               for (col = 0; col < TABLE_MAX_COL; col++)
+                       table[row][col][0] = '\0';
+
+       return 0;
+}

diff --git a/include/autoadjust_table.h b/include/autoadjust_table.h
new file mode 100644 (file)
index 0000000..1be96ad
--- /dev/null
+++ b/include/autoadjust_table.h
@@ -0,0 +1,74 @@
+/*
+ * Table printing library helpers
+ *
+ * Copyright (C) 2010-2019 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#ifndef __AUTOADJUST_TABLE_H
+#define __AUTOADJUST_TABLE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+
+#define TABLE_MAX_ROW          4000
+#define TABLE_MAX_COL          20
+#define TABLE_MAX_ELT_LEN      100
+
+#define TABLE_HAS_TITLE                1
+#define TABLE_HAS_SUBTITLE     2
+
+int autoadjust_table_init(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN]);
+
+int autoadjust_table_print(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr);
+
+int autoadjust_table_fprint(FILE *stream,
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr);
+
+int autoadjust_table_generic_fprint(FILE *stream,
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row_nbr, unsigned int col_nbr, unsigned int flags);
+
+int autoadjust_table_strncpy(
+       char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN],
+       unsigned int row, unsigned int col, char s[TABLE_MAX_ELT_LEN]);
+
+
+#endif