--- /dev/null
+#ifndef lint
+static char *RCSid() { return RCSid("$Id: datafile.c,v 1.110.2.21 2009/03/26 04:29:10 sfeam Exp $"); }
+#endif
+
+/* 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 */
+/* couldn't decide how to implement 'thru' only for 2d and 'index'
+ * for only 3d, so I did them for both - I can see a use for
+ * index in 2d, especially for fit.
+ *
+ * I keep thru for backwards compatibility, and extend it to allow
+ * more natural plot 'data' thru f(y) - I (personally) prefer
+ * my syntax, but then I'm biased...
+ *
+ * - because I needed it, I have added a range of indexes...
+ * (s)plot 'data' [index i[:j]]
+ *
+ * also 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<=f; line+=b)
+ * for (point=c; point >=e; point+=a)
+ *
+ *
+ * I dont like mixing this with the time series hack... I am
+ * very into modular code, so I would prefer to not have to
+ * have _anything_ to do with time series... for example,
+ * we just look at columns in file, and that is independent
+ * of 2d/3d. I really dont want to have to pass a flag to
+ * this is plot or splot.
+ *
+ * Now that df_2dbinary() and df_3dbinary() are here, I am seriously
+ * tempted to move get_data() and get_3ddata() in here too
+ *
+ * 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
+ * TBOOLEAN df_binary - it's a binary file
+ * [ might change this to return value from df_open() ]
+ * int df_eof - end of file
+ *
+ * functions
+ * int df_open(char *file_name, int max_using)
+ * parses thru / index / using on command line
+ * max_using is max no of 'using' columns allowed
+ * 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 blank line, but no valid data],
+ * DF_EOF for EOF
+ * DF_UNDEFINED - undefined result during eval of extended using spec
+ * DF_MISSING - requested column matched that of 'set missing <foo>'
+ * DF_FIRST_BLANK for first consecutive blank line
+ * DF_SECOND_BLANK for second consecutive blank line
+ * will return FIRST before SECOND
+ *
+ * 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 slightly differently from previous versions of gnuplot...
+ * given a line containing fewer columns than asked for, gnuplot used to make
+ * up values... I say that if I have explicitly said 'using 1:2:3', then if
+ * column 3 doesn't exist, I dont want this point...
+ *
+ * a column number of 0 means generate a value... as before, this value
+ * is useful in 2d as an x value, and is reset at blank lines.
+ * a column number of -1 means the (data) line number (not the file line
+ * number). splot 'file' using 1 is equivalent to
+ * splot 'file' using 0:-1:1
+ * column number -2 is the index. It was put in to kludge multi-branch
+ * fitting.
+ *
+ * 20/5/95 : accept 1.23d4 in place of e (but not in scanf string)
+ * : autoextend data line buffer and MAX_COLS
+ *
+ * 11/8/96 : add 'columns' -1 for suggested y value, and -2 for
+ * current index.
+ * using 1:-1:-2 and column(-1) are supported.
+ * $-1 and $-2 are not yet supported, because of the
+ * way the parser works
+ *
+ */
+/*}}} */
+
+/* Daniel Sebald: added general binary 2d data support. (20 August 2004)
+ */
+
+#include "datafile.h"
+
+#include "alloc.h"
+#include "axis.h"
+#include "binary.h"
+#include "command.h"
+#include "eval.h"
+#include "gp_time.h"
+#include "graphics.h"
+#include "misc.h"
+#include "parse.h"
+#include "plot.h"
+#include "util.h"
+#ifdef BINARY_DATA_FILE
+#include "breaders.h"
+#endif
+
+/* 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))
+
+/*{{{ static fns */
+#if 0 /* not used */
+static int get_time_cols __PROTO((char *fmt));
+static void mod_def_usespec __PROTO((int specno, int jump));
+#endif
+static int check_missing __PROTO((char *s));
+static char *df_gets __PROTO((void));
+static int df_tokenise __PROTO((char *s));
+#ifdef BINARY_DATA_FILE
+static float *df_read_matrix __PROTO((int *rows, int *columns));
+#else
+static float **df_read_matrix __PROTO((int *rows, int *columns));
+#endif
+static void plot_option_every __PROTO((void));
+static void plot_option_index __PROTO((void));
+static void plot_option_thru __PROTO((void));
+static void plot_option_using __PROTO((int));
+static TBOOLEAN valid_format __PROTO((const char *));
+#ifdef EAM_DATASTRINGS
+static void plot_ticlabel_using __PROTO((int));
+static void df_parse_string_field __PROTO((char *, char *));
+#endif
+#ifdef EAM_HISTOGRAMS
+static void add_key_entry __PROTO((char *temp_string, int df_datum));
+#endif
+
+/*}}} */
+
+/*{{{ variables */
+
+#ifdef EAM_DATASTRINGS
+enum COLUMN_TYPE { CT_DEFAULT, CT_STRING, CT_KEYLABEL,
+ CT_XTICLABEL, CT_X2TICLABEL, CT_YTICLABEL, CT_Y2TICLABEL,
+ CT_ZTICLABEL, CT_CBTICLABEL };
+#endif
+
+/* public variables client might access */
+
+int df_no_use_specs; /* how many using columns were specified */
+#ifdef EAM_HISTOGRAMS
+struct curve_points *df_current_plot; /* set before calling df_readline() */
+#endif
+int df_line_number;
+int df_datum; /* suggested x value if none given */
+int df_eof = 0;
+AXIS_INDEX df_axis[MAXDATACOLS];
+TBOOLEAN df_matrix = FALSE; /* indicates if data originated from a 2D or 3D format */
+TBOOLEAN df_binary = FALSE; /* this is a binary file */
+
+/* jev -- the 'thru' function --- NULL means no dummy vars active */
+/* HBB 990829: moved this here, from command.c */
+struct udft_entry ydata_func;
+
+/* string representing missing values in ascii datafiles */
+char *missing_val = NULL;
+
+/* input field separator, NUL if whitespace is the separator */
+char df_separator = '\0';
+
+/* 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;
+
+/* 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;
+
+/* private variables */
+
+/* in order to allow arbitrary data line length, we need to use the heap
+ * might consider free-ing it in df_close, especially for small systems
+ */
+static char *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
+static TBOOLEAN mixed_data_fp = FALSE; /* inline data */
+char *df_filename; /* name of data file */
+
+#ifdef EAM_DATASTRINGS
+static int df_no_tic_specs; /* ticlabel columns not counted in df_no_use_specs */
+#define MAX_TOKEN_LENGTH 64
+#endif
+
+#ifndef MAXINT /* should there be one already defined ? */
+# ifdef INT_MAX /* in limits.h ? */
+# define MAXINT INT_MAX
+# else
+# define MAXINT ((~0)>>1)
+# endif
+#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 */
+
+/* stuff for every point:line */
+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 */
+
+/* parsing stuff */
+struct use_spec_s use_spec[MAXDATACOLS];
+static char df_format[MAX_LINE_LEN + 1];
+static TBOOLEAN evaluate_inside_using = 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_BAD, DF_GOOD
+ } good;
+ char *position;
+} 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; /* cols read */
+static int fast_columns; /* corey@cac optimization */
+
+#ifdef EAM_DATASTRINGS
+char *df_tokens[MAXDATACOLS]; /* filled in by df_tokenise */
+#ifdef GP_STRING_VARS
+static char *df_stringexpression[MAXDATACOLS] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
+#endif
+#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 key_title_auto_col = FALSE;
+static char df_key_title[MAX_TOKEN_LENGTH]; /* filled in from <col> in 1st row by df_tokenise */
+#endif
+
+#ifdef BINARY_DATA_FILE
+
+/* Binary *read* variables used by df_readbinary(). The difference between matrix
+ * binary and general binary is that matrix binary requires an extra first column
+ * and extra first row giving the sample coordinates. Furthermore, note that if
+ * ASCII matrix data is converted to floats (i.e., binary) then it really falls in
+ * the general binary class, not the matrix binary class.
+ */
+TBOOLEAN df_read_binary;
+TBOOLEAN df_matrix_binary;
+int df_plot_mode;
+
+/* Define the following true of binary is to have it's own format string. */
+#define BINARY_HAS_OWN_FORMAT_STRING 1
+
+static int df_readascii __PROTO((double [], int));
+static int df_readbinary __PROTO((double [], int));
+
+static void initialize_use_spec __PROTO((void));
+
+static void initialize_binary_vars __PROTO((void));
+static void df_insert_scanned_use_spec __PROTO((int));
+static void adjust_binary_use_spec __PROTO((void));
+static void clear_binary_records __PROTO((df_records_type));
+static void plot_option_binary_format __PROTO((void));
+static void plot_option_binary __PROTO((TBOOLEAN, TBOOLEAN));
+static void plot_option_array __PROTO((void));
+static TBOOLEAN rotation_matrix_2D __PROTO((double R[][2], double));
+static TBOOLEAN rotation_matrix_3D __PROTO((double P[][3], double *));
+static int token2tuple __PROTO((double *, int));
+static void df_determine_matrix_info __PROTO((FILE *));
+static void df_swap_bytes_by_endianess __PROTO((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 __PROTO((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 )
+
+#else /* ifdef BINARY_DATA_FILE */
+
+typedef enum df_byte_read_order_type {
+ DF_01,
+ DF_10
+} df_byte_read_order_type;
+
+static int int_1 = 1;
+#define THIS_COMPILER_ENDIAN ( ((char *)&int_1)[0] ? DF_LITTLE_ENDIAN : DF_BIG_ENDIAN )
+
+#endif /* ifdef BINARY_DATA_FILE */
+
+/* Argument is file's endianess type. */
+static df_byte_read_order_type byte_read_order __PROTO((df_endianess_type));
+
+/* Logical variables indicating information about data file. */
+TBOOLEAN df_binary_file;
+TBOOLEAN df_matrix_file;
+
+int df_M_count;
+int df_N_count;
+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},
+
+ NULL
+};
+
+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;
+
+typedef struct df_bin_filetype_table_struct {
+ char *extension;
+ void (*function)(void);
+} df_bin_filetype_table_struct;
+
+static void gpbin_filetype_function __PROTO((void));
+static void raw_filetype_function __PROTO((void));
+static void avs_filetype_function __PROTO((void));
+
+df_bin_filetype_table_struct df_bin_filetype_table[] = {
+ {"gpbin", gpbin_filetype_function},
+ {"raw", raw_filetype_function},
+ {"rgb", raw_filetype_function},
+ {"bin", raw_filetype_function},
+#if 1
+ {"avs", avs_filetype_function},
+ {"edf", edf_filetype_function},
+ {"ehf", edf_filetype_function},
+#endif
+ {"auto", raw_filetype_function} /* "auto" is trapped, but if the actual file extension is "auto" then use raw. */
+};
+#define RAW_FILETYPE 1
+
+/* Initially set to default and then possibly altered by command line. */
+int df_bin_filetype;
+df_endianess_type df_bin_file_endianess;
+/* Default setting. */
+int df_bin_filetype_default;
+df_endianess_type df_bin_file_endianess_default;
+/* Setting that is transferred to default upon reset. */
+int df_bin_filetype_reset = -1;
+#define DF_BIN_FILE_ENDIANESS_RESET THIS_COMPILER_ENDIAN
+
+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)}}
+};
+
+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
+
+/*}}} */
+
+
+/*{{{ static char *df_gets() */
+static char *
+df_gets()
+{
+ int len = 0;
+
+ /* HBB 20000526: prompt user for inline data, if in interactive mode */
+ if (mixed_data_fp && interactive)
+ fputs("input data ('e' ends) > ", stderr);
+
+ if (!fgets(line, max_line_len, data_fp))
+ return NULL;
+
+ if (mixed_data_fp)
+ ++inline_num;
+
+ for (;;) {
+ len += strlen(line + len);
+
+ if (len > 0 && line[len - 1] == '\n') {
+ /* we have read an entire text-file line.
+ * Strip the trailing linefeed and return
+ */
+ line[len - 1] = 0;
+ return line;
+ }
+ /* buffer we provided may not be full - dont grab extra
+ * memory un-necessarily. This may trap a problem with last
+ * line in file not being properly terminated - each time
+ * through a replot loop, it was doubling buffer size
+ */
+
+ if ((max_line_len - len) < 32)
+ line = gp_realloc(line, max_line_len *= 2, "datafile line buffer");
+
+ if (!fgets(line + len, max_line_len - len, data_fp))
+ return line; /* unexpected end of file, but we have something to do */
+ }
+
+ /* NOTREACHED */
+ return NULL;
+}
+
+/*}}} */
+
+/*{{{ static int df_tokenise(s) */
+static int
+df_tokenise(char *s)
+{
+ /* implement our own sscanf that takes 'missing' into account,
+ * and can understand fortran quad format
+ */
+ TBOOLEAN in_string;
+#ifdef EAM_DATASTRINGS
+ int i;
+
+ for (i = 0; i<MAXDATACOLS; i++)
+ df_tokens[i] = NULL;
+
+#ifdef EAM_HISTOGRAMS
+ /* Auto-titling of histograms is a bit tricky because the x coord did not come */
+ /* from an explicit input column. This means our previous guess of what column */
+ /* to take the title from was probably wrong. */
+ if (key_title_auto_col && df_current_plot
+ && (df_current_plot->plot_style == HISTOGRAMS))
+ column_for_key_title = use_spec[0].column;
+#endif
+#endif
+
+
+#define NOTSEP (*s != df_separator)
+
+ df_no_cols = 0;
+
+ while (*s) {
+ /* check store - double max cols or add 20, whichever is greater */
+ if (df_max_cols <= df_no_cols) {
+ int new_max = df_max_cols + (df_max_cols < 20 ? 20 : df_max_cols);
+ df_column = gp_realloc(df_column,
+ new_max * sizeof(df_column_struct),
+ "datafile column");
+ while (df_max_cols < new_max)
+ df_column[df_max_cols++].datum = 0;
+ }
+
+ /* have always skipped spaces at this point */
+ df_column[df_no_cols].position = s;
+ in_string = FALSE;
+
+#ifdef EAM_DATASTRINGS
+ /* Keep pointer to start of this token if user wanted it for
+ * anything, particularly if it is a string */
+ for (i = 0; i<MAXDATACOLS; i++) {
+ if (df_no_cols == use_spec[i].column-1) {
+ df_tokens[i] = s;
+ if (use_spec[i].expected_type == CT_STRING)
+ df_column[df_no_cols].good = DF_GOOD;
+ }
+ }
+ /* Particularly if it is supposed to be a key title */
+ if (df_no_cols == column_for_key_title-1)
+ strncpy(df_key_title,s,sizeof(df_key_title)-1);
+#endif
+
+ /* CSV files must accept numbers inside quotes also,
+ * so we step past the quote */
+ if (*s == '"' && df_separator != '\0') {
+ in_string = TRUE;
+ df_column[df_no_cols].position = ++s;
+ }
+
+ if (*s == '"') {
+ /* treat contents of a quoted string as single column */
+ in_string = !in_string;
+ df_column[df_no_cols].good = DF_MISSING;
+ /* Allow timedata input to be contained in quotes */
+ if (axis_array[df_axis[df_no_cols]].timefmt)
+ df_column[df_no_cols].good = DF_STRINGDATA;
+ } else if (check_missing(s)) {
+ df_column[df_no_cols].good = DF_MISSING;
+ df_column[df_no_cols].datum = atof("NaN");
+ } else {
+ int used;
+ int count;
+ int dfncp1 = df_no_cols + 1;
+
+ /* optimizations by Corey Satten, corey@cac.washington.edu */
+ if ((fast_columns == 0)
+ || (df_no_use_specs == 0)
+ || ((df_no_use_specs > 0)
+ && (use_spec[0].column == dfncp1
+ || (df_no_use_specs > 1
+ && (use_spec[1].column == dfncp1
+ || (df_no_use_specs > 2
+ && (use_spec[2].column == dfncp1
+ || (df_no_use_specs > 3
+ && (use_spec[3].column == dfncp1
+ || (df_no_use_specs > 4
+ && (use_spec[4].column
+ == dfncp1
+ || df_no_use_specs > 5)
+ )
+ )
+ )
+ )
+ )
+ )
+ )
+ )
+ )
+ ) {
+
+#if (0)
+ /* This was the [slow] code used through version 4.0 */
+ count = sscanf(s, "%lf%n", &df_column[df_no_cols].datum, &used);
+#else
+ /* 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 = gp_strtod(s, &next);
+ used = next - s;
+ count = (used) ? 1 : 0;
+#endif
+ } else {
+ /* skip any space at start of column */
+ /* HBB tells me that the cast must be to
+ * unsigned char instead of int. */
+ while (isspace((unsigned char) *s) && NOTSEP)
+ ++s;
+ count = (*s && NOTSEP) ? 1 : 0;
+ /* skip chars to end of column */
+ used = 0;
+ if (df_separator != '\0' && 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 = gp_strtod(s, &endptr);
+ count = (endptr == s) ? 0 : 1;
+ s[used] = save_char;
+ }
+
+ df_column[df_no_cols].good = count == 1 ? DF_GOOD : DF_BAD;
+#ifdef HAVE_ISNAN
+ if (isnan(df_column[df_no_cols].datum))
+ df_column[df_no_cols].good = DF_BAD;
+#endif
+ }
+
+ ++df_no_cols;
+
+ /* EAM - 19 Aug 2002 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 past next separator */
+ if (df_separator != '\0') {
+ while (*s && NOTSEP)
+ ++s;
+ if (*s == df_separator)
+ /* skip leading whitespace in next field */
+ do
+ ++s;
+ while (*s && isspace((unsigned char) *s) && NOTSEP);
+ } else {
+ /* skip chars to end of column */
+ while ((!isspace((unsigned char) *s)) && (*s != '\0'))
+ ++s;
+ /* skip spaces to start of next column */
+ while (isspace((unsigned char) *s))
+ ++s;
+ }
+ }
+
+ return df_no_cols;
+#undef NOTSEP
+}
+
+/*}}} */
+
+#ifdef BINARY_DATA_FILE
+/*{{{ static float *df_read_matrix() */
+/* Reads a matrix from a text file and stores it as floats 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 float *
+df_read_matrix(int *rows, int *cols)
+{
+ int max_rows = 0;
+ int c;
+ float *linearized_matrix = NULL;
+ int bad_data = 0;
+ char *s;
+ int index = 0;
+
+ *rows = 0;
+ *cols = 0;
+
+ for (;;) {
+ if (!(s = df_gets())) {
+ df_eof = 1;
+ /* NULL if we have not read anything yet */
+ return linearized_matrix;
+ }
+
+ while (isspace((unsigned char) *s))
+ ++s;
+
+ if (!*s || is_comment(*s)) {
+ if (linearized_matrix)
+ return linearized_matrix;
+ else
+ continue;
+ }
+ if (mixed_data_fp && is_EOF(*s)) {
+ df_eof = 1;
+ return linearized_matrix;
+ }
+ c = df_tokenise(s);
+
+ if (!c)
+ return linearized_matrix;
+
+ if (*cols && c != *cols) {
+ /* its 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(float),
+ "df_matrix");
+ }
+
+ /* store data */
+ {
+ int i;
+
+ for (i = 0; i < c; ++i) {
+ 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++] = (float) df_column[i].datum;
+
+ if (df_column[i].good != DF_GOOD) {
+ if (bad_data++ == 0)
+ int_warn(NO_CARET,"matrix contains missing or undefined values");
+ }
+ }
+ }
+ }
+}
+/*}}} */
+
+#else /* BINARY_DATA_FILE */
+
+/*{{{ static float **df_read_matrix() */
+/* reads a matrix from a text file stores in same storage format as
+ * fread_matrix */
+/* FIXME HBB 20001207: doesn't respect 'index' at all, even though it
+ * could, and probably should. */
+static float **
+df_read_matrix(int *rows, int *cols)
+{
+ int max_rows = 0;
+ int c;
+ float **rmatrix = NULL;
+ char *s;
+
+ *rows = 0;
+ *cols = 0;
+
+ for (;;) {
+ if (!(s = df_gets())) {
+ df_eof = 1;
+ return rmatrix; /* NULL if we have not read anything yet */
+ }
+ while (isspace((unsigned char) *s))
+ ++s;
+
+ if (!*s || is_comment(*s)) {
+ if (rmatrix)
+ return rmatrix;
+ else
+ continue;
+ }
+ if (mixed_data_fp && is_EOF(*s)) {
+ df_eof = 1;
+ return rmatrix;
+ }
+ c = df_tokenise(s);
+
+ if (!c)
+ return rmatrix;
+
+ if (*cols && c != *cols) {
+ /* its not regular */
+ int_error(NO_CARET, "Matrix does not represent a grid");
+ }
+ *cols = c;
+
+ if (*rows >= max_rows) {
+ rmatrix = gp_realloc(rmatrix,
+ (max_rows += 10) * sizeof(float *),
+ "df_matrix");
+ }
+
+ /* allocate a row and store data */
+ {
+ int i;
+ float *row = rmatrix[*rows] = gp_alloc(c * sizeof(float),
+ "df_matrix row");
+
+ for (i = 0; i < c; ++i) {
+ if (df_column[i].good != DF_GOOD && i >= firstpoint)
+ int_error(NO_CARET, "Bad number in matrix");
+
+ row[i] = (float) df_column[i].datum;
+ }
+ ++*rows;
+ }
+ }
+}
+/*}}} */
+#endif /* BINARY_DATA_FILE */
+
+
+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 */
+#ifdef EAM_DATASTRINGS
+ use_spec[i].expected_type = CT_DEFAULT; /* no particular expectation */
+#endif
+ if (use_spec[i].at) {
+ free_at(use_spec[i].at);
+ use_spec[i].at = NULL; /* no expression */
+ }
+ df_axis[i] = -1; /* no timefmt for this output column */
+ }
+}
+
+
+/*{{{ int df_open(char *file_name, max_using) */
+
+/* open file, parsing using/thru/index stuff return number of using
+ * specs [well, we have to return something !]
+ */
+int
+df_open(const char *cmd_filename, int max_using)
+{
+ int name_token = c_token - 1;
+ TBOOLEAN duplication = FALSE;
+ TBOOLEAN set_index = FALSE, set_every = FALSE, set_thru = FALSE;
+ TBOOLEAN set_using = FALSE;
+#ifdef BINARY_DATA_FILE
+ TBOOLEAN set_matrix = FALSE;
+#endif
+
+ fast_columns = 1; /* corey@cac */
+
+ /*{{{ close file if necessary */
+ if (data_fp)
+ df_close();
+ /*}}} */
+
+ /*{{{ initialise static variables */
+ df_format[0] = NUL; /* no format string */
+
+#ifdef EAM_DATASTRINGS
+ df_no_tic_specs = 0;
+#endif
+ df_key_title[0] = '\0';
+
+ initialize_use_spec();
+
+ 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;
+
+ df_current_index = 0;
+ blank_count = 2;
+ /* by initialising blank_count, leading blanks will be ignored */
+
+ everypoint = everyline = 1; /* unless there is an every spec */
+ firstpoint = firstline = 0;
+ lastpoint = lastline = MAXINT;
+
+#ifdef BINARY_DATA_FILE
+ df_binary_file = df_matrix_file = FALSE;
+#endif
+
+ df_eof = 0;
+
+#ifdef EAM_DATASTRINGS
+ column_for_key_title = NO_COLUMN_HEADER;
+ key_title_auto_col = FALSE;
+#endif
+ /*}}} */
+
+ assert(max_using <= MAXDATACOLS);
+
+ if (!cmd_filename)
+ int_error(c_token, "missing filename");
+ if (!cmd_filename[0]) {
+ if (!df_filename || !*df_filename)
+ int_error(c_token, "No previous filename");
+ } else {
+ free(df_filename);
+ df_filename = gp_strdup(cmd_filename);
+ }
+
+ /* defer opening until we have parsed the modifiers... */
+
+ if (ydata_func.at) /* something for thru (?) */
+ free_at(ydata_func.at);
+ ydata_func.at = NULL;
+
+ df_binary = df_matrix = FALSE;
+
+ /* pm 25.11.2001 allow any order of options */
+ while (!END_OF_COMMAND) {
+
+ /* look for binary / matrix */
+ if (almost_equals(c_token, "bin$ary")) {
+ c_token++;
+#ifdef BINARY_DATA_FILE
+ if (df_binary_file) {
+ duplication=TRUE;
+ break;
+ }
+ 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);
+#else
+ if (df_matrix) {
+ duplication=TRUE;
+ break;
+ }
+ df_binary = TRUE;
+ df_matrix = TRUE;
+#endif
+ continue;
+ }
+
+ /* deal with matrix */
+ if (almost_equals(c_token, "mat$rix")) {
+ c_token++;
+#ifdef BINARY_DATA_FILE
+ 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;
+#else
+ if (df_matrix) { duplication=TRUE; break; }
+ df_matrix = TRUE;
+#endif
+ fast_columns = 0;
+ 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 thru */
+ /* jev -- support for passing data from file thru user function */
+ if (almost_equals(c_token, "thru$")) {
+ if (set_thru) { duplication=TRUE; break; }
+ plot_option_thru();
+ set_thru = TRUE;
+ 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;
+ }
+
+#ifdef EAM_DATASTRINGS
+ /* Take key title from column head? */
+ if (almost_equals(c_token, "t$itle")) {
+ struct value a;
+ c_token++;
+ if (almost_equals(c_token, "col$umnheader") && equals(c_token+1,"(")) {
+ c_token += 2;
+ column_for_key_title = (int)real(const_express(&a));
+ c_token++;
+ } else if (almost_equals(c_token, "col$umnheader")) {
+ key_title_auto_col = TRUE;
+ if (df_no_use_specs == 1)
+ column_for_key_title = use_spec[0].column;
+ else
+ column_for_key_title = use_spec[1].column;
+ c_token++;
+ } else if (!END_OF_COMMAND && isanumber(c_token)) {
+ column_for_key_title = (int)real(const_express(&a));
+ } else /* Let the general case parser handle it */
+ c_token--;
+ break;
+ }
+#endif
+ break; /* unknown option */
+
+ } /* while (!END_OF_COMMAND) */
+
+ if (duplication)
+ int_error(c_token,
+ "duplicated or contradicting arguments in datafile options");
+
+#ifdef EAM_DATASTRINGS
+ /* Check for auto-generation of key title from column header */
+ if (column_for_key_title == NO_COLUMN_HEADER) {
+ legend_key *key = &keyT;
+
+ if (key->auto_titles == COLUMNHEAD_KEYTITLES) {
+ key_title_auto_col = TRUE;
+ if (df_no_use_specs == 1)
+ column_for_key_title = use_spec[0].column;
+ else
+ column_for_key_title = use_spec[1].column;
+ }
+ }
+#endif
+
+ /*{{{ more variable inits */
+ point_count = -1; /* we preincrement */
+ line_count = 0;
+
+ /* here so it's not done for every line in df_readline */
+ if (max_line_len < DATA_LINE_BUFSIZ) {
+ max_line_len = DATA_LINE_BUFSIZ;
+ line = gp_alloc(max_line_len, "datafile line buffer");
+ }
+ /*}}} */
+
+ /*{{{ open file */
+#if defined(PIPES)
+ if (*df_filename == '<') {
+ if ((data_fp = popen(df_filename + 1, "r")) == (FILE *) NULL)
+ os_error(name_token, "cannot create pipe for data");
+ else
+ df_pipe_open = TRUE;
+ } else
+#endif /* PIPES */
+ /* I don't want to call strcmp(). Does it make a difference? */
+ if (*df_filename == '-' && strlen(df_filename) == 1) {
+ plotted_data_from_stdin = TRUE;
+ data_fp = lf_top();
+ if (!data_fp)
+ data_fp = stdin;
+ mixed_data_fp = TRUE; /* don't close command file */
+ } else {
+ /* filename cannot be static array! */
+ gp_expand_tilde(&df_filename);
+#ifdef HAVE_SYS_STAT_H
+ {
+ struct stat statbuf;
+ if ((stat(df_filename, &statbuf) > -1) &&
+ !S_ISREG(statbuf.st_mode) && !S_ISFIFO(statbuf.st_mode)) {
+ os_error(name_token, "\"%s\" is not a regular file or pipe",
+ df_filename);
+ }
+ }
+#endif /* HAVE_SYS_STAT_H */
+#ifdef BINARY_DATA_FILE
+ if ((data_fp = loadpath_fopen(df_filename, df_binary_file ? "rb" : "r")) ==
+#else
+ if ((data_fp = loadpath_fopen(df_filename, df_binary ? "rb" : "r")) ==
+#endif
+ (FILE *) NULL) {
+ int_warn(NO_CARET, "Skipping unreadable file \"%s\"", df_filename);
+ df_eof = 1;
+ return DF_EOF;
+ }
+ }
+/*}}} */
+
+#ifdef BINARY_DATA_FILE
+ /* If the data is in binary matrix form, read in some values
+ * to determine the nubmer of columns and rows. If data is in
+ * ASCII matrix form, read in all the data to memory in preparation
+ * for using df_readbinary() routine.
+ */
+ if (df_matrix_file)
+ df_determine_matrix_info(data_fp);
+
+ /* 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();
+ } 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))));
+
+ /* Same idea, but try removing this one. I can't see why it is
+ * important for the rest of the program to know if if the data
+ * came from a binary file. (DJS 20 Aug 2004) */
+ df_binary = df_binary_file;
+#endif /* BINARY_DATA_FILE */
+
+ 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)
+ return;
+
+ if (ydata_func.at) {
+ free_at(ydata_func.at);
+ ydata_func.at = NULL;
+ }
+ /*{{{ 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;
+ }
+ /*}}} */
+
+ if (!mixed_data_fp) {
+#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 && line) {
+ /* display no more than 77 characters */
+ fprintf(stderr, "%.77s%s\n%s:%d:", line,
+ (strlen(line) > 77) ? "..." : "",
+ df_filename, df_line_number);
+ }
+}
+
+/*}}} */
+
+
+static void
+plot_option_every()
+{
+ struct value a;
+
+ 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) real(const_express(&a));
+ 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) real(const_express(&a));
+ if (everyline < 1)
+ int_error(c_token, "Expected positive integer");
+ }
+ if (equals(c_token, ":") && !equals(++c_token, ":")) {
+ firstpoint = (int) real(const_express(&a));
+ if (firstpoint < 0)
+ int_error(c_token, "Expected non-negative integer");
+ }
+ if (equals(c_token, ":") && !equals(++c_token, ":")) {
+ firstline = (int) real(const_express(&a));
+ if (firstline < 0)
+ int_error(c_token, "Expected non-negative integer");
+ }
+ if (equals(c_token, ":") && !equals(++c_token, ":")) {
+ lastpoint = (int) real(const_express(&a));
+ if (lastpoint < firstpoint)
+ int_error(c_token, "Last point must not be before first point");
+ }
+ if (equals(c_token, ":")) {
+ ++c_token;
+ lastline = (int) real(const_express(&a));
+ if (lastline < firstline)
+ int_error(c_token, "Last line must not be before first line");
+ }
+}
+
+
+static void
+plot_option_index()
+{
+ struct value a;
+
+#ifdef BINARY_DATA_FILE
+ if (df_binary_file && df_matrix_file)
+ int_error(c_token, "Binary matrix file format does not allow more than one surface per file");
+#else
+ if (df_binary)
+ int_error(c_token, "Binary file format does not allow more than one surface per file");
+#endif
+
+ ++c_token;
+ df_lower_index = (int) real(const_express(&a));
+ if (equals(c_token, ":")) {
+ ++c_token;
+ df_upper_index = (int) magnitude(const_express(&a));
+ 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) magnitude(const_express(&a));
+ 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_thru()
+{
+ c_token++;
+ strcpy(c_dummy_var[0], set_dummy_var[0]);
+ /* allow y also as a dummy variable.
+ * during plot, c_dummy_var[0] and [1] are 'sacred'
+ * ie may be set by splot [u=1:2] [v=1:2], and these
+ * names are stored only in c_dummy_var[]
+ * so choose dummy var 2 - can anything vital be here ?
+ */
+ dummy_func = &ydata_func;
+ strcpy(c_dummy_var[2], "y");
+ ydata_func.at = perm_at();
+ dummy_func = NULL;
+}
+
+
+static void
+plot_option_using(int max_using)
+{
+
+ int no_cols = 0; /* For general binary only. */
+
+#ifdef BINARY_DATA_FILE
+ /* The filetype function may have set the using specs, so reset
+ * them before processing tokens. */
+ if (df_binary_file)
+ initialize_use_spec();
+#endif
+
+ if (!END_OF_COMMAND && !isstring(++c_token)) {
+ struct value a;
+
+ do { /* must be at least one */
+ 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, "(")) {
+ fast_columns = 0; /* corey@cac */
+ dummy_func = NULL; /* no dummy variables active */
+ /* this will match ()'s: */
+ at_highest_column_used = NO_COLUMN_HEADER;
+ use_spec[df_no_use_specs].at = perm_at();
+ if (no_cols < at_highest_column_used)
+ no_cols = at_highest_column_used;
+ /* Catch at least the simplest case of 'autotitle columnhead' using an expression */
+ use_spec[df_no_use_specs++].column = at_highest_column_used;
+
+#ifdef EAM_DATASTRINGS
+ /* FIXME EAM - It would be nice to handle these like any other */
+ /* internal function via perm_at() but there are problems. */
+ } 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);
+#endif /* EAM_DATASTRINGS */
+ } else {
+ int col = (int) real(const_express(&a));
+
+ if (col < -2)
+ int_error(c_token, "Column must be >= -2");
+ use_spec[df_no_use_specs++].column = col;
+ if (col > no_cols)
+ no_cols = col;
+ }
+ } while (equals(c_token, ":") && ++c_token);
+ }
+#ifdef BINARY_DATA_FILE
+ if (df_binary_file) {
+ /* If the highest user column number is greater than number of binary
+ * columns, set the unitialized columns binary info to that of the last
+ * specified column or the default.
+ */
+ df_extend_binary_columns(no_cols);
+ }
+#endif
+ if (!END_OF_COMMAND && isstring(c_token)) {
+#ifdef BINARY_DATA_FILE
+ if (df_binary_file)
+# if BINARY_HAS_OWN_FORMAT_STRING
+ int_error(NO_CARET, "Place format string with `binary` keyword, i.e., \"binary format='...'\"\n\t or use \"binary filetype=...\" for in-file format if supported");
+# else
+ if (df_matrix_file)
+ int_error(c_token, matrix_general_binary_conflict_msg);
+ plot_option_binary_format();
+# endif /* BINARY_HAS_OWN_FORMAT_STRING */
+#else /* BINARY_DATA_FILE */
+ if (df_binary)
+ int_error(NO_CARET, "Format string meaningless with binary data");
+#endif /* BINARY_DATA_FILE */
+ quote_str(df_format, c_token, MAX_LINE_LEN);
+ if (!valid_format(df_format))
+ int_error(c_token,
+ "Please use between 1 and 7 conversions, of type double (%%lf)");
+
+ c_token++; /* skip format */
+ } /* if (!EOC) */
+}
+
+
+#ifdef EAM_DATASTRINGS
+static
+void plot_ticlabel_using(int axis)
+{
+ struct value a;
+ int col = 0;
+
+ c_token += 2;
+
+#ifdef GP_STRING_VARS
+ /* 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) real(const_express(&a));
+ 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 */
+ }
+#else
+ col = (int) real(const_express(&a));
+#endif
+
+ if (col < 1)
+ int_error(c_token, "ticlabels must come from a real column");
+ 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++;
+}
+#endif /* EAM_DATASTRINGS */
+
+
+/*{{{ int df_readline(v, max) */
+int
+df_readline(double v[], int max)
+{
+ if (!data_fp)
+ return DF_EOF;
+
+#ifdef BINARY_DATA_FILE
+ if (df_read_binary)
+ /* General binary, matrix binary or matrix ascii
+ * that's been converted to binary.
+ */
+ return df_readbinary(v, max);
+ else
+#endif
+ 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;
+
+ assert(data_fp != NULL);
+ assert(max_line_len); /* alloc-ed in df_open() */
+ assert(max <= MAXDATACOLS);
+
+ /* catch attempt to read past EOF on mixed-input */
+ if (df_eof)
+ return DF_EOF;
+
+ /*{{{ process line */
+ while ((s = df_gets()) != NULL) {
+ int line_okay = 1;
+ int output = 0; /* how many numbers written to v[] */
+
+ ++df_line_number;
+ df_no_cols = 0;
+
+ /*{{{ check for blank lines, and reject by index/every */
+ /*{{{ skip leading spaces */
+ while (isspace((unsigned char) *s))
+ ++s; /* will skip the \n too, to point at \0 */
+ /*}}} */
+
+ /*{{{ skip comments */
+ if (is_comment(*s))
+ 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;
+ /* ignore line if current_index has just become
+ * first required one - client doesn't want this
+ * blank line. While we're here, check for <=
+ * - we need to do it outside this conditional, but
+ * probably no extra cost at assembler level
+ */
+ if (df_current_index <= df_lower_index)
+ continue; /* dont tell client */
+
+ /* df_upper_index is MAXINT-1 if we are not doing index */
+ if (df_current_index > df_upper_index) {
+ /* oops - need to gobble rest of input if mixed */
+ if (mixed_data_fp)
+ continue;
+ else {
+ df_eof = 1;
+ return DF_EOF; /* no point continuing */
+ }
+ }
+ }
+ /* dont tell client if we haven't reached first index */
+ if (df_current_index < df_lower_index)
+ continue;
+
+ /* ignore blank lines after blank_index */
+ if (blank_count > 2)
+ continue;
+
+ return DF_FIRST_BLANK - (blank_count - 1);
+ }
+ /*}}} */
+
+ /* get here => was not blank */
+
+ blank_count = 0;
+
+ /*{{{ 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;
+ /*}}} */
+ /*}}} */
+
+ ++df_datum;
+
+ if (*df_format) {
+ /*{{{ do a sscanf */
+ int i;
+
+ assert(MAXDATACOLS == 7);
+
+ /* check we have room for at least 7 columns */
+ if (df_max_cols < 7) {
+ df_max_cols = 7;
+ df_column = gp_realloc(df_column,
+ df_max_cols * sizeof(df_column_struct),
+ "datafile columns");
+ }
+
+ df_no_cols = sscanf(line, df_format,
+ &df_column[0].datum,
+ &df_column[1].datum,
+ &df_column[2].datum,
+ &df_column[3].datum,
+ &df_column[4].datum,
+ &df_column[5].datum,
+ &df_column[6].datum);
+
+ if (df_no_cols == EOF) {
+ df_eof = 1;
+ return DF_EOF; /* tell client */
+ }
+ for (i = 0; i < df_no_cols; ++i) { /* may be zero */
+ df_column[i].good = DF_GOOD;
+ df_column[i].position = NULL; /* cant get a time */
+ }
+ /*}}} */
+ } else
+ df_tokenise(s);
+
+#ifdef EAM_DATASTRINGS
+ /* If we are supposed to read plot or key titles from the
+ * first line of the data then do that and nothing else. */
+ if (column_for_key_title != NO_COLUMN_HEADER) {
+ df_datum--;
+ if (!(*df_key_title)) {
+ FPRINTF((stderr,
+ "df_readline: missing column head for key title\n"));
+ return(DF_KEY_TITLE_MISSING);
+ }
+ df_parse_string_field(df_key_title, df_key_title);
+ FPRINTF((stderr,
+ "df_readline: Found key title in col %d %s\n",
+ column_for_key_title, df_key_title));
+ column_for_key_title = NO_COLUMN_HEADER;
+ key_title_auto_col = FALSE;
+ return(DF_FOUND_KEY_TITLE);
+ }
+#endif
+
+ /*{{{ copy column[] to v[] via use[] */
+ {
+#ifdef EAM_DATASTRINGS
+ int limit = (df_no_use_specs
+ ? df_no_use_specs + df_no_tic_specs
+ : MAXDATACOLS);
+
+ if (limit > max + df_no_tic_specs)
+ limit = max + df_no_tic_specs;
+#else
+ int limit = (df_no_use_specs ? df_no_use_specs : MAXDATACOLS);
+ if (limit > max)
+ limit = max;
+#endif
+
+ for (output = 0; output < limit; ++output) {
+ /* if there was no using spec, column is output+1 and
+ * at=NULL */
+ int column = use_spec[output].column;
+
+#ifdef EAM_DATASTRINGS
+ /* Handle cases where column holds a meta-data string */
+ /* Axis labels, plot titles, etc. */
+ if (use_spec[output].expected_type >= CT_XTICLABEL) {
+ char temp_string[MAX_TOKEN_LENGTH];
+ int axis, axcol;
+ float xpos;
+
+ switch (use_spec[output].expected_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:
+ /* EAM FIXME - Which column to set for cbtic? */
+ axis = COLOR_AXIS;
+ axcol = 3;
+ break;
+ }
+ /* FIXME EAM - Trap special case of only a single
+ * 'using' column. But really we need to handle
+ * general case of implicit column 0 */
+ if (output == 1)
+ xpos = (axcol == 0) ? df_datum : v[axcol-1];
+ else
+ xpos = v[axcol];
+#ifdef EAM_HISTOGRAMS
+ if (df_current_plot
+ && df_current_plot->plot_style == HISTOGRAMS) {
+ if (output == 2) /* Can only happen for HT_ERRORBARS */
+ xpos = (axcol == 0) ? df_datum : v[axcol-1];
+ xpos += df_current_plot->histogram->start;
+ }
+#endif
+
+#ifdef GP_STRING_VARS
+ /* Tic label is generated by a string-valued function */
+ if (use_spec[output].at) {
+ struct value a;
+ evaluate_inside_using = TRUE;
+ evaluate_at(use_spec[output].at, &a);
+ evaluate_inside_using = FALSE;
+ if (a.type == STRING) {
+ add_tic_user(axis,a.v.string_val, xpos, -1);
+ gpfree_string(&a);
+ } else
+ fprintf(stderr,"Tic label does not evaluate as string!\n");
+ } else
+#endif
+ {
+ df_parse_string_field(temp_string,df_tokens[output]);
+ add_tic_user(axis,temp_string, xpos, -1);
+ }
+#ifdef EAM_HISTOGRAMS
+ } else if (use_spec[output].expected_type == CT_KEYLABEL) {
+ char temp_string[MAX_TOKEN_LENGTH];
+ df_parse_string_field(temp_string,df_tokens[output]);
+ if (df_current_plot)
+ add_key_entry(temp_string,df_datum);
+#endif
+ } else
+#endif
+ 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)
+ return DF_UNDEFINED; /* store undefined point in plot */
+
+#if defined(GP_STRING_VARS) && defined(EAM_DATASTRINGS)
+ if (a.type == STRING) {
+ /* 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 ((df_axis[output] != -1)
+ && axis_array[df_axis[output]].is_timedata) {
+ struct tm tm;
+ if (gstrptime(a.v.string_val,
+ axis_array[df_axis[output]].timefmt, &tm))
+ v[output] = (double) gtimegm(&tm);
+ else /* FIXME - Is this correct? Is it needed? */
+ line_okay = 0;
+ }
+ gpfree_string(&a);
+ } else
+#endif
+ v[output] = real(&a);
+
+ } 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 <= 0) /* really < -2, but */
+ int_error(NO_CARET, "internal error: column <= 0 in datafile.c");
+ else if ((df_axis[output] != -1)
+ && (axis_array[df_axis[output]].is_timedata)) {
+ struct tm tm;
+ if (column > df_no_cols ||
+ df_column[column - 1].good == DF_MISSING ||
+ !df_column[column - 1].position ||
+ !gstrptime(df_column[column - 1].position,
+ axis_array[df_axis[output]].timefmt, &tm)
+ ) {
+ /* line bad only if user explicitly asked for this column */
+ if (df_no_use_specs)
+ line_okay = 0;
+
+ /* return or ignore line depending on line_okay */
+ break;
+ }
+ v[output] = (double) gtimegm(&tm);
+#ifdef EAM_DATASTRINGS
+ } else if (use_spec[output].expected_type == CT_STRING) {
+ /* Do nothing. */
+ /* String tokens were loaded into df_tokens already. */
+#endif
+ } else {
+ /* column > 0 */
+ if ((column <= df_no_cols)
+ && df_column[column - 1].good == DF_GOOD)
+ v[output] = df_column[column - 1].datum;
+ /* EAM - Oct 2002 Distinguish between
+ * DF_MISSING and DF_BAD. Previous versions
+ * would never notify caller of either case.
+ * Now missing data will be noted. Bad data
+ * should arguably be noted also, but that
+ * would change existing default behavior. */
+ else if ((column <= df_no_cols)
+ && (df_column[column - 1].good == DF_MISSING))
+ return DF_MISSING;
+ else {
+ /* line bad only if user explicitly asked
+ * for this column */
+ if (df_no_use_specs)
+ line_okay = 0;
+ break; /* return or ignore depending on line_okay */
+ }
+ }
+ }
+ }
+ /*}}} */
+
+ if (!line_okay)
+ continue;
+
+ /* output == df_no_use_specs if using was specified -
+ * actually, smaller of df_no_use_specs and max */
+#ifdef EAM_DATASTRINGS
+ /* FIXME EAM - In theory it might be useful for the caller to
+ * know whether or not tic specs were read from this line, but
+ * all callers would have to be modified to deal with it one
+ * way or the other. */
+ output -= df_no_tic_specs;
+#endif
+ assert(df_no_use_specs == 0
+ || output == df_no_use_specs
+ || output == max);
+
+ return output;
+
+ }
+ /*}}} */
+
+ /* get here => fgets failed */
+
+ /* no longer needed - mark column(x) as invalid */
+ df_no_cols = 0;
+
+ df_eof = 1;
+ return DF_EOF;
+}
+/*}}} */
+
+
+#ifndef BINARY_DATA_FILE
+/*{{{ int df_2dbinary(this_plot) */
+int
+df_2dbinary(struct curve_points *this_plot)
+{
+ (void) this_plot; /* avoid -Wunused warning */
+ int_error(NO_CARET, "Binary file format for 2d data not yet defined");
+ return 0; /* keep compiler happy */
+}
+/*}}} */
+#endif
+
+
+#ifndef BINARY_DATA_FILE /* NO LONGER REQUIRED FOR GENERAL BINARY DATA */
+/*{{{ int df_3dmatrix(this_plot, ret_this_iso) */
+/*
+ * formerly in gnubin.c
+ *
+ * modified by div for 3.6
+ * obey the 'every' field from df_open
+ * outrange points are marked as such, not omitted
+ * obey using - treat x as column 1, y as col 2 and z as col 3
+ * ( ie $1 gets x, $2 gets y, $3 gets z)
+ *
+ * we are less optimal for case of log plot and no using spec,
+ * (call log too often) but that is price for flexibility
+ * I suspect it didn't do autoscaling of x and y for log scale
+ * properly ?
+ *
+ * Trouble figuring out file format ! Is it
+
+ width x1 x2 x3 x4 x5 ...
+ y1 z11 z12 z13 z14 z15 ...
+ y2 x21 z22 z23 .....
+ . .
+ . .
+ . .
+
+ * with perhaps x and y swapped...
+ *
+ * - presumably rows continue to end of file, hence no indexing...
+ *
+ * Last update: 3/3/92 for Gnuplot 3.24.
+ * Created from code for written by RKC for gnuplot 2.0b.
+ *
+ * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu)
+ * Added user-specified bases for log scaling.
+ *
+ * Copyright (c) 1991,1992 Robert K. Cunningham, MIT Lincoln Laboratory
+ *
+ */
+
+/*
+ * Here we keep putting new plots onto the end of the linked list
+ *
+ * We assume the data's x,y values have x1<x2, x2<x3... and
+ * y1<y2, y2<y3... .
+ * Actually, I think the assumption is less strong than that--it looks like
+ * the direction just has to be the same.
+ *
+ * This routine expects all the 'axis array' variables (now gathered
+ * in axis.h) to be properly initialized
+ *
+ * does the autoscaling into the array versions (min_array[], max_array[]) */
+
+int
+df_3dmatrix(struct surface_points *this_plot, int need_palette)
+{
+ float GPFAR * GPFAR * dmatrix, GPFAR * rt, GPFAR * ct;
+ int nr, nc;
+ int width, height;
+ int row, col;
+ struct iso_curve *this_iso;
+ double used[4]; /* output from using manip */
+ /* evaluate used[0..use_spec_34] */
+ int use_spec_34 = (need_palette && df_no_use_specs == 4) ? 4 : 3;
+ struct coordinate GPHUGE *point; /* HBB 980308: added 'GPHUGE' flag */
+
+ assert(df_matrix);
+
+ if (df_eof)
+ return 0; /* hope caller understands this */
+
+ if (df_binary) {
+ if (!fread_matrix(data_fp, &dmatrix, &nr, &nc, &rt, &ct))
+ int_error(NO_CARET, "Binary file read error: format unknown!");
+ /* fread_matrix() drains the file */
+ df_eof = 1;
+ } else {
+ if (!(dmatrix = df_read_matrix(&nr, &nc))) {
+ df_eof = 1;
+ return 0;
+ }
+ /* HBB 20001208: implement 'index' for matrix files: don't return
+ * the data to caller if index is not among of the selected
+ * ones */
+ if (df_current_index < df_lower_index
+ || df_current_index > df_upper_index
+ || (df_current_index - df_lower_index) % df_index_step != 0
+ ) {
+ free_matrix(dmatrix, 0, nr - 1, 0);
+ df_current_index ++;
+ return 0;
+ }
+
+ rt = NULL;
+ ct = NULL;
+ }
+
+ if (nc == 0 || nr == 0)
+ int_error(NO_CARET, "Read grid of zero height or zero width");
+
+ this_plot->plot_type = DATA3D;
+ this_plot->has_grid_topology = TRUE;
+
+ if (df_no_use_specs != 0
+ && df_no_use_specs != 3
+ && df_no_use_specs != use_spec_34 /*3 or 4*/)
+ int_error(NO_CARET, "Current implementation requires full `using` spec");
+
+ if (need_palette && df_no_use_specs == 4)
+ this_plot->pm3d_color_from_column = 1;
+
+ /* columns are those in the binary data file, not those of `using` spec */
+ if (df_max_cols < 3) {
+ df_max_cols = 3;
+ df_column = gp_realloc(df_column,
+ df_max_cols * sizeof(df_column_struct),
+ "datafile columns");
+ }
+
+ df_no_cols = 3;
+ df_column[0].good = df_column[1].good = df_column[2].good = DF_GOOD;
+
+ assert(everyline > 0);
+ assert(everypoint > 0);
+ width = (nc - firstpoint + everypoint - 1) / everypoint; /* ? ? ? ? ? */
+ height = (nr - firstline + everyline - 1) / everyline; /* ? ? ? ? ? */
+
+ for (row = firstline; row < nr; row += everyline) {
+ df_column[1].datum = rt ? rt[row] : row;
+
+ /* Allocate the correct number of entries */
+ this_iso = iso_alloc(width);
+
+ point = this_iso->points;
+
+ /* Cycle through data */
+ for (col = firstpoint; col < nc; col += everypoint, ++point) {
+ /*{{{ process one point */
+ int i;
+
+ df_column[0].datum = ct ? ct[col] : col;
+ df_column[2].datum = dmatrix[row][col];
+
+ /*{{{ pass through using spec */
+ for (i = 0; i < use_spec_34; ++i) {
+ int column = use_spec[i].column;
+
+ if (df_no_use_specs == 0)
+ used[i] = df_column[i].datum;
+ else if (use_spec[i].at) {
+ struct value a;
+ evaluate_inside_using = TRUE;
+ evaluate_at(use_spec[i].at, &a);
+ evaluate_inside_using = FALSE;
+ if (undefined) {
+ point->type = UNDEFINED;
+ goto skip; /* continue _outer_ loop */
+ }
+ used[i] = real(&a);
+ } else if (column < 1 || column > df_no_cols) {
+ point->type = UNDEFINED;
+ goto skip;
+ } else
+ used[i] = df_column[column - 1].datum;
+ }
+ /*}}} */
+ if (df_no_use_specs != 4)
+ used[3] = used[2]; /* 3 parameters of `using` => 4th color-value equals z-value */
+
+ point->type = INRANGE; /* so far */
+
+ STORE_WITH_LOG_AND_UPDATE_RANGE(point->x, used[0], point->type, FIRST_X_AXIS, NOOP, goto skip);
+ STORE_WITH_LOG_AND_UPDATE_RANGE(point->y, used[1], point->type, FIRST_Y_AXIS, NOOP, goto skip);
+ STORE_WITH_LOG_AND_UPDATE_RANGE(point->z, used[2], point->type, FIRST_Z_AXIS, NOOP, goto skip);
+ if (need_palette) {
+ COLOR_STORE_WITH_LOG_AND_UPDATE_RANGE(point->CRD_COLOR, used[3], point->type, COLOR_AXIS, NOOP, goto skip);
+ }
+
+ /* some of you won't like this, but I say goto is for this */
+
+ skip:
+ ; /* ansi requires this */
+ /*}}} */
+ }
+ this_iso->p_count = width;
+ this_iso->next = this_plot->iso_crvs;
+ this_plot->iso_crvs = this_iso;
+ this_plot->num_iso_read++;
+ }
+
+ free_matrix(dmatrix, 0, nr - 1, 0);
+ if (rt)
+ free_vector(rt, 0);
+ if (ct)
+ free_vector(ct, 0);
+
+ /* HBB 20001208: implement 'index' for matrix datafiles */
+ df_current_index ++;
+
+ return (nc);
+}
+
+/*}}} */
+
+#else /* REPLACED BY df_readbinary() READING JUST THE FIRST ROW AND SAVING FOR LATER USE. */
+
+char *read_error_msg = "Data file read error";
+double df_matrix_corner[2][2]; /* First argument is corner, second argument is x (0) or y(1). */
+
+float
+df_read_a_float(FILE *fin) {
+ float fdummy;
+ if (fread(&fdummy, sizeof(fdummy), 1, fin) != 1) {
+ if (feof(fin))
+ int_error(NO_CARET, "Data file is empty");
+ else
+ int_error(NO_CARET, read_error_msg);
+ }
+ df_swap_bytes_by_endianess((char *)&fdummy, byte_read_order(df_bin_file_endianess), sizeof(fdummy));
+ return fdummy;
+}
+
+void
+df_determine_matrix_info(FILE *fin)
+{
+
+ if (df_binary_file) {
+
+ /* Binary matrix format. */
+ float fdummy;
+ int nc, nr;
+ long flength;
+
+ /* Read first value for number of columns. */
+ fdummy = df_read_a_float(fin);
+ nc = ((size_t) fdummy);
+ if (nc == 0)
+ int_error(NO_CARET, "Read grid of zero width");
+ else if (nc > 1e8)
+ int_error(NO_CARET, "Read grid width too large"); /* A sanity check on reading absurd numbers. */
+
+ /* Read second value for corner_0 x. */
+ fdummy = df_read_a_float(fin);
+ df_matrix_corner[0][0] = fdummy;
+
+ /* Read nc+1 value for corner_1 x. */
+ if (nc > 1) {
+ fseek(fin, (nc-2)*sizeof(float), SEEK_CUR);
+ fdummy = df_read_a_float(fin);
+ }
+ df_matrix_corner[1][0] = fdummy;
+
+ /* Read nc+2 value for corner_0 y. */
+ df_matrix_corner[0][1] = df_read_a_float(fin);
+
+ /* Compute length of file and number of columns. */
+ fseek(fin, 0L, SEEK_END);
+ flength = ftell(fin)/sizeof(float);
+ nr = flength/(nc + 1);
+ if (nr*(nc + 1) != flength)
+ int_error(NO_CARET, "File doesn't factorize into full matrix");
+
+ /* Read last value for corner_1 y */
+ fseek(fin, -(nc + 1)*sizeof(float), SEEK_END);
+ df_matrix_corner[1][1] = df_read_a_float(fin);
+
+ /* Set up scan information for df_readbinary(). */
+ df_bin_record[0].scan_dim[0] = nc;
+ df_bin_record[0].scan_dim[1] = nr;
+
+ /* Reset counter file pointer. */
+ fseek(fin, 0L, SEEK_SET);
+
+ } else {
+
+ /* ASCII matrix format, converted to binary memory format. */
+ static float *matrix = NULL;
+ int nr, nc;
+
+ /* Insurance against creating a matrix with df_read_matrix()
+ * and then erroring out through df_add_binary_records().
+ */
+ if (matrix)
+ free(matrix);
+
+ /* Set important binary variables, then free memory for all default
+ * binary records and set number of records to 0. */
+ initialize_binary_vars();
+ clear_binary_records(DF_CURRENT_RECORDS);
+
+ /* Keep reading matrices until file is empty. */
+ while (1) {
+ if ((matrix = df_read_matrix(&nr, &nc)) != NULL) {
+ int index = df_num_bin_records;
+ /* *** Careful! Could error out in next step. "matrix" should
+ * be static and test next time. ***
+ */
+ df_add_binary_records(1, DF_CURRENT_RECORDS);
+ df_bin_record[index].memory_data = (char *) matrix;
+ matrix = NULL;
+ df_bin_record[index].scan_dim[0] = nc;
+ df_bin_record[index].scan_dim[1] = nr;
+ df_bin_record[index].scan_dim[2] = 0;
+ df_bin_file_endianess = THIS_COMPILER_ENDIAN;
+ } else
+ break;
+ }
+
+ /* Data from file is now in memory. Make the rest of gnuplot think
+ * that the data stream has not yet reached the end of file.
+ */
+ df_eof = 0;
+
+ }
+
+}
+#endif
+
+
+/* stuff for implementing the call-backs for picking up data values
+ * do it here so we can make the variables private to this file
+ */
+
+/*{{{ void f_dollars(x) */
+void
+f_dollars(union argument *x)
+{
+ int column = x->v_arg.v.int_val - 1;
+ /* we checked it was an integer >= 0 at compile time */
+ struct value a;
+
+ if (column == -1) {
+ push(Gcomplex(&a, (double) df_datum, 0.0)); /* $0 */
+ } else if (column >= df_no_cols || df_column[column].good != DF_GOOD) {
+ undefined = TRUE;
+ push(&(x->v_arg)); /* this okay ? */
+ } else
+ push(Gcomplex(&a, df_column[column].datum, 0.0));
+}
+
+/*}}} */
+
+/*{{{ void f_column() */
+void
+f_column(union argument *arg)
+{
+ struct value a;
+ int column;
+
+ (void) arg; /* avoid -Wunused warning */
+ (void) pop(&a);
+ column = (int) real(&a);
+
+ if (!evaluate_inside_using)
+ int_error(c_token-1, "column() called from invalid context");
+
+ if (column == -2)
+ push(Ginteger(&a, df_current_index));
+ else if (column == -1)
+ push(Ginteger(&a, line_count));
+ else if (column == 0) /* $0 = df_datum */
+ push(Gcomplex(&a, (double) df_datum, 0.0));
+ else if (column < 1
+ || column > df_no_cols
+ || df_column[column - 1].good != DF_GOOD
+ ) {
+ undefined = TRUE;
+ push(&a); /* any objection to this ? */
+ } else
+ push(Gcomplex(&a, df_column[column - 1].datum, 0.0));
+}
+
+/* Called from int_error() */
+void
+df_reset_after_error()
+{
+ evaluate_inside_using = FALSE;
+}
+
+#ifdef GP_STRING_VARS
+void
+f_stringcolumn(union argument *arg)
+{
+ struct value a;
+ int column;
+
+ (void) arg; /* avoid -Wunused warning */
+ (void) pop(&a);
+ column = (int) real(&a);
+
+ if (!evaluate_inside_using)
+ int_error(c_token-1, "stringcolumn() called from invalid context");
+
+ if (column < 1 || column > df_no_cols) {
+ undefined = TRUE;
+ push(&a); /* any objection to this ? */
+ } else {
+ static char temp_string[MAX_TOKEN_LENGTH];
+ df_parse_string_field(temp_string, df_column[column-1].position);
+ push(Gstring(&a, temp_string ));
+ }
+}
+#endif
+
+/*{{{ void f_valid() */
+void
+f_valid(union argument *arg)
+{
+ struct value a;
+ int column, good;
+
+ (void) arg; /* avoid -Wunused warning */
+ (void) pop(&a);
+ column = (int) magnitude(&a) - 1;
+ good = column >= 0
+ && column < df_no_cols
+ && df_column[column].good == DF_GOOD;
+ push(Ginteger(&a, good));
+}
+
+/*}}} */
+
+/*{{{ void f_timecolumn() */
+/* HBB NOTE 20050505: this job is excessively tricky. We have one
+ * timefmt string per axis. Back then, that was essentially the only
+ * possibility, but it now poses a severe limitation. For simple
+ * using specs, the time parsing format should be a function of the
+ * column number in the datafile, not of the axis the data will be
+ * used for. For extended using specs, the value to go on a given
+ * axis could conceivably be built from multiple time/date entries in
+ * the datafile, each with its own format. */
+/* HBB FIXME 20050505: this really should take two arguments, at
+ * least. First, the datafile column number. Second either a timefmt
+ * string (variable), or an axis index. For now, we have to try to
+ * guess the right axis index */
+void
+f_timecolumn(union argument *arg)
+{
+ struct value a;
+ int column, spec;
+ AXIS_INDEX whichaxis;
+ struct tm tm;
+ int limit = (df_no_use_specs ? df_no_use_specs : MAXDATACOLS);
+
+ (void) arg; /* avoid -Wunused warning */
+ (void) pop(&a);
+ column = (int) magnitude(&a); /* HBB 20050505: removed - 1*/
+
+ if (!evaluate_inside_using)
+ int_error(c_token-1, "timecolumn() called from invalid context");
+
+ /* try to match datafile column with spec field number */
+ whichaxis = FIRST_X_AXIS;
+ for (spec = 0; spec<limit; spec++)
+ if(use_spec[spec].column == column) {
+ /* Found a 'using' specifier whose (default) column number
+ * is the same as the column being referred to here. So
+ * assume this spec's output axis is the one that we want
+ * to use the timefmt of. */
+ whichaxis = df_axis[spec];
+ break;
+ }
+
+ if (column < 1
+ || column > df_no_cols
+ || !df_column[column - 1].position
+ || !gstrptime(df_column[column - 1].position,
+ axis_array[whichaxis].timefmt, &tm)) {
+ undefined = TRUE;
+ push(&a); /* any objection to this ? */
+ } else
+ push(Gcomplex(&a, gtimegm(&tm), 0.0));
+}
+
+/*}}} */
+
+#if 0 /* not used */
+/*{{{ static int get_time_cols(fmt) */
+/* count columns in timefmt */
+static int
+get_time_cols(char *fmt)
+{
+ int cnt, i;
+ char *p;
+
+ p = fmt;
+ cnt = 0;
+ while (isspace((unsigned char) *p))
+ p++;
+ if (!strlen(p))
+ int_error(NO_CARET, "Empty time-data format");
+ cnt++;
+ for (i = 0; i < strlen(p) - 1; i++) {
+ if (isspace((unsigned char) p[i])
+ && !isspace((unsigned char) p[i + 1]))
+ cnt++;
+ }
+ return (cnt);
+}
+/*}}} */
+
+/*{{{ static void mod_def_usespec(specno,jump) */
+/* modify default use_spec, applies for no user spec and time datacolumns */
+static void
+mod_def_usespec(
+ int specno, /* which spec in ?:?:? */
+ int jump) /* no of columns in timefmt (time data) */
+{
+ int i;
+
+ for (i = specno + 1; i < MAXDATACOLS; ++i)
+ use_spec[i].column += jump; /* add no of columns in time to the rest */
+ df_no_use_specs = 0;
+}
+
+/*}}} */
+#endif /* not used */
+
+/*{{{ static int check_missing(s) */
+static int
+check_missing(char *s)
+{
+ if (missing_val != NULL) {
+ size_t len = strlen(missing_val);
+ if (strncmp(s, missing_val, len) == 0 &&
+ (isspace((unsigned char) s[len]) || !s[len]))
+ return 1; /* store undefined point in plot */
+ }
+ return (0);
+}
+
+/*}}} */
+
+
+/* formerly in misc.c, but only used here */
+/* check user defined format strings for valid double conversions */
+/* HBB 20040601: Added check that the number of format specifiers is
+ * workable (between 0 and 7) */
+static TBOOLEAN
+valid_format(const char *format)
+{
+ int formats_found = 0;
+
+ for (;;) {
+ if (!(format = strchr(format, '%'))) /* look for format spec */
+ return (formats_found > 0 && formats_found <= 7);
+
+ /* Found a % to check --- scan past option specifiers: */
+ do {
+ format++;
+ } while (strchr("+-#0123456789.", *format));
+
+ /* Now at format modifier */
+ switch (*format) {
+ case '*': /* Ignore '*' statements */
+ case '%': /* Char '%' itself */
+ format++;
+ continue;
+ case 'l': /* Now we found it !!! */
+ if (!strchr("fFeEgG", format[1])) /* looking for a valid format */
+ return FALSE;
+ formats_found++;
+ format++;
+ break;
+ default:
+ return FALSE;
+ }
+ }
+}
+
+#ifdef EAM_DATASTRINGS
+/*
+ * Plotting routines can call this prior to invoking df_readline() to indicate
+ * that they expect a certain column to contain an ascii string rather than a
+ * number.
+ */
+int
+expect_string(const char column)
+{
+ use_spec[column-1].expected_type = CT_STRING;
+ FPRINTF((stderr,"expecting to find string in input column %d\n",use_spec[column-1].column));
+ return(use_spec[column-1].column);
+}
+
+/*
+ * Load plot title for key box from the string found earlier by df_readline.
+ * Called from get_data().
+ */
+void
+df_set_key_title(struct curve_points *plot)
+{
+#ifdef EAM_HISTOGRAMS
+ if (plot->plot_style == HISTOGRAMS
+ && histogram_opts.type == HT_STACKED_IN_TOWERS) {
+ /* In this case it makes no sense to treat key titles in the usual */
+ /* way, so we assume that it is supposed to be an xtic label. */
+ /* FIXME EAM - This style should default to notitle! */
+ double xpos = plot->histogram_sequence + plot->histogram->start;
+ add_tic_user(FIRST_X_AXIS, df_key_title, xpos, -1);
+ df_key_title[0] = '\0';
+ return;
+ }
+#endif
+
+ /* What if there was already a title specified? */
+ if (plot->title && !plot->title_is_filename)
+ return;
+ if (plot->title_is_suppressed)
+ return;
+ if (plot->title)
+ free(plot->title);
+
+ plot->title = gp_strdup(df_key_title);
+ plot->title_no_enhanced = !keyT.enhanced;
+}
+
+static void
+df_parse_string_field(char *string, char *field)
+{
+ char temp_string[MAX_TOKEN_LENGTH];
+ temp_string[sizeof(temp_string)-1] = '\0';
+
+ if (!field) {
+ *string = '\0';
+ return;
+ } else if (*field == '"') {
+ strncpy(temp_string,&(field[1]),sizeof(temp_string)-1);
+ temp_string[strcspn(temp_string,"\"")] = '\0';
+ } else if (df_separator != '\0') {
+ char eor[3];
+ eor[0] = df_separator; eor[1] = '"'; eor[2] = '\0';
+ strncpy(temp_string,field,sizeof(temp_string)-1);
+ temp_string[strcspn(temp_string,eor)] = '\0';
+ } else {
+ strncpy(temp_string,field,sizeof(temp_string)-1);
+ temp_string[strcspn(temp_string,"\t ")] = '\0';
+ }
+ parse_esc(temp_string);
+ strcpy(string,temp_string);
+}
+
+#ifdef EAM_HISTOGRAMS
+static void
+add_key_entry(char *temp_string, int df_datum)
+{
+ text_label *new_entry = gp_alloc(sizeof(text_label), "key entry");
+
+ /* Associate this key list with the histogram it belongs to. */
+ if (!df_current_plot->labels) {
+ /* The first text_label structure in the list is a place-holder */
+ df_current_plot->labels = gp_alloc(sizeof(text_label), "key entry");
+ memset(df_current_plot->labels, 0, sizeof(text_label));
+ df_current_plot->labels->tag = -1;
+ }
+
+ new_entry->text = gp_strdup(temp_string);
+ new_entry->tag = df_datum;
+ new_entry->font = NULL;
+ new_entry->next = df_current_plot->labels->next;
+ df_current_plot->labels->next = new_entry;
+}
+#endif
+
+#endif /* EAM_DATASTRINGS */
+
+
+#ifdef BINARY_DATA_FILE
+
+/* Construct 2D rotation matrix. */
+/* R - Matrix to construct. */
+/* alpha - Rotation angle. */
+/* return - TRUE means a translation is required. */
+TBOOLEAN
+rotation_matrix_2D(double R[][2], double alpha)
+{
+ static double I[2][2] = {{1, 0},
+ {0, 1}};
+#define ANGLE_TOLERANCE 0.001
+ if (fabs(alpha) < ANGLE_TOLERANCE) {
+ /* Zero angle. Unity rotation. */
+ memcpy(R, I, sizeof(I));
+ return FALSE;
+ } else {
+ R[0][0] = cos(alpha);
+ R[0][1] = -sin(alpha);
+ R[1][0] = sin(alpha);
+ R[1][1] = cos(alpha);
+ return TRUE;
+ }
+}
+
+
+/* Construct 3D rotation matrix. */
+/* P - Matrix to construct. */
+/* p - Pointer to perpendicular vector. */
+/* return - TRUE means a translation is required. */
+TBOOLEAN
+rotation_matrix_3D(double P[][3], double *p)
+{
+ static double I[3][3] = {{1, 0, 0},
+ {0, 1, 0},
+ {0, 0, 1}};
+ double scale, C1, C2;
+#define x p[0]
+#define y p[1]
+#define z p[2]
+ C1 = sqrt(x*x + y*y + z*z);
+ C2 = sqrt(x*x + y*y);
+ /* ????? Is there a precision constant for doubles similar to what is in limits.h for other types? */
+ if ((C1 < 10e-10) || (C2 < (10e-5*C1))) {
+ /* Zero vector (invalid) || vector perpendiculat to x/y plane. Unity rotation. */
+ memcpy(P, I, sizeof(I));
+ return FALSE;
+ } else {
+ scale = 1.0/(C1*C2);
+ P[0][0] = x*z * scale;
+ P[0][1] = -y*C1 * scale;
+ P[0][2] = x*C2 * scale;
+ P[1][0] = y*z * scale;
+ P[1][1] = x*C1 * scale;
+ P[1][2] = y*C2 * scale;
+ P[2][0] = -C2*C2 * scale;
+ P[2][1] = 0;
+ P[2][2] = z*C2 * scale;
+ return TRUE;
+ }
+#undef x
+#undef y
+#undef z
+}
+
+
+df_byte_read_order_type
+byte_read_order (df_endianess_type file_endian)
+{
+ /* Range limit file endianess to ensure that future file type function
+ * programmer doesn't incorrectly access array and cause segmentation
+ * fault unknowingly.
+ */
+ return df_byte_read_order_map[THIS_COMPILER_ENDIAN][GPMIN(file_endian, DF_ENDIAN_TYPE_LENGTH-1)];
+}
+
+
+void
+df_unset_datafile_binary(void)
+{
+ clear_binary_records(DF_DEFAULT_RECORDS);
+ df_bin_filetype_default = df_bin_filetype_reset;
+ df_bin_file_endianess_default = DF_BIN_FILE_ENDIANESS_RESET;
+}
+
+
+void
+df_set_datafile_binary()
+{
+ c_token++;
+ if (END_OF_COMMAND)
+ int_error(c_token, "option expected");
+ clear_binary_records(DF_CURRENT_RECORDS);
+ /* Set current records to default in order to retain current default settings. */
+ if (df_bin_record_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);
+ }
+ /* Process the binary tokens. */
+ df_set_plot_mode(MODE_QUERY);
+ plot_option_binary(FALSE, TRUE);
+ /* Copy the modified settings as the new default settings. */
+ df_bin_filetype_default = df_bin_filetype;
+ df_bin_file_endianess_default = df_bin_file_endianess;
+ clear_binary_records(DF_DEFAULT_RECORDS);
+ df_add_binary_records(df_num_bin_records, DF_DEFAULT_RECORDS);
+ memcpy(df_bin_record_default, df_bin_record, df_num_bin_records_default*sizeof(df_binary_file_record_struct));
+}
+
+
+void
+gpbin_filetype_function(void)
+{
+ /* Gnuplot binary. */
+ df_matrix_file = TRUE;
+ df_binary_file = TRUE;
+}
+
+
+void
+raw_filetype_function(void)
+{
+ /* No information in file, just data. */
+ df_matrix_file = FALSE;
+ df_binary_file = TRUE;
+}
+
+
+void
+avs_filetype_function(void)
+{
+ /* A very simple file format:
+ * 8 byte header (width and height, 4 bytes each), unknown endian
+ * followed by 4 bytes per pixel (alpha, red, green, blue).
+ */
+
+ FILE *fp;
+ unsigned long M, N;
+ int read_order = 0;
+
+ /* open (header) file */
+ fp = loadpath_fopen(df_filename, "rb");
+ if (!fp)
+ os_error(NO_CARET, "Can't open data file \"%s\"", df_filename);
+
+ /* read header: it is only 8 bytes */
+ if (!fread(&M, 4, 1, fp))
+ os_error(NO_CARET, "Can't read first dimension in data file \"%s\"", df_filename);
+ if (M > 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. Treat as three components
+ with the first one ignored. */
+ df_extend_binary_columns(3);
+ df_set_read_type(1, DF_UCHAR); /* Each pixel component is 1 byte */
+ df_set_read_type(2, DF_UCHAR);
+ df_set_read_type(3, DF_UCHAR);
+ df_set_skip_before(1,1); /* Ignore the alpha component of 4-tuple */
+
+ df_no_use_specs = 3;
+ use_spec[0].column = 1;
+ use_spec[1].column = 2;
+ use_spec[2].column = 3;
+
+}
+
+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.
+ */
+#define LAST_PLOT_STYLE 26
+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[LAST_PLOT_STYLE + 1] = {
+ {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},
+ {HISTEPS, 1, 1},
+ {VECTOR, 2, 2},
+ {CANDLESTICKS, 4, 1},
+ {FINANCEBARS, 4, 1},
+ {XERRORLINES, 2, 1},
+ {YERRORLINES, 2, 1},
+ {XYERRORLINES, 3, 1},
+ {FILLEDCURVES, 1, 1},
+ {PM3DSURFACE, 1, 2},
+#ifdef EAM_DATASTRINGS
+ {LABELPOINTS, 2, 1},
+#endif
+#ifdef EAM_HISTOGRAMS
+ {HISTOGRAMS, 1, 0},
+#endif
+#ifdef WITH_IMAGE
+ {IMAGE, 1, 2},
+ {RGBIMAGE, 3, 2}
+#endif
+};
+
+
+static void
+adjust_binary_use_spec()
+{
+
+ char *nothing_known = "No default columns known for that plot style";
+ enum PLOT_STYLE plot_style;
+ unsigned ps_index;
+ int c_token_copy;
+
+ /* This may appear strange, but ASCII matrix is not the same
+ * format as gnuplot matrix binary. So, although the ASCII
+ * *file* may be matrix, it's data structure is similar to
+ * an M x N general binary file, i.e., no extra row and column
+ * for sample coordinates.
+ */
+ df_matrix_binary = (df_matrix_file && df_binary_file);
+
+ c_token_copy = c_token;
+ for (; !END_OF_COMMAND; c_token++)
+ if (almost_equals(c_token, "w$ith"))
+ break;
+ if (!END_OF_COMMAND)
+ plot_style = get_style();
+ else
+ plot_style = LINES;
+ c_token = c_token_copy;
+
+ /* 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;
+ }
+ if (ps_index == sizeof(default_style_cols)/sizeof(default_style_cols[0]))
+ int_error(c_token_copy, nothing_known);
+
+ /* Matrix format is interpretted 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(c_token_copy, 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(c_token_copy, "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 <= MAXDATACOLS);
+
+ /* Nothing need be done here to set the using specs because they
+ * will have been initialized appropriately and left unaltered.
+ * So just set the number of specs.
+ */
+ df_no_use_specs = no_cols;
+ df_extend_binary_columns(no_cols);
+
+ } else {
+
+ /* Number of columns is fixed at three and no using specs given. Do what we can.
+ * The obvious best combination is two dimensional coordinates and one information
+ * value. One wonders what to do if a matrix is only one column; can be treated
+ * as linear? This isn't implemented here, but if it were, this is where it
+ * should go.
+ */
+
+ if ((default_style_cols[ps_index].dimen_in_2d == 2)
+ && (default_style_cols[ps_index].excluding_gen_coords == 1)) {
+ df_no_use_specs = 3;
+ } else if ((default_style_cols[ps_index].dimen_in_2d == 1)
+ && (default_style_cols[ps_index].excluding_gen_coords == 1) ) {
+ if (df_plot_mode == MODE_SPLOT)
+ df_no_use_specs = 3;
+ else {
+ /* Command: plot 'foo' matrix with no using spec */
+ /* Matix element treated as y value rather than z value */
+ df_no_use_specs = 2;
+ use_spec[1].column = 3;
+ }
+ } else
+ int_error(NO_CARET, "Plot style does not conform to three column data in this graph mode");
+ }
+
+ }
+
+ /* Adjust for ASCII matrix format. The first two "columns" come from indices. */
+ if (df_matrix_file && !df_binary_file) {
+ }
+
+ if (df_num_bin_records && df_bin_record[0].scan_generate_coord && !df_matrix_file) {
+
+ int i;
+
+ struct use_spec_s original_use_spec[MAXDATACOLS];
+ int added_columns = 0;
+
+ /* Keep record of the original using specs. */
+ memcpy(original_use_spec, use_spec, sizeof(use_spec));
+
+ /* Put in columns at front for generated variables. */
+ for (i = 0; i < 3; i++) {
+ if (df_bin_record[0].cart_dim[i] || df_bin_record[0].scan_dim[i])
+ added_columns++;
+ else
+ break;
+ }
+ if ((df_no_use_specs + added_columns) >= MAXDATACOLS)
+ int_error(NO_CARET, too_many_cols_msg);
+ else {
+
+ /* Shift the original columns over by added number of columns, but only
+ * if not matrix data.
+ */
+ memcpy(&use_spec[added_columns], original_use_spec, df_no_use_specs*sizeof(use_spec[0]));
+
+ /* 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 memcpy().
+ */
+ for (i = 0; i < added_columns; i++) {
+ use_spec[i].column = df_bin_record[0].cart_scan[i];
+ use_spec[i].at = NULL; /* Not a bad memory pointer overwrite!! */
+ }
+
+ df_no_use_specs += added_columns; /* Do not extend columns for generated coordinates. */
+ }
+
+ if (df_plot_mode == MODE_SPLOT) {
+
+ /* For binary data having an implied uniformly sampled grid, treat
+ * less than three-dimensional data in special ways based upon what
+ * is being plotted.
+ */
+ int k;
+ for (k = 0; k < df_num_bin_records; k++) {
+ if ((df_bin_record[k].cart_dim[2] == 0) && (df_bin_record[k].scan_dim[2] == 0)) {
+ if (default_style_cols[ps_index].dimen_in_2d > 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)
+{
+#define MAX_FILE_EXT_LEN 10
+ char file_ext[MAX_FILE_EXT_LEN+1];
+
+ 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;
+#if BINARY_HAS_OWN_FORMAT_STRING
+ TBOOLEAN set_format = FALSE;
+#endif
+
+ /* Binary file type must be the first word in the command following `binary`" */
+ if (almost_equals(c_token, "file$type") || (df_bin_filetype >= 0)) {
+ int i;
+
+ /* 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")) {
+ c_token++;
+#define EQUAL_SYMBOL_NOT_REQUIRED 0
+#if EQUAL_SYMBOL_NOT_REQUIRED
+ /* Ignore or do not require equal symbol. */
+ if (equals(c_token, "=")) c_token++;
+#else
+ /* else equal symbol. */
+ if (!equals(c_token, "="))
+ int_error(c_token, equal_symbol_msg);
+ c_token++;
+#endif
+ copy_str(file_ext, c_token, MAX_FILE_EXT_LEN);
+
+ for (i=0; i < (sizeof(df_bin_filetype_table)/sizeof(df_bin_filetype_table_struct)); i++) {
+ if (!strcasecmp(file_ext, df_bin_filetype_table[i].extension)) {
+ df_bin_filetype = i;
+ break;
+ }
+ }
+ if (i == (sizeof(df_bin_filetype_table)/sizeof(df_bin_filetype_table_struct)))
+ int_error(c_token, "Unsupported file type");
+ c_token++;
+
+ }
+
+ /* This section of code entails being able to read various types of
+ * binary data files. Some decisions need to be made on exactly what
+ * type or how many kinds should be allowed. Perhaps some system
+ * similar to the terminal scheme can be devised so that volunteers
+ * can provide code to read their favorite file type.
+ *
+ * My suggestion for a good scheme would be to have short little
+ * routines that look into the file in question and pull from the
+ * header the necessary information to fill in the details about
+ * "record", "array", "skip", etc. Then just let the current gnuplot
+ * code continue on. If the data file in question has compressed
+ * or encoded data, perhaps the data could be uncompressed or decoded
+ * into an intermediate, temporary file. In that case, the file name
+ * could be changed to the temporary file name and, again, just let
+ * gnuplot continue. Other approaches are possible.
+ */
+ if (!strcasecmp("auto", df_bin_filetype_table[df_bin_filetype].extension) && (df_plot_mode != MODE_QUERY)) {
+ int i;
+ char *ext_start = strrchr (df_filename, '.');
+ if (!ext_start)
+ df_bin_filetype = RAW_FILETYPE;
+ else {
+ strncpy(file_ext, (ext_start+1), MAX_FILE_EXT_LEN);
+ for (i=0; i < (sizeof(df_bin_filetype_table)/sizeof(df_bin_filetype_table_struct)); i++) {
+ if (!strcasecmp(file_ext, df_bin_filetype_table[i].extension)) {
+ df_bin_filetype = i;
+ break;
+ }
+ }
+ if (i == (sizeof(df_bin_filetype_table)/sizeof(df_bin_filetype_table_struct)))
+ int_error(c_token, "Unsupported file type");
+ }
+ }
+
+ /* Unless only querying settings, call the routine to prep binary data parameters. */
+ if (df_plot_mode != MODE_QUERY)
+ df_bin_filetype_table[df_bin_filetype].function();
+
+ /* 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;
+ continue;
+ }
+
+ /* look for array */
+ if (almost_equals(c_token, "arr$ay")) {
+ 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();
+ {int i;
+ for (i = 0; i < df_num_bin_records; i++)
+ df_bin_record[i].scan_generate_coord = TRUE; /* Indicate that coordinate info should be generated by gnuplot code. */
+ }
+ set_array = TRUE;
+ 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 EQUAL_SYMBOL_NOT_REQUIRED
+ if (!equals(c_token, "=") && !isanumber(c_token)) {
+#else
+ if (!equals(c_token, "=")) {
+#endif
+ 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 EQUAL_SYMBOL_NOT_REQUIRED
+ if (!equals(c_token, "=") && !isanumber(c_token)) {
+#else
+ if (!equals(c_token, "=")) {
+#endif
+ 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 EQUAL_SYMBOL_NOT_REQUIRED
+ if (!equals(c_token, "=") && !isanumber(c_token)) {
+#else
+ if (!equals(c_token, "=")) {
+#endif
+ 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++;
+ 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;
+ 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++;
+#if EQUAL_SYMBOL_NOT_REQUIRED
+ /* Ignore or do not require equal symbol. */
+ if (equals(c_token, "=")) c_token++;
+#else
+ /* Require equal symbol. */
+ if (!equals(c_token, "="))
+ int_error(c_token, equal_symbol_msg);
+ c_token++;
+#endif
+ 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;
+ }
+
+#if BINARY_HAS_OWN_FORMAT_STRING
+ /* deal with various types of binary files */
+ if (almost_equals(c_token, "form$at")) {
+ if (set_default)
+ int_error(c_token, "Sorry - default binary properties not fully implemented");
+ 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;
+#if EQUAL_SYMBOL_NOT_REQUIRED
+ /* Ignore or do not require equal symbol. */
+ if (equals(c_token, "=")) c_token++;
+#else
+ /* Require equal symbol. */
+ if (!equals(c_token, "="))
+ int_error(c_token, equal_symbol_msg);
+ c_token++;
+#endif
+ if (isstring(c_token))
+ plot_option_binary_format();
+ else
+ int_error(c_token, "Expecting format string");
+ set_format = TRUE;
+ continue;
+ }
+#endif
+
+ break; /* unknown option */
+
+ } /* while (!END_OF_COMMAND) */
+
+ if (duplication)
+ int_error(c_token, "Duplicated or contradicting arguments in datafile options");
+
+}
+
+
+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");
+ if (!*bin_record) {
+ *max_num_bin_records = 0;
+ int_error(c_token,
+ "Error assigning memory for 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;
+}
+
+
+#define TUPLE_SEPARATOR_CHAR ":"
+#define LEFT_TUPLE_CHAR "(" /* Parser problems with (#,#) considered complex. */
+#define RIGHT_TUPLE_CHAR ")"
+
+static void
+plot_option_array(void)
+{
+ /* Process command line definition of array. */
+ if (!END_OF_COMMAND) {
+ int number_of_records = 0;
+ char *token_string;
+ TBOOLEAN expecting_number;
+ int ival;
+ int i_dimension = 0;
+
+#if EQUAL_SYMBOL_NOT_REQUIRED
+ /* Ignore or do not require equal symbol. */
+ if (equals(c_token, "="))
+ c_token++;
+#else
+ /* Require equal symbol. */
+ if (!equals(c_token, "="))
+ int_error(c_token, equal_symbol_msg);
+ c_token++;
+#endif
+
+ /* Set true in case user starts string with a comma. */
+ expecting_number = TRUE;
+
+ /* If the user has no space between 'x' or 'X' and number, the
+ * parser creates a single token x#. So, copy string and work
+ * with that rather than the tokens directly. Null terminate
+ * and point to empty string. */
+ c_token--;
+ df_format[0] = '\0';
+ token_string = df_format;
+
+ while (1) {
+ if (*token_string == '\0') {
+ c_token++;
+ if (END_OF_COMMAND) break;
+ copy_str(df_format, c_token, MAX_LINE_LEN);
+ token_string = df_format;
+ }
+
+ if (expecting_number
+ && !(isdigit(*token_string)
+ || !strncasecmp(token_string, "Inf", 3)))
+ break;
+
+ if (!strcmp(token_string, TUPLE_SEPARATOR_CHAR)) {
+ i_dimension = 0;
+ token_string++;
+ expecting_number = TRUE;
+ continue;
+ }
+
+ if ((*token_string=='x') || (*token_string=='X') ) {
+ i_dimension++;
+ if (i_dimension >= 2)
+ int_error(c_token,
+ "Currently do not support sampled array dimensions greater than 2");
+ expecting_number = TRUE;
+ token_string++;
+ continue;
+ }
+
+ if (!expecting_number
+ && (isdigit(*token_string)
+ || !strncasecmp(token_string, "Inf", 3))) {
+#if 0
+ /* No dimension symbol required. */
+ i_dimension++;
+ if (i_dimension >= 2)
+ int_error(c_token, "Currently do not support sampled array dimensions greater than 2");
+#else
+ /* Dimension symbol or comma required. */
+ int_error(c_token, "Use '" TUPLE_SEPARATOR_CHAR "' between records or 'x' between dimensions");
+#endif
+ }
+
+ if (!isdigit(*token_string) && strncasecmp(token_string, "Inf", 3)) break;
+
+ /* Read number, add records if necessary, record number, advance past number. */
+ if (isdigit(*token_string)) {
+ sscanf(token_string,"%d",&ival);
+ while(isdigit(*token_string)) token_string++;
+ } else {
+ int_error(c_token, "Sorry - Inf keyword not implemented");
+ }
+ if (!i_dimension) {
+ number_of_records++;
+ 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[i_dimension] = ival;
+ expecting_number = FALSE;
+
+ }
+
+ /* Don't allow ending while expecting a number. */
+ if (expecting_number)
+ int_error(c_token, "Missing a number");
+
+ }
+
+}
+
+
+/* Evaluate a tuple of up to specified dimension. */
+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) {
+ struct value a;
+ double x;
+
+ x = real(const_express(&a));
+ N++;
+ if (N <= dimension)
+ *tuple++ = x;
+ else
+ int_error(c_token-1, "More than %d elements", N);
+ expecting_number = FALSE;
+ } else {
+ if (equals(c_token, ",")) {
+ c_token++;
+ expecting_number = TRUE;
+ } else if (equals(c_token, RIGHT_TUPLE_CHAR)) {
+ c_token++;
+ return N;
+ } else
+ int_error(c_token, "Expecting ',' or '" RIGHT_TUPLE_CHAR "'");
+ }
+ }
+ }
+
+ /* Not a tuple */
+ return 0;
+}
+
+
+/* Determine the 2D rotational matrix from the "rotation" qualifier. */
+void
+plot_option_multivalued(df_multivalue_type type, int arg)
+{
+ int bin_record_count = 0;
+ int test_val;
+#if EQUAL_SYMBOL_NOT_REQUIRED
+ /* Ignore or do not require equal symbol. */
+ if (equals(c_token, "=")) c_token++;
+#else
+ /* Require equal symbol. */
+ if (!equals(c_token, "="))
+ int_error(c_token, equal_symbol_msg);
+ c_token++;
+#endif
+
+ while (!END_OF_COMMAND) {
+ double tuple[3];
+
+ switch (type) {
+ case DF_ORIGIN:
+ case DF_CENTER:
+ case DF_PERPENDICULAR:
+ test_val = token2tuple(tuple, sizeof(tuple)/sizeof(tuple[0]));
+ break;
+ case DF_SCAN:
+ case DF_FLIP:
+ /* Check if there are any characters in string that shouldn't be. */
+ copy_str(df_format, c_token, MAX_LINE_LEN);
+ test_val = ( (strlen(df_format) == strspn(df_format, "xXyYzZ")) || (strlen(df_format) == strspn(df_format, "tTrRzZ")) );
+ break;
+ default: {
+ /* Check if a valid number. */
+ struct value a;
+ tuple[0] = real(const_express(&a));
+ test_val = 1;
+ }
+ }
+
+ if (test_val) {
+ char const * cannot_flip_msg
+ = "Cannot flip a non-existent dimension";
+
+ if (bin_record_count >= 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] <= 0)
+ int_error(c_token - 2, "\
+Sample period must be positive. Try `flip` for changing direction");
+ break;
+
+ case DF_FLIP_AXIS:
+ /* Set the direction of grid points increment in
+ * the specified dimension. */
+ if (df_bin_record[bin_record_count].cart_dim[0] > 0) {
+ if (tuple[0] == 0.0)
+ df_bin_record[bin_record_count].cart_dir[arg] = 0;
+ else if (tuple[0] == 1.0)
+ df_bin_record[bin_record_count].cart_dir[arg] = 1;
+ else
+ int_error(c_token-1, "\
+Flipping dimension direction must be 1 or 0");
+ } else
+ int_error(c_token, cannot_flip_msg);
+ break;
+
+ case DF_FLIP:
+ /* Set the direction of grid points increment in
+ * based upon letters for axes. Check if there are
+ * any characters in string that shouldn't be. */
+ copy_str(df_format, c_token, MAX_LINE_LEN);
+ if (strlen(df_format) != strspn(df_format, "xXyYzZ"))
+ int_error(c_token, "\
+Invalid character in dimension string. Only x, X, y, Y, z, or Z acceptable");
+ /* Check for valid dimensions. */
+ if (strpbrk(df_format, "xX")) {
+ if (df_bin_record[bin_record_count].cart_dim[0] > 0)
+ df_bin_record[bin_record_count].cart_dir[0] = arg;
+ else
+ int_error(c_token, cannot_flip_msg);
+ }
+ if (strpbrk(df_format, "yY")) {
+ if (df_bin_record[bin_record_count].cart_dim[1] > 0)
+ df_bin_record[bin_record_count].cart_dir[1] = arg;
+ else
+ int_error(c_token, cannot_flip_msg);
+ }
+ if (strpbrk(df_format, "zZ")) {
+ if (df_bin_record[bin_record_count].cart_dim[2] > 0)
+ df_bin_record[bin_record_count].cart_dir[2] = arg;
+ else
+ int_error(c_token, cannot_flip_msg);
+ }
+ c_token++;
+ break;
+
+ case DF_SCAN: {
+ /* Set the method in which data is scanned from
+ * file. Compare against a set number of strings. */
+ int i;
+
+ if (!(df_bin_record[bin_record_count].cart_dim[0]
+ || df_bin_record[bin_record_count].scan_dim[0])
+ || !(df_bin_record[bin_record_count].cart_dim[1]
+ || df_bin_record[bin_record_count].scan_dim[1]))
+ int_error(c_token, "\
+Cannot alter scanning method for one-dimensional data");
+ else if (df_bin_record[bin_record_count].cart_dim[2]
+ || df_bin_record[bin_record_count].scan_dim[2]) {
+ for (i = 0;
+ i < sizeof(df_bin_scan_table_3D)
+ /sizeof(df_bin_scan_table_3D_struct);
+ i++)
+ if (equals(c_token,
+ df_bin_scan_table_3D[i].string)) {
+ memcpy(df_bin_record[bin_record_count].cart_scan,
+ df_bin_scan_table_3D[i].scan,
+ sizeof(df_bin_record[0].cart_scan));
+ break;
+ }
+ if (i == sizeof(df_bin_scan_table_3D)
+ /sizeof(df_bin_scan_table_3D_struct))
+ int_error(c_token, "\
+Improper scanning string. Try 3 character string for 3D data");
+ } else {
+ for (i = 0;
+ i < sizeof(df_bin_scan_table_2D)
+ /sizeof(df_bin_scan_table_2D_struct); i++)
+ if (equals(c_token,
+ df_bin_scan_table_2D[i].string)) {
+ memcpy(df_bin_record[bin_record_count].cart_scan,
+ df_bin_scan_table_2D[i].scan,
+ sizeof(df_bin_record[0].cart_scan));
+ break;
+ }
+ if (i == sizeof(df_bin_scan_table_2D)
+ /sizeof(df_bin_scan_table_2D_struct))
+ int_error(c_token, "\
+Improper scanning string. Try 2 character string for 2D data");
+ }
+ /* Remove the file supplied scan direction. */
+ memcpy(df_bin_record[bin_record_count].scan_dir,
+ df_bin_record_reset.scan_dir,
+ sizeof(df_bin_record[0].scan_dir));
+ c_token++;
+ break;
+ }
+
+ case DF_SKIP:
+ /* Set the number of bytes to skip before reading
+ * record. */
+ df_bin_record[bin_record_count].scan_skip[0] = tuple[0];
+ if (df_bin_record[bin_record_count].scan_skip[0] != tuple[0])
+ int_error(c_token, "\
+The number of bytes to skip must be an integer");
+ if (df_bin_record[bin_record_count].scan_skip[0] < 0)
+ int_error(c_token, "\
+The number of bytes to skip must be positive");
+ break;
+
+ case DF_ORIGIN:
+ case DF_CENTER:
+ /* Set the origin or center of the image based upon
+ * the plot mode. */
+ if (type == DF_ORIGIN)
+ df_bin_record[bin_record_count].cart_trans
+ = DF_TRANSLATE_VIA_ORIGIN;
+ else
+ df_bin_record[bin_record_count].cart_trans
+ = DF_TRANSLATE_VIA_CENTER;
+ if (arg == MODE_PLOT) {
+ if (test_val != 2)
+ int_error(c_token, "\
+Two-dimensional tuple required for 2D plot");
+ tuple[2] = 0.0;
+ } else if (arg == MODE_SPLOT) {
+ if (test_val != 3)
+ int_error(c_token, "\
+Three-dimensional tuple required for 3D plot");
+ } else if (arg == MODE_QUERY) {
+ if (test_val != 3)
+ int_error(c_token, "\
+Three-dimensional tuple required for setting binary parameters");
+ } else {
+ int_error(c_token, "\
+Internal error (datafile.c): Unknown plot mode");
+ }
+ memcpy(df_bin_record[bin_record_count].cart_cen_or_ori,
+ tuple, sizeof(tuple));
+ break;
+
+ case DF_ROTATION:
+ /* Allow user to enter angle in terms of pi or degrees. */
+ if (equals(c_token, "pi")) {
+ tuple[0] *= M_PI;
+ c_token++;
+ } else if (almost_equals(c_token, "d$egrees")) {
+ tuple[0] *= M_PI/180;
+ c_token++;
+ }
+ /* Construct 2D rotation matrix. */
+ df_bin_record[bin_record_count].cart_alpha = tuple[0];
+ break;
+
+ case DF_PERPENDICULAR:
+ /* Make sure in three dimensional plotting mode before
+ * accepting the perpendicular vector for translation. */
+ if (test_val != 3)
+ int_error(c_token, "Three-dimensional tuple required");
+ /* Compare vector length against variable precision
+ * to determine if this is the null vector */
+ if ((tuple[0]*tuple[0]
+ + tuple[1]*tuple[1]
+ + tuple[2]*tuple[2]) < 100.*DBL_EPSILON)
+ int_error(c_token, "\
+Perpendicular vector cannot be zero");
+ memcpy(df_bin_record[bin_record_count].cart_p,
+ tuple,
+ sizeof(tuple));
+ break;
+
+ default:
+ int_error(NO_CARET, "\
+Internal error (datafile.c): Invalid comma separated type");
+ } /* switch() */
+ } else {
+ int_error(c_token, "Invalid numeric or tuple form");
+ }
+
+ if (equals(c_token, TUPLE_SEPARATOR_CHAR)) {
+ bin_record_count++;
+ c_token++;
+ } else
+ break;
+
+ } /* while(!EOC) */
+
+ return;
+}
+
+
+/* Set the 'bytes' to skip before column 'col'. */
+void
+df_set_skip_before(int col, int bytes)
+{
+ assert(col > 0);
+ /* Check if we have room at least col columns */
+ if (col > df_max_bininfo_cols) {
+ df_column_bininfo = gp_realloc(df_column_bininfo,
+ col * sizeof(df_column_bininfo_struct),
+ "datafile columns binary information");
+ df_max_bininfo_cols = col;
+ }
+ df_column_bininfo[col-1].skip_bytes = bytes;
+}
+
+
+/* Set the column data type. */
+void
+df_set_read_type(int col, df_data_type type)
+{
+ assert(col > 0);
+ /* Check if we have room at least col columns */
+ if (col > df_max_bininfo_cols) {
+ df_column_bininfo = gp_realloc(df_column_bininfo,
+ col * sizeof(df_column_bininfo_struct),
+ "datafile columns binary information");
+ df_max_bininfo_cols = col;
+ }
+ df_column_bininfo[col-1].column.read_type = type;
+ df_column_bininfo[col-1].column.read_size
+ = df_binary_details[type].type.read_size;
+}
+
+
+/* Get the column data type. */
+df_data_type
+df_get_read_type(int col)
+{
+ assert(col > 0);
+ /* Check if we have room at least col columns */
+ if (col < df_max_bininfo_cols)
+ return(df_column_bininfo[col].column.read_type);
+ else
+ return -1;
+}
+
+
+/* Get the binary column data size. */
+int
+df_get_read_size(int col)
+{
+ assert(col > 0);
+ /* Check if we have room at least col columns */
+ if (col < df_max_bininfo_cols)
+ return(df_column_bininfo[col].column.read_size);
+ else
+ return -1;
+}
+
+
+/* If the column number is greater than number of binary columns, set
+ * the unitialized columns binary info to that of the last specified
+ * column or the default if none were set. */
+void
+df_extend_binary_columns(int no_cols)
+{
+ if (no_cols > df_no_bin_cols) {
+ int i;
+ df_data_type type;
+ if (df_no_bin_cols > 0)
+ type = df_column_bininfo[df_no_bin_cols-1].column.read_type;
+ else
+ type = DF_DEFAULT_TYPE;
+ for (i = no_cols; i > df_no_bin_cols; i--) {
+ df_set_skip_after(i, 0);
+ df_set_read_type(i, type);
+ }
+ df_no_bin_cols = no_cols;
+ }
+}
+
+
+/* Determine binary data widths from the `using` (or `binary`) format
+ * specification. */
+void
+plot_option_binary_format(void)
+{
+
+ int prev_read_type = DF_DEFAULT_TYPE; /* Defaults when none specified. */
+ int i, no_fields = 0;
+
+ /* Copy the token for our own analysis. */
+ copy_str(df_format, c_token, MAX_LINE_LEN);
+
+ for (i=1;
+ df_format[i] != '\0'
+ && df_format[i] != '\"'
+ && df_format[i] != '\''
+ && i <= MAX_LINE_LEN;
+ ) {
+ if (df_format[i] == ' ') {
+ i++;
+ continue;
+ } /* Ignore spaces. */
+
+ if (df_format[i] == '%') {
+ int ignore, field_repeat, j = 0, k = 0, m = 0, breakout;
+
+ i++;
+ ignore = (df_format[i] == '*');
+ if(ignore)
+ i++;
+
+ /* Number of columns is less than a single digit, so check
+ * only a single digit. If the user enters more than one
+ * digit, the routine fails on the next pass. */
+ if (isdigit(df_format[i])) {
+ /* Convert to a number. Let zero be a valid entry. */
+ field_repeat = df_format[i] - '0';
+ i++;
+ } else
+ field_repeat = 1;
+
+ /* Try finding the word among the valid type names. */
+ for (j = 0, breakout = 0;
+ j < (sizeof(df_binary_tables)
+ /sizeof(df_binary_tables[0]));
+ j++) {
+ for (k = 0, breakout = 0;
+ k < df_binary_tables[j].group_length;
+ k++) {
+ for (m = 0;
+ m < df_binary_tables[j].group[k].no_names;
+ m++) {
+ int strl
+ = strlen(df_binary_tables[j].group[k].name[m]);
+
+ if (!strncmp(df_format + i,
+ df_binary_tables[j].group[k].name[m],
+ strl)
+ && strchr("%\'\" ", df_format[i + strl]) ) {
+ i += strl; /* Advance pointer in array to next text. */
+ if (!ignore) {
+ int n;
+
+ for (n = 0; n < field_repeat; n++) {
+ no_fields++;
+ df_set_skip_after(no_fields, 0);
+ df_set_read_type(no_fields,
+ df_binary_tables[j].group[k].type.read_type);
+ prev_read_type = df_binary_tables[j].group[k].type.read_type;
+ }
+ } else
+ df_column_bininfo[no_fields].skip_bytes
+ += field_repeat
+ * df_binary_tables[j].group[k].type.read_size;
+ breakout = 1;
+ break;
+ }
+ }
+ if (breakout)
+ break;
+ }
+ if (breakout)
+ break;
+ }
+
+ if (j == (sizeof(df_binary_tables)
+ /sizeof(df_binary_tables[0]))
+ && (k == df_binary_tables[j-1].group_length)
+ && (m == df_binary_tables[j-1].group[k-1].no_names)) {
+ int_error(c_token, "Unrecognized binary format specification");
+ }
+ } else {
+ int_error(c_token, "Format specifier must begin with '%'");
+ }
+ }
+
+ /* Any remaining unspecified fields are assumed to be of the same type
+ * as the last specified field.
+ */
+ for ( ; no_fields < df_no_bin_cols; no_fields++) {
+ df_set_skip_after(no_fields, 0);
+ df_set_skip_before(no_fields, 0);
+ df_set_read_type(no_fields, prev_read_type);
+ }
+ df_no_bin_cols = no_fields;
+
+ c_token++; /* Advance to next token character. */
+
+}
+
+
+void
+df_show_binary(FILE *fp)
+{
+ int i, num_record;
+ df_binary_file_record_struct *bin_record;
+
+ fprintf(fp, "\
+\tDefault binary data file settings (in-file settings may override):\n");
+
+ if (!df_num_bin_records_default) {
+ bin_record = &df_bin_record_reset;
+ num_record = 1;
+ } else {
+ bin_record = df_bin_record_default;
+ num_record = df_num_bin_records_default;
+ }
+
+ fprintf(fp, "\n\t File Type: ");
+ if (df_bin_filetype_default >= 0)
+ fprintf(fp, "%s",
+ df_bin_filetype_table[df_bin_filetype_default].extension);
+ else
+ fprintf(fp, "none");
+ fprintf(fp, "\n\t File Endianess: %s",
+ df_endian[df_bin_file_endianess_default]);
+
+ for (i = 0; i < num_record; i++) {
+ int dimension = 1;
+
+ fprintf(fp, "\n\t Record %d:\n", i);
+ fprintf(fp, "\t Dimension: ");
+ if (bin_record[i].cart_dim[0] < 0)
+ fprintf(fp, "Inf");
+ else {
+ fprintf(fp, "%d", bin_record[i].cart_dim[0]);
+ if (bin_record[i].cart_dim[1] > 0) {
+ dimension = 2;
+ fprintf(fp, "x%d", bin_record[i].cart_dim[1]);
+ if (bin_record[i].cart_dim[2] > 0) {
+ dimension = 3;
+ fprintf(fp, "x%d", bin_record[i].cart_dim[2]);
+ }
+ }
+ }
+ fprintf(fp, "\n\t Generate coordinates: %s",
+ (bin_record[i].scan_generate_coord ? "yes" : "no"));
+ if (bin_record[i].scan_generate_coord) {
+ int j;
+ TBOOLEAN no_flip = TRUE;
+
+ fprintf(fp, "\n\t Direction: ");
+ if (bin_record[i].cart_dir[0] == -1) {
+ fprintf(fp, "flip x");
+ no_flip = FALSE;
+ }
+ if ((dimension > 1) && (bin_record[i].cart_dir[1] == -1)) {
+ fprintf(fp, "%sflip y", (no_flip ? "" : ", "));
+ no_flip = FALSE;
+ }
+ if ((dimension > 2) && (bin_record[i].cart_dir[2] == -1)) {
+ fprintf(fp, "%sflip z", (no_flip ? "" : ", "));
+ no_flip = FALSE;
+ }
+ if (no_flip)
+ fprintf(fp, "all forward");
+ fprintf(fp, "\n\t Sample periods: dx=%f",
+ bin_record[i].cart_delta[0]);
+ if (dimension > 1)
+ fprintf(fp, ", dy=%f", bin_record[i].cart_delta[1]);
+ if (dimension > 2)
+ fprintf(fp, ", dz=%f", bin_record[i].cart_delta[2]);
+ if (bin_record[i].cart_trans == DF_TRANSLATE_VIA_ORIGIN)
+ fprintf(fp, "\n\t Origin:");
+ else if (bin_record[i].cart_trans == DF_TRANSLATE_VIA_CENTER)
+ fprintf(fp, "\n\t Center:");
+ if ((bin_record[i].cart_trans == DF_TRANSLATE_VIA_ORIGIN)
+ || (bin_record[i].cart_trans == DF_TRANSLATE_VIA_CENTER))
+ fprintf(fp, " (%f, %f, %f)",
+ bin_record[i].cart_cen_or_ori[0],
+ bin_record[i].cart_cen_or_ori[1],
+ bin_record[i].cart_cen_or_ori[2]);
+ fprintf(fp, "\n\t 2D rotation angle: %f",
+ bin_record[i].cart_alpha);
+ fprintf(fp, "\n\t 3D normal vector: (%f, %f, %f)",
+ bin_record[i].cart_p[0],
+ bin_record[i].cart_p[1],
+ bin_record[i].cart_p[2]);
+ for (j = 0;
+ j < (sizeof(df_bin_scan_table_3D)
+ /sizeof(df_bin_scan_table_3D[0]));
+ j++) {
+ if (!strncmp((char *)bin_record[i].cart_scan,
+ (char *)df_bin_scan_table_3D[j].scan,
+ sizeof(bin_record[0].cart_scan)) ) {
+ fprintf(fp, "\n\t Scan: ");
+ fprintf(fp,
+ (bin_record[i].cart_dim[2] ? "%s" : "%2.2s"),
+ df_bin_scan_table_3D[j].string);
+ break;
+ }
+ }
+ fprintf(fp, "\n\t Skip bytes: %d before record",
+ bin_record[i].scan_skip[0]);
+ if (dimension > 1)
+ fprintf(fp, ", %d before line", bin_record[i].scan_skip[1]);
+ if (dimension > 2)
+ fprintf(fp, ", %d before plane", bin_record[i].scan_skip[2]);
+ }
+ fprintf(fp, "\n");
+ }
+}
+
+
+void
+df_show_datasizes(FILE *fp)
+{
+ int i;
+
+ fprintf(fp,"\tThe following binary data sizes are machine dependent:\n\n"
+ "\t name (size in bytes)\n\n");
+ for (i = 0;
+ i < sizeof(df_binary_details)/sizeof(df_binary_details[0]);
+ i++) {
+ int j;
+
+ fprintf(fp,"\t ");
+ for (j = 0; j < df_binary_details[i].no_names; j++) {
+ fprintf(fp,"\"%s\" ",df_binary_details[i].name[j]);
+ }
+ fprintf(fp,"(%d)\n",df_binary_details[i].type.read_size);
+ }
+
+ fprintf(fp,"\n\
+\tThe following binary data sizes attempt to be machine independent:\n\n\
+\t name (size in bytes)\n\n");
+ for (i = 0;
+ i < sizeof(df_binary_details_independent)
+ /sizeof(df_binary_details_independent[0]);
+ i++) {
+ int j;
+
+ fprintf(fp,"\t ");
+ for (j = 0; j < df_binary_details_independent[i].no_names; j++) {
+ fprintf(fp,"\"%s\" ",df_binary_details_independent[i].name[j]);
+ }
+ fprintf(fp,"(%d)",df_binary_details_independent[i].type.read_size);
+ if (df_binary_details_independent[i].type.read_type == DF_BAD_TYPE)
+ fprintf(fp," -- processor does not support this size");
+ fputc('\n', fp);
+ }
+}
+
+
+void
+df_show_filetypes(FILE *fp)
+{
+ int i;
+
+ fprintf(fp,"\tThe following binary file types are understood by gnuplot:\n\n");
+ for (i = 0;
+ i < sizeof(df_bin_filetype_table)
+ /sizeof(df_bin_filetype_table_struct);
+ i++) {
+ fprintf(fp, "\t %s\n", df_bin_filetype_table[i].extension);
+ }
+}
+
+
+void
+df_swap_bytes_by_endianess(char *data, int read_order, int read_size)
+{
+ if ((read_order == DF_3210)
+#if SUPPORT_MIDDLE_ENDIAN
+ || (read_order == DF_2301)
+#endif
+ ) {
+ int j = 0;
+ int k = read_size - 1;
+
+ for (; j < k; j++, k--) {
+ char temp = data[j];
+
+ data[j] = data[k];
+ data[k] = temp;
+ }
+ }
+
+#if SUPPORT_MIDDLE_ENDIAN
+ if ((read_order == DF_1032) || (read_order == DF_2301)) {
+ int j= read_size - 1;
+
+ for (; j > 0; j -= 2) {
+ char temp = data[j-1];
+
+ data[j-1] = data[j];
+ data[j] = temp;
+ }
+ }
+#endif
+}
+
+
+/*{{{ int df_readbinary(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_readbinary(double v[], int max)
+{
+ /* For general column structured binary. */
+ static int scan_size[3];
+ static double delta[3]; /* sampling periods */
+ static double o[3]; /* add after rotations */
+ static double c[3]; /* subtract before doing rotations */
+ static double P[3][3]; /* 3D rotation matrix (perpendicular) */
+ static double R[2][2]; /* 2D rotation matrix (rotate) */
+ static int read_order;
+ static int record_skip;
+ static int end_of_scan_line;
+ static int end_of_block;
+ static TBOOLEAN translation_required;
+ static char *memory_data;
+
+ /* For matrix data structure (i.e., gnuplot binary). */
+ static double first_matrix_column;
+ static float *scanned_matrix_row = 0;
+ static int first_matrix_row_col_count;
+ TBOOLEAN saved_first_matrix_column = FALSE;
+
+ assert(data_fp != NULL);
+ assert(max <= MAXDATACOLS);
+ assert(df_max_bininfo_cols > df_no_bin_cols);
+ assert(df_no_bin_cols);
+
+ /* catch attempt to read past EOF on mixed-input */
+ if (df_eof)
+ return DF_EOF;
+
+ /* Check if we have room for at least df_no_bin_cols columns */
+ if (df_max_cols < df_no_bin_cols) {
+ df_column = gp_realloc(df_column,
+ df_no_bin_cols * sizeof(df_column_struct),
+ "datafile columns");
+ df_max_cols = df_no_bin_cols;
+ }
+
+ /* In binary mode, the number of user specs was increased by the
+ * number of dimensions in the underlying uniformly sampled grid
+ * previously. Fill in those values. Also, compute elements of
+ * formula x' = P*R*(x - c) + o */
+ if (!df_M_count && !df_N_count && !df_O_count) {
+ int i;
+ TBOOLEAN D2, D3;
+ df_binary_file_record_struct *this_record
+ = df_bin_record + df_bin_record_count;
+
+ scan_size[0] = scan_size[1] = scan_size[2] = 0;
+
+ D2 = rotation_matrix_2D(R, this_record->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 (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
+ 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] = 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 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;
+ }
+
+ while (!df_eof) {
+ /*{{{ process line */
+ int line_okay = 1;
+ 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;
+ 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. */
+ while (record_skip) {
+ if (memory_data) {
+ memory_data++;
+ } else if ((fread_ret = fread(&io_val.ch,
+ sizeof(io_val.ch),
+ 1, data_fp))
+ != 1) {
+ if (feof(data_fp)) {
+ df_eof = 1;
+ return DF_EOF;
+ } else
+ int_error(NO_CARET, read_error_msg);
+ }
+ record_skip--;
+ } /* while(record_skip) */
+
+ /* 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++) {
+ int skip_bytes = df_column_bininfo[i].skip_bytes;
+
+ if (skip_bytes) {
+ if (memory_data) {
+ memory_data += skip_bytes;
+ } else if ((fread_ret = fread(&io_val.ch, sizeof(io_val.ch),
+ skip_bytes, data_fp))
+ != skip_bytes) {
+ if (feof(data_fp)) {
+ df_eof = 1;
+ return DF_EOF;
+ } else
+ int_error(NO_CARET, read_error_msg);
+ }
+ }
+
+ /* 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 (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;
+ }
+ }
+
+ 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_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 then decide on what
+ * to do with it. */
+ if (df_matrix_file)
+ break;
+
+ } /* for(i) */
+
+ if (df_matrix_file) {
+ if (df_matrix_binary) {
+ /* 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(float),
+ "gpbinary matrix row")))
+ int_error(NO_CARET, "not enough memory to create vector");
+ 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 = 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_matrix_binary
+ ? scanned_matrix_row[df_M_count]
+ : df_M_count;
+ else if (j == 1)
+ df_column[j].datum
+ = df_matrix_binary
+ ? 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 binray. */
+ 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)
+ /* store undefined point in plot */
+ return DF_UNDEFINED;
+
+ v[output] = real(&a);
+ } else if (column == -5) {
+ /* Perhaps try using a switch statement to
+ * avoid so many tests. */
+ v[output] = o_value*delta[2];
+ } else if (column == -4) {
+ v[output] = n_value*delta[1];
+ } else if (column == -3) {
+ 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 <= 0)
+ int_error(NO_CARET, "\
+internal error: unkown column type");
+ else if ((df_axis[output] != -1)
+ && (axis_array[df_axis[output]].is_timedata)) {
+ struct tm tm;
+
+ if (column > df_no_cols
+ || df_column[column - 1].good == DF_MISSING
+ || !df_column[column - 1].position
+ || !gstrptime(df_column[column - 1].position,
+ axis_array[df_axis[output]].timefmt,
+ &tm)) {
+ /* line bad only if user explicitly asked
+ * for this column */
+ if (df_no_use_specs)
+ line_okay = 0;
+
+ /* return or ignore line depending on line_okay */
+ break;
+ }
+ v[output] = (double) gtimegm(&tm);
+ } else if ((column <= df_no_cols)
+ && df_column[column - 1].good == DF_GOOD)
+ v[output] = df_column[column - 1].datum;
+
+ /* EAM - Oct 2002 Distinguish between DF_MISSING
+ * and DF_BAD. Previous versions would never
+ * notify caller of either case. Now missing data
+ * will be noted. Bad data should arguably be
+ * noted also, but that would change existing
+ * default behavior. */
+ else if ((column <= df_no_cols)
+ && (df_column[column - 1].good == DF_MISSING))
+ return DF_MISSING;
+ else {
+ /* line bad only if user explicitly asked
+ * for this column */
+ if (df_no_use_specs)
+ line_okay = 0;
+ break; /* return or ignore depending on line_okay */
+ }
+ }
+
+ /* Linear translation. */
+ if (translation_required) {
+ double x, y, z;
+
+ x = v[0] - c[0];
+ y = v[1] - c[1];
+
+ v[0] = R[0][0] * x + R[0][1] * y;
+ v[1] = R[1][0] * x + R[1][1] * y;
+ if (df_plot_mode == MODE_SPLOT) {
+ x = v[0];
+ y = v[1];
+ z = v[2] - c[2];
+ v[0] = P[0][0] * x + P[0][1] * y + P[0][2] * z;
+ v[1] = P[1][0] * x + P[1][1] * y + P[1][2] * z;
+ v[2] = P[2][0] * x + P[2][1] * y + P[2][2] * z;
+ }
+
+ v[0] += o[0];
+ v[1] += o[1];
+ if (df_plot_mode == MODE_SPLOT)
+ v[2] += o[2];
+ }
+
+ }
+ /*}}} */
+
+ if (!line_okay)
+ continue;
+
+ /* output == df_no_use_specs if using was specified -
+ * actually, smaller of df_no_use_specs and max */
+ assert(df_no_use_specs == 0
+ || output == df_no_use_specs
+ || output == max);
+
+ return output;
+
+ }
+ /*}}} */
+
+ df_eof = 1;
+ return DF_EOF;
+
+}
+
+void
+df_set_plot_mode(int mode)
+{
+ df_plot_mode = mode;
+}
+#endif /* BINARY_DATA_FILE */
+
projects / gnuplot / blobdiff