#include "datafile.h"

#include "datablock.h"

#include "alloc.h"

#include "command.h"

#include "eval.h"

#include "gp_time.h"

#include "gplocale.h"

#include "graphics.h"

#include "misc.h"

#include "parse.h"

#include "plot.h"

#include "plot2d.h" /* For reevaluate_plot_title() */

#include "readline.h"

#include "util.h"

#include "breaders.h"

#include "tabulate.h" /* For sanity check inblock != outblock */

#include "voxelgrid.h"

#define is_EOF(c) ((c) == 'e' || (c) == 'E')

#define is_comment(c) ((c) && (strchr(df_commentschars, (c)) != NULL))

#define NOTSEP (!df_separators || !strchr(df_separators,*s))

enum COLUMN_TYPE { CT_DEFAULT, CT_STRING, CT_KEYLABEL, CT_MUST_HAVE,

CT_XTICLABEL, CT_X2TICLABEL, CT_YTICLABEL, CT_Y2TICLABEL,

CT_ZTICLABEL, CT_CBTICLABEL };

static int check_missing(char *s);

static void expand_df_column(int);

static void clear_df_column_headers(void);

static char *df_gets(void);

static int df_tokenise(char *s);

static double *df_read_matrix(int *rows, int *columns);

static void plot_option_every(void);

static void plot_option_index(void);

static void plot_option_using(int);

static TBOOLEAN valid_format(const char *);

static void plot_ticlabel_using(int);

static void add_key_entry(char *temp_string, int df_datum);

static char * df_generate_pseudodata(void);

static char * df_generate_ascii_array_entry(void);

static int df_skip_bytes(off_t nbytes);

static int axcol_for_ticlabel(enum COLUMN_TYPE type, int *axis);

int df_no_use_specs; /* how many using columns were specified */

int df_line_number;

int df_datum; /* suggested x value if none given */

int df_last_col = 0; /* visible to user via STATS_columns */

int df_bad_matrix_values;

AXIS_INDEX df_axis[MAXDATACOLS];

TBOOLEAN df_matrix = FALSE; /* indicates if data originated from a 2D or 3D format */

void *df_pixeldata; /* pixel data from an external library (e.g. libgd) */

char *missing_val = NULL;

char *df_separators = NULL;

char *df_commentschars = 0;

TBOOLEAN plotted_data_from_stdin = FALSE;

TBOOLEAN df_columnheaders = FALSE;

TBOOLEAN df_fortran_constants = FALSE;

TBOOLEAN df_nofpe_trap = FALSE;

static char *df_line = NULL;

static size_t max_line_len = 0;

#define DATA_LINE_BUFSIZ 160

static FILE *data_fp = NULL;

#if defined(PIPES)

static TBOOLEAN df_pipe_open = FALSE;

#if defined(HAVE_FDOPEN)

static int data_fd = -2; /* only used for file redirection */

static TBOOLEAN mixed_data_fp = FALSE; /* inline data */

char *df_filename = NULL; /* name of data file */

static int df_eof = 0;

static int df_no_tic_specs; /* ticlabel columns not counted in df_no_use_specs */

#ifndef MAXINT /* should there be one already defined ? */

# define MAXINT INT_MAX /* from <limits.h> */

static int blank_count = 0; /* how many blank lines recently */

static int df_lower_index = 0; /* first mesh required */

static int df_upper_index = MAXINT;

static int df_index_step = 1; /* 'every' for indices */

static int df_current_index; /* current mesh */

static int df_last_index_read; /* last mesh we actually read data from */

static char *indexname = NULL;

static TBOOLEAN index_found = FALSE;

static int df_longest_columnhead = 0;

static TBOOLEAN set_every = FALSE;

static int everypoint = 1;

static int firstpoint = 0;

static int lastpoint = MAXINT;

static int everyline = 1;

static int firstline = 0;

static int lastline = MAXINT;

static int point_count = -1; /* point counter - preincrement and test 0 */

static int line_count = 0; /* line counter */

static int df_skip_at_front = 0;

static int df_pseudodata = 0;

static int df_pseudorecord = 0;

static int df_pseudospan = 0;

static double df_pseudovalue_0 = 0;

static double df_pseudovalue_1 = 0;

static TBOOLEAN df_datablock = FALSE;

static char **df_datablock_line = NULL;

static int df_array_index = 0;

static char *df_arrayname = NULL;

static unsigned int df_xpixels;

static unsigned int df_ypixels;

static TBOOLEAN df_transpose;

static double df_image_origin[2];

static double df_image_deltas[2];

struct use_spec_s use_spec[MAXDATACOLS];

static char *df_format = NULL;

static char *df_binary_format = NULL;

TBOOLEAN evaluate_inside_using = FALSE;

TBOOLEAN df_warn_on_missing_columnheader = FALSE;

typedef struct df_column_struct {

} df_column_struct;

static df_column_struct *df_column = NULL; /* we'll allocate space as needed */

static int df_max_cols = 0; /* space allocated */

static int df_no_cols; /* total number of columns found in input lines */

static int fast_columns; /* corey@cac optimization */

char *df_tokens[MAXDATACOLS]; /* filled in by df_tokenise */

static char *df_stringexpression[MAXDATACOLS]; /* filled in after evaluate_at() */

static struct curve_points *df_current_plot; /* used to process histogram labels + key entries */

struct value df_strings[MAXDATACOLS]; /* used only by TABLESTYLE */

static TBOOLEAN df_tabulate_strings = FALSE; /* used only by TABLESTYLE */

#define NO_COLUMN_HEADER (-99) /* some value that can never be a real column */

static int column_for_key_title = NO_COLUMN_HEADER;

static TBOOLEAN df_already_got_headers = FALSE;

char *df_key_title = NULL; /* filled in from column header if requested */

struct at_type *df_plot_title_at; /* used for deferred evaluation of plot title */

static TBOOLEAN df_missing_data_in_expression = FALSE;

static TBOOLEAN df_read_binary;

static TBOOLEAN df_nonuniform_matrix;

static TBOOLEAN df_matrix_columnheaders, df_matrix_rowheaders;

static int df_plot_mode;

static int df_readascii(double [], int);

static int df_readbinary(double [], int);

static void initialize_use_spec(void);

static void initialize_plot_style(struct curve_points *);

static void initialize_binary_vars(void);

static void df_insert_scanned_use_spec(int);

static void adjust_binary_use_spec(struct curve_points *);

static void clear_binary_records(df_records_type);

static void plot_option_binary_format(char *);

static void plot_option_binary(TBOOLEAN, TBOOLEAN);

static void plot_option_array(void);

static void plot_option_sparse(void);

static TBOOLEAN rotation_matrix_2D(double R[][2], double);

static TBOOLEAN rotation_matrix_3D(double P[][3], double *);

static int token2tuple(double *, int);

static void df_determine_matrix_info(FILE *);

static void df_swap_bytes_by_endianess(char *, int, int);

typedef enum df_multivalue_type {

} df_multivalue_type;

static void plot_option_multivalued(df_multivalue_type,int);

char *df_endian[DF_ENDIAN_TYPE_LENGTH] = {

"little",

"pdp (middle)",

"swapped pdp (dimmle)",

"big"

};

#define SUPPORT_MIDDLE_ENDIAN 1

#if SUPPORT_MIDDLE_ENDIAN

typedef enum df_byte_read_order_type {

} df_byte_read_order_type;

static char df_byte_read_order_map[4][4] = {

{DF_0123, DF_1032, DF_2301, DF_3210},

{DF_1032, DF_0123, DF_1032, DF_2301},

{DF_2301, DF_1032, DF_0123, DF_1032},

{DF_3210, DF_2301, DF_1032, DF_0123}

};

static long long_0x2468 = 0x2468;

#define TEST_BIG_PDP ( (((char *)&long_0x2468)[0] < 3) ? DF_BIG_ENDIAN : DF_PDP_ENDIAN )

#define THIS_COMPILER_ENDIAN ( (((char *)&long_0x2468)[0] < 5) ? TEST_BIG_PDP : DF_LITTLE_ENDIAN )

static df_byte_read_order_type byte_read_order(df_endianess_type);

TBOOLEAN df_binary_file;

TBOOLEAN df_matrix_file;

TBOOLEAN df_sparse_matrix;

TBOOLEAN df_voxelgrid;

static int df_M_count;

static int df_N_count;

static int df_O_count;

df_binary_file_record_struct *df_bin_record = 0;

df_binary_file_record_struct *df_bin_record_default = 0;

df_binary_file_record_struct df_bin_record_reset = {

{-1, 0, 0},

{1, 1, 1},

{1, 1, 1},

DF_TRANSLATE_DEFAULT,

{0, 0, 0},

0,

{0, 0, 1},

{DF_SCAN_POINT, DF_SCAN_LINE, DF_SCAN_PLANE},

FALSE,

{0, 0, 0},

{0, 0, 0},

{1, 1, 1},

{0, 0, 0},

DF_TRANSLATE_DEFAULT,

{0, 0, 0},

0, 0, /* submatrix size */

NULL /* data_memory */

};

int df_max_num_bin_records = 0, df_num_bin_records, df_bin_record_count;

int df_max_num_bin_records_default = 0, df_num_bin_records_default;

const struct coordinate blank_data_line = {-999, -999, -999, -999, -999, -999, -999, UNDEFINED};

static void gpbin_filetype_function(void);

static void raw_filetype_function(void);

static void avs_filetype_function(void);

static void (*binary_input_function)(void); /* Will point to one of the above */

static void auto_filetype_function(void){} /* Just a placeholder for auto */

struct gen_ftable df_bin_filetype_table[] = {

{"avs", avs_filetype_function},

{"bin", raw_filetype_function},

{"edf", edf_filetype_function},

{"ehf", edf_filetype_function},

{"gif", gif_filetype_function},

{"gpbin", gpbin_filetype_function},

{"jpeg", jpeg_filetype_function},

{"jpg", jpeg_filetype_function},

{"png", png_filetype_function},

{"raw", raw_filetype_function},

{"rgb", raw_filetype_function},

{"auto", auto_filetype_function},

{NULL, NULL}

};

#define RAW_FILETYPE 1

static int df_bin_filetype;

static int df_bin_filetype_default;

static df_endianess_type df_bin_file_endianess_default;

static int df_bin_filetype_reset = -1;

#define DF_BIN_FILE_ENDIANESS_RESET THIS_COMPILER_ENDIAN

df_endianess_type df_bin_file_endianess;

typedef struct df_bin_scan_table_2D_struct {

char *string;

df_sample_scan_type scan[3];

} df_bin_scan_table_2D_struct;

df_bin_scan_table_2D_struct df_bin_scan_table_2D[] = {

{"xy", {DF_SCAN_POINT, DF_SCAN_LINE, DF_SCAN_PLANE}},

{"yx", {DF_SCAN_LINE, DF_SCAN_POINT, DF_SCAN_PLANE}},

{"tr", {DF_SCAN_POINT, DF_SCAN_LINE, DF_SCAN_PLANE}},

{"rt", {DF_SCAN_LINE, DF_SCAN_POINT, DF_SCAN_PLANE}}

};

#define TRANSPOSE_INDEX 1

typedef struct df_bin_scan_table_3D_struct {

char *string;

df_sample_scan_type scan[3];

} df_bin_scan_table_3D_struct;

df_bin_scan_table_3D_struct df_bin_scan_table_3D[] = {

{"xyz", {DF_SCAN_POINT, DF_SCAN_LINE, DF_SCAN_PLANE}},

{"zxy", {DF_SCAN_LINE, DF_SCAN_PLANE, DF_SCAN_POINT}},

{"yzx", {DF_SCAN_PLANE, DF_SCAN_POINT, DF_SCAN_LINE}},

{"yxz", {DF_SCAN_LINE, DF_SCAN_POINT, DF_SCAN_PLANE}},

{"xzy", {DF_SCAN_POINT, DF_SCAN_PLANE, DF_SCAN_LINE}},

{"zyx", {DF_SCAN_PLANE, DF_SCAN_LINE, DF_SCAN_POINT}},

{"trz", {DF_SCAN_POINT, DF_SCAN_LINE, DF_SCAN_PLANE}},

{"ztr", {DF_SCAN_LINE, DF_SCAN_PLANE, DF_SCAN_POINT}},

{"rzt", {DF_SCAN_PLANE, DF_SCAN_POINT, DF_SCAN_LINE}},

{"rtz", {DF_SCAN_LINE, DF_SCAN_POINT, DF_SCAN_PLANE}},

{"tzr", {DF_SCAN_POINT, DF_SCAN_PLANE, DF_SCAN_LINE}},

{"zrt", {DF_SCAN_PLANE, DF_SCAN_LINE, DF_SCAN_POINT}}

};

char *ch_names[] = {"char","schar","c"};

char *uc_names[] = {"uchar"};

char *sh_names[] = {"short"};

char *us_names[] = {"ushort"};

char *in_names[] = {"int","sint","i","d"};

char *ui_names[] = {"uint","u"};

char *lo_names[] = {"long","ld"};

char *ul_names[] = {"ulong","lu"};

char *fl_names[] = {"float","f"};

char *db_names[] = {"double","lf"};

char *byte_names[] = {"int8","byte"};

char *ubyte_names[] = {"uint8","ubyte"};

char *word_names[] = {"int16","word"};

char *uword_names[] = {"uint16","uword"};

char *word2_names[] = {"int32"};

char *uword2_names[] = {"uint32"};

char *word4_names[] = {"int64"};

char *uword4_names[] = {"uint64"};

char *float_names[] = {"float32"};

char *float2_names[] = {"float64"};

typedef struct df_binary_details_struct {

} df_binary_details_struct;

typedef struct df_binary_tables_struct {

df_binary_details_struct *group;

unsigned short group_length;

} df_binary_tables_struct;

df_binary_details_struct df_binary_details[] = {

{ch_names,sizeof(ch_names)/sizeof(ch_names[0]),{DF_CHAR,sizeof(char)}},

{uc_names,sizeof(uc_names)/sizeof(uc_names[0]),{DF_UCHAR,sizeof(unsigned char)}},

{sh_names,sizeof(sh_names)/sizeof(sh_names[0]),{DF_SHORT,sizeof(short)}},

{us_names,sizeof(us_names)/sizeof(us_names[0]),{DF_USHORT,sizeof(unsigned short)}},

{in_names,sizeof(in_names)/sizeof(in_names[0]),{DF_INT,sizeof(int)}},

{ui_names,sizeof(ui_names)/sizeof(ui_names[0]),{DF_UINT,sizeof(unsigned int)}},

{lo_names,sizeof(lo_names)/sizeof(lo_names[0]),{DF_LONG,sizeof(long)}},

{ul_names,sizeof(ul_names)/sizeof(ul_names[0]),{DF_ULONG,sizeof(unsigned long)}},

{fl_names,sizeof(fl_names)/sizeof(fl_names[0]),{DF_FLOAT,sizeof(float)}},

{db_names,sizeof(db_names)/sizeof(db_names[0]),{DF_DOUBLE,sizeof(double)}},

{NULL,0, {DF_LONGLONG,sizeof(long long)}},

{NULL,0, {DF_ULONGLONG,sizeof(unsigned long long)}}

};

df_binary_details_struct df_binary_details_independent[] = {

{byte_names,sizeof(byte_names)/sizeof(byte_names[0]),{SIGNED_TEST(1),1}},

{ubyte_names,sizeof(ubyte_names)/sizeof(ubyte_names[0]),{UNSIGNED_TEST(1),1}},

{word_names,sizeof(word_names)/sizeof(word_names[0]),{SIGNED_TEST(2),2}},

{uword_names,sizeof(uword_names)/sizeof(uword_names[0]),{UNSIGNED_TEST(2),2}},

{word2_names,sizeof(word2_names)/sizeof(word2_names[0]),{SIGNED_TEST(4),4}},

{uword2_names,sizeof(uword2_names)/sizeof(uword2_names[0]),{UNSIGNED_TEST(4),4}},

{word4_names,sizeof(word4_names)/sizeof(word4_names[0]),{SIGNED_TEST(8),8}},

{uword4_names,sizeof(uword4_names)/sizeof(uword4_names[0]),{UNSIGNED_TEST(8),8}},

{float_names,sizeof(float_names)/sizeof(float_names[0]),{FLOAT_TEST(4),4}},

{float2_names,sizeof(float2_names)/sizeof(float2_names[0]),{FLOAT_TEST(8),8}}

};

int df_no_bin_cols; /* binary columns to read */

df_binary_tables_struct df_binary_tables[] = {

{df_binary_details,sizeof(df_binary_details)/sizeof(df_binary_details[0])},

{df_binary_details_independent,sizeof(df_binary_details_independent)/sizeof(df_binary_details_independent[0])}

};

static df_column_bininfo_struct *df_column_bininfo = NULL; /* allocate space as needed */

static int df_max_bininfo_cols = 0; /* space allocated */

static const char *matrix_general_binary_conflict_msg

= "Conflict between some matrix binary and general binary keywords";

df_init()

{

if (max_line_len < DATA_LINE_BUFSIZ) {

max_line_len = DATA_LINE_BUFSIZ;

df_line = gp_alloc(max_line_len, "datafile line buffer");

}

}

static char *

df_gets()

{

/* HBB 20000526: prompt user for inline data, if in interactive mode */

if (mixed_data_fp && interactive)

fputs("input data ('e' ends) > ", stderr);

/* Special pseudofiles '+' and '++' return coords of sample */

if (df_pseudodata)

return df_generate_pseudodata();

if (df_datablock)

return *(df_datablock_line++);

if (df_array)

return df_generate_ascii_array_entry();

return df_fgets(data_fp);

}

char *

df_fgets( FILE *fin )

{

int len = 0;

if (!fgets(df_line, max_line_len, fin))

return NULL;

if (mixed_data_fp)

++inline_num;

for (;;) {

len += strlen(df_line + len);

if (len > 0 && df_line[len - 1] == '\n') {

/* we have read an entire text-file line.

df_line[len - 1] = 0;

return df_line;

}

if ((max_line_len - len) < 32)

df_line = gp_realloc(df_line, max_line_len *= 2, "datafile line buffer");

if (!fgets(df_line + len, max_line_len - len, fin))

return df_line; /* unexpected end of file, but we have something to do */

}

/* NOTREACHED */

return NULL;

}

static int

df_tokenise(char *s)

{

/* implement our own sscanf that takes 'missing' into account,

TBOOLEAN in_string;

int i;

/* "here data" lines may end in \n rather than \0. */

/* DOS/Windows lines may end in \r rather than \0. */

if (s[strlen(s)-1] == '\n' || s[strlen(s)-1] == '\r')

s[strlen(s)-1] = '\0';

for (i = 0; i<MAXDATACOLS; i++)

df_tokens[i] = NULL;

df_no_cols = 0;

while (*s) {

/* We may poke at 2 new fields before coming back here - make sure there is room */

if (df_max_cols <= df_no_cols + 2)

expand_df_column((df_max_cols < 20) ? df_max_cols+20 : 2*df_max_cols);

/* have always skipped spaces at this point */

df_column[df_no_cols].position = s;

in_string = FALSE;

/* Keep pointer to start of this token if user wanted it for

for (i = 0; i<MAXDATACOLS; i++) {

if (df_no_cols == use_spec[i].column-1) {

df_tokens[i] = s;

if (use_spec[i].expected_type == CT_STRING)

df_column[df_no_cols].good = DF_GOOD;

}

}

/* CSV files must accept numbers inside quotes also,

if (*s == '"' && df_separators != NULL) {

in_string = TRUE;

df_column[df_no_cols].position = ++s;

}

if (*s == '"') {

/* treat contents of a quoted string as single column */

in_string = !in_string;

df_column[df_no_cols].good = DF_STRINGDATA;

} else if (check_missing(s)) {

df_column[df_no_cols].good = DF_MISSING;

df_column[df_no_cols].datum = not_a_number();

df_column[df_no_cols].position = NULL;

} else {

int used;

int count;

int dfncp1 = df_no_cols + 1;

/* optimizations by Corey Satten, [email protected] */

/* only scanf the field if it is mentioned in one of the using specs */

if ((fast_columns == 0)

|| (df_no_use_specs == 0)

|| ((df_no_use_specs > 0)

&& (use_spec[0].column == dfncp1

|| (df_no_use_specs > 1

&& (use_spec[1].column == dfncp1

|| (df_no_use_specs > 2

&& (use_spec[2].column == dfncp1

|| (df_no_use_specs > 3

&& (use_spec[3].column == dfncp1

|| (df_no_use_specs > 4

&& (use_spec[4].column == dfncp1

|| df_no_use_specs > 5)

)

)

)

)

)

)

)

)

)

) {

/* Use strtod() because

char *next;

df_column[df_no_cols].datum = strtod(s, &next);

used = next - s;

count = (used) ? 1 : 0;

} else {

/* skip any space at start of column */

while (isspace((unsigned char) *s) && NOTSEP)

++s;

count = (*s && NOTSEP) ? 1 : 0;

/* skip chars to end of column */

used = 0;

if (df_separators != NULL && in_string) {

do

++s;

while (*s && *s != '"');

in_string = FALSE;

}

while (!isspace((unsigned char) *s)

&& (*s != NUL) && NOTSEP)

++s;

}

/* it might be a fortran double or quad precision.

if (df_fortran_constants && count == 1 &&

(s[used] == 'd' || s[used] == 'D' ||

s[used] == 'q' || s[used] == 'Q')) {

/* HBB 20001221: avoid breaking parsing of time/date

char *endptr;

char save_char = s[used];

/* might be fortran double */

s[used] = 'e';

/* and try again */

df_column[df_no_cols].datum = strtod(s, &endptr);

count = (endptr == s) ? 0 : 1;

s[used] = save_char;

}

df_column[df_no_cols].good = count == 1 ? DF_GOOD : DF_BAD;

if (isnan(df_column[df_no_cols].datum)) {

df_column[df_no_cols].good = DF_UNDEFINED;

FPRINTF((stderr,"NaN in column %d\n", df_no_cols));

}

}

++df_no_cols;

/* If we are in a quoted string, skip to end of quote */

if (in_string) {

do

s++;

while (*s && (unsigned char) *s != '"');

}

/* skip to 1st character in the next field */

if (df_separators != NULL && !df_array) {

/* skip to next separator or end of line */

while ((*s != '\0') && (*s != '\n') && NOTSEP)

++s;

if ((*s == '\0') || (*s == '\n')) /* End of line; we're done */

break;

/* step over field separator */

++s;

/* skip whitespace at start of next field */

while ((*s == ' ' || *s == '\t') && NOTSEP)

++s;

if ((*s == '\0') || (*s == '\n')) { /* Last field is empty */

df_column[df_no_cols].good = DF_MISSING;

df_column[df_no_cols].datum = not_a_number();

df_column[df_no_cols].position = NULL;

++df_no_cols;

break;

}

} else {

/* skip trash chars remaining in this column */

while ((*s != '\0') && (*s != '\n') && !isspace((unsigned char) *s))

++s;

/* skip whitespace to start of next column */

while (isspace((unsigned char) *s) && *s != '\n')

++s;

}

}

return df_no_cols;

}

static double *

df_read_matrix(int *rows, int *cols)

{

int max_rows = 0;

int c;

double *linearized_matrix = NULL;

char *s;

int index = 0;

df_bad_matrix_values = 0;

*rows = 0;

*cols = 0;

for (;;) {

if (!(s = df_gets())) {

df_eof = 1;

/* NULL if we have not read anything yet */

return linearized_matrix;

}

/* skip leading spaces */

while (isspace((unsigned char) *s) && NOTSEP)

++s;

/* skip blank lines and comments */

if (!*s || is_comment(*s)) {

/* except that some comments hide an index name */

if (indexname) {

while (is_comment(*s) || isspace((unsigned char)*s))

++s;

if (*s && !strncmp(s, indexname, strlen(indexname)))

index_found = TRUE;

}

/* This whole section copied with minor tweaks from df_readascii() */

if (++blank_count == 1) {

/* first blank line */

if (linearized_matrix)

return linearized_matrix;

if (indexname && !index_found)

continue;

if (df_current_index < df_lower_index)

continue;

}

if (blank_count == 2) {

/* just reached the end of a data block */

++df_current_index;

if (indexname && index_found) {

df_eof = 1;

return linearized_matrix;

}

if (df_current_index <= df_lower_index)

continue;

if (df_current_index > df_upper_index) {

df_eof = 1;

return linearized_matrix;

}

} else {

/* Ignore any blank lines beyond the 2nd */

continue;

}

}

/* get here => was not blank */

df_last_index_read = df_current_index;

/* TODO: Handle columnheaders for 2nd and subsequent data blocks?

blank_count = 0;

if (mixed_data_fp && is_EOF(*s)) {

df_eof = 1;

return linearized_matrix;

}

c = df_tokenise(s);

if (!c)

return linearized_matrix;

/* If the first row of matrix data contains column headers */

if (!df_already_got_headers && df_matrix_columnheaders && *rows == 0) {

int i;

char *temp_string;

df_already_got_headers = TRUE;

for (i = (df_matrix_rowheaders ? 1 :0); i < c; i++) {

double xpos = df_matrix_rowheaders ? (i-1) : i;

if (use_spec[0].at) {

struct value a;

df_column[0].datum = xpos;

df_column[0].good = DF_GOOD;

evaluate_inside_using = TRUE;

evaluate_at(use_spec[0].at, &a);

evaluate_inside_using = FALSE;

xpos = real(&a);

}

temp_string = df_parse_string_field(df_column[i].position);

add_tic_user(&axis_array[FIRST_X_AXIS], temp_string, xpos, -1);

free(temp_string);

}

continue;

}

if (*cols && c != *cols) {

/* it's not regular */

if (linearized_matrix)

free(linearized_matrix);

int_error(NO_CARET, "Matrix does not represent a grid");

}

*cols = c;

++*rows;

if (*rows > max_rows) {

max_rows = GPMAX(2*max_rows,1);

linearized_matrix = gp_realloc(linearized_matrix,

*cols * max_rows * sizeof(double),

"df_matrix");

}

/* store data */

{

int i;

for (i = 0; i < c; ++i) {

/* First column in "matrix rowheaders" is a ytic label */

if (df_matrix_rowheaders && i == 0) {

char *temp_string;

double ypos = *rows - 1;