mcTable.c File Reference

Read and write routines for Multi-Column Tables. More...

#include "mdb.h"
#include "column.h"
#include <ctype.h>

Go to the source code of this file.

Macros
#define	DEBUG   0

Functions
char *	fgets_mc_skip (char *s, long slen, FILE *fp, char skip_char)
void	get_name_unit_descrip_format (char **name, char **unit, char **descrip, char **format, char *_buffer)
long	get_mc_table (MC_TABLE *table, char *file, long flags)
	Reads a multi-column table from a file.
long	put_mc_table (char *file, MC_TABLE *table)
long	put_mc_table_header (FILE *fpo, MC_TABLE *table)

Variables
static char	buffer [1024]
static char	buffer1 [1024]

Detailed Description

Read and write routines for Multi-Column Tables.

This file contains functions to handle multi-column table operations, including reading from and writing to table files. It provides mechanisms to parse table headers, handle auxiliary quantities, and manage table data.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, C. Saunders, R. Soliday

Definition in file mcTable.c.

Macro Definition Documentation

DEBUG

#define DEBUG   0

Definition at line 24 of file mcTable.c.

Function Documentation

fgets_mc_skip()

char * fgets_mc_skip	(	char *	s,
		long	slen,
		FILE *	fp,
		char	skip_char )

Definition at line 197 of file mcTable.c.

  {
  do {
    if (!fgets(s, slen, fp))
      return (NULL);
    chop_nl(s);
    if (s[0] != skip_char)
      break;
  } while (1);
  return (s);
}

get_mc_table()

long get_mc_table	(	MC_TABLE *	table,
		char *	file,
		long	flags )

Reads a multi-column table from a file.

Parses the specified file to populate the MC_TABLE structure with column information, auxiliary quantities, and table data.

Parameters

table	Pointer to the MC_TABLE structure to populate.
file	Path to the table file to read.
flags	Flags to control warning messages and behavior.

Returns

Returns 1 on success, 0 on failure.

Definition at line 42 of file mcTable.c.

                                                           {
  FILE *fpi;
  long i, j, i_col;
  char *ptr;
 
  if (!(fpi = fopen_e(file, "r", 1)))
    return (0);
 
  if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
    bomb("unable to read first line of table file", NULL);
  if (!(get_long(&table->n_cols, buffer)))
    bomb("unable to scan number of columns in table file", NULL);
  if (table->n_cols <= 0)
    bomb("number of columns is invalid in table file", NULL);
  table->n_lines_per_row = 1;
  table->n_auxiliaries = 0;
  if (get_long(&table->n_lines_per_row, buffer)) {
    if (table->n_lines_per_row <= 0)
      bomb("number of lines per row is invalid in table file", NULL);
    if (get_long(&table->n_auxiliaries, buffer) &&
        table->n_auxiliaries < 0)
      bomb("number of auxiliary quantities is invalid in table file", NULL);
  }
 
#if DEBUG
  printf("file %s\nn_cols = %ld  n_lines_per_row = %ld  n_auxiliaries = %ld\n",
         file, table->n_cols, table->n_lines_per_row, table->n_auxiliaries);
#endif
 
  table->name = tmalloc(sizeof(char *) * table->n_cols);
  table->unit = tmalloc(sizeof(char *) * table->n_cols);
  table->description = tmalloc(sizeof(char *) * table->n_cols);
  table->format = tmalloc(sizeof(char *) * table->n_cols);
 
  for (i = 0; i < table->n_cols; i++) {
    if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
      bomb("missing quantity name and units line in table file", NULL);
    get_name_unit_descrip_format(table->name + i, table->unit + i,
                                 table->description + i, table->format + i, buffer);
    if (table->format[i] && !strchr(table->format[i], '%'))
      table->format[i] = NULL;
  }
 
#if DEBUG
  for (i = 0; i < table->n_cols; i++)
    printf("column %ld:  %s in %s--%s in format %s\n",
           i, table->name[i], table->unit[i], table->description[i],
           (table->format[i] ? table->format[i] : "{null}"));
#endif
 
  if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
    bomb("missing title string in table file", NULL);
  cp_str(&table->title, buffer);
 
  if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
    bomb("missing label string in table file", NULL);
  cp_str(&table->label, buffer);
 
#if DEBUG
  printf("title: %s\nlabel: %s\n", table->title, table->label);
#endif
 
  if (table->n_auxiliaries) {
#if DEBUG
    printf("%ld auxuliary quantities are expected\n", table->n_auxiliaries);
#endif
    /* get auxiliary quantity names\units... */
    table->aux_name = tmalloc(sizeof(char *) * table->n_auxiliaries);
    table->aux_unit = tmalloc(sizeof(char *) * table->n_auxiliaries);
    table->aux_description = tmalloc(sizeof(char *) * table->n_auxiliaries);
    table->aux_value = tmalloc(sizeof(*(table->aux_value)) * table->n_auxiliaries);
    for (i = 0; i < table->n_auxiliaries; i++) {
      if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
        bomb("missing quantity name and units line in table file", NULL);
      get_name_unit_descrip_format(table->aux_name + i, table->aux_unit + i,
                                   table->aux_description + i, &ptr, buffer);
      if ((!ptr || 1 != sscanf(ptr, "%lf", table->aux_value + i)) && flags & GMCT_WARN_MISSING_AUXVAL)
        printf("warning: missing value for auxiliary quantity %s---zero assumed\n", table->aux_name[i]);
    }
  }
 
#if DEBUG
  for (i = 0; i < table->n_auxiliaries; i++) {
    printf("auxiliary %ld:  %s = %le %s---%s\n",
           i, table->aux_name[i], table->aux_value[i], table->aux_unit[i],
           table->aux_description[i]);
  }
#endif
 
  if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
    bomb("missing number of data rows in table file", NULL);
  if (!get_long(&table->n_rows, buffer) || table->n_rows < 0)
    bomb("invalid number of data rows specified in table file", NULL);
  if (table->n_rows == 0)
    return (1);
 
#if DEBUG
  printf("n_rows = %ld\n", table->n_rows);
#endif
 
  table->value = (double **)zarray_2d(sizeof(double), table->n_cols, table->n_rows);
  table->row_label = (char **)tmalloc(sizeof(char *) * table->n_rows);
 
  for (i = 0; i < table->n_rows; i++) {
    i_col = 0;
    table->row_label[i] = NULL;
    for (j = 0; j < table->n_lines_per_row && i_col < table->n_cols; j++) {
      if (!fgets_mc_skip(buffer, 1024, fpi, '!'))
        break;
      strcpy(buffer1, buffer);
#if DEBUG
      printf("row %ld, line %ld:\n%s\n", i, j, buffer);
#endif
      while (i_col < table->n_cols && get_double(table->value[i_col] + i, buffer))
        i_col++;
    }
 
    if (!is_blank(buffer)) {
      cp_str(table->row_label + i, buffer);
      while (isspace(*table->row_label[i]))
        table->row_label[i]++;
    } else
      cp_str(table->row_label + i, "");
 
    if (i_col == 0) {
      if (flags & GMCT_WARN_WRONG_COUNT)
        printf("warning: fewer data rows than expected in file %s\n", file);
      break;
    } else if (i_col != table->n_cols) {
      if (flags & GMCT_WARN_INCOMPLETE_ROW) {
        printf("warning: incomplete data row in file %s\n", file);
        printf("line in question is:\n%s\n", buffer1);
        printf("skipping to next line\n");
      }
      i--;
      continue;
    }
#if DEBUG
    printf("%ld: ", i);
    for (i_col = 0; i_col < table->n_cols; i_col++)
      printf("%.4le  ", table->value[i_col][i]);
    putchar('\n');
#endif
  }
  if (i == table->n_rows && fgets_mc_skip(buffer, 1024, fpi, '!') && flags & GMCT_WARN_EXTRA_ROWS)
    printf("warning: file %s contains extra rows, which are ignored\n",
           file);
  table->n_rows = i;
  return (1);
}

get_name_unit_descrip_format()

void get_name_unit_descrip_format	(	char **	name,
		char **	unit,
		char **	descrip,
		char **	format,
		char *	_buffer )

Definition at line 269 of file mcTable.c.

                                                                                                      {
  char *ptr, *ptrn, *ptru, *ptrd, *ptrf;
  char *blank_string;
 
  cp_str(&blank_string, " ");
 
  ptr = ptrn = buf;
  ptru = ptrd = ptrf = NULL;
  while ((ptr = strchr(ptr, '\\'))) {
    if (ptr[1] == '\\')
      ptr += 2;
    else {
      if (!ptru) {
        *ptr = 0;
        ptru = ++ptr;
      } else if (!ptrd) {
        *ptr = 0;
        ptrd = ++ptr;
      } else {
        *ptr = 0;
        ptrf = ++ptr;
        break;
      }
    }
  }
  cp_str(name, ptrn);
  trim_spaces(*name);
  if (ptru) {
    cp_str(unit, ptru);
    trim_spaces(*unit);
  } else
    *unit = blank_string;
  if (ptrd && !is_blank(ptrd)) {
    cp_str(descrip, ptrd);
    trim_spaces(*descrip);
  } else
    cp_str(descrip, *name);
  if (ptrf) {
    cp_str(format, ptrf);
    trim_spaces(*format);
  } else
    *format = NULL;
}

put_mc_table()

long put_mc_table	(	char *	file,
		MC_TABLE *	table )

Definition at line 213 of file mcTable.c.

                                               {
  FILE *fpo;
  long i, j, wrap;
 
  if (!(fpo = fopen(file, "w"))) {
    printf("unable to write to file %s\n", file);
    return (0);
  }
 
  if (table->n_lines_per_row < 1)
    table->n_lines_per_row = 1;
 
  put_mc_table_header(fpo, table);
 
  wrap = table->n_cols / table->n_lines_per_row;
  for (i = 0; i < table->n_rows; i++) {
    j = 0;
    while (j < table->n_cols) {
      fprintf(fpo, (table->format && table->format[j] ? table->format[j] : "%le"),
              table->value[j][i]);
      if (j == table->n_cols - 1 && table->row_label && table->row_label[j])
        fprintf(fpo, " %s", table->row_label[j]);
      if (++j % wrap == 0)
        fputc('\n', fpo);
      else
        fputs("  ", fpo);
    }
  }
  fclose(fpo);
  return (1);
}

put_mc_table_header()

long put_mc_table_header	(	FILE *	fpo,
		MC_TABLE *	table )

Definition at line 245 of file mcTable.c.

                                                     {
  long i;
 
  fprintf(fpo, "%ld  %ld  %ld\n", table->n_cols, table->n_lines_per_row, table->n_auxiliaries);
 
  for (i = 0; i < table->n_cols; i++)
    fprintf(fpo, "%s\\%s\\%s\\%s\n",
            table->name[i],
            (table->unit[i] && (long)strlen(table->unit[i]) > 1) ? table->unit[i] : " ",
            (table->description[i] && (long)strlen(table->description[i]) > 1) ? table->description[i] : " ",
            (table->format[i] ? table->format[i] : ""));
 
  fprintf(fpo, "%s\n%s\n",
          (table->title && (long)strlen(table->title) > 1) ? table->title : " ",
          (table->label && (long)strlen(table->label) > 1) ? table->label : " ");
 
  for (i = 0; i < table->n_auxiliaries; i++)
    fprintf(fpo, "%s\\%s\\%s\\%.16e\n", table->aux_name[i], table->aux_unit[i],
            table->aux_description[i], table->aux_value[i]);
 
  fprintf(fpo, "%ld\n", table->n_rows);
  return (1);
}

Variable Documentation

buffer

char buffer[1024]

static

Definition at line 26 of file mcTable.c.

buffer1

char buffer1[1024]

static

Definition at line 27 of file mcTable.c.