/***************************************************************************
* 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: messages.c
* Purpose: (most) console messages
* Author: Charles Peterson (CPP)
* History: 3-August-1993 CPP; Created.
* 30-June-1994 CPP (0.72); Expanded launching script for MORE
* 6-July-1994 CPP (0.73); call display_file() in more_strings
* 6-July-1994 CPP (0.74); allow simultaneous MORE sessions
* 27-July-1994 CPP (1.03); fix COPYING display under ADOS 1.3
* 12-Aug-1994 CPP (1.11); fix enforcer hit in more_strings
* 13-January-1995 CPP (1.19) use <string.h> for ANSI compat
* 17-Jan-1995 CPP (1.20); Size shells nicely
* 20-Jan-1995 CPP (1.24); Remove enforcer hits during show
* 20-Jan-1994 CPP (1.23); Use icon tooltypes
* 15-Feb-1995 CPP (1.43); Show all non-default settings
*
* Comments: This is where message strings are output.
* The include file messages.h should ONLY be included here.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h> /* tolower */
#include "gfft.h"
#include "settings.h"
#include "messages.h"
#include "format.h"
#include "wbench.h"
extern struct Window *dialog_window_p;
extern struct Gadget *message_gadgetp;
#define CONSOLE_WIDTH 79
#define PAGE_SIZE 20
#define MESSAGE_BUFSIZE 160
extern Name_Info_St Gfft_Command[];
extern int Shell_Width;
extern int Shell_Height;
static char message___message_buf[MESSAGE_IOBUFFER_SIZE];
static FILE *message___read_file = NULL;
static char **message___strings = NULL;
static int message___string_index = 0;
static void display_iterate (char *iterator_func());
static void display_strings (char *messagestrings[]);
static char *next_file_line (void);
static char *next_string (void);
static void message_display (char *message_string, FILE *output_ptr);
static void error_message_display (char *message_string, FILE *output_ptr);
static void more_strings (char **message_strings);
#ifdef AMIGA
static void display_file (char *filename, BOOLEAN delete);
#else
static void display_file (FILE *read_file);
#endif
static int count = 0;
char *banner_message (char *arguments)
{
char name_string[82];
int i;
int name_length;
int name_delta;
int name_indent;
int copyright_length = strlen (Copyright);
int copyright_delta = CONSOLE_WIDTH - copyright_length;
int copyright_indent = copyright_delta / 2;
strcpy (name_string, NameAuthor);
strcat (name_string, VersionData);
name_length = strlen (name_string);
name_delta = CONSOLE_WIDTH - name_length;
name_indent = name_delta / 2;
printf ("\n");
for (i = 0; i < name_indent; i++) printf (" ");
printf (name_string);
printf ("\n");
for (i = 0; i < copyright_indent; i++) printf (" ");
printf (Copyright);
display_strings (banner_strings);
return arguments;
}
char *about_message (char *arguments)
{
display_strings (Author_Strings);
return arguments;
}
#define HELP_BUFSIZ 90
static char *help_message_with_arguments (char *arguments)
/*
* Note: the assumption is made that all arguments present are to be
* used in the help command (even though only one argument is currently
* supported). Thus, a help command could not be used at the beginning
* of a batch command, followed by 'real' commands. In fact, given the
* current batch command algorithm, a help command with arguments in
* batch wouldn't work anyway...the arguments would be assumed to be
* real commands.
*/
{
FILE *help_file_ptr;
FILE *message_file_ptr;
char help_buf[HELP_BUFSIZ];
char message_file_name[MAX_PATH];
int i;
int length = strlen (arguments);
#ifdef AMIGA
sprintf (message_file_name, "%s%d",
MESSAGE_FILE_NAME, ++count);
message_file_ptr = fopen (message_file_name, "w");
if (!message_file_ptr)
{
error_message (CANT_CREATE_MESSAGE_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
#else
message_file_ptr = stdout;
#endif
if (help_file_ptr = gopen (HelpPathList, HELP_FILE_NAME, "r"))
{
while (fgets (help_buf, HELP_BUFSIZ, help_file_ptr))
{
if (help_buf[0] == '?')
{
for (i = 0; i < length; i++)
{
if (tolower (help_buf[i+1]) != tolower (arguments[i]))
break;
}
if (length == i) /* No mismatch */
{
BOOLEAN line_output_already = FALSE;
while (fgets (help_buf, HELP_BUFSIZ, help_file_ptr))
{
if (help_buf[0] != ' ' && help_buf[0] != '\n')
{
if (line_output_already) break;
continue;
}
line_output_already = TRUE;
fputs (help_buf, message_file_ptr);
}
# ifdef AMIGA
fclose (message_file_ptr);
display_file (message_file_name, TRUE);
# else
display_file (message_file_ptr);
fclose (message_file_ptr);
# endif
fclose (help_file_ptr);
return NullString;
}
}
}
fclose (help_file_ptr);
fclose (message_file_ptr);
error_message (HELP_MESSAGE_UNAVAILABLE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here */
}
fclose (message_file_ptr);
error_message (HELP_FILE_NOT_FOUND);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here */
return NullString; /* shouldn't get here actually */
}
char *copying_message (char *arguments)
{
FILE *copying_file;
if (copying_file = gopen (HelpPathList,"COPYING","r"))
{
# ifdef AMIGA
/* bugfix (1.03)
* under 1.3, spawned process doesn't inheirit current directory (DAMN!)
* so, we must copy COPYING into a temporary file so that we know where
* it is.
*/
FILE *message_file;
char buffer[HELP_BUFSIZ];
char message_file_name[MAX_PATH];
sprintf (message_file_name, "%s%d",
MESSAGE_FILE_NAME, ++count);
message_file = fopen (message_file_name, "w");
if (!message_file)
{
error_message (CANT_CREATE_MESSAGE_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
while (fgets (buffer, HELP_BUFSIZ, copying_file))
{
fputs (buffer, message_file);
}
fclose (copying_file);
fclose (message_file);
display_file (message_file_name, TRUE);
# else /* AMIGA not defined */
display_file (copying_file);
fclose (copying_file);
# endif
}
else
{
more_strings (copying_unavailable_strings);
}
return arguments;
}
char *no_warranty_message (char *arguments)
{
more_strings (no_warranty_strings);
return arguments;
}
char *question_message (char *arguments)
{
display_strings (question_message_strings);
return arguments;
}
#define HELP_COLUMNS 3
#if (HELP_COLUMNS == 3)
#define TAB_1 26
#define TAB_2 52
#else
#define TAB_1 20
#define TAB_2 40
#define TAB_3 60
#endif
char *help_message (char *arguments)
{
/*
* I find it easier to read commands if they are listed in multiple columns
* AND if each column has commands in alphabetical order
*/
int i;
int midcommand;
int end_command_number;
int col;
char message_file_name[MAX_PATH];
FILE *message_file_ptr;
if (arguments[0] != '\0')
{
return help_message_with_arguments (arguments);
}
#ifdef AMIGA /* Use MORE to display in separate shell */
sprintf (message_file_name, "%s%d",
MESSAGE_FILE_NAME, ++count);
message_file_ptr = fopen (message_file_name, "w");
if (!message_file_ptr)
{
error_message (CANT_CREATE_MESSAGE_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
#else
message_file_ptr = stdout;
#endif
for (i = 0; strlen (Gfft_Command[i].full_string); i++);
end_command_number = i + 1;
midcommand = end_command_number / HELP_COLUMNS;
for (i = 0; help_prolog_strings[i]; i++)
{
fprintf (message_file_ptr, "%s\n", help_prolog_strings[i]);
}
for (i = 0; i < midcommand; i++)
{
col = 0;
col += fprintf (message_file_ptr, "%s", Gfft_Command[i].full_string);
if (i + midcommand < end_command_number)
{
fputc (' ', message_file_ptr);
while (++col < TAB_1) fputc (' ', message_file_ptr);
col += fprintf (message_file_ptr, "%s",
Gfft_Command[i + midcommand].full_string);
if (i + midcommand*2 < end_command_number)
{
fputc (' ', message_file_ptr);
while (++col < TAB_2) fputc (' ', message_file_ptr);
col += fprintf (message_file_ptr, "%s",
Gfft_Command[i + midcommand*2].full_string);
#if (TAB_COLUMNS == 4)
if (i + midcommand*3 < end_command_number)
{
fputc (' ', message_file_ptr);
while (++col < TAB_3) fputc (' ', message_file_ptr);
col += fprintf (message_file_ptr, "%s",
Gfft_Command[i + midcommand*3].full_string);
}
#endif
}
}
fprintf (message_file_ptr,"\n");
}
for (i = 0; help_epilog_strings[i]; i++)
{
fprintf (message_file_ptr, "%s\n", help_epilog_strings[i]);
}
if (message_file_ptr != stdout)
{
# ifdef AMIGA
fclose (message_file_ptr);
display_file (message_file_name, TRUE);
# else
display_file (message_file_ptr);
fclose (message_file_ptr);
# endif
}
return arguments;
}
#ifdef AMIGA
static void display_file (char *filename, BOOLEAN delete)
#else
static void display_file (FILE *read_file)
#endif
{
#ifdef AMIGA /* Run MORE command to display file in new shell */
char buffer[COMMAND_BUFFER_SIZE];
char command_file_name[MAX_PATH];
FILE *comfile_ptr;
sprintf (command_file_name, "%s%d",
MORE_COMMAND_FILE_NAME, ++count);
comfile_ptr = fopen (command_file_name,"w");
if (!comfile_ptr)
{
error_message (CANT_CREATE_MORE_COMMAND_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
fprintf (comfile_ptr, "which >nil: more\n");
fprintf (comfile_ptr, "if warn\n");
fprintf (comfile_ptr, "if exists sys:utilities\n");
fprintf (comfile_ptr, "path >nil: sys:utilities add\n");
fprintf (comfile_ptr, "endif\n");
fprintf (comfile_ptr, "endif\n");
fprintf (comfile_ptr, "more %s\n", filename);
fprintf (comfile_ptr, "failat 100\n");
if (delete)
{
fprintf (comfile_ptr, "delete >nil: %s QUIET\n", filename);
}
fprintf (comfile_ptr,
";The following is to delete EARLIER scripts still hanging around.\n");
fprintf (comfile_ptr, "delete >nil: %s QUIET\n",
COMMAND_FILE_WILDCARD); /* delete OLDer versions */
fprintf (comfile_ptr, "endcli\n");
fclose (comfile_ptr);
sprintf (buffer,
"newshell CON:0/0/%d/%d/Gfft-More-Shell from %s",
Shell_Width, Shell_Height, command_file_name);
system (buffer);
#else /* Display file directly in current shell */
message___read_file = read_file;
display_iterate (next_file_line);
#endif
}
static void more_strings (char **message_strings)
{
#ifdef AMIGA /* Use MORE command to display strings in new shell */
FILE *message_file_ptr;
char message_file_name[MAX_PATH];
int i;
sprintf (message_file_name, "%s%d",
MESSAGE_FILE_NAME, ++count);
message_file_ptr = fopen (message_file_name,"w");
if (!message_file_ptr)
{
error_message (CANT_CREATE_MESSAGE_FILE);
RAISE_ERROR (NOTHING_SPECIAL); /* longjmp outa here! */
}
for (i = 0; message_strings[i]; i++)
{
fprintf (message_file_ptr, "%s\n", message_strings[i]);
}
fclose (message_file_ptr);
display_file (message_file_name, TRUE);
#else /* Display strings in current shell */
display_strings (message_strings);
#endif
}
static void display_strings (char **message_strings)
{
message___strings = message_strings;
message___string_index = 0;
display_iterate (next_string);
message___strings = NULL;
}
static char *next_file_line (void)
{
int i = 0;
int c;
static ff_found = FALSE;
if (ff_found)
{
ff_found = FALSE;
message___message_buf[0] = '\f';
message___message_buf[1] = '\0';
return message___message_buf;
}
while (EOF != (c = getc (message___read_file)))
{
if (c == '\n')
{
break;
}
if (c == '\f')
{
ff_found = TRUE;
break;
}
message___message_buf[i] = (char) c;
if (++i >= MESSAGE_IOBUFFER_SIZE - 1)
{
break;
}
}
message___message_buf[i] = '\0';
if (c == EOF && i == 0)
{
return NULL;
}
else
{
return message___message_buf;
}
}
static char *next_string (void)
{
char *string = NULL;
if (message___strings)
{
if (message___strings[message___string_index])
{
string = message___strings[message___string_index++];
}
else
{
message___strings = NULL;
}
}
return string;
}
static void display_iterate (char *iterator_function(void))
{
char input_line[MESSAGE_IOBUFFER_SIZE];
char *message_string;
int i = 0;
while (message_string = (*iterator_function)())
{
if (++i > PAGE_SIZE)
{
printf ("\n%s",MORE_STRING);
gets (input_line);
if (strlen(input_line) > 0 && (input_line[0] == NO_MORE_CHAR_1 ||
input_line[0] == NO_MORE_CHAR_2))
{
break;
}
printf("\n");
i = 1;
}
if (message_string[0] == '\f')
{
printf ("\n");
i = PAGE_SIZE;
}
else
{
printf ("%s\n",message_string);
}
}
}
void command_error_message (int message_number, char *bad_charp)
{
long spaces;
if (Quiet) return;
if (CommandMode != WORKBENCH_MODE)
{
spaces = strlen (PROMPT) + (bad_charp - Command);
if (CommandMode != INTERACTIVE_MODE)
{
fprintf (stderr,"%s\n",Command);
spaces -= strlen (PROMPT);
}
for (; spaces > 0; spaces--)
{
fprintf (stderr," ");
}
fprintf (stderr,"^\n");
}
error_message (message_number);
}
void error_message (int message_number)
{
/*
* Since all messages herein are error messages
* They are all written to stderr (or, output to a window)
*/
char *message_string;
Error_Count++;
switch (message_number)
{
case NO_SUCH_COMMAND:
message_string = NO_SUCH_COMMAND_S;
break;
case OUT_OF_MEMORY:
message_string = OUT_OF_MEMORY_S;
break;
case REQUESTER_STACK_OVERFLOW:
message_string = REQUESTER_STACK_OVERFLOW_S;
break;
case UNSUPPORTED_COMMAND:
message_string = UNSUPPORTED_COMMAND_S;
break;
case MISSING_ARGUMENT:
message_string = MISSING_ARGUMENT_S;
break;
case BAD_ARGUMENT:
message_string = BAD_ARGUMENT_S;
break;
case ALREADY_IN_CLI_MODE:
message_string = ALREADY_IN_CLI_MODE_S;
break;
case BAD_NAME:
message_string = BAD_NAME_S;
break;
case AMBIGUOUS_COMMAND:
message_string = AMBIGUOUS_COMMAND_S;
break;
case BACKUP_CREATED:
message_string = BACKUP_CREATED_S;
break;
case OUTPUT_BACKUP_FAILURE:
message_string = OUTPUT_BACKUP_FAILURE_S;
break;
case CANT_CREATE_OUTPUT_FILE:
message_string = CANT_CREATE_OUTPUT_FILE_S;
break;
case CANT_CLEANUP_BATCH_PLOT:
message_string = CANT_CLEANUP_BATCH_PLOT_S;
break;
case CANT_RE_OUTPUT:
message_string = CANT_RE_OUTPUT_S;
break;
case CANT_RE_PLOT:
message_string = CANT_RE_PLOT_S;
break;
case BACKUP_OVERWRITTEN:
message_string = BACKUP_OVERWRITTEN_S;
break;
case CANT_OPEN_INPUT_FILE:
message_string = CANT_OPEN_INPUT_FILE_S;
break;
case SCANNING_FILE:
if (CommandMode == WORKBENCH_MODE) return; /* redundant here */
message_string = SCANNING_FILE_S;
break;
case NO_DATA_PRESENT:
message_string = NO_DATA_PRESENT_S;
break;
case PADDING_TAILEND:
return; /* Now a non-default option */
/* message_string = PADDING_TAILEND_S; */
/* break; */
case AMBIGUOUS_ARGUMENT:
message_string = AMBIGUOUS_ARGUMENT_S;
break;
case NO_SUCH_ARGUMENT:
message_string = NO_SUCH_ARGUMENT_S;
break;
case NO_NUMERICAL:
message_string = NO_NUMERICAL_S;
break;
case INVALID_NUMBER:
message_string = INVALID_NUMBER_S;
break;
case IGNORING_TAILEND:
message_string = IGNORING_TAILEND_S;
break;
case INSUFFICIENT_DATA:
message_string = INSUFFICIENT_DATA_S;
break;
case FILENAME_TOO_LONG:
message_string = FILENAME_TOO_LONG_S;
break;
case NO_RATE_SPECIFIED:
message_string = NO_RATE_SPECIFIED_S;
break;
case NO_READ_FILE:
message_string = NO_READ_FILE_S;
break;
case UNSUPPORTED_FORMAT:
message_string = UNSUPPORTED_FORMAT_S;
break;
case TOOLTYPE_ERROR:
message_string = TOOLTYPE_ERROR_S;
break;
case STARTUP_FILE_ERROR:
message_string = STARTUP_FILE_ERROR_S;
break;
case CORRUPT_IFF:
message_string = CORRUPT_IFF_S;
break;
case CORRUPT_AVR:
message_string = CORRUPT_AVR_S;
break;
case COMPRESSION_NOT_SUPPORTED:
message_string = COMPRESSION_NOT_SUPPORTED_S;
break;
case ONESHOT_BUT_NOT_8SVX:
message_string = ONESHOT_BUT_NOT_8SVX_S;
break;
case FORMAT_NOT_OK:
message_string = FORMAT_NOT_OK_S;
break;
case NOT_ENOUGH_FRAMES:
message_string = NOT_ENOUGH_FRAMES_S;
break;
case OCTAVE_NOT_PRESENT:
message_string = OCTAVE_NOT_PRESENT_S;
break;
case CORRUPT_AIFF:
message_string = CORRUPT_AIFF_S;
break;
case CORRUPT_AIFC:
message_string = CORRUPT_AIFC_S;
break;
case NO_WRITE_FILE:
message_string = NO_WRITE_FILE_S;
break;
case DB_OF_ZERO:
message_string = DB_OF_ZERO_S;
break;
case NO_FILE_REQSTR:
message_string = NO_FILE_REQSTR_S;
break;
case SPEC_CHANNEL_UNAVAIL:
message_string = SPEC_CHANNEL_UNAVAIL_S;
break;
case INVALID_BINS_SPEC:
message_string = INVALID_BINS_SPEC_S;
break;
case INVALID_INTERLEAVE_SPEC:
message_string = INVALID_INTERLEAVE_SPEC_S;
break;
case INVALID_SMOOTHING_SPEC:
message_string = INVALID_SMOOTHING_SPEC_S;
break;
case INVALID_TIMESEG_PARAMETERS:
message_string = INVALID_TIMESEG_PARAMETERS_S;
break;
case MISSING_TIMESEG_PARAMETERS:
message_string = MISSING_TIMESEG_PARAMETERS_S;
break;
case CANT_CREATE_PLOTTER_FILE:
message_string = CANT_CREATE_PLOTTER_FILE_S;
break;
case CANT_CREATE_MORE_COMMAND_FILE:
message_string = CANT_CREATE_MORE_COMMAND_FILE_S;
break;
case CANT_CREATE_MESSAGE_FILE:
message_string = CANT_CREATE_MESSAGE_FILE_S;
break;
case HELP_MESSAGE_UNAVAILABLE:
message_string = HELP_MESSAGE_UNAVAILABLE_S;
break;
case HELP_FILE_NOT_FOUND:
message_string = HELP_FILE_NOT_FOUND_S;
break;
case CANT_PLOT_FROM_STDOUT:
message_string = CANT_PLOT_FROM_STDOUT_S;
break;
case INVALID_ROTATION_SPEC:
message_string = INVALID_ROTATION_SPEC_S;
break;
case CHANGED_FORMAT_DEP_VALUE:
message_string = CHANGED_FORMAT_DEP_VALUE_S;
break;
case INVALID_CALIBRATION_FILE:
message_string = INVALID_CALIBRATION_FILE_S;
break;
case CANT_OPEN_INTUITION:
message_string = CANT_OPEN_INTUITION_S;
break;
case WINDOW_OPEN_FAILED:
message_string = WINDOW_OPEN_FAILED_S;
break;
default:
message_string = UNDOCUMENTED_ERROR_S;
break;
}
error_message_display (message_string, stderr);
}
static void error_message_display (char *message_string, FILE *output_ptr)
{
if (Quiet) return;
#ifdef AMIGA
if (CommandMode == WORKBENCH_MODE && dialog_window_p)
{
message_requester (dialog_window_p, message_string);
}
else
#endif
{
fprintf (output_ptr, "%s\n", message_string);
}
}
static void message_display (char *message_string, FILE *output_ptr)
{
if (Quiet) return;
#ifdef AMIGA
if (CommandMode == WORKBENCH_MODE && dialog_window_p)
{
message_gadget__write (message_gadgetp, message_string,
dialog_window_p);
}
else
#endif
{
fprintf (output_ptr, "%s\n", message_string);
}
}
void loop_time_message (double seconds)
{
char time_string[160];
if (Quiet) return;
sprintf (time_string,
"FFT loop elapsed time (sec): %-11.5g Now writing fft data...",
seconds);
message_display (time_string, stdout);
}
void loop_time_message_done (double seconds)
{
char time_string[160];
if (Quiet) return;
sprintf (time_string,
"FFT loop elapsed time (sec): %-11.5g Ready for next analysis.",
seconds);
message_display (time_string, stdout);
}
void bins_d_message (unsigned long total_actually_read,
unsigned long number_bins)
{
if (Quiet) return;
/*
* In workbench mode, gadget shows maximum value all the time
* (at least, for formatted files)
*/
if (CommandMode != WORKBENCH_MODE || FileFormat == UNFORMATTED)
{
char message_string[MESSAGE_BUFSIZE];
sprintf (message_string, BINS_DETERMINED_S,
total_actually_read, number_bins);
message_display (message_string, stdout);
}
}
void bins_s_message (void)
{
char message_string[MESSAGE_BUFSIZE];
if (Quiet) return;
sprintf (message_string, BINS_SELECTED_S, NumberBins);
message_display (message_string, stdout);
}
char *settings_message (char *arguments)
{
printf ("Synopsis: \n");
if (ReadPtr == stdin)
{
printf (KEYBOARD_INPUT_S);
}
else
{
if (ReadName && ReadName != NullString)
{
printf (INPUT_FILENAME_S, ReadName);
if (StartByte)
{
printf (STARTBYTE_S, StartByte);
}
}
}
if (WritePtr == stdout)
{
printf (OUTPUT_SCREEN_S);
}
else if (WriteName && WriteName != NullString)
{
printf (OUTPUT_FILENAME_S,WriteName);
}
if (Rate)
{
printf (SAMPLING_RATE_S);
#ifdef _FFP
printf ("%-15.8g\n", Rate);
#else
printf ("%-19.12g\n", Rate);
#endif
}
else
{
error_message (NO_RATE_SPECIFIED);
}
if (Numerical)
{
printf (NUMERICAL_RECIPES_USED_S);
}
if (Amplitude)
{
printf (AMPLITUDE_SPECTRUM_S);
}
if (Power)
{
printf (POWER_SPECTRUM_S);
}
if (!Power && !Amplitude)
{
printf (FFT_S);
}
else
{
if (Mean)
{
printf (MEAN_NORMALIZED_S);
}
else
{
printf (SUMMED_S);
}
if (NumberBins < 0)
{
printf (DEFAULT_BINS_S);
}
else
{
printf (BINS_S, NumberBins);
}
switch (WindowType)
{
case RECTANGLE_WINDOW:
printf (RECTANGLE_WINDOWS_S);
break;
case HANN_WINDOW:
printf (HANN_WINDOWS_S);
break;
case PARZEN_WINDOW:
printf (PARZEN_WINDOWS_S);
break;
case WELCH_WINDOW:
printf (WELCH_WINDOWS_S);
break;
case TRIANGLE_WINDOW:
printf (TRIANGLE_WINDOWS_S);
break;
case HAMMING_WINDOW:
printf (HAMMING_WINDOWS_S);
break;
case BLACKMAN_HARRIS_74DB_WINDOW:
printf (BLACKMAN_HARRIS_74DB_WINDOWS_S);
break;
case BLACKMAN_HARRIS_92DB_WINDOW:
printf (BLACKMAN_HARRIS_92DB_WINDOWS_S);
break;
}
if (Overlap)
{
printf (OVERLAP_S);
}
else
{
printf (NO_OVERLAP_S);
}
if (Interleave > 1)
{
printf (INTERLEAVE_S);
}
if (Pink)
{
printf (PINK_S);
}
}
if (HighFrequency != HIGHEST_FREQUENCY)
{
printf (MAX_FREQUENCY_S, HighFrequency);
}
if (LowFrequency != LOWEST_FREQUENCY)
{
printf (MIN_FREQUENCY_S, LowFrequency);
}
printf ("\nList of non-default settings:\n");
write_settings (stdout, NullString, TRUE, TRUE);
return arguments;
}
