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 "rtbl.h" 38 39 struct column_entry { 40 char *data; 41 }; 42 43 struct column_data { 44 char *header; 45 char *prefix; 46 int width; 47 unsigned flags; 48 size_t num_rows; 49 struct column_entry *rows; 50 unsigned int column_id; 51 char *suffix; 52 }; 53 54 struct rtbl_data { 55 char *column_prefix; 56 size_t num_columns; 57 struct column_data **columns; 58 unsigned int flags; 59 char *column_separator; 60 }; 61 62 ROKEN_LIB_FUNCTION rtbl_t ROKEN_LIB_CALL 63 rtbl_create (void) 64 { 65 return calloc (1, sizeof (struct rtbl_data)); 66 } 67 68 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL 69 rtbl_set_flags (rtbl_t table, unsigned int flags) 70 { 71 table->flags = flags; 72 } 73 74 ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL 75 rtbl_get_flags (rtbl_t table) 76 { 77 return table->flags; 78 } 79 80 static struct column_data * 81 rtbl_get_column_by_id (rtbl_t table, unsigned int id) 82 { 83 size_t i; 84 for(i = 0; i < table->num_columns; i++) 85 if(table->columns[i]->column_id == id) 86 return table->columns[i]; 87 return NULL; 88 } 89 90 static struct column_data * 91 rtbl_get_column (rtbl_t table, const char *column) 92 { 93 size_t i; 94 for(i = 0; i < table->num_columns; i++) 95 if(strcmp(table->columns[i]->header, column) == 0) 96 return table->columns[i]; 97 return NULL; 98 } 99 100 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL 101 rtbl_destroy (rtbl_t table) 102 { 103 size_t i, j; 104 105 for (i = 0; i < table->num_columns; i++) { 106 struct column_data *c = table->columns[i]; 107 108 for (j = 0; j < c->num_rows; j++) 109 free (c->rows[j].data); 110 free (c->rows); 111 free (c->header); 112 free (c->prefix); 113 free (c->suffix); 114 free (c); 115 } 116 free (table->column_prefix); 117 free (table->column_separator); 118 free (table->columns); 119 free (table); 120 } 121 122 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 123 rtbl_add_column_by_id (rtbl_t table, unsigned int id, 124 const char *header, unsigned int flags) 125 { 126 struct column_data *col, **tmp; 127 128 tmp = realloc (table->columns, (table->num_columns + 1) * sizeof (*tmp)); 129 if (tmp == NULL) 130 return ENOMEM; 131 table->columns = tmp; 132 col = malloc (sizeof (*col)); 133 if (col == NULL) 134 return ENOMEM; 135 col->header = strdup (header); 136 if (col->header == NULL) { 137 free (col); 138 return ENOMEM; 139 } 140 col->prefix = NULL; 141 col->width = 0; 142 col->flags = flags; 143 col->num_rows = 0; 144 col->rows = NULL; 145 col->column_id = id; 146 col->suffix = NULL; 147 table->columns[table->num_columns++] = col; 148 return 0; 149 } 150 151 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 152 rtbl_add_column (rtbl_t table, const char *header, unsigned int flags) 153 { 154 return rtbl_add_column_by_id(table, 0, header, flags); 155 } 156 157 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 158 rtbl_new_row(rtbl_t table) 159 { 160 size_t max_rows = 0; 161 size_t c; 162 for (c = 0; c < table->num_columns; c++) 163 if(table->columns[c]->num_rows > max_rows) 164 max_rows = table->columns[c]->num_rows; 165 for (c = 0; c < table->num_columns; c++) { 166 struct column_entry *tmp; 167 168 if(table->columns[c]->num_rows == max_rows) 169 continue; 170 tmp = realloc(table->columns[c]->rows, 171 max_rows * sizeof(table->columns[c]->rows)); 172 if(tmp == NULL) 173 return ENOMEM; 174 table->columns[c]->rows = tmp; 175 while(table->columns[c]->num_rows < max_rows) { 176 if((tmp[table->columns[c]->num_rows++].data = strdup("")) == NULL) 177 return ENOMEM; 178 } 179 } 180 return 0; 181 } 182 183 static void 184 column_compute_width (rtbl_t table, struct column_data *column) 185 { 186 size_t i; 187 188 if(table->flags & RTBL_HEADER_STYLE_NONE) 189 column->width = 0; 190 else 191 column->width = strlen (column->header); 192 for (i = 0; i < column->num_rows; i++) 193 column->width = max (column->width, (int) strlen (column->rows[i].data)); 194 } 195 196 /* DEPRECATED */ 197 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 198 rtbl_set_prefix (rtbl_t table, const char *prefix) 199 { 200 if (table->column_prefix) 201 free (table->column_prefix); 202 table->column_prefix = strdup (prefix); 203 if (table->column_prefix == NULL) 204 return ENOMEM; 205 return 0; 206 } 207 208 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 209 rtbl_set_separator (rtbl_t table, const char *separator) 210 { 211 if (table->column_separator) 212 free (table->column_separator); 213 table->column_separator = strdup (separator); 214 if (table->column_separator == NULL) 215 return ENOMEM; 216 return 0; 217 } 218 219 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 220 rtbl_set_column_prefix (rtbl_t table, const char *column, 221 const char *prefix) 222 { 223 struct column_data *c = rtbl_get_column (table, column); 224 225 if (c == NULL) 226 return -1; 227 if (c->prefix) 228 free (c->prefix); 229 c->prefix = strdup (prefix); 230 if (c->prefix == NULL) 231 return ENOMEM; 232 return 0; 233 } 234 235 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 236 rtbl_set_column_affix_by_id(rtbl_t table, unsigned int id, 237 const char *prefix, const char *suffix) 238 { 239 struct column_data *c = rtbl_get_column_by_id (table, id); 240 241 if (c == NULL) 242 return -1; 243 if (c->prefix) 244 free (c->prefix); 245 if(prefix == NULL) 246 c->prefix = NULL; 247 else { 248 c->prefix = strdup (prefix); 249 if (c->prefix == NULL) 250 return ENOMEM; 251 } 252 253 if (c->suffix) 254 free (c->suffix); 255 if(suffix == NULL) 256 c->suffix = NULL; 257 else { 258 c->suffix = strdup (suffix); 259 if (c->suffix == NULL) 260 return ENOMEM; 261 } 262 return 0; 263 } 264 265 266 static const char * 267 get_column_prefix (rtbl_t table, struct column_data *c) 268 { 269 if (c == NULL) 270 return ""; 271 if (c->prefix) 272 return c->prefix; 273 if (table->column_prefix) 274 return table->column_prefix; 275 return ""; 276 } 277 278 static const char * 279 get_column_suffix (rtbl_t table, struct column_data *c) 280 { 281 if (c && c->suffix) 282 return c->suffix; 283 return ""; 284 } 285 286 static int 287 add_column_entry (struct column_data *c, const char *data) 288 { 289 struct column_entry row, *tmp; 290 291 row.data = strdup (data); 292 if (row.data == NULL) 293 return ENOMEM; 294 tmp = realloc (c->rows, (c->num_rows + 1) * sizeof (*tmp)); 295 if (tmp == NULL) { 296 free (row.data); 297 return ENOMEM; 298 } 299 c->rows = tmp; 300 c->rows[c->num_rows++] = row; 301 return 0; 302 } 303 304 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 305 rtbl_add_column_entry_by_id (rtbl_t table, unsigned int id, const char *data) 306 { 307 struct column_data *c = rtbl_get_column_by_id (table, id); 308 309 if (c == NULL) 310 return -1; 311 312 return add_column_entry(c, data); 313 } 314 315 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 316 rtbl_add_column_entryv_by_id (rtbl_t table, unsigned int id, 317 const char *fmt, ...) 318 { 319 va_list ap; 320 char *str; 321 int ret; 322 323 va_start(ap, fmt); 324 ret = vasprintf(&str, fmt, ap); 325 va_end(ap); 326 if (ret == -1) 327 return -1; 328 ret = rtbl_add_column_entry_by_id(table, id, str); 329 free(str); 330 return ret; 331 } 332 333 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 334 rtbl_add_column_entry (rtbl_t table, const char *column, const char *data) 335 { 336 struct column_data *c = rtbl_get_column (table, column); 337 338 if (c == NULL) 339 return -1; 340 341 return add_column_entry(c, data); 342 } 343 344 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 345 rtbl_add_column_entryv (rtbl_t table, const char *column, const char *fmt, ...) 346 { 347 va_list ap; 348 char *str; 349 int ret; 350 351 va_start(ap, fmt); 352 ret = vasprintf(&str, fmt, ap); 353 va_end(ap); 354 if (ret == -1) 355 return -1; 356 ret = rtbl_add_column_entry(table, column, str); 357 free(str); 358 return ret; 359 } 360 361 362 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL 363 rtbl_format (rtbl_t table, FILE * f) 364 { 365 size_t i, j; 366 367 for (i = 0; i < table->num_columns; i++) 368 column_compute_width (table, table->columns[i]); 369 if((table->flags & RTBL_HEADER_STYLE_NONE) == 0) { 370 for (i = 0; i < table->num_columns; i++) { 371 struct column_data *c = table->columns[i]; 372 373 if(table->column_separator != NULL && i > 0) 374 fprintf (f, "%s", table->column_separator); 375 fprintf (f, "%s", get_column_prefix (table, c)); 376 if(i == table->num_columns - 1 && c->suffix == NULL) 377 /* last column, so no need to pad with spaces */ 378 fprintf (f, "%-*s", 0, c->header); 379 else 380 fprintf (f, "%-*s", (int)c->width, c->header); 381 fprintf (f, "%s", get_column_suffix (table, c)); 382 } 383 fprintf (f, "\n"); 384 } 385 386 for (j = 0;; j++) { 387 int flag = 0; 388 389 /* are there any more rows left? */ 390 for (i = 0; flag == 0 && i < table->num_columns; ++i) { 391 struct column_data *c = table->columns[i]; 392 393 if (c->num_rows > j) { 394 ++flag; 395 break; 396 } 397 } 398 if (flag == 0) 399 break; 400 401 for (i = 0; i < table->num_columns; i++) { 402 int w; 403 struct column_data *c = table->columns[i]; 404 405 if(table->column_separator != NULL && i > 0) 406 fprintf (f, "%s", table->column_separator); 407 408 w = c->width; 409 410 if ((c->flags & RTBL_ALIGN_RIGHT) == 0) { 411 if(i == table->num_columns - 1 && c->suffix == NULL) 412 /* last column, so no need to pad with spaces */ 413 w = 0; 414 else 415 w = -w; 416 } 417 fprintf (f, "%s", get_column_prefix (table, c)); 418 if (c->num_rows <= j) 419 fprintf (f, "%*s", w, ""); 420 else 421 fprintf (f, "%*s", w, c->rows[j].data); 422 fprintf (f, "%s", get_column_suffix (table, c)); 423 } 424 fprintf (f, "\n"); 425 } 426 return 0; 427 } 428 429 #ifdef TEST 430 int 431 main (int argc, char **argv) 432 { 433 rtbl_t table; 434 435 table = rtbl_create (); 436 rtbl_add_column_by_id (table, 0, "Issued", 0); 437 rtbl_add_column_by_id (table, 1, "Expires", 0); 438 rtbl_add_column_by_id (table, 2, "Foo", RTBL_ALIGN_RIGHT); 439 rtbl_add_column_by_id (table, 3, "Principal", 0); 440 441 rtbl_add_column_entry_by_id (table, 0, "Jul 7 21:19:29"); 442 rtbl_add_column_entry_by_id (table, 1, "Jul 8 07:19:29"); 443 rtbl_add_column_entry_by_id (table, 2, "73"); 444 rtbl_add_column_entry_by_id (table, 2, "0"); 445 rtbl_add_column_entry_by_id (table, 2, "-2000"); 446 rtbl_add_column_entry_by_id (table, 3, "krbtgt/NADA.KTH.SE@NADA.KTH.SE"); 447 448 rtbl_add_column_entry_by_id (table, 0, "Jul 7 21:19:29"); 449 rtbl_add_column_entry_by_id (table, 1, "Jul 8 07:19:29"); 450 rtbl_add_column_entry_by_id (table, 3, "afs/pdc.kth.se@NADA.KTH.SE"); 451 452 rtbl_add_column_entry_by_id (table, 0, "Jul 7 21:19:29"); 453 rtbl_add_column_entry_by_id (table, 1, "Jul 8 07:19:29"); 454 rtbl_add_column_entry_by_id (table, 3, "afs@NADA.KTH.SE"); 455 456 rtbl_set_separator (table, " "); 457 458 rtbl_format (table, stdout); 459 460 rtbl_destroy (table); 461 462 printf("\n"); 463 464 table = rtbl_create (); 465 rtbl_add_column_by_id (table, 0, "Column A", 0); 466 rtbl_set_column_affix_by_id (table, 0, "<", ">"); 467 rtbl_add_column_by_id (table, 1, "Column B", 0); 468 rtbl_set_column_affix_by_id (table, 1, "[", "]"); 469 rtbl_add_column_by_id (table, 2, "Column C", 0); 470 rtbl_set_column_affix_by_id (table, 2, "(", ")"); 471 472 rtbl_add_column_entry_by_id (table, 0, "1"); 473 rtbl_new_row(table); 474 rtbl_add_column_entry_by_id (table, 1, "2"); 475 rtbl_new_row(table); 476 rtbl_add_column_entry_by_id (table, 2, "3"); 477 rtbl_new_row(table); 478 479 rtbl_set_separator (table, " "); 480 rtbl_format (table, stdout); 481 482 rtbl_destroy (table); 483 484 return 0; 485 } 486 487 #endif 488