/* GNUPLOT - datafile.c */
/*[
* Copyright 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley
*
* Permission to use, copy, and distribute this software and its
* documentation for any purpose with or without fee is hereby granted,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.
*
* Permission to modify the software is granted, but not the right to
* distribute the complete modified source code. Modifications are to
* be distributed as patches to the released version. Permission to
* distribute binaries produced by compiling modified sources is granted,
* provided you
* 1. distribute the corresponding source modifications from the
* released version in the form of a patch file along with the binaries,
* 2. add special version identification to distinguish your version
* in addition to the base release version number,
* 3. provide your name and address as the primary contact for the
* support of your modified version, and
* 4. retain our contact information in regard to use of the base
* software.
* Permission to distribute the released version of the source code along
* with corresponding source modifications in the form of a patch file is
* granted with same provisions 2 through 4 for binary distributions.
*
* This software is provided "as is" without express or implied warranty
* to the extent permitted by applicable law.
]*/
/* AUTHOR : David Denholm */
/*
* this file provides the functions to handle data-file reading..
* takes care of all the pipe / stdin / index / using worries
*/
/*{{{ notes */
/*
* every a:b:c:d:e:f - plot every a'th point from c to e,
* in every b lines from d to f
* ie for (line=d; line=e; point+=a)
*
* public variables declared in this file.
* int df_no_use_specs - number of columns specified with 'using'
* int df_no_tic_specs - count of additional ticlabel columns
* int df_line_number - for error reporting
* int df_datum - increases with each data point
* int df_eof - end of file
*
* public information about the data file or format
* TBOOLEAN df_matrix - TRUE if splot matrix
* TBOOLEAN df_binary - binary data file format (maybe auto-generated)
*
* functions
* int df_open(char *file_name, int max_using, plot_header *plot)
* parses index / using on command line
* max_using is max no of 'using' columns allowed (obsolete?)
* plot_header is NULL if called from fit or set_palette code
* returns number of 'using' cols specified, or -1 on error (?)
*
* int df_readline(double vector[], int max)
* reads a line, does all the 'index' and 'using' manipulation
* deposits values into vector[]
* returns
* number of columns parsed [0 = not a blank line, but no valid data],
* DF_EOF - end of file
* DF_UNDEFINED - undefined result during eval of extended using spec
* DF_MISSING - requested column matched that of 'set missing '
* DF_FIRST_BLANK - first consecutive blank line
* DF_SECOND_BLANK - second consecutive blank line
* DF_FOUND_KEY_TITLE - only relevant to first line of data
* DF_KEY_TITLE_MISSING and only for 'set key autotitle columnhead'
* DF_STRINGDATA - not currently used by anyone
* DF_COLUMN_HEADERS - first row used as headers rather than data
*
* if a using spec was given, lines not fulfilling spec are ignored.
* we will always return exactly the number of items specified
*
* if no spec given, we return number of consecutive columns we parsed.
*
* if we are processing indexes, separated by 'n' blank lines,
* we will return n-1 blank lines before noticing the index change
*
* void df_close()
* closes a currently open file.
*
* void f_dollars(x)
* void f_column() actions for expressions using $i, column(j), etc
* void f_valid()
*
*
* Line parsing is slightly differently from previous versions of gnuplot...
* given a line containing fewer columns than asked for, gnuplot used to make
* up values... Now if I have explicitly said 'using 1:2:3', then if
* column 3 doesn't exist, I dont want this point...
*
*/
/*}}} */
/* Daniel Sebald: added general binary 2d data support. (20 August 2004)
*/
#include "datafile.h"
#include "datablock.h"
#include "alloc.h"
#include "command.h"
#include "eval.h"
#include "gp_time.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 "variable.h" /* For locale handling */
#include "voxelgrid.h"
/* test to see if the end of an inline datafile is reached */
#define is_EOF(c) ((c) == 'e' || (c) == 'E')
/* is it a comment line? */
#define is_comment(c) ((c) && (strchr(df_commentschars, (c)) != NULL))
/* Used to skip whitespace but not cross a field boundary */
#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 fns */
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);
/*}}} */
/*{{{ variables */
/* public (exported) variables client might access */
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) */
/* string representing missing values in ascii datafiles */
char *missing_val = NULL;
/* input field separators, NULL if whitespace is the separator */
char *df_separators = NULL;
/* comments chars */
char *df_commentschars = 0;
/* If any 'inline data' are in use for the current plot, flag this */
TBOOLEAN plotted_data_from_stdin = FALSE;
/* This flag is controlled by 'set/unset datafile columnheaders'.
* Even if it is FALSE, columnheader processing may still be triggered
* implicitly by use of the columheader function or keyword
* in a using spec or title.
*/
TBOOLEAN df_columnheaders = FALSE;
/* Setting this allows the parser to recognize Fortran D or Q */
/* format constants in the input file. But it slows things down */
TBOOLEAN df_fortran_constants = FALSE;
/* Setting this disables re-initialization of the floating point exception */
/* handler before every expression evaluation in a using spec. */
TBOOLEAN df_nofpe_trap = FALSE;
/* private variables */
/* Bookkeeping for df_fgets() and df_gets().
* Must be initialized before any calls to either function.
*/
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;
#endif
#if defined(HAVE_FDOPEN)
static int data_fd = -2; /* only used for file redirection */
#endif
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 */
#endif
/* stuff for implementing index */
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 */
/* stuff for named index support */
static char *indexname = NULL;
static TBOOLEAN index_found = FALSE;
static int df_longest_columnhead = 0;
/* stuff for every point:line */
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 */
/* for ascii file "skip" lines at head of file */
static int df_skip_at_front = 0;
/* for pseudo-data (1 if filename = '+'; 2 if filename = '++') */
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;
/* for datablocks */
static TBOOLEAN df_datablock = FALSE;
static char **df_datablock_line = NULL;
/* for arrays */
static int df_array_index = 0;
static char *df_arrayname = NULL;
/* track dimensions of input matrix/array/image */
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];
/* parsing stuff */
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;
/* rather than three arrays which all grow dynamically, make one
* dynamic array of this structure
*/
typedef struct df_column_struct {
double datum;
enum DF_STATUS good;
char *position; /* points to start of this field in current line */
char *header; /* points to copy of the header for this column */
} 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 */
/* These control the handling of fields in the first row of a data file.
* See also parse_1st_row_as_headers.
*/
#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 */
/* last resort mechanism to catch missing data */
static TBOOLEAN df_missing_data_in_expression = FALSE;
/* Binary *read* variables used by df_readbinary().
* There is a confusing difference between the ascii and binary "matrix" keywords.
* Ascii matrix data by default is interpreted as having an implicit uniform grid
* of x and y coords that are not actually present in the data file.
* The equivalent binary data format is called "binary general".
* In both of these cases the internal flag df_nonuniform_matrix is FALSE;
* Binary matrix data contains explicit y values in the first row, and explicit x
* values in the first column. This is signalled by "binary matrix".
* In this case the internal flag df_nonuniform_matrix is TRUE.
*
* EAM May 2011 - Add a keyword "nonuniform matrix" to indicate ascii matrix data
* in the same format as "binary matrix", i.e. with explicit x and y coordinates.
* EAM Jul 2014 - Add keywords "columnheaders" and "rowheaders" to indicate ascii
* matrix data in the uniform grid format containing labels in row 1 and column 1.
* EAM Jul 2021 - Add keyword "sparse matrix" to indicate ascii matrix data
* provided as individual entries (x y value) in any order.
*/
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_DELTA,
DF_FLIP_AXIS,
DF_FLIP,
DF_SCAN,
DF_ORIGIN,
DF_CENTER,
DF_ROTATION,
DF_PERPENDICULAR,
DF_SKIP
} 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
/* To generate a swap, take the bit-wise complement of the lowest two bits. */
typedef enum df_byte_read_order_type {
DF_0123,
DF_1032,
DF_2301,
DF_3210
} df_byte_read_order_type;
/* First argument, this program's endianess. Second argument, file's endianess.
* Don't use directly. Use 'byte_read_order()' function instead.*/
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 )
/* Argument is file's endianess type. */
static df_byte_read_order_type byte_read_order(df_endianess_type);
/* Logical variables indicating information about data file. */
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;
/* Initially set to default and then possibly altered by command line. */
df_binary_file_record_struct *df_bin_record = 0;
/* Default settings. */
df_binary_file_record_struct *df_bin_record_default = 0;
/* Settings that are transferred to default upon reset. */
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;
/* Used to mark the location of a blank line in the original data input file */
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
/* Initially set to default and then possibly altered by command line. */
static int df_bin_filetype;
/* Default setting. */
static int df_bin_filetype_default;
static df_endianess_type df_bin_file_endianess_default;
/* Setting that is transferred to default upon reset. */
static int df_bin_filetype_reset = -1;
#define DF_BIN_FILE_ENDIANESS_RESET THIS_COMPILER_ENDIAN
/* This one is needed by breaders.c */
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}}
};
/* Names for machine dependent field sizes. */
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"};
/* Machine independent names. */
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 {
char **name;
unsigned short no_names;
df_binary_type_struct type;
} 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])}
};
/* Information about binary data structure, to be determined by the
* using and format options. This should be one greater than df_no_bin_cols.
*/
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";
#endif
/*}}} */
/* Initialize input buffer used by df_gets and df_fgets. */
/* Called via reset_command() on program entry. */
void
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() */
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_gets() */
/*
* This one is shared by df_gets() and by datablock.c:datablock_command
*/
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.
* Strip the trailing linefeed and return
*/
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,
* and can understand fortran quad format
*/
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 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)
)
)
)
)
)
)
)
)
)
) {
/* This was the [slow] code used through version 4.0
* count = sscanf(s, "%lf%n", &df_column[df_no_cols].datum, &used);
*/
/* Use strtod() because
* - it is faster than sscanf()
* - sscanf(... %n ...) may not be portable
* - it allows error checking
* - atof() does not return a count or new position
*/
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.
* 'used' is only safe if count is 1
*/
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
* strings like 01Dec2000 that would be caused by
* overwriting the 'D' with an 'e'... */
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) {
/* 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_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() */
/* Reads a matrix from a text file and stores it in allocated memory.
*
* IMPORTANT NOTE: The routine returns the memory pointer for that matrix,
* but does not retain the pointer. Maintenance of the memory is left to
* the calling code.
*/
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_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?
* if (blank_count >= 2) { do something }
*/
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;
if (use_spec[1].at) {
/* The save/restore is to make sure 1:(f($2)):3 works */
struct value a;
double save = df_column[1].datum;
df_column[1].datum = ypos;
evaluate_inside_using = TRUE;
evaluate_at(use_spec[1].at, &a);
evaluate_inside_using = FALSE;
ypos = real(&a);
df_column[1].datum = save;
}
temp_string = df_parse_string_field(df_column[0].position);
add_tic_user(&axis_array[FIRST_Y_AXIS], temp_string, ypos, -1);
free(temp_string);
continue;
}
if (i < firstpoint && df_column[i].good != DF_GOOD) {
/* It's going to be skipped anyhow, so... */
linearized_matrix[index++] = 0;
} else
linearized_matrix[index++] = df_column[i].datum;
if (df_column[i].good != DF_GOOD) {
if (df_nonuniform_matrix && index == 1)
/* This field is typically a label or comment */
;
else if (df_bad_matrix_values++ == 0)
int_warn(NO_CARET,"matrix contains missing or undefined values");
}
}
}
}
}
/*}}} */
static void
initialize_use_spec()
{
int i;
df_no_use_specs = 0;
for (i = 0; i < MAXDATACOLS; ++i) {
use_spec[i].column = i + 1; /* default column */
use_spec[i].expected_type = CT_DEFAULT; /* no particular expectation */
if (use_spec[i].at) {
free_at(use_spec[i].at);
use_spec[i].at = NULL; /* no expression */
}
use_spec[i].depends_on_column = -1; /* we don't know of any dependence */
df_axis[i] = NO_AXIS; /* no timefmt for this output column */
}
}
static void
initialize_plot_style(struct curve_points *plot)
{
int save_token = c_token;
if (!plot)
return;
for ( ; !END_OF_COMMAND; c_token++)
if (almost_equals(c_token, "w$ith")) {
plot->plot_style = get_style();
break;
}
c_token = save_token;
}
/*{{{ int df_open(char *file_name, int max_using, plot_header *plot) */
/* open file, parsing using/index stuff return number of using
* specs [well, we have to return something !]
*/
int
df_open(const char *cmd_filename, int max_using, struct curve_points *plot)
{
int name_token = c_token - 1;
TBOOLEAN duplication = FALSE;
TBOOLEAN set_index = FALSE, set_skip = FALSE;
TBOOLEAN set_using = FALSE;
TBOOLEAN set_matrix = FALSE;
fast_columns = 1; /* corey@cac */
/* close file if necessary */
if (data_fp) {
df_close();
data_fp = NULL;
}
free(df_format);
df_format = NULL; /* no format string */
df_no_tic_specs = 0;
free(df_key_title);
df_key_title = NULL;
initialize_use_spec();
clear_df_column_headers();
df_datum = -1; /* it will be preincremented before use */
df_line_number = 0; /* ditto */
df_lower_index = 0;
df_index_step = 1;
df_upper_index = MAXINT;
free(indexname);
indexname = NULL;
df_current_index = 0;
df_last_index_read = 0;
blank_count = 2;
/* by initialising blank_count, leading blanks will be ignored */
set_every = FALSE;
everypoint = everyline = 1; /* unless there is an every spec */
firstpoint = firstline = 0;
lastpoint = lastline = MAXINT;
df_binary_file = df_matrix_file = FALSE;
df_pixeldata = NULL;
df_num_bin_records = 0;
df_matrix = FALSE;
df_nonuniform_matrix = FALSE;
df_sparse_matrix = FALSE;
df_matrix_columnheaders = FALSE;
df_matrix_rowheaders = FALSE;
df_skip_at_front = 0;
df_xpixels = 0;
df_ypixels = 0;
df_transpose = FALSE;
df_voxelgrid = FALSE;
df_eof = 0;
/* Save for use by df_readline(). */
/* Perhaps it should be a parameter to df_readline? */
df_current_plot = plot;
/* If either 'set datafile columnhead' or 'set key autotitle columnhead'
* is in effect we always treat the * first data row as non-data
* (df_readline() will return DF_COLUMN_HEADERS rather than the column count).
* This is true even if the key is off or the data is read from 'stats'
* or from 'fit' rather than plot.
*/
column_for_key_title = NO_COLUMN_HEADER;
df_already_got_headers = FALSE;
if ((&keyT)->auto_titles == COLUMNHEAD_KEYTITLES)
parse_1st_row_as_headers = TRUE;
else if (df_columnheaders)
parse_1st_row_as_headers = TRUE;
else
parse_1st_row_as_headers = FALSE;
if (!cmd_filename)
int_error(c_token, "missing filename");
if (!cmd_filename[0]) {
if (!df_filename || !*df_filename)
int_error(c_token-1, "No previous filename");
if (!strcmp(df_filename,"@@") && df_arrayname) {
df_array = get_udv_by_name(df_arrayname);
if (df_array->udv_value.type != ARRAY)
int_error(c_token-1, "Array %s invalid", df_arrayname);
}
} else if (cmd_filename[0] == '$' && get_vgrid_by_name(cmd_filename)) {
/* The rest of the df_open() processing is not relevant */
df_voxelgrid = TRUE;
return(1);
} else {
free(df_filename);
df_filename = gp_strdup(cmd_filename);
}
/* defer opening until we have parsed the modifiers... */
/* pm 25.11.2001 allow any order of options */
while (!END_OF_COMMAND) {
/* look for binary / matrix */
if (almost_equals(c_token, "bin$ary")) {
if (df_filename[0] == '@')
int_error(c_token, "an array is not a binary file");
if (df_filename[0] == '$')
int_error(c_token, "data blocks cannot be binary");
if (!strcmp(df_filename,"+") || !strcmp(df_filename,"++"))
int_error(c_token, "pseudofiles '+' and '++' cannot be binary");
c_token++;
if (df_binary_file || set_skip) {
duplication=TRUE;
break;
}
gp_expand_tilde(&df_filename);
df_binary_file = TRUE;
/* Up to the time of adding the general binary code, only matrix
* binary for 3d was defined. So, use matrix binary by default.
*/
df_matrix_file = TRUE;
initialize_binary_vars();
plot_option_binary(set_matrix, FALSE);
continue;
}
/* deal with matrix */
if (almost_equals(c_token, "mat$rix")) {
c_token++;
if (set_matrix) {
duplication=TRUE;
break;
}
/* `binary` default is both df_matrix_file and df_binary_file.
* So if df_binary_file is true, but df_matrix_file isn't, then
* some keyword specific to general binary has been given.
*/
if (!df_matrix_file && df_binary_file)
int_error(c_token, matrix_general_binary_conflict_msg);
df_matrix_file = TRUE;
set_matrix = TRUE;
fast_columns = 0;
continue;
}
/* May 2011 - "nonuniform matrix" indicates an ascii data file
* with the same row/column layout as "binary matrix" */
if (almost_equals(c_token, "nonuni$form")) {
c_token++;
df_matrix_file = TRUE;
df_nonuniform_matrix = TRUE;
fast_columns = 0;
if (df_sparse_matrix || df_matrix_rowheaders || df_matrix_columnheaders)
duplication = TRUE;
continue;
}
/* Jul 2021 - "sparse matrix" indicates an ascii data file
* with individual [x y value] triples in any order
*/
if (equals(c_token, "sparse")) {
c_token++;
df_matrix_file = FALSE;
df_sparse_matrix = TRUE;
if (df_nonuniform_matrix || df_matrix_rowheaders || df_matrix_columnheaders)
duplication = TRUE;
else
plot_option_sparse();
if (plot)
plot->image_properties.fallback = TRUE;
continue;
}
/* "matrix columnheaders" indicates an ascii data file
* in uniform grid format but with column labels in row 1
*/
if (almost_equals(c_token, "columnhead$ers")) {
c_token++;
df_matrix_file = TRUE;
df_matrix_columnheaders = TRUE;
if (df_nonuniform_matrix || !set_matrix)
duplication = TRUE;
continue;
}
/* "matrix rowheaders" indicates an ascii data file
* in uniform grid format but with row labels in column 1
*/
if (almost_equals(c_token, "rowhead$ers")) {
c_token++;
df_matrix_file = TRUE;
df_matrix_rowheaders = TRUE;
if (df_nonuniform_matrix || !set_matrix)
duplication = TRUE;
continue;
}
/* deal with index */
if (almost_equals(c_token, "i$ndex")) {
if (set_index) { duplication=TRUE; break; }
plot_option_index();
set_index = TRUE;
continue;
}
/* deal with every */
if (almost_equals(c_token, "ev$ery")) {
if (set_every) { duplication=TRUE; break; }
plot_option_every();
set_every = TRUE;
continue;
}
/* deal with skip */
if (equals(c_token, "skip")) {
if (set_skip || df_binary_file) { duplication=TRUE; break; }
set_skip = TRUE;
c_token++;
df_skip_at_front = int_expression();
if (df_skip_at_front < 0)
df_skip_at_front = 0;
continue;
}
/* deal with using */
if (almost_equals(c_token, "u$sing")) {
if (set_using) { duplication=TRUE; break; }
plot_option_using(max_using);
set_using = TRUE;
continue;
}
/* deal with volatile */
if (almost_equals(c_token, "volatile")) {
c_token++;
volatile_data = TRUE;
continue;
}
/* Allow this plot not to affect autoscaling */
if (almost_equals(c_token, "noauto$scale")) {
c_token++;
if (plot)
plot->noautoscale = TRUE;
continue;
}
/* zsort filter will be applied to this data */
if (equals(c_token, "zsort")) {
c_token++;
plot->plot_filter = FILTER_ZSORT;
continue;
}
break; /* unknown option */
} /* while (!END_OF_COMMAND) */
if (duplication)
int_error(c_token,
"duplicated or contradicting arguments in datafile options");
/* Check for auto-generation of key title from column header */
if ((&keyT)->auto_titles == COLUMNHEAD_KEYTITLES) {
if (df_no_use_specs == 1)
column_for_key_title = use_spec[0].column;
else if (plot && plot->plot_style == HISTOGRAMS)
column_for_key_title = use_spec[0].column;
else if (plot && plot->plot_type == DATA3D)
column_for_key_title = use_spec[2].column;
else
column_for_key_title = use_spec[1].column;
}
/*{{{ more variable inits */
point_count = -1; /* we preincrement */
line_count = 0;
df_pseudodata = 0;
df_pseudorecord = 0;
df_pseudospan = 0;
df_datablock = FALSE;
df_datablock_line = NULL;
df_tabulate_strings = FALSE;
if (plot) {
/* Save the matrix/array/image dimensions for binary image plot styles */
plot->image_properties.ncols = df_xpixels;
plot->image_properties.nrows = df_ypixels;
FPRINTF((stderr,"datafile.c:%d (ncols,nrows) set to (%d,%d)\n", __LINE__,
df_xpixels, df_ypixels));
if (set_every && df_xpixels && df_ypixels) {
plot->image_properties.ncols = 1 +
((int)(GPMIN(lastpoint,df_xpixels-1)) - firstpoint) / everypoint;
plot->image_properties.nrows = 1 +
((int)(GPMIN(lastline,df_ypixels-1)) - firstline) / everyline;
FPRINTF((stderr,"datafile.c:%d adjusting to (%d, %d)\n", __LINE__,
plot->image_properties.ncols, plot->image_properties.nrows));
}
if (df_transpose) {
unsigned int temp = plot->image_properties.ncols;
plot->image_properties.ncols = plot->image_properties.nrows;
plot->image_properties.nrows = temp;
FPRINTF((stderr,"datafile.c:%d adjusting to (%d, %d)\n", __LINE__,
plot->image_properties.ncols, plot->image_properties.nrows));
}
}
/*}}} */
/*{{{ open file */
#if defined(HAVE_FDOPEN)
if (*df_filename == 'image_properties.ncols = df_xpixels;
plot->image_properties.nrows = df_ypixels;
}
}
}
/* General binary, matrix binary and ASCII matrix all use the
* df_readbinary() routine.
*/
if (df_binary_file || df_matrix_file) {
df_read_binary = TRUE;
adjust_binary_use_spec(plot);
} else {
df_read_binary = FALSE;
}
/* Make information about whether the data forms a grid or not
* available to the outside world. */
df_matrix = (df_matrix_file
|| ((df_num_bin_records == 1)
&& ((df_bin_record[0].cart_dim[1] > 0)
|| (df_bin_record[0].scan_dim[1] > 0))));
return df_no_use_specs;
}
/*}}} */
/*{{{ void df_close() */
void
df_close()
{
int i;
/* paranoid - mark $n and column(n) as invalid */
df_no_cols = 0;
if (!data_fp && !df_datablock)
return;
/* free any use expression storage */
for (i = 0; i < MAXDATACOLS; ++i)
if (use_spec[i].at) {
free_at(use_spec[i].at);
use_spec[i].at = NULL;
}
/* free binary matrix data */
if (df_matrix) {
for (i = 0; i < df_num_bin_records; i++) {
free(df_bin_record[i].memory_data);
df_bin_record[i].memory_data = NULL;
}
}
if (!mixed_data_fp && !df_datablock) {
#if defined(HAVE_FDOPEN)
if (data_fd == fileno(data_fp)) {
/* This will allow replotting if this stream is backed by a file,
* and hopefully is harmless if it connects to a pipe.
* Leave it open in either case.
*/
rewind(data_fp);
fprintf(stderr,"Rewinding fd %d\n", data_fd);
} else
#endif
#if defined(PIPES)
if (df_pipe_open) {
(void) pclose(data_fp);
df_pipe_open = FALSE;
} else
#endif /* PIPES */
(void) fclose(data_fp);
}
mixed_data_fp = FALSE;
data_fp = NULL;
}
/*}}} */
/*{{{ void df_showdata() */
/* display the current data file line for an error message
*/
void
df_showdata()
{
if (data_fp && df_filename && df_line) {
/* display no more than 77 characters */
fprintf(stderr, "%.77s%s\n%s:%d:", df_line,
(strlen(df_line) > 77) ? "..." : "",
df_filename, df_line_number);
}
}
/*}}} */
static void
plot_option_every()
{
fast_columns = 0; /* corey@cac */
/* allow empty fields - every a:b:c::e we have already established
* the defaults */
if (!equals(++c_token, ":")) {
everypoint = int_expression();
if (everypoint < 0) everypoint = 1;
else if (everypoint < 1)
int_error(c_token, "Expected positive integer");
}
/* if it fails on first test, no more tests will succeed. If it
* fails on second test, next test will succeed with correct
* c_token */
if (equals(c_token, ":") && !equals(++c_token, ":")) {
everyline = int_expression();
if (everyline < 0) everyline = 1;
else if (everyline < 1)
int_error(c_token, "Expected positive integer");
}
if (equals(c_token, ":") && !equals(++c_token, ":")) {
firstpoint = int_expression();
if (firstpoint < 0) firstpoint = 0;
}
if (equals(c_token, ":") && !equals(++c_token, ":")) {
firstline = int_expression();
if (firstline < 0) firstline = 0;
}
if (equals(c_token, ":") && !equals(++c_token, ":")) {
lastpoint = int_expression();
if (lastpoint < 0) lastpoint = MAXINT;
else if (lastpoint < firstpoint)
int_error(c_token, "Last point must not be before first point");
}
if (equals(c_token, ":")) {
++c_token;
lastline = int_expression();
if (lastline < 0) lastline = MAXINT;
else if (lastline < firstline)
int_error(c_token, "Last line must not be before first line");
}
}
static void
plot_option_index()
{
if (df_binary_file && df_matrix_file)
int_error(c_token, "Binary matrix file format does not allow more than one surface per file");
++c_token;
/* Check for named index */
if ((indexname = try_to_get_string())) {
index_found = FALSE;
return;
}
/* Numerical index list */
df_lower_index = int_expression();
if (df_lower_index < 0)
int_error(c_token, "index must be non-negative");
if (equals(c_token, ":")) {
++c_token;
if (equals(c_token, ":")) {
df_upper_index = MAXINT; /* If end index not specified */
} else {
df_upper_index = int_expression();
if (df_upper_index < df_lower_index)
int_error(c_token, "Upper index should be bigger than lower index");
}
if (equals(c_token, ":")) {
++c_token;
df_index_step = int_expression();
if (df_index_step < 1)
int_error(c_token, "Index step must be positive");
}
} else {
df_upper_index = df_lower_index;
}
}
static void
plot_option_using(int max_using)
{
int no_cols = 0; /* For general binary only. */
char *column_label;
/* The filetype function may have set the using specs, so reset
* them before processing tokens. */
if (df_binary_file)
initialize_use_spec();
/* Try to distinguish between 'using "A":"B"' and 'using "%lf %lf" */
if (!END_OF_COMMAND && isstring(++c_token)) {
int save_token = c_token;
df_format = try_to_get_string();
if (valid_format(df_format))
return;
free(df_format);
df_format = NULL;
c_token = save_token;
}
if (!END_OF_COMMAND) {
do { /* must be at least one */
if (df_no_use_specs >= MAXDATACOLS)
int_error(c_token, "at most %d columns allowed in using spec", MAXDATACOLS);
if (df_no_use_specs >= max_using)
int_error(c_token, "Too many columns in using specification");
if (equals(c_token, ":")) {
/* empty specification - use default */
use_spec[df_no_use_specs].column = df_no_use_specs;
if (df_no_use_specs > no_cols)
no_cols = df_no_use_specs;
++df_no_use_specs;
/* do not increment c+token ; let while() find the : */
} else if (equals(c_token, "(")) {
int i;
struct use_spec_s *spec = &use_spec[df_no_use_specs];
fast_columns = 0; /* corey@cac */
dummy_func = NULL; /* no dummy variables active */
at_highest_column_used = NO_COLUMN_HEADER;
spec->at = perm_at();
if (no_cols < at_highest_column_used)
no_cols = at_highest_column_used;
/* An imperfect test for dependence on particular columns
* so that we do not try to evaluate this expression if a
* column it refers to contains a "missing value" placeholder.
*/
for (i = 0; i < spec->at->a_count; i++) {
if (spec->at->actions[i].index == DOLLARS)
spec->depends_on_column = (int)spec->at->actions[i].arg.v_arg.v.int_val;
if ((spec->at->actions[i].index == COLUMN)
&& (spec->at->actions[i-1].index == PUSHC)
&& (spec->at->actions[i-1].arg.v_arg.type == INTGR))
spec->depends_on_column = (int)spec->at->actions[i-1].arg.v_arg.v.int_val;
}
/* Catch at least the simplest case of 'autotitle columnhead' using an expression */
spec->column = at_highest_column_used;
df_no_use_specs++;
/* It would be nice to handle these like any other */
/* internal function via perm_at() but it doesn't work. */
} else if (almost_equals(c_token, "xtic$labels")) {
plot_ticlabel_using(CT_XTICLABEL);
} else if (almost_equals(c_token, "x2tic$labels")) {
plot_ticlabel_using(CT_X2TICLABEL);
} else if (almost_equals(c_token, "ytic$labels")) {
plot_ticlabel_using(CT_YTICLABEL);
} else if (almost_equals(c_token, "y2tic$labels")) {
plot_ticlabel_using(CT_Y2TICLABEL);
} else if (almost_equals(c_token, "ztic$labels")) {
plot_ticlabel_using(CT_ZTICLABEL);
} else if (almost_equals(c_token, "cbtic$labels")) {
plot_ticlabel_using(CT_CBTICLABEL);
} else if (almost_equals(c_token, "key")) {
plot_ticlabel_using(CT_KEYLABEL);
} else if ((column_label = try_to_get_string())) {
/* ...using "A"... Dummy up a call to column(column_label) */
use_spec[df_no_use_specs].at = create_call_column_at(column_label);
use_spec[df_no_use_specs++].column = NO_COLUMN_HEADER;
parse_1st_row_as_headers = TRUE;
fast_columns = 0;
/* FIXME - is it safe to always take the title from the 2nd use spec? */
if (df_no_use_specs == 2) {
free(df_key_title);
df_key_title = gp_strdup(column_label);
}
} else {
int col = int_expression();
if (col < -2)
int_error(c_token, "Column must be >= -2");
use_spec[df_no_use_specs++].column = col;
/* Supposedly only happens for binary files, but don't bet on it */
if (col > no_cols)
no_cols = col;
}
} while (equals(c_token, ":") && ++c_token);
}
if (df_binary_file) {
/* If the highest user column number is greater than number of binary
* columns, set the uninitialized columns binary info to that of the last
* specified column or the default.
*/
df_extend_binary_columns(no_cols);
}
/* Allow a format specifier after the enumeration of columns. */
/* Note: This was left out by mistake in versions 4.6.0 + 4.6.1 */
if (!END_OF_COMMAND && isstring(c_token)) {
df_format = try_to_get_string();
if (!valid_format(df_format))
int_error(c_token, "format must have 1-7 conversions of type double (%%lf)");
}
}
static void
plot_ticlabel_using(int axis)
{
int col = 0;
c_token ++;
if (!equals(c_token,"("))
int_error(c_token, "missing '('");
c_token++;
/* FIXME: What we really want is a test for a constant expression as */
/* opposed to a dummy expression. This is similar to the problem with */
/* with parsing the first argument of the plot command itself. */
if (isanumber(c_token) || type_udv(c_token)==INTGR) {
col = int_expression();
use_spec[df_no_use_specs+df_no_tic_specs].at = NULL;
} else {
use_spec[df_no_use_specs+df_no_tic_specs].at = perm_at();
fast_columns = 0; /* Force all columns to be evaluated */
col = 1; /* Redundant because of the above */
}
if (col < 1)
int_error(c_token, "ticlabels must come from a real column");
if (!equals(c_token,")"))
int_error(c_token, "missing ')'");
c_token++;
use_spec[df_no_use_specs+df_no_tic_specs].expected_type = axis;
use_spec[df_no_use_specs+df_no_tic_specs].column = col;
df_no_tic_specs++;
}
/*{{{ int df_readline(v, max) */
int
df_readline(double v[], int max)
{
if (!data_fp && !df_pseudodata && !df_datablock && !df_array)
return DF_EOF;
if (df_read_binary) {
/* General binary, matrix binary or matrix ascii converted to binary */
return df_readbinary(v, max);
} else {
return df_readascii(v, max);
}
}
/*}}} */
/* do the hard work... read lines from file,
* - use blanks to get index number
* - ignore lines outside range of indices required
* - fill v[] based on using spec if given
*/
int
df_readascii(double v[], int max)
{
char *s;
int return_value = DF_GOOD;
/* Version 5.3
* Some plot styles (e.g. PARALLELPLOT) must guarantee that every line
* of data will return some input value even if it is missing or bad.
* This flag will force the line to return NaN rather than being skipped.
* FIXME: it would be better to make this flag generic and set before entry.
*/
TBOOLEAN df_bad_returns_NaN
= (df_current_plot
&& (df_current_plot->plot_style == PARALLELPLOT
|| df_current_plot->plot_style == TABLESTYLE));
assert(max = 0)
return DF_EOF;
/*{{{ process line */
while ((s = df_gets()) != NULL) {
TBOOLEAN line_okay = TRUE;
int output = 0; /* how many numbers written to v[] */
return_value = DF_GOOD;
/* "skip" option */
if (df_skip_at_front > 0) {
df_skip_at_front--;
continue;
}
++df_line_number;
df_no_cols = 0;
/*{{{ check for blank lines, and reject by index/every */
/*{{{ skip leading spaces */
while (isspace((unsigned char) *s) && NOTSEP)
++s; /* will skip the \n too, to point at \0 */
/*}}} */
/*{{{ skip comments */
if (is_comment(*s)) {
if (indexname) { /* Look for index name in comment */
while (is_comment(*s) || isspace((unsigned char)*s))
++s;
if (*s && !strncmp(s, indexname, strlen(indexname)))
index_found = TRUE;
}
continue; /* ignore comments */
}
/*}}} */
/*{{{ check EOF on mixed data */
if (mixed_data_fp && is_EOF(*s)) {
df_eof = 1; /* trap attempts to read past EOF */
return DF_EOF;
}
/*}}} */
/*{{{ its a blank line - update counters and continue or return */
if (*s == 0) {
/* argh - this is complicated ! we need to
* ignore it if we haven't reached first index
* report EOF if passed last index
* report blank line unless we've already done 2 blank lines
*
* - I have probably missed some obvious way of doing all this,
* but its getting late
*/
point_count = -1; /* restart counter within line */
if (++blank_count == 1) {
/* first blank line */
++line_count;
}
/* just reached end of a group/surface */
if (blank_count == 2) {
++df_current_index;
line_count = 0;
df_datum = -1;
/* Found two blank lines after a block of data with a named index */
if (indexname && index_found) {
df_eof = 1;
return DF_EOF;
}
/* start of a new data block that might have column headers */
if (((&keyT)->auto_titles == COLUMNHEAD_KEYTITLES)
|| (df_columnheaders)) {
parse_1st_row_as_headers = TRUE;
df_already_got_headers = FALSE;
}
/* ignore line if current_index has just become
* first required one - client doesn't want this
* blank line. While we're here, check for 0) {
if ((use_spec[output].depends_on_column > df_no_cols)
|| df_column[use_spec[output].depends_on_column-1].good == DF_MISSING) {
FPRINTF((stderr,
"df_readascii: skipping evaluation that uses missing value in $%d\n",
use_spec[output].depends_on_column));
v[output] = not_a_number();
return_value = DF_MISSING;
continue;
}
}
df_missing_data_in_expression = FALSE;
a.type = NOTDEFINED;
evaluate_inside_using = TRUE;
evaluate_at(use_spec[output].at, &a);
evaluate_inside_using = FALSE;
/* We tried to avoid evaluating this expression at all if its
* dependence on a data column N was obvious (e.g. 'using ($N)')
* and that column was seen to be missing from this input line.
* Here we check whether actual evaluation tripped over missing
* data values referenced indirectly (e.g. 'using (column($1))'.
*/
if (df_missing_data_in_expression) {
FPRINTF((stderr,
"df_readascii: hit missing data value during evaluation\n"));
v[output] = not_a_number();
return_value = DF_MISSING;
continue;
}
/* June 2018: CHANGE. For consistency with function plots, */
/* treat imaginary result as UNDEFINED. */
if (a.type == CMPLX && (fabs(imag(&a)) > zero) && !isnan(real(&a))) {
return_value = DF_COMPLEX_VALUE;
v[output] = not_a_number();
continue;
}
if (undefined) {
return_value = DF_UNDEFINED;
v[output] = not_a_number();
continue;
}
if ((df_axis[output] != NO_AXIS)
&& axis_array[df_axis[output]].datatype == DT_TIMEDATE)
timefield = TRUE;
if (timefield && (a.type != STRING)
&& !strcmp(timefmt,"%s")) {
/* Handle the case of timefmt "%s" which expects a string */
/* containing a number. If evaluate_at() above returned a */
/* bare number then we must convert it to a sting before */
/* falling through to the usual processing case. */
/* NB: We only accept time values of +/- 10^12 seconds. */
char *timestring = gp_alloc(20,"timestring");
sprintf(timestring,"%16.3f",real(&a));
a.type = STRING;
a.v.string_val = timestring;
}
if (a.type == STRING) {
v[output] = not_a_number(); /* found a string, not a number */
if (df_tabulate_strings) {
/* Save for TABLESTYLE */
df_strings[output].type = STRING;
df_strings[output].v.string_val = gp_strdup(a.v.string_val);
}
/* This string value will get parsed as if it were a data column */
/* so put it in quotes to allow embedded whitespace. */
if (use_spec[output].expected_type == CT_STRING) {
char *s = gp_alloc(strlen(a.v.string_val)+3,"quote");
*s = '"';
strcpy(s+1, a.v.string_val);
strcat(s, "\"");
free(df_stringexpression[output]);
df_tokens[output] = df_stringexpression[output] = s;
}
/* Check for timefmt string generated by a function */
if (timefield) {
struct tm tm;
double reltime;
double usec = 0.0;
td_type status
= gstrptime(a.v.string_val, timefmt, &tm, &usec, &reltime);
if (status == DT_TIMEDATE)
v[output] = (double) gtimegm(&tm) + usec;
else if (status == DT_DMS)
v[output] = reltime;
else
return_value = DF_BAD;
}
/* Expecting a numerical type but got a string value */
else
/* 'with points pt variable' is the only current user */
if (df_current_plot
&& (df_current_plot->lp_properties.p_type == PT_VARIABLE))
{
static char varchar[8];
safe_strncpy(varchar, a.v.string_val, 8);
df_tokens[output] = varchar;
}
gpfree_string(&a);
}
else {
v[output] = real(&a);
if (isnan(v[output]))
return_value = DF_UNDEFINED;
}
} else if (column == -2) {
v[output] = df_current_index;
} else if (column == -1) {
v[output] = line_count;
} else if (column == 0) {
v[output] = df_datum; /* using 0 */
} else if (column df_no_cols ||
df_column[column - 1].good == DF_MISSING ||
!df_column[column - 1].position ||
(status = gstrptime(df_column[column - 1].position,
timefmt, &tm, &usec, &reltime),
status == DT_BAD)
) {
/* line bad only if user explicitly asked for this column */
if (df_no_use_specs) {
line_okay = FALSE;
if (df_bad_returns_NaN) {
v[output] = not_a_number();
return DF_UNDEFINED;
}
}
/* return or ignore line depending on line_okay */
break;
}
if (status == DT_DMS)
v[output] = reltime;
else
v[output] = (double) gtimegm(&tm) + usec;
} else if (use_spec[output].expected_type == CT_STRING) {
/* Do nothing. */
/* String tokens were loaded into df_tokens already. */
} else {
/* column > 0 */
if ((column 0xFFFF)
read_order = DF_3210;
df_swap_bytes_by_endianess((char *) &M, read_order, 4);
if (!fread(&N, 4, 1, fp))
os_error(NO_CARET, "Can't read second dimension in data file \"%s\"", df_filename);
df_swap_bytes_by_endianess((char *) &N, read_order, 4);
fclose(fp);
df_matrix_file = FALSE;
df_binary_file = TRUE;
df_bin_record[0].scan_skip[0] = 8;
df_bin_record[0].scan_dim[0] = M;
df_bin_record[0].scan_dim[1] = N;
df_bin_record[0].scan_dir[0] = 1;
df_bin_record[0].scan_dir[1] = -1;
df_bin_record[0].scan_generate_coord = TRUE;
df_bin_record[0].cart_scan[0] = DF_SCAN_POINT;
df_bin_record[0].cart_scan[1] = DF_SCAN_LINE;
/* The four components are 1 byte each. Permute ARGB to RGBA */
df_extend_binary_columns(4);
df_set_read_type(1, DF_UCHAR);
df_set_read_type(2, DF_UCHAR);
df_set_read_type(3, DF_UCHAR);
df_set_read_type(4, DF_UCHAR);
df_set_skip_before(1,0);
df_no_use_specs = 4;
use_spec[0].column = 2;
use_spec[1].column = 3;
use_spec[2].column = 4;
use_spec[3].column = 1;
}
static void
initialize_binary_vars()
{
/* Initialize for the df_readline() routine. */
df_bin_record_count = 0;
df_M_count = df_N_count = df_O_count = 0;
/* Set default binary data widths and skip paratemers. */
df_no_bin_cols = 0;
df_set_skip_before(1, 0);
/* Copy the default binary records to the active binary records. The number
* of records will always be at least one in case "record", "array",
* or "filetype" are not issued by the user.
*/
clear_binary_records(DF_CURRENT_RECORDS);
if (df_num_bin_records_default) {
df_bin_filetype = df_bin_filetype_default;
df_bin_file_endianess = df_bin_file_endianess_default;
df_add_binary_records(df_num_bin_records_default, DF_CURRENT_RECORDS);
memcpy(df_bin_record, df_bin_record_default, df_num_bin_records*sizeof(df_binary_file_record_struct));
} else {
df_bin_filetype = df_bin_filetype_reset;
df_bin_file_endianess = DF_BIN_FILE_ENDIANESS_RESET;
df_add_binary_records(1, DF_CURRENT_RECORDS);
}
}
static char *too_many_cols_msg = "Too many columns in using specification and implied sampling array";
/* Place a special marker in the using list to derive the x/y/z value
* from the appropriate dimensional counter.
*/
void
df_insert_scanned_use_spec(int uspec)
{
/* Place a special marker in the using list to derive the z value
* from the third dimensional counter, which will be zero.
*/
if (df_no_use_specs >= MAXDATACOLS)
int_error(NO_CARET, too_many_cols_msg);
else {
int j;
for (j=df_no_use_specs; j > uspec; j--)
use_spec[j] = use_spec[j - 1];
use_spec[uspec].column = (uspec == 2 ? DF_SCAN_PLANE : DF_SCAN_LINE);
/* The at portion is set to NULL here, but this doesn't mash
* a valid memory pointer because any valid memory pointers
* were copied to new locations in the previous for loop.
*/
use_spec[uspec].at = NULL; /* Not a bad memory pointer overwrite!! */
df_no_use_specs++;
}
}
/* Not the most elegant way of defining the default columns, but I prefer
* this to switch and conditional statements when there are so many styles.
*/
typedef struct df_bin_default_columns {
PLOT_STYLE plot_style;
short excluding_gen_coords; /* Number of columns of information excluding generated coordinates. */
short dimen_in_2d; /* Number of additional columns required (in 2D plot) if coordinates not generated. */
} df_bin_default_columns;
df_bin_default_columns default_style_cols[] = {
{LINES, 1, 1},
{POINTSTYLE, 1, 1},
{IMPULSES, 1, 1},
{LINESPOINTS, 1, 1},
{DOTS, 1, 1},
{XERRORBARS, 2, 1},
{YERRORBARS, 2, 1},
{XYERRORBARS, 3, 1},
{BOXXYERROR, 3, 1},
{BOXES, 1, 1},
{BOXERROR, 3, 1},
{STEPS, 1, 1},
{FSTEPS, 1, 1},
{FILLSTEPS, 1, 1},
{HISTEPS, 1, 1},
{VECTOR, 2, 2},
{CANDLESTICKS, 4, 1},
{FINANCEBARS, 4, 1},
{BOXPLOT, 2, 1},
{XERRORLINES, 2, 1},
{YERRORLINES, 2, 1},
{XYERRORLINES, 3, 1},
{FILLEDCURVES, 1, 1},
{PM3DSURFACE, 1, 2},
{LABELPOINTS, 1, 1},
{HISTOGRAMS, 1, 0},
{IMAGE, 1, 2},
{RGBIMAGE, 3, 2},
{RGBA_IMAGE, 4, 2},
{CIRCLES, 2, 1},
{ELLIPSES, 2, 3},
{TABLESTYLE, 0, 0}
};
/* FIXME!!!
* EAM Feb 2008:
* This whole routine is a disaster. It makes so many broken assumptions it's not funny.
* Other than filling in the first two columns of an implicit matrix, I suspect we can
* do away with it altogether. Frankly, we _don't care_ how many columns there are,
* so long as the ones that are present are mapped to the right ordering.
*/
static void
adjust_binary_use_spec(struct curve_points *plot)
{
char *nothing_known = "a 'using' specifier is required for that binary plot style";
unsigned int ps_index;
enum PLOT_STYLE plot_style = plot ? plot->plot_style : LINES;
/* The default binary matrix format is nonuniform, i.e.
* it has an extra row and column for sample coordinates.
*/
if (df_matrix_file && df_binary_file)
df_nonuniform_matrix = TRUE;
/* Determine index. */
for (ps_index = 0; ps_index < sizeof(default_style_cols)/sizeof(default_style_cols[0]); ps_index++) {
if (default_style_cols[ps_index].plot_style == plot_style)
break;
}
/* A known default is all very well, but if there was an actual using spec
* that's all we need.
*/
if (ps_index == sizeof(default_style_cols)/sizeof(default_style_cols[0])
&& !df_no_use_specs)
int_error(NO_CARET, nothing_known);
/* Matrix format is interpreted as always having three columns. */
if (df_matrix_file) {
if (df_no_bin_cols > 3)
int_error(NO_CARET, "Matrix data contains only three columns");
df_extend_binary_columns(3);
}
/* If nothing has been done to set the using specs, use the default using
* characteristics for the style.
*/
if (!df_no_use_specs) {
if (!df_matrix_file) {
int no_cols = default_style_cols[ps_index].excluding_gen_coords;
if (!no_cols)
int_error(NO_CARET, nothing_known);
/* If coordinates are generated, make sure this plot style allows it.
* Otherwise, add in the number of generated coordinates and add an
* extra column if using `splot`.
*/
if (df_num_bin_records && df_bin_record[0].scan_generate_coord) {
if (default_style_cols[ps_index].dimen_in_2d == 0)
int_error(NO_CARET, "Cannot generate coords for that plot style");
} else {
/* If there aren't generated coordinates, then add the
* amount of columns that would be generated.
*/
no_cols += default_style_cols[ps_index].dimen_in_2d;
if (df_plot_mode == MODE_SPLOT)
no_cols++;
}
assert(no_cols 2)
int_error(NO_CARET, "Plot style requires higher than two-dimensional sampling array");
else {
if ((df_bin_record[k].cart_dim[1] == 0) && (df_bin_record[k].scan_dim[1] == 0)) {
if (default_style_cols[ps_index].dimen_in_2d > 1)
int_error(NO_CARET, "Plot style requires higher than one-dimensional sampling array");
else {
/* Place a special marker in the using list to derive the y value
* from the second dimensional counter.
*/
df_insert_scanned_use_spec(1);
}
}
/* Place a special marker in the using list to derive the z value
* from the third dimensional counter.
*/
df_insert_scanned_use_spec(2);
}
}
}
}
}
}
char *equal_symbol_msg = "Equal ('=') symbol required";
static void
plot_option_binary(TBOOLEAN set_matrix, TBOOLEAN set_default)
{
TBOOLEAN duplication = FALSE;
TBOOLEAN set_record = FALSE;
TBOOLEAN set_array = FALSE, set_dx = FALSE, set_dy = FALSE, set_dz = FALSE;
TBOOLEAN set_center = FALSE, set_origin = FALSE, set_skip = FALSE, set_endian = FALSE;
TBOOLEAN set_rotation = FALSE, set_perpendicular = FALSE;
TBOOLEAN set_flip = FALSE, set_noflip = FALSE;
TBOOLEAN set_flipx = FALSE, set_flipy = FALSE, set_flipz = FALSE;
TBOOLEAN set_scan = FALSE;
TBOOLEAN set_format = FALSE;
/* Binary file type must be the first word in the command following `binary`" */
if (df_bin_filetype_default >= 0)
df_bin_filetype = df_bin_filetype_default;
if (almost_equals(c_token, "file$type") || (df_bin_filetype >= 0)) {
int i;
char file_ext[8] = {'\0','\0','\0','\0','\0','\0','\0','\0'};
/* Above keyword not part of pre-existing binary definition.
* So use general binary. */
if (set_matrix)
int_error(c_token, matrix_general_binary_conflict_msg);
df_matrix_file = FALSE;
if (almost_equals(c_token, "file$type")) {
if (!equals(++c_token, "="))
int_error(c_token, equal_symbol_msg);
copy_str(file_ext, ++c_token, 8);
for (i=0; df_bin_filetype_table[i].key; i++)
if (!strcasecmp(file_ext, df_bin_filetype_table[i].key)) {
binary_input_function = df_bin_filetype_table[i].value;
df_bin_filetype = i;
break;
}
if (df_bin_filetype != i)
/* Maybe set to "auto" and continue? */
int_error(c_token, "Unrecognized filetype; try \"show datafile binary filetypes\"");
c_token++;
}
if (df_plot_mode != MODE_QUERY
&& !strcmp("auto", df_bin_filetype_table[df_bin_filetype].key)) {
int i;
char *file_ext = strrchr(df_filename, '.');
if (file_ext++) {
for (i=0; df_bin_filetype_table[i].key; i++)
if (!strcasecmp(file_ext, df_bin_filetype_table[i].key))
binary_input_function = df_bin_filetype_table[i].value;
}
if (binary_input_function == auto_filetype_function)
int_error(NO_CARET, "Unrecognized filename extension; try \"show datafile binary filetypes\"");
}
/* Unless only querying settings, call the routine to prep binary data parameters. */
if (df_plot_mode != MODE_QUERY) {
(*binary_input_function)();
df_xpixels = df_bin_record[0].scan_dim[0];
df_ypixels = df_bin_record[0].scan_dim[1];
FPRINTF((stderr,"datafile.c:%d image dimensions %d x %d\n", __LINE__,
df_xpixels, df_ypixels));
}
/* Now, at this point anything that was filled in for "scan" should
* override the "cart" variables.
*/
for (i=0; i < df_num_bin_records; i++) {
int j;
/* Dimension */
if (df_bin_record[i].scan_dim[0] != df_bin_record_reset.scan_dim[0])
for (j=0; j < 3; j++)
df_bin_record[i].cart_dim[j] = 0;
/* Delta */
for (j=0; j < 3; j++)
if (df_bin_record[i].scan_delta[j] != 0.0) {
int k;
for (k=0; k < 3; k++)
if (df_bin_record[i].cart_scan[k] == (DF_SCAN_POINT - j))
df_bin_record[i].cart_delta[k] = 0;
}
/* Translation */
if (df_bin_record[i].scan_trans != DF_TRANSLATE_DEFAULT)
df_bin_record[i].cart_trans = DF_TRANSLATE_DEFAULT;
}
}
while (!END_OF_COMMAND) {
char origin_and_center_conflict_message[] = "Can specify `origin` or `center`, but not both";
/* look for record */
if (almost_equals(c_token, "rec$ord")) {
if (set_record) { duplication=TRUE; break; }
c_token++;
/* Above keyword not part of pre-existing binary definition. So use general binary. */
if (set_matrix)
int_error(c_token, matrix_general_binary_conflict_msg);
df_matrix_file = FALSE;
plot_option_array();
set_record = TRUE;
df_xpixels = df_bin_record[df_num_bin_records - 1].cart_dim[0];
df_ypixels = df_bin_record[df_num_bin_records - 1].cart_dim[1];
FPRINTF((stderr,"datafile.c:%d record dimensions %d x %d\n", __LINE__,
df_xpixels, df_ypixels));
continue;
}
/* look for array */
if (almost_equals(c_token, "arr$ay")) {
int i;
if (set_array) { duplication=TRUE; break; }
c_token++;
/* Above keyword not part of pre-existing binary definition. So use general binary. */
if (set_matrix)
int_error(c_token, matrix_general_binary_conflict_msg);
df_matrix_file = FALSE;
plot_option_array();
for (i = 0; i < df_num_bin_records; i++) {
/* Indicate that coordinate info should be generated internally */
df_bin_record[i].scan_generate_coord = TRUE;
}
set_array = TRUE;
df_xpixels = df_bin_record[df_num_bin_records - 1].cart_dim[0];
df_ypixels = df_bin_record[df_num_bin_records - 1].cart_dim[1];
FPRINTF((stderr,"datafile.c:%d array dimensions %d x %d\n", __LINE__,
df_xpixels, df_ypixels));
continue;
}
/* deal with spacing between array points */
if (equals(c_token, "dx") || equals(c_token, "dt")) {
if (set_dx) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_DELTA, 0);
if (!set_dy) {
int i;
for (i = 0; i < df_num_bin_records; i++)
df_bin_record[i].cart_delta[1] = df_bin_record[i].cart_delta[0];
}
if (!set_dz) {
int i;
for (i = 0; i < df_num_bin_records; i++)
df_bin_record[i].cart_delta[2] = df_bin_record[i].cart_delta[0];
}
set_dx = TRUE;
continue;
}
if (equals(c_token, "dy") || equals(c_token, "dr")) {
if (set_dy) { duplication=TRUE; break; }
if (!set_array && !df_bin_record)
int_error(c_token, "Must specify a sampling array size before indicating spacing in second dimension");
c_token++;
plot_option_multivalued(DF_DELTA, 1);
if (!set_dz) {
int i;
for (i = 0; i < df_num_bin_records; i++)
df_bin_record[i].cart_delta[2] = df_bin_record[i].cart_delta[1];
}
set_dy = TRUE;
continue;
}
if (equals(c_token, "dz")) {
int_error(c_token, "Currently not supporting three-dimensional sampling");
if (set_dz) { duplication=TRUE; break; }
if (!set_array && !df_bin_record)
int_error(c_token, "Must specify a sampling array size before indicating spacing in third dimension");
c_token++;
plot_option_multivalued(DF_DELTA, 2);
set_dz = TRUE;
continue;
}
/* deal with direction in which sampling increments */
if (equals(c_token, "flipx")) {
if (set_flipx) { duplication=TRUE; break; }
c_token++;
/* If no equal sign, then set flip true for all records. */
if (!equals(c_token, "=")) {
int i;
for (i = 0; i < df_num_bin_records; i++)
df_bin_record[i].cart_dir[0] = -1;
} else {
plot_option_multivalued(DF_FLIP_AXIS, 0);
}
set_flipx = TRUE;
continue;
}
if (equals(c_token, "flipy")) {
if (set_flipy) { duplication=TRUE; break; }
if (!set_array && !df_bin_record)
int_error(c_token, "Must specify a sampling array size before indicating flip in second dimension");
c_token++;
/* If no equal sign, then set flip true for all records. */
if (!equals(c_token, "=")) {
int i;
for (i = 0; i < df_num_bin_records; i++)
df_bin_record[i].cart_dir[1] = -1;
} else {
plot_option_multivalued(DF_FLIP_AXIS, 1);
}
set_flipy = TRUE;
continue;
}
if (equals(c_token, "flipz")) {
int_error(c_token, "Currently not supporting three-dimensional sampling");
if (set_flipz) { duplication=TRUE; break; }
if (!set_array && !df_bin_record)
int_error(c_token, "Must specify a sampling array size before indicating spacing in third dimension");
c_token++;
/* If no equal sign, then set flip true for all records. */
if (!equals(c_token, "=")) {
int i;
for (i=0; i < df_num_bin_records; i++)
df_bin_record[i].cart_dir[2] = -1;
} else {
plot_option_multivalued(DF_FLIP_AXIS, 2);
}
set_flipz = TRUE;
continue;
}
/* Deal with flipping data for individual records. */
if (equals(c_token, "flip")) {
if (set_flip) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_FLIP, -1);
set_flip = TRUE;
continue;
}
/* Deal with flipping data for individual records. */
if (equals(c_token, "noflip")) {
if (set_noflip) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_FLIP, 1);
set_noflip = TRUE;
continue;
}
/* Deal with manner in which dimensions are scanned from file. */
if (equals(c_token, "scan")) {
if (set_scan) { duplication=TRUE; break; }
c_token++;
if (almost_equals(c_token+1, "yx$z"))
df_transpose = TRUE;
plot_option_multivalued(DF_SCAN, 0);
set_scan = TRUE;
continue;
}
/* Deal with manner in which dimensions are scanned from file. */
if (almost_equals(c_token, "trans$pose")) {
int i;
if (set_scan) { duplication=TRUE; break; }
c_token++;
for (i=0; i < df_num_bin_records; i++)
memcpy(df_bin_record[i].cart_scan, df_bin_scan_table_2D[TRANSPOSE_INDEX].scan, sizeof(df_bin_record[0].cart_scan));
set_scan = TRUE;
df_transpose = TRUE;
continue;
}
/* deal with origin */
if (almost_equals(c_token, "orig$in")) {
if (set_center)
int_error(c_token, origin_and_center_conflict_message);
if (set_origin) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_ORIGIN, df_plot_mode);
set_origin = TRUE;
continue;
}
/* deal with origin */
if (almost_equals(c_token, "cen$ter")) {
if (set_origin)
int_error(c_token, origin_and_center_conflict_message);
if (set_center) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_CENTER, df_plot_mode);
set_center = TRUE;
continue;
}
/* deal with rotation angle */
if (almost_equals(c_token, "rot$ation") || almost_equals(c_token, "rot$ate")) {
if (set_rotation) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_ROTATION, 0);
set_rotation = TRUE;
continue;
}
/* deal with rotation angle */
if (almost_equals(c_token, "perp$endicular")) {
if (df_plot_mode == MODE_PLOT)
int_error(c_token, "Key word `perpendicular` is not allowed with `plot` command");
if (set_perpendicular) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_PERPENDICULAR, 0);
set_perpendicular = TRUE;
continue;
}
/* deal with number of bytes to skip before record */
if (almost_equals(c_token, "skip")) {
if (set_skip) { duplication=TRUE; break; }
c_token++;
plot_option_multivalued(DF_SKIP, 0);
set_skip = TRUE;
continue;
}
/* deal with byte order */
if (almost_equals(c_token, "end$ian")) {
if (set_endian) { duplication=TRUE; break; }
c_token++;
/* Require equal symbol. */
if (!equals(c_token, "="))
int_error(c_token, equal_symbol_msg);
c_token++;
if (almost_equals(c_token, "def$ault"))
df_bin_file_endianess = THIS_COMPILER_ENDIAN;
else if (equals(c_token, "swap") || equals(c_token, "swab"))
df_bin_file_endianess = (~df_bin_file_endianess)&3; /* complement and isolate lowest two bits */
else if (almost_equals(c_token, "lit$tle"))
df_bin_file_endianess = DF_LITTLE_ENDIAN;
else if (equals(c_token, "big"))
df_bin_file_endianess = DF_BIG_ENDIAN;
#if SUPPORT_MIDDLE_ENDIAN
else if (almost_equals(c_token, "mid$dle") || equals(c_token, "pdp"))
df_bin_file_endianess = DF_PDP_ENDIAN;
else
int_error(c_token, "Options are default, swap (swab), little, big, middle (pdp)");
#else
else
int_error(c_token, "Options are default, swap (swab), little, big");
#endif
c_token++;
set_endian = TRUE;
continue;
}
/* deal with various types of binary files */
if (almost_equals(c_token, "form$at")) {
if (set_format) { duplication=TRUE; break; }
c_token++;
/* Format string not part of pre-existing binary definition. So use general binary. */
if (set_matrix)
int_error(c_token, matrix_general_binary_conflict_msg);
df_matrix_file = FALSE;
/* Require equal sign */
if (!equals(c_token, "="))
int_error(c_token, equal_symbol_msg);
c_token++;
if (set_default) {
char *tmp = try_to_get_string();
free(df_binary_format);
df_binary_format = tmp;
} else {
char *format_string = try_to_get_string();
if (!format_string)
int_error(c_token, "missing format string");
plot_option_binary_format(format_string);
free(format_string);
}
set_format = TRUE;
continue;
}
break; /* unknown option */
} /* while (!END_OF_COMMAND) */
if (duplication)
int_error(c_token, "Duplicated or contradicting arguments in datafile options");
if (!set_default && !set_matrix && df_num_bin_records_default) {
int_warn(NO_CARET, "using default binary record/array structure");
}
if (!set_format && !df_matrix_file) {
if (df_binary_format) {
plot_option_binary_format(df_binary_format);
int_warn(NO_CARET, "using default binary format");
}
}
}
void
df_add_binary_records(int num_records_to_add, df_records_type records_type)
{
int i;
int new_number;
df_binary_file_record_struct **bin_record;
int *num_bin_records;
int *max_num_bin_records;
if (records_type == DF_CURRENT_RECORDS) {
bin_record = &df_bin_record;
num_bin_records = &df_num_bin_records;
max_num_bin_records = &df_max_num_bin_records;
} else {
bin_record = &df_bin_record_default;
num_bin_records = &df_num_bin_records_default;
max_num_bin_records = &df_max_num_bin_records_default;
}
new_number = *num_bin_records + num_records_to_add;
if (new_number > *max_num_bin_records) {
*bin_record = gp_realloc(*bin_record,
new_number * sizeof(df_binary_file_record_struct),
"binary file data records");
*max_num_bin_records = new_number;
}
for (i = 0; i < num_records_to_add; i++) {
memcpy(*bin_record + *num_bin_records,
&df_bin_record_reset,
sizeof(df_binary_file_record_struct));
(*num_bin_records)++;
}
}
static void
clear_binary_records(df_records_type records_type)
{
df_binary_file_record_struct *temp_bin_record;
int *temp_num_bin_records;
int i;
if (records_type == DF_CURRENT_RECORDS) {
temp_bin_record = df_bin_record;
temp_num_bin_records = &df_num_bin_records;
} else {
temp_bin_record = df_bin_record_default;
temp_num_bin_records = &df_num_bin_records_default;
}
for (i = 0; i < *temp_num_bin_records; i++) {
if (temp_bin_record[i].memory_data != NULL) {
free(temp_bin_record[i].memory_data);
temp_bin_record[i].memory_data = NULL;
}
}
*temp_num_bin_records = 0;
}
/*
* Syntax:
* plot FOO binary array=(xdim,ydim)[:(xdim,ydim)[...]]
* or
* plot FOO binary record=(xdim,ydim)[:(xdim,ydim)[...]]
*/
static void
plot_option_array(void)
{
int number_of_records = 0;
if (!equals(c_token, "="))
int_error(c_token, equal_symbol_msg);
do {
c_token++;
/* Partial backward compatibility with syntax up to 4.2.4 */
if (isanumber(c_token)) {
if (++number_of_records > df_num_bin_records)
df_add_binary_records(1, DF_CURRENT_RECORDS);
df_bin_record[df_num_bin_records - 1].cart_dim[0] = int_expression();
/* Handle the old syntax: array=123x456 (still used by Octave) */
if (!END_OF_COMMAND) {
char xguy[8]; int itmp=0;
copy_str(xguy, c_token, 6);
if (xguy[0] == 'x') {
sscanf(&xguy[1],"%d",&itmp);
df_bin_record[df_num_bin_records - 1].cart_dim[1] = itmp;
c_token++;
}
}
} else
if (equals(c_token, "(")) {
c_token++;
if (++number_of_records > df_num_bin_records)
df_add_binary_records(1, DF_CURRENT_RECORDS);
df_bin_record[df_num_bin_records - 1].cart_dim[0] = int_expression();
if (equals(c_token, ",")) {
c_token++;
df_bin_record[df_num_bin_records - 1].cart_dim[1] = int_expression();
}
if (!equals(c_token, ")"))
int_error(c_token, "tuple syntax error");
c_token++;
}
} while (equals(c_token, ":"));
}
/*
* Syntax:
* plot FOO sparse matrix=(,) dx= dy= origin=(x0,y0)
* The size is required. Origin defaults to (0,0), dx default to 1,
* dy defaults to dx.
* This provides an alternative input format for matrix data
* that is neither "uniform matrix" nor "nonuniform matrix".
* The full matrix grid is defined in advance here, to be followed
* by input of individual entries one per line: x y value
*/
void
plot_option_sparse()
{
double dx = 1, dy = 0;
double image_xy[2];
const char *sparse_error_msg =
"syntax: sparse matrix=(,) [dx= dy= origin=(,)]";
if (!equals(c_token++, "matrix") || !equals(c_token++, "=") || !token2tuple(image_xy,2))
int_error(c_token, sparse_error_msg);
df_xpixels = image_xy[0];
df_ypixels = image_xy[1];
while (!END_OF_COMMAND) {
if (equals(c_token, "dx")) {
c_token++;
if (!equals(c_token++,"="))
int_error(c_token, sparse_error_msg);
dx = real_expression();
} else if (equals(c_token, "dy")) {
c_token++;
if (!equals(c_token++,"="))
int_error(c_token, sparse_error_msg);
dy = real_expression();
} else if (almost_equals(c_token, "ori$gin")) {
c_token++;
df_image_origin[0] = df_image_origin[1] = 0.0;
if (!equals(c_token++, "=") || !token2tuple(df_image_origin,2))
int_error(c_token, sparse_error_msg);
} else
break;
}
if (dx == 0)
int_error(c_token, sparse_error_msg);
if (dy == 0)
dy = dx;
/* Save for populate_sparse_matrix */
df_image_deltas[0] = dx;
df_image_deltas[1] = dy;
}
/* Evaluate a tuple of up to specified dimension. */
#define TUPLE_SEPARATOR_CHAR ":"
#define LEFT_TUPLE_CHAR "("
#define RIGHT_TUPLE_CHAR ")"
int
token2tuple(double *tuple, int dimension)
{
if (equals(c_token, LEFT_TUPLE_CHAR)) {
TBOOLEAN expecting_number = TRUE;
int N = 0;
c_token++;
while (!END_OF_COMMAND) {
if (expecting_number) {
if (++N = df_num_bin_records)
int_error(c_token, "More parameters specified than data records specified");
switch (type) {
case DF_DELTA:
/* Set the spacing between grid points in the
* specified dimension. */
*(df_bin_record[bin_record_count].cart_delta + arg) = tuple[0];
if (df_bin_record[bin_record_count].cart_delta[arg] cart_alpha);
D3 = rotation_matrix_3D(P, this_record->cart_p);
translation_required = D2 || D3;
if (df_matrix_file) {
/* Dimensions */
scan_size[0] = this_record->scan_dim[0];
scan_size[1] = this_record->scan_dim[1];
if (df_xpixels == 0) {
/* df_xpixels and df_ypixels were corrected for ascii `matrix every`
* but scan_size was not. For that case we must not overwrite here.
* For binary matrix, df_xpixels is still 0.
*/
FPRINTF((stderr,"datafile.c:%d matrix dimensions %d x %d\n",
__LINE__, scan_size[1], scan_size[0]));
df_xpixels = scan_size[1];
df_ypixels = scan_size[0];
}
if (scan_size[0] == 0)
int_error(NO_CARET, "Scan size of matrix is zero");
/* To accomplish flipping in this case, multiply the
* appropriate column of the rotation matrix by -1. */
for (i = 0; i < 2; i++) {
int j;
for (j = 0; j < 2; j++) {
R[i][j] *= this_record->cart_dir[i];
}
}
/* o */
for (i = 0; i < 3; i++) {
if (this_record->cart_trans != DF_TRANSLATE_DEFAULT) {
o[i] = this_record->cart_cen_or_ori[i];
} else {
/* Default is translate by center. */
if (i < 2)
o[i] = (df_matrix_corner[1][i]
+ df_matrix_corner[0][i]) / 2;
else
o[i] = 0;
}
}
/* c */
for (i = 0; i < 3; i++) {
if (this_record->cart_trans == DF_TRANSLATE_VIA_ORIGIN) {
if (i < 2)
c[i] = df_matrix_corner[0][i];
else
c[i] = 0;
} else {
if (i < 2)
c[i] = (df_matrix_corner[1][i]
+ df_matrix_corner[0][i]) / 2;
else
c[i] = 0;
}
}
first_matrix_row_col_count = 0;
} else { /* general binary */
for (i = 0; i < 3; i++) {
int map;
/* How to direct the generated coordinates in regard
* to scan direction */
if (this_record->cart_dim[i] || this_record->scan_dim[i]) {
if (this_record->scan_generate_coord)
use_spec[i].column = this_record->cart_scan[i];
}
/* Dimensions */
map = DF_SCAN_POINT - this_record->cart_scan[i];
if (this_record->cart_dim[i] > 0)
scan_size[map] = this_record->cart_dim[i];
else if (this_record->cart_dim[i] < 0)
scan_size[map] = MAXINT;
else
scan_size[map] = this_record->scan_dim[map];
/* Sample periods */
if (this_record->cart_delta[i])
delta[map] = this_record->cart_delta[i];
else
delta[map] = this_record->scan_delta[map];
delta[map] *= this_record->scan_dir[map] * this_record->cart_dir[i];
/* o */
if (this_record->cart_trans != DF_TRANSLATE_DEFAULT)
o[i] = this_record->cart_cen_or_ori[i];
else if (this_record->scan_trans != DF_TRANSLATE_DEFAULT)
o[i] = this_record->scan_cen_or_ori[map];
else if (scan_size[map] > 0)
o[i] = (scan_size[map] - 1)*fabs(delta[map])/2;
else
o[i] = 0;
/* c */
if (this_record->cart_trans == DF_TRANSLATE_VIA_ORIGIN
|| (this_record->cart_trans == DF_TRANSLATE_DEFAULT
&& this_record->scan_trans == DF_TRANSLATE_VIA_ORIGIN)
) {
if ((scan_size[map] > 0) && (delta[map] < 0))
c[i] = (scan_size[map] - 1)*delta[map];
else
c[i] = 0;
} else {
if (scan_size[map] > 0)
c[i] = (scan_size[map] - 1)*(delta[map]/2);
else
c[i] = 0;
}
}
}
/* Check if c and o are the same. */
for (i = 0; i < 3; i++)
translation_required = translation_required || (c[i] != o[i]);
/* Should data come from memory? */
memory_data = this_record->memory_data;
/* byte read order */
read_order = byte_read_order(df_bin_file_endianess);
/* amount to skip before first record */
record_skip = this_record->scan_skip[0];
end_of_scan_line = FALSE;
end_of_block = FALSE;
point_count = -1;
line_count = 0;
df_current_index = df_bin_record_count;
df_last_index_read = df_current_index;
/* Craig DeForest Feb 2013 - Fast version of uniform binary matrix.
* Don't apply this to ascii input or special filetypes.
* Slurp all data from file or pipe in one shot to minimize fread calls.
*/
if (!memory_data && !(df_bin_filetype > 0)
&& df_binary_file && df_matrix && !df_nonuniform_matrix) {
int i;
unsigned long int bytes_per_point = 0;
unsigned long int bytes_per_line = 0;
unsigned long int bytes_per_plane = 0;
unsigned long int bytes_total = 0;
size_t fread_ret;
/* Accumulate total number of bytes in this tuple */
for (i=0; i 0) ? scan_size[0] : 1 );
bytes_per_plane = bytes_per_line
* ( (scan_size[1] > 0) ? scan_size[1] : 1 );
bytes_total = bytes_per_plane
* ( (scan_size[2]>0) ? scan_size[2] : 1);
bytes_total += record_skip;
/* Allocate a chunk of memory and stuff it */
memory_data = gp_alloc(bytes_total, "df_readbinary slurper");
this_record->memory_data = memory_data;
FPRINTF((stderr,"Fast matrix code:\n"));
FPRINTF((stderr,"\t\t %d binary columns\n", df_no_bin_cols));
FPRINTF((stderr,"\t\t skip %ld bytes, read %ld bytes per point %ld total as %d x %d array\n",
record_skip, bytes_per_point, bytes_total, scan_size[0], scan_size[1]));
/* Do the actual slurping */
fread_ret = fread(memory_data, 1, bytes_total, data_fp);
if (fread_ret != bytes_total) {
int_warn(NO_CARET, "Couldn't slurp %ld bytes (return was %zd)\n",
bytes_total, fread_ret);
df_eof = 1;
return DF_EOF;
}
}
}
while (!df_eof) {
/*{{{ process line */
TBOOLEAN line_okay = TRUE;
int output = 0; /* how many numbers written to v[] */
int i, fread_ret = 0;
int m_value, n_value, o_value;
union io_val {
char ch;
unsigned char uc;
short sh;
unsigned short us;
int in;
unsigned int ui;
long lo;
unsigned long ul;
long long llo;
unsigned long long ull;
float fl;
double db;
} io_val;
/* Scan in a number of floats based upon the largest index in
* the use_specs array. If the largest index in the array is
* greater than maximum columns then issue an error.
*/
/* Handle end of line or end of block on previous read. */
if (end_of_scan_line) {
end_of_scan_line = FALSE;
point_count = -1;
line_count++;
return DF_FIRST_BLANK;
}
if (end_of_block) {
end_of_block = FALSE;
line_count = 0;
return DF_SECOND_BLANK;
}
/* Possibly skip bytes before starting to read record. */
if (record_skip) {
if (memory_data)
memory_data += record_skip;
else if (df_skip_bytes(record_skip))
return DF_EOF;
record_skip = 0;
}
/* Bring in variables as described by the field parameters.
* If less than than the appropriate number of bytes have been
* read, issue an error stating not enough columns were found. */
for (i = 0; ; i++) {
off_t skip_bytes = df_column_bininfo[i].skip_bytes;
if (skip_bytes) {
if (memory_data)
memory_data += skip_bytes;
else if (df_skip_bytes(skip_bytes))
return DF_EOF;
}
/* Last entry only has skip bytes, no data. */
if (i == df_no_bin_cols)
break;
/* Read in a "column", i.e., a binary value of various types. */
if (df_pixeldata) {
io_val.uc = df_libgd_get_pixel(df_M_count, df_N_count, i);
} else
if (memory_data) {
for (fread_ret = 0;
fread_ret < df_column_bininfo[i].column.read_size;
fread_ret++)
(&io_val.ch)[fread_ret] = *memory_data++;
} else {
fread_ret = fread(&io_val.ch,
df_column_bininfo[i].column.read_size,
1, data_fp);
if (fread_ret != 1) {
df_eof = 1;
return DF_EOF;
}
}
if (read_order != 0)
df_swap_bytes_by_endianess(&io_val.ch, read_order,
df_column_bininfo[i].column.read_size);
switch (df_column_bininfo[i].column.read_type) {
case DF_CHAR:
df_column[i].datum = io_val.ch;
break;
case DF_UCHAR:
df_column[i].datum = io_val.uc;
break;
case DF_SHORT:
df_column[i].datum = io_val.sh;
break;
case DF_USHORT:
df_column[i].datum = io_val.us;
break;
case DF_INT:
df_column[i].datum = io_val.in;
break;
case DF_UINT:
df_column[i].datum = io_val.ui;
break;
case DF_LONG:
df_column[i].datum = io_val.lo;
break;
case DF_ULONG:
df_column[i].datum = io_val.ul;
break;
case DF_LONGLONG:
df_column[i].datum = io_val.llo;
break;
case DF_ULONGLONG:
df_column[i].datum = io_val.ull;
break;
case DF_FLOAT:
df_column[i].datum = io_val.fl;
break;
case DF_DOUBLE:
df_column[i].datum = io_val.db;
break;
default:
int_error(NO_CARET, "Binary data type unknown");
}
df_column[i].good = DF_GOOD;
df_column[i].position = NULL; /* cant get a time */
/* Matrix file data is a special case. After reading in just
* one binary value, stop and decide on what to do with it. */
if (df_matrix_file)
break;
} /* for(i) */
if (df_matrix_file) {
if (df_nonuniform_matrix) {
/* Store just first column? */
if (!df_M_count && !saved_first_matrix_column) {
first_matrix_column = df_column[i].datum;
saved_first_matrix_column = TRUE;
continue;
}
/* Read reset of first row? */
if (!df_M_count && !df_N_count && !df_O_count
&& first_matrix_row_col_count < scan_size[0]) {
if (!first_matrix_row_col_count)
scanned_matrix_row = gp_realloc(scanned_matrix_row,
scan_size[0]*sizeof(double), "gpbinary matrix row");
scanned_matrix_row[first_matrix_row_col_count] = df_column[i].datum;
first_matrix_row_col_count++;
if (first_matrix_row_col_count == scan_size[0]) {
/* Start of the second row. */
saved_first_matrix_column = FALSE;
}
continue;
}
}
/* Update all the binary columns. Matrix binary and
* matrix ASCII is a slight abuse of notation. At the
* command line, 1 means first row, 2 means first
* column. There can only be one column of data input
* because it is a matrix of data, not columns. */
{
int j;
/* df_datum will be returned as column(0)
* Aug 2022: CHANGE
* I do not know why the original code set this to df_column[i].datum.
* Returning the linear order in the matrix is more useful for both
* ascii and binary nonuniform matrices.
*/
if (df_nonuniform_matrix)
df_datum++;
else
df_datum = df_column[i].datum;
/* Fill backward so that current read value is not
* overwritten. */
for (j = df_no_bin_cols-1; j >= 0; j--) {
if (j == 0)
df_column[j].datum = df_nonuniform_matrix ? scanned_matrix_row[df_M_count] : df_M_count;
else if (j == 1)
df_column[j].datum = df_nonuniform_matrix ? first_matrix_column : df_N_count;
else
df_column[j].datum = df_column[i].datum;
df_column[j].good = DF_GOOD;
df_column[j].position = NULL;
}
}
} else { /* Not matrix file, general binary. */
df_datum = point_count + 1;
if (i != df_no_bin_cols) {
if (feof(data_fp)) {
if (i != 0)
int_error(NO_CARET, "Last point in the binary file did not match the specified `using` columns");
df_eof = 1;
return DF_EOF;
} else {
int_error(NO_CARET, read_error_msg);
}
}
}
m_value = df_M_count;
n_value = df_N_count;
o_value = df_O_count;
df_M_count++;
if ((scan_size[0] > 0) && (df_M_count >= scan_size[0])) {
/* This is a new "line". */
df_M_count = 0;
df_N_count++;
end_of_scan_line = TRUE;
if ((scan_size[1] >= 0) && (df_N_count >= scan_size[1])) {
/* This is a "block". */
df_N_count = 0;
df_O_count++;
if ((scan_size[2] >= 0) && (df_O_count >= scan_size[2])) {
df_O_count = 0;
end_of_block = TRUE;
if (++df_bin_record_count >= df_num_bin_records) {
df_eof = 1;
}
}
}
}
/*{{{ ignore points outside range of index */
/* we try to return end-of-file as soon as we pass upper
* index, but for mixed input stream, we must skip garbage */
if (df_current_index < df_lower_index
|| df_current_index > df_upper_index
|| ((df_current_index - df_lower_index) % df_index_step) != 0)
continue;
/*}}} */
/*{{{ reject points by every */
/* accept only lines with (line_count%everyline) == 0 */
if (line_count < firstline
|| line_count > lastline
|| (line_count - firstline) % everyline != 0)
continue;
/* update point_count. ignore point if
point_count%everypoint != 0 */
if (++point_count < firstpoint
|| point_count > lastpoint
|| (point_count - firstpoint) % everypoint != 0)
continue;
/*}}} */
/* At this point the binary columns have been read
* successfully. Set df_no_cols to df_no_bin_cols for use
* in the interpretation code. */
df_no_cols = df_no_bin_cols;
/*{{{ copy column[] to v[] via use[] */
{
int limit = (df_no_use_specs ? df_no_use_specs : MAXDATACOLS);
if (limit > max)
limit = max;
for (output = 0; output < limit; ++output) {
int column = use_spec[output].column;
/* if there was no using spec, column is output+1 and at=NULL */
if (use_spec[output].at) {
struct value a;
/* no dummy values to set up prior to... */
evaluate_inside_using = TRUE;
evaluate_at(use_spec[output].at, &a);
evaluate_inside_using = FALSE;
if (undefined) {
v[output] = not_a_number();
return DF_UNDEFINED;
}
if (a.type == STRING) {
v[output] = not_a_number(); /* found a string, not a number */
if (use_spec[output].expected_type == CT_STRING) {
char *s = gp_alloc(strlen(a.v.string_val)+3,"quote");
*s = '"';
strcpy(s+1, a.v.string_val);
strcat(s, "\"");
free(df_stringexpression[output]);
df_tokens[output] = df_stringexpression[output] = s;
}
/* Expecting a numerical type but got a string value */
else if (df_current_plot
&& (df_current_plot->lp_properties.p_type == PT_VARIABLE)) {
static char varchar[8];
safe_strncpy(varchar, a.v.string_val, 8);
df_tokens[output] = varchar;
}
gpfree_string(&a);
continue; /* otherwise isnan(v[output]) would terminate */
} else if (a.type == CMPLX && (fabs(imag(&a)) > zero)) {
/* June 2018: CHANGE. For consistency with function plots, */
/* imaginary results are treated as UNDEFINED. */
v[output] = not_a_number();
return DF_UNDEFINED;
} else {
v[output] = real(&a);
}
} else if (column == DF_SCAN_PLANE) {
if ((df_current_plot->plot_style == IMAGE)
|| (df_current_plot->plot_style == RGBIMAGE))
v[output] = o_value*delta[2];
/* EAM August 2009
* This was supposed to be "z" in a 3D grid holding a binary
* value at each voxel. But in fact the binary code does not
* support 3D grids, only 2D. So this always got set to 0,
* making the whole thing pretty useless except for inherently.
* planar objects like 2D images.
* Now I set Z to be the pixel value, which allows you
* to draw surfaces described by a 2D binary array.
*/
else
v[output] = df_column[0].datum;
} else if (column == DF_SCAN_LINE) {
v[output] = n_value*delta[1];
} else if (column == DF_SCAN_POINT) {
v[output] = m_value*delta[0];
} else if (column == -2) {
v[output] = df_current_index;
} else if (column == -1) {
v[output] = line_count;
} else if (column == 0) {
v[output] = df_datum;
} else if (column linked_to_secondary;
t = eval_link_function(visible, t);
}
}
/* This allows commands of the form
* plot sample [foo=0:10] '+' using (sin(foo)):(cos(foo)):(foo)
*/
if (df_current_plot && df_current_plot->sample_var)
Gcomplex(&(df_current_plot->sample_var->udv_value), t, 0.0);
df_pseudovalue_0 = t;
sprintf(df_line,"%g",t);
++df_pseudorecord;
}
/* Pseudofile '++' returns a (samples X isosamples) grid of x,y coordinates */
/* This code copied from that in second pass through eval_3dplots */
if (df_pseudodata == 2) {
static double u_min, u_max, u_step, v_min, v_max, v_isostep;
static int nusteps, nvsteps;
double u, v;
/* (March 2017) THIS IS A CHANGE
* Sample on u and v rather than on x and y.
* This decouples the sampling range from the plot range.
* Allow explicit sampling interval in the range specifiers for u and v.
*/
AXIS_INDEX u_axis = U_AXIS;
AXIS_INDEX v_axis = V_AXIS;
/* Fill in the static variables only once per plot */
if (df_pseudospan == 0 && df_pseudorecord == 0) {
if (samples_1 < 2 || samples_2 < 2 || iso_samples_1 < 2 || iso_samples_2 < 2)
int_error(NO_CARET, "samples or iso_samples < 2. Must be at least 2.");
if (parametric) {
u_min = axis_array[U_AXIS].min;
u_max = axis_array[U_AXIS].max;
v_min = axis_array[V_AXIS].min;
v_max = axis_array[V_AXIS].max;
} else {
axis_checked_extend_empty_range(u_axis, "u range is invalid");
axis_checked_extend_empty_range(v_axis, "v range is invalid");
if (nonlinear(&(axis_array[u_axis]))) {
u_min = axis_array[u_axis].linked_to_primary->min;
u_max = axis_array[u_axis].linked_to_primary->max;
} else {
u_min = axis_array[u_axis].min;
u_max = axis_array[u_axis].max;
}
if (nonlinear(&axis_array[v_axis])) {
v_min = axis_array[v_axis].linked_to_primary->min;
v_max = axis_array[v_axis].linked_to_primary->max;
} else {
v_min = axis_array[v_axis].min;
v_max = axis_array[v_axis].max;
}
}
if ((axis_array[u_axis].range_flags & RANGE_SAMPLED)
&& (axis_array[u_axis].SAMPLE_INTERVAL != 0)) {
u_step = axis_array[u_axis].SAMPLE_INTERVAL;
nusteps = floor( (u_max - u_min) / u_step ) + 1;
} else if (hidden3d) {
u_step = (u_max - u_min) / (iso_samples_1 - 1);
nusteps = iso_samples_1;
} else {
u_step = (u_max - u_min) / (samples_1 - 1);
nusteps = samples_1;
}
if ((axis_array[v_axis].range_flags & RANGE_SAMPLED)
&& (axis_array[v_axis].SAMPLE_INTERVAL != 0)) {
v_isostep = axis_array[v_axis].SAMPLE_INTERVAL;
nvsteps = floor( (v_max - v_min) / v_isostep ) + 1;
} else {
v_isostep = (v_max - v_min) / (iso_samples_2 - 1);
nvsteps = iso_samples_2;
}
}
/* wrap at end of each line */
if (df_pseudorecord >= nusteps) {
df_pseudorecord = 0;
if (++df_pseudospan >= nvsteps)
return NULL;
else
return ""; /* blank record for end of scan line */
}
/* Duplicate algorithm from calculate_set_of_isolines() */
u = u_min + df_pseudorecord * u_step;
v = v_max - df_pseudospan * v_isostep;
/* Round-off error is most visible at the border */
if (df_pseudorecord == nusteps-1)
u = u_max;
if (df_pseudospan == nvsteps-1)
v = v_min;
if (parametric) {
df_pseudovalue_0 = u;
df_pseudovalue_1 = v;
} else {
if (nonlinear(&axis_array[u_axis]))
df_pseudovalue_0 = eval_link_function(&axis_array[u_axis], u);
else
df_pseudovalue_0 = u;
if (nonlinear(&axis_array[v_axis]))
df_pseudovalue_1 = eval_link_function(&axis_array[v_axis], v);
else
df_pseudovalue_1 = v;
}
sprintf(df_line,"%g %g", df_pseudovalue_0, df_pseudovalue_1);
++df_pseudorecord;
/* This allows commands of the form
* splot sample [foo=0:10][baz=44:55] '++' using (foo):(baz):(foo*baz)
*/
if (df_current_plot && df_current_plot->sample_var)
Gcomplex(&(df_current_plot->sample_var->udv_value), df_pseudovalue_0, 0.0);
if (df_current_plot && df_current_plot->sample_var2)
Gcomplex(&(df_current_plot->sample_var2->udv_value), df_pseudovalue_1, 0.0);
}
return df_line;
}
/* Allocate space for more data columns as needed */
void
expand_df_column(int new_max)
{
df_column = gp_realloc(df_column,
new_max * sizeof(df_column_struct),
"datafile column");
for (; df_max_cols < new_max; df_max_cols++) {
df_column[df_max_cols].datum = 0;
df_column[df_max_cols].header = NULL;
df_column[df_max_cols].position = NULL;
}
}
/* Clear column headers stored for previous plot */
void
clear_df_column_headers()
{
int i;
for (i=0; i df_array->udv_value.v.value_array[0].v.int_val)
return NULL;
entry = &(df_array->udv_value.v.value_array[df_array_index]);
if (entry->type == STRING) {
while (max_line_len < strlen(entry->v.string_val))
df_line = gp_realloc(df_line, max_line_len *= 2, "datafile line buffer");
snprintf(df_line, max_line_len-1, "%d \"%s\"", df_array_index, entry->v.string_val);
} else {
snprintf(df_line, max_line_len-1, "%d %g %g", df_array_index, real(entry), imag(entry));
}
return df_line;
}
/* utility routine shared by df_readascii and df_readbinary */
static int
axcol_for_ticlabel(enum COLUMN_TYPE type, int *axis)
{
int axcol;
switch (type) {
default:
case CT_XTICLABEL:
*axis = FIRST_X_AXIS;
axcol = 0;
break;
case CT_X2TICLABEL:
*axis = SECOND_X_AXIS;
axcol = 0;
break;
case CT_YTICLABEL:
*axis = FIRST_Y_AXIS;
axcol = 1;
break;
case CT_Y2TICLABEL:
*axis = SECOND_Y_AXIS;
axcol = 1;
break;
case CT_ZTICLABEL:
*axis = FIRST_Z_AXIS;
axcol = 2;
break;
case CT_CBTICLABEL:
*axis = COLOR_AXIS;
if (df_axis[2] == FIRST_Z_AXIS)
axcol = 2;
else
axcol = df_no_use_specs - 1;
break;
}
return axcol;
}
/* Expand sparse matrix to fill entire grid defined by
* plot FOO sparse matrix=(cols,rows) origin=(x0,y0) dx=dx dy=dy
* Note: the extra level of indirection for points and p_count
* is so that this can be called from either plot or splot.
*/
void
populate_sparse_matrix(struct coordinate **points, int *p_count)
{
const struct coordinate empty = {0, 0, 0, NAN, NAN, NAN, NAN, UNDEFINED};
struct coordinate *matrix;
int i,j,m;
int msize = df_ypixels * df_xpixels;
int noutside = 0;
/* Create a new an empty matrix, fill in coordinates, initialize to UNDEFINED */
matrix = gp_alloc(msize*sizeof(struct coordinate), "sparse matrix");
m = 0;
for (j=0; jy - df_image_origin[1]) / df_image_deltas[1]);
if (i >= df_xpixels || j >= df_ypixels || i < 0 || j < 0)
noutside++;
else
matrix[ j*df_xpixels + i ] = *p;
}
fprintf(stderr, "Loaded %d points into %d x %d sparse matrix\n",
*p_count-noutside, df_xpixels, df_ypixels);
if (noutside > 0)
fprintf(stderr, " %d points outside defined matrix extent\n", noutside);
/* Replace the original data with the full sparse matrix */
free(*points);
*points = matrix;
*p_count = msize;
}