/***************************************************************************
* Copyright (C) 1994 Charles P. Peterson *
* 4007 Enchanted Sun, San Antonio, Texas 78244-1254 *
* Email: Charles_P_Peterson@fcircus.sat.tx.us *
* *
* This is free software with NO WARRANTY. *
* See gfft.c, or run program itself, for details. *
* Support is available for a fee. *
***************************************************************************
*
* Program: gfft--General FFT analysis
* File: settings.c
* Purpose: set values, names, and operation types
* Author: Charles Peterson (CPP)
* History: 31-May-1993 CPP; Created.
* 9-Aug-94 CPP (1.10); Hidden3D option
* 19-Jan-95 CPP (1.21); Topaz command
* 10-Feb-95 CPP (1.39; save settings or parameters
* 14-Feb-95 CPP (1.42); PlotCommands
*/
#include <stdio.h> /* printf */
#include <string.h> /* strtok, strlen */
#include <stdlib.h> /* strtoul */
#include <errno.h> /* errno */
#include "gfft.h"
#define DEFINE_HERE
#include "settings.h"
#undef DEFINE_HERE
extern Name_Info_St Gfft_Command[]; /* GFFT commands */
static char *set_ulong (char *arguments, unsigned long *longp,
int gt_0_req, int arg_req);
static char *set_double (char *arguments, double *doublep,
int gt_0_req, int arg_req);
static char *get_filename (char *arguments, char **filename_pp);
static char *add_calibration (char *arguments, BOOLEAN db_scale);
char *set (char *arguments)
{
/*
* Dummy command which invokes its arguments as a command string
*/
if (arguments && arguments != NullString)
{
invoke_method (arguments, Gfft_Command);
}
return arguments;
}
/*
* Functions to set various parameters
*/
char *set_time_offset (char *arguments)
{
char *more_arguments;
ULONG time_offset;
TimeOffset = INVALID_SET; /* unless this succeeds */
more_arguments = set_ulong (arguments, &time_offset, FALSE, FALSE);
if (more_arguments == NullString)
{
TimeOffset = NOT_SET;
}
else
{
Time3D = TRUE;
if (time_offset > 0 && time_offset < LONG_MAX)
{
TimeOffset = (long) time_offset;
}
else
{
command_error_message (BAD_ARGUMENT, more_arguments-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
return more_arguments;
}
char *set_time_segments (char *arguments)
{
char *more_arguments;
ULONG time_segments;
TimeSegments = INVALID_SET; /* unless this succeeds */
more_arguments = set_ulong (arguments, &time_segments, FALSE, FALSE);
if (more_arguments == NullString)
{
TimeSegments = NOT_SET;
}
else
{
Time3D = TRUE;
TimeSegSize = NOT_SET;
if (time_segments > 0 && time_segments < LONG_MAX)
{
TimeSegments = (long) time_segments;
}
else
{
command_error_message (BAD_ARGUMENT, more_arguments-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
return more_arguments;
}
char *set_key (char *arguments)
{
char *more_arguments;
more_arguments = set_ulong (arguments, &Key, FALSE, FALSE);
return more_arguments;
}
char *set_time_seg_size (char *arguments)
{
char *more_arguments;
ULONG time_seg_size;
TimeSegSize = INVALID_SET; /* unless this succeeds */
more_arguments = set_ulong (arguments, &time_seg_size, FALSE, FALSE);
if (more_arguments == NullString)
{
TimeSegSize = NOT_SET;
}
else
{
Time3D = TRUE;
TimeSegments = NOT_SET;
if (time_seg_size > 0 && time_seg_size < LONG_MAX)
{
TimeSegSize = (long) time_seg_size;
}
else
{
command_error_message (BAD_ARGUMENT, more_arguments-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
return more_arguments;
}
char *set_smoothing_segments (char *arguments)
{
char *more_arguments;
ULONG smoothing_segs;
SmoothingSegments = INVALID_SMOOTHING; /* unless this succeeds */
more_arguments = set_ulong (arguments, &smoothing_segs, TRUE, FALSE);
if (more_arguments == NullString)
{
SmoothingSegments = NO_SMOOTHING;
}
else
{
if (smoothing_segs <= LONG_MAX)
{
SmoothingSegments = (long) smoothing_segs;
}
else
{
command_error_message (BAD_ARGUMENT, more_arguments-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
return more_arguments;
}
char *set_time_3d (char *arguments)
{
Time3D = TRUE;
return arguments;
}
char *set_no_time_3d (char *arguments)
{
Time3D = FALSE;
return arguments;
}
char *set_hidden_3d (char *arguments)
{
Hidden3D = TRUE;
return arguments;
}
char *set_no_hidden_3d (char *arguments)
{
Hidden3D = FALSE;
return arguments;
}
char *set_signed (char *arguments)
{
InputFormat.zero = 0;
return arguments;
}
char *set_unsigned (char *arguments)
{
int sample_width = (InputFormat.bits > 8) ? 16 : 8;
InputFormat.zero = ((unsigned long) 0xffffffff >>
(33 - sample_width)) + (unsigned long) 1;
/*
* This is re-done at time of 'ok' command to be sure bits spec is final
*/
return arguments;
}
char *set_terminal (char *arguments)
{
char *more_arguments;
char *terminal;
if (Terminal && Terminal != NullString)
{
gfree (Terminal);
Terminal = NULL;
}
more_arguments = get_filename (arguments, &terminal);
if (terminal == NullString || strlen (terminal) == 0)
{
Terminal = NULL;
}
else
{
Terminal = terminal;
}
return more_arguments;
}
char *set_plot_output (char *arguments)
{
char *more_arguments;
char *plot_output;
if (PlotOutput && PlotOutput != NullString)
{
gfree (PlotOutput);
PlotOutput = NULL;
}
more_arguments = get_filename (arguments, &plot_output);
if (plot_output == NullString || strlen (plot_output) == 0)
{
PlotOutput = NULL;
}
else
{
PlotOutput = plot_output;
}
return more_arguments;
}
char *set_save_memory (char *arguments)
{
SaveMemory = TRUE;
return arguments;
}
char *set_no_save_memory (char *arguments)
{
SaveMemory = FALSE;
return arguments;
}
char *set_psdensity (char *arguments)
{
PSDensity = TRUE;
return arguments;
}
char *set_no_psdensity (char *arguments)
{
PSDensity = FALSE;
return arguments;
}
char *set_squared_smoothing (char *arguments)
{
SquaredSmoothing = TRUE;
return arguments;
}
char *set_no_squared_smoothing (char *arguments)
{
SquaredSmoothing = FALSE;
return arguments;
}
char *set_combine_plots (char *arguments)
{
extern int Old_File_Count;
if (!CombinePlots)
{
CombinePlots = TRUE;
Old_File_Count = (Old_File_Count > 0) ? 1 : 0;
}
return arguments;
}
char *set_no_combine_plots (char *arguments)
{
CombinePlots = FALSE;
Old_File_Count = 0;
return arguments;
}
char *cut_combined_plot (char *arguments)
{
if (Old_File_Count > 0) Old_File_Count--;
return arguments;
}
char *set_db (char *arguments)
{
Db = TRUE;
return arguments;
}
char *set_header (char *arguments)
{
Header = TRUE;
return arguments;
}
char *set_no_header (char *arguments)
{
Header = FALSE;
return arguments;
}
char *set_logx (char *arguments)
{
LogX = TRUE;
return arguments;
}
char *set_logy (char *arguments)
{
LogY = TRUE;
return arguments;
}
char *set_no_logx (char *arguments)
{
LogX = FALSE;
return arguments;
}
char *set_no_logy (char *arguments)
{
LogY = FALSE;
return arguments;
}
char *set_no_db (char *arguments)
{
Db = FALSE;
return arguments;
}
char *set_time_overlap (char *arguments)
{
char *beyond_argument;
TimeOverlap = INVALID_SET;
beyond_argument = set_double (arguments, &TimeOverlap, FALSE, FALSE);
if (beyond_argument == NullString)
{
TimeOverlap = DEFAULT_TIME_OVERLAP;
}
else
{
Time3D = TRUE;
TimeOffset = NOT_SET;
if (TimeOverlap >= 1.0 || TimeOverlap < 0.0)
{
TimeOverlap = INVALID_SET;
command_error_message (BAD_ARGUMENT, beyond_argument-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
return beyond_argument;
}
char *set_no_quantization (char *arguments)
{
Quantization = MIN_QUANTIZATION;
return arguments;
}
char *set_quantization (char *arguments)
{
double quantization = 0.0;
char *beyond_argument;
Quantization = BAD_QUANTIZATION;
beyond_argument = set_double (arguments, &quantization, FALSE, FALSE);
if (beyond_argument == NullString || quantization == 0.0)
{
Quantization = MIN_QUANTIZATION; /* Default value if no argument */
}
else if (quantization < 0.0)
{
command_error_message (BAD_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else
{
Quantization = quantization;
}
return beyond_argument;
}
char *set_multiply (char *arguments)
{
char *beyond_argument;
beyond_argument = set_double (arguments, &Multiply, FALSE, FALSE);
if (beyond_argument == NullString)
{
Multiply = 1.0L; /* Default value if no argument */
}
return beyond_argument;
}
char *set_no_one_shot_only (char *arguments)
{
OneShotOnly = FALSE;
return arguments;
}
char *set_topaz (char *arguments)
{
Topaz = TRUE;
return arguments;
}
char *set_no_repeat_only (char *arguments)
{
RepeatOnly = FALSE;
return arguments;
}
char *set_bits (char *arguments)
{
char *more_arguments;
ULONG bits;
more_arguments = set_ulong (arguments, &bits, TRUE, FALSE);
if (more_arguments == NullString)
{
bits = DEFAULT_INPUT_BITS;
}
else if (1 > bits || bits > 16)
{
command_error_message (BAD_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else
{
InputFormat.bits = bits;
}
return more_arguments;
}
char *set_octave (char *arguments)
{
char *more_arguments;
more_arguments = set_ulong (arguments, &Octave, FALSE, FALSE);
if (more_arguments == NullString)
{
Octave = 1L;
}
return more_arguments;
}
char *set_one_shot_only (char *arguments)
{
OneShotOnly = TRUE;
RepeatOnly = FALSE;
return arguments;
}
char *set_repeat_only (char *arguments)
{
RepeatOnly = TRUE;
OneShotOnly = FALSE;
return arguments;
}
char *set_ignore_format (char *arguments)
{
IgnoreFormat = TRUE;
return arguments;
}
char *set_no_ignore_format (char *arguments)
{
IgnoreFormat = FALSE;
return arguments;
}
char *set_pink (char *arguments)
{
Pink = TRUE;
return arguments;
}
char *set_no_pink (char *arguments)
{
Pink = FALSE;
return arguments;
}
char *set_parseval (char *arguments)
{
Parseval = TRUE;
return arguments;
}
char *set_no_parseval (char *arguments)
{
Parseval = FALSE;
return arguments;
}
char *set_overlap (char *arguments)
{
Overlap = TRUE;
return arguments;
}
char *set_no_overlap (char *arguments)
{
Overlap = FALSE;
return arguments;
}
char *set_high_frequency (char *arguments)
{
char *more_arguments;
more_arguments = set_double (arguments, &HighFrequency, FALSE, FALSE);
if (more_arguments == NullString)
{
HighFrequency = HIGHEST_FREQUENCY; /* No arg, return to default */
}
return more_arguments;
}
char *set_low_frequency (char *arguments)
{
char *more_arguments;
more_arguments = set_double (arguments, &LowFrequency, FALSE, FALSE);
if (more_arguments == NullString)
{
LowFrequency = LOWEST_FREQUENCY; /* No arg, return to default */
}
return more_arguments;
}
char *set_low_y (char *arguments)
{
char *more_arguments;
more_arguments = set_double (arguments, &LowY, FALSE, FALSE);
if (more_arguments == NullString)
{
LowY = LOWEST_Y; /* No arg, return to default */
}
return more_arguments;
}
char *set_high_y (char *arguments)
{
char *more_arguments;
more_arguments = set_double (arguments, &HighY, FALSE, FALSE);
if (more_arguments == NullString)
{
HighY = HIGHEST_Y; /* No arg, return to default */
}
return more_arguments;
}
char *set_channel (char *arguments)
{
char *more_arguments;
Channel = 0L; /* Purposely set to invalid value here */
more_arguments = set_ulong (arguments, &Channel, TRUE, FALSE);
if (more_arguments == NullString)
{
Channel = 1L; /* Return to default if no argument */
}
if (Channel > FileChannels || Channel < 1)
{
error_message (SPEC_CHANNEL_UNAVAIL);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return more_arguments;
}
char *set_start_byte (char *arguments)
{
char *more_arguments;
more_arguments = set_ulong (arguments, &StartByte, FALSE, FALSE);
if (more_arguments == NullString)
{
StartByte = 0; /* Return to default if no argument */
}
return more_arguments;
}
char *set_start_frame (char *arguments)
{
char *more_arguments;
more_arguments = set_ulong (arguments, &StartFrame, FALSE, FALSE);
if (more_arguments == NullString)
{
StartFrame = 0; /* Return to default if no argument */
}
return more_arguments;
}
char *set_frames (char *arguments)
{
char *more_arguments;
more_arguments = set_ulong (arguments, &Frames, FALSE, FALSE);
if (more_arguments == NullString)
{
Frames = ULONG_MAX; /* Return to default if no argument */
}
return more_arguments;
}
char *set_pad (char *arguments)
{
Pad = TRUE;
return arguments;
}
char *set_no_pad (char *arguments)
{
Pad = FALSE;
return arguments;
}
char *set_no_numerical (char *arguments)
{
Numerical = FALSE;
return arguments;
}
char *set_numerical (char *arguments)
{
#ifdef NUMERICAL_RECIPES_AVAILABLE
Numerical = TRUE;
#else
error_message (NO_NUMERICAL);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
#endif
return arguments;
}
#define GNUPLOT 1
static char *set_plot_gnuplot (char *arguments)
{
Plot = GNUPLOT_PLOT;
return arguments;
}
static Name_Info_St plotter_names[] = {
{"GNUPLOT","G", set_plot_gnuplot},
{"","", default_argument},
};
char *set_plot (char *arguments)
{
char *arg;
arg = strtok (arguments, " ");
if (!arg) /* No argument present */
{
Plot = ANY_PLOT; /* use the default plotter */
}
else
{
invoke_method (arg, plotter_names);
}
return arguments;
}
char *set_no_plot (char *arguments)
{
Plot = NO_PLOT;
return arguments;
}
#define ASCII 1
#define BINARY 2
static char *set_output_format_binary (char *arguments)
{
OutputFormat.binary = TRUE;
return arguments;
}
static char *set_output_format_ascii (char *arguments)
{
OutputFormat.binary = FALSE;
return arguments;
}
static Name_Info_St output_format_names[] = {
{"ASCII","A", set_output_format_ascii},
{"BINARY","B", set_output_format_binary},
{"","", default_argument},
};
char *set_output (char *arguments)
{
char *arg;
arg = strtok (arguments, " ");
if (!arg) /* No argument present */
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
invoke_method (arg, output_format_names);
return arguments;
}
char *set_amplitude (char *arguments)
{
Amplitude = TRUE;
Power = FALSE;
return arguments;
}
char *set_power (char *arguments)
{
Power = TRUE;
Amplitude = FALSE;
return arguments;
}
char *set_fft (char *arguments)
{
Power = FALSE;
Amplitude = FALSE;
return arguments;
}
char *set_mean (char *arguments)
{
Mean = TRUE;
return arguments;
}
char *set_sum (char *arguments)
{
Mean = FALSE;
return arguments;
}
char *set_hann (char *arguments)
{
WindowType = HANN_WINDOW;
return arguments;
}
char *set_hamming (char *arguments)
{
WindowType = HAMMING_WINDOW;
return arguments;
}
char *set_parzen (char *arguments)
{
WindowType = PARZEN_WINDOW;
return arguments;
}
char *set_rectangle (char *arguments)
{
WindowType = RECTANGLE_WINDOW;
return arguments;
}
char *set_triangle (char *arguments)
{
WindowType = TRIANGLE_WINDOW;
return arguments;
}
char *set_blackman_harris_74db (char *arguments)
{
WindowType = BLACKMAN_HARRIS_74DB_WINDOW;
return arguments;
}
char *set_blackman_harris_92db (char *arguments)
{
WindowType = BLACKMAN_HARRIS_92DB_WINDOW;
return arguments;
}
char *set_welch (char *arguments)
{
WindowType = WELCH_WINDOW;
return arguments;
}
char *set_rotation_x (char *arguments)
{
char *more_arguments;
double rot_x;
RotX = INVALID_ROTATION;
more_arguments = set_double (arguments, &rot_x, FALSE, FALSE);
if (more_arguments == NullString)
{
RotX = DEF_ROT_X;
}
else if (0. <= rot_x && rot_x <= 180.)
{
RotX = rot_x;
}
else
{
command_error_message (BAD_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return more_arguments;
}
char *set_rotation_z (char *arguments)
{
char *more_arguments;
double rot_z;
RotZ = INVALID_ROTATION;
more_arguments = set_double (arguments, &rot_z, FALSE, FALSE);
if (more_arguments == NullString)
{
RotZ = DEF_ROT_Z;
}
else if (0. <= rot_z && rot_z <= 360.)
{
RotZ = rot_z;
}
else
{
command_error_message (BAD_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return more_arguments;
}
char *set_rate (char *arguments)
{
char *more_arguments;
Rate = INVALID_RATE; /* Preset to <invalid> rate */
more_arguments = set_double (arguments, &Rate, TRUE, FALSE);
if (more_arguments == NullString)
{
Rate = AUTO_RATE; /* Set to <auto/default> rate */
}
return more_arguments;
}
char *set_interleave (char *arguments)
{
char *end_argument;
ULONG interleave = 0;
Interleave = INVALID_INTERLEAVE; /* Force flagged value on error */
end_argument = set_ulong (arguments, &interleave, TRUE, TRUE);
if (interleave < 2)
{
command_error_message (BAD_ARGUMENT, end_argument-1);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else
{
Interleave = interleave;
}
return end_argument;
}
char *set_no_interleave (char *arguments)
{
Interleave = 1;
return arguments;
}
char *set_bins (char *arguments)
{
unsigned long bins = 1;
unsigned long okbins = 1;
char *new_arguments;
NumberBins = INVALID_BINS; /* Preset invalid value in case of error */
new_arguments = set_ulong (arguments, &bins, FALSE, FALSE);
if (new_arguments != NullString)
{
if (bins == 0)
{
NumberBins = 0;
return new_arguments;
}
okbins = get_pos_power_2 (bins);
if (okbins > LONG_MAX)
{
okbins = get_pos_power_2 (LONG_MAX / 2L);
}
NumberBins = (long) okbins;
if (NumberBins != bins)
{
bins_s_message ();
}
}
else
{
NumberBins = MAX_BINS; /* Default...based on data count of file */
}
return new_arguments;
}
unsigned long get_pos_power_2 (unsigned long i)
{
unsigned long j = 1; /* minimum useful value */
unsigned long max = ULONG_MAX / 2; /* max value we can safely handle */
for (j = 1; j < max; j *= 2)
{
if (j >= i) break;
}
return j;
}
char *set_no_calibrations (char *arguments)
{
calibration_list__cancel (&CalibrationList);
CalibrationList = NULL;
return arguments;
}
char *set_db_calibration (char *arguments)
{
arguments = add_calibration (arguments, TRUE);
return arguments;
}
char *set_calibration (char *arguments)
{
arguments = add_calibration (arguments, FALSE);
return arguments;
}
static char *add_calibration (char *arguments, BOOLEAN db_scale)
{
char *more_arguments;
FILE *cal_file;
char *cal_name;
more_arguments = get_filename (arguments, &cal_name);
if (cal_name == NullString)
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here */
}
if (!(cal_file = fopen (cal_name,"r")))
{
error_message (CANT_OPEN_INPUT_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here */
}
calibration_list__add (&CalibrationList, cal_name, cal_file, db_scale);
return more_arguments;
}
char *load_settings (char *arguments)
{
char *more_arguments;
char *filename;
FILE *fptr;
more_arguments = get_filename (arguments, &filename);
if (filename == NullString)
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
if (!(fptr = fopen (filename,"r")))
{
error_message (CANT_OPEN_INPUT_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
CATCH_ERROR
{
execute_file_commands (fptr);
}
END_CATCH_ERROR;
fclose (fptr);
return more_arguments;
}
char *set_read (char *arguments)
{
char *more_arguments;
if (ReadName && ReadName != NullString)
{
gfree (ReadName);
ReadName = NullString;
}
if (ReadPtr != NULL && ReadPtr != stdin)
{
fclose (ReadPtr);
}
if (Save_Data)
{
gfree (Save_Data);
Save_Data = NULL;
}
more_arguments = get_filename (arguments, &ReadName);
if (ReadName == NullString)
{
reset_format ();
ReadPtr = NULL;
ReadName = NULL;
return more_arguments;
}
if (strlen (ReadName) == 4 && !strcmp (ReadName,"con:"))
{
reset_format ();
ReadPtr = stdin;
return more_arguments;
}
if (!(ReadPtr = fopen (ReadName,"r")))
{
error_message (CANT_OPEN_INPUT_FILE);
reset_format ();
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else
{
read_format ();
}
return more_arguments;
}
char *set_append (char *arguments)
{
char *more_arguments;
Appending = FALSE;
if (WriteName && WriteName != NullString)
{
/* gfree (WriteName); aliased name! unsafe to free! */
WriteName = NullString;
}
if (WritePtr != NULL && WritePtr != stdout)
{
fclose (WritePtr);
}
WritePtr = NULL;
more_arguments = get_filename (arguments, &WriteName);
if (WriteName == NullString)
{
Appending = TRUE;
WriteName = NULL;
return more_arguments;
}
WritePtr = fopen (WriteName,"a");
if (!WritePtr)
{
error_message (CANT_CREATE_OUTPUT_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
Appending = TRUE;
return more_arguments;
}
char *set_write (char *arguments)
{
/*
* The following is intended to maximize portability
* by using (ultimately) only ANSI C functions and notions
*
* Note: If the first characters match the TEMP_DATAFILE_NAME, the
* previous version will be overwritten with impunity, otherwise:
* if a file exists with the same name, it will be renamed to backup.
* Only one level of backup files is created.
* It will fail if filesystem does not allow a one character suffix.
* If the backup fails, file is not opened for output.
*/
char *more_arguments;
FILE *temp_ptr;
Appending = FALSE;
if (WriteName && WriteName != NullString)
{
/* gfree (WriteName); aliased name! unsafe to free! */
WriteName = NullString;
}
if (WritePtr != NULL && WritePtr != stdout)
{
fclose (WritePtr);
}
WritePtr = NULL;
more_arguments = get_filename (arguments, &WriteName);
if (WriteName == NullString)
{
WriteName = NULL;
return more_arguments;
}
if (strlen (WriteName) == 4 && !strcmp (WriteName,"con:"))
{
WritePtr = stdout;
return more_arguments;
}
if (!is_temp_file (WriteName))
{
if (temp_ptr = fopen (WriteName,"r"))
{
int oldlen;
char *newname;
int old_backup_deleted = FALSE;
fclose (temp_ptr);
oldlen = strlen (WriteName);
newname = gmalloc (oldlen + 2, NOTHING_SPECIAL);
strcpy (newname, WriteName);
newname[oldlen] = BACKUP_FILE_CHARACTER;
newname[oldlen + 1] = '\0';
if (temp_ptr = fopen (newname,"r"))
{
old_backup_deleted = TRUE;
fclose (temp_ptr);
remove (newname);
}
if (rename (WriteName, newname))
{
error_message (OUTPUT_BACKUP_FAILURE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else if (old_backup_deleted)
{
error_message (BACKUP_OVERWRITTEN); /* Warning only. */
}
else
{
error_message (BACKUP_CREATED); /* Warning only. */
}
gfree (newname);
}
}
WritePtr = fopen (WriteName,"w");
if (!WritePtr)
{
error_message (CANT_CREATE_OUTPUT_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return more_arguments;
}
char *clear_plot_commands (char *arguments)
{
PlotCommands = NULL;
return arguments;
}
char *add_plot_command (char *arguments)
{
struct list_st **plot_basep = &PlotCommands;
char *command;
while (*plot_basep != NULL)
{
plot_basep = &((*plot_basep)->next);
}
*plot_basep = (struct list_st *) gcalloc (1, sizeof (struct list_st),
NOTHING_SPECIAL);
command = (char *) gmalloc (1+strlen(arguments), NOTHING_SPECIAL);
strcpy (command, arguments);
(*plot_basep)->node = (void *) command;
(*plot_basep)->next = NULL;
return NullString;
}
void write_plot_commands (FILE *fp, char *cstr, char *name,
struct list_st *plot_commands)
{
while (plot_commands)
{
/* fortunately, GNUPLOT ignores leading whitespace */
fprintf (fp, "%s%s %s\n", cstr, name,
(char *) plot_commands->node);
plot_commands = plot_commands->next;
}
}
/* Utility functions *****************************************************/
/*
* Set an unsigned long value
* decimal, octal, or hex accepted
* handle error, incl. termination by other than NULL, space, or newline
* on error, longjmp (to command loop)
* a flag determines if value greater than 0 is required
* a flag determines if argument is mandatory (then longjmp if not present)
* if argument not mandatory, return NullString if no arg found,
* otherwise, return string pointer to first char past end of filename
* (this may be simply a pointer to a '\0' byte)
* value is only set if found and successful
*/
static char *set_ulong (char *arguments, unsigned long *valuep,
int gt_0_req, int arg_req)
{
char *arg;
char *beyondpointer = NULL;
unsigned long newvalue;
arg = strtok (arguments, " ");
if (!arg) /* No argument present */
{
if (arg_req)
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return NullString;
}
errno = 0;
newvalue = strtoul (arg, &beyondpointer, 0);
if (errno || (newvalue == 0 && gt_0_req))
{
command_error_message (BAD_ARGUMENT, arg);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
if (*beyondpointer != ' ' && *beyondpointer != '\0' &&
*beyondpointer != '\n') /* illegal character in number */
{
command_error_message (BAD_ARGUMENT, beyondpointer);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
*valuep = newvalue;
return beyondpointer;
}
/*
* Set a double value
* handle error, incl. termination by other than NULL, space, or newline
* on error, longjmp (to command loop)
* a flag determines if value greater than 0 is required
* a flag determines if argument is mandatory (then longjmp if not present)
* if argument not mandatory, return NullString if no argument found
* otherwise, return string ptr to character following argument
* (this may be a string ptr to a '\0' byte)
* value is only set if found and successful
*/
static char *set_double (char *arguments, double *valuep,
int gt_0_req, int arg_req)
{
char *arg;
char *beyondpointer = NULL;
double newvalue;
arg = strtok (arguments, " ");
if (!arg) /* No argument present */
{
if (arg_req)
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
return NullString;
}
errno = 0;
newvalue = strtod (arg, &beyondpointer);
if (errno || (newvalue <= 0.0L && gt_0_req))
{
command_error_message (BAD_ARGUMENT, arg);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
if (*beyondpointer != ' ' && *beyondpointer != '\0' &&
*beyondpointer != '\n') /* illegal character in number */
{
command_error_message (BAD_ARGUMENT, beyondpointer);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
*valuep = newvalue;
return beyondpointer; /* beyondpointer points to char past arg */
}
static char* get_filename (char *arguments, char **filename_pp)
{
char *arg;
char *end;
char *name;
char old_endc;
int len;
arg = strtok (arguments, "\n");
if (!arg)
{
if (CommandMode == INTERACTIVE_MODE ||
CommandMode == WORKBENCH_MODE)
{
*filename_pp = NullString; /* Default to stdin or stdout */
return NullString;
}
else
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
}
if (*arg == '\"' || *arg == '\'') /* filename in quotes */
{
end = arg + 1;
while (*end != '\0' && *end != *arg && *end != '\n')
{
end++;
}
if (*end != *arg)
{
command_error_message (BAD_NAME, end);
RAISE_ERROR (NOTHING_SPECIAL);
}
arg++; /* Pass initial quote */
}
else
{
end = arg;
while (*end != '\0' && *end != ' ' && *end != '\n')
{
end++;
}
}
old_endc = *end; /* save original termination */
*end = '\0'; /* terminate name string */
len = strlen (arg);
name = gmalloc (len + 1, NOTHING_SPECIAL); /* Leave room for null! */
strcpy (name,arg);
*filename_pp = name;
if (old_endc != '\0')
{
*end++ = old_endc; /* restore original term, then skip it */
}
return end;
}
BOOLEAN is_temp_file (char *filename)
{
char *template = TEMP_NAME_PREFIX;
char fchar, tchar;
if (!filename || filename == NullString)
{
return FALSE;
}
while (tchar = *template++)
{
if (!(fchar = *filename++)) return FALSE;
if (fchar != tchar) return FALSE;
}
return TRUE;
}
ULONG magic_number (char *string)
{
ULONG magic = 0;
for (;*string;magic+=*string,string++);
return magic;
}
char *save_settings (char *arguments)
{
return save_settings_or_parameters (arguments, FALSE);
}
char *save_parameters (char *arguments)
{
return save_settings_or_parameters (arguments, TRUE);
}
char *save_settings_or_parameters
(char *arguments, BOOLEAN parameters_only)
{
/*
* This follows much of the same logic as is used for opening a spectrum
*
* If a file exists with the same name, it will be renamed to backup.
* Only one level of backup files is created.
* It will fail if filesystem does not allow a one character suffix.
* If the backup fails, file is not opened for output.
*/
char *more_arguments;
FILE *temp_ptr = NULL;
FILE *savefile_ptr = NULL;
char *savefile_name;
more_arguments = get_filename (arguments, &savefile_name);
if (savefile_name == NullString)
{
command_error_message (MISSING_ARGUMENT, arguments);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
if (temp_ptr = fopen (savefile_name, "r"))
{
int oldlen;
char *newname;
int old_backup_deleted = FALSE;
fclose (temp_ptr);
oldlen = strlen (savefile_name);
newname = gmalloc (oldlen + 2, NOTHING_SPECIAL);
strcpy (newname, savefile_name);
newname[oldlen] = BACKUP_FILE_CHARACTER;
newname[oldlen + 1] = '\0';
if (temp_ptr = fopen (newname,"r"))
{
old_backup_deleted = TRUE;
fclose (temp_ptr);
remove (newname);
}
if (rename (savefile_name, newname))
{
error_message (OUTPUT_BACKUP_FAILURE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
else if (old_backup_deleted)
{
error_message (BACKUP_OVERWRITTEN); /* Warning only. */
}
else
{
error_message (BACKUP_CREATED); /* Warning only. */
}
gfree (newname);
}
savefile_ptr = fopen (savefile_name,"w");
if (!savefile_ptr)
{
error_message (CANT_CREATE_OUTPUT_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
write_settings (savefile_ptr, NullString, parameters_only,
parameters_only);
fclose (savefile_ptr);
return more_arguments;
}
