home *** CD-ROM | disk | FTP | other *** search
/ The AGA Experience 2 / agavol2.iso / software / sound / utils / gfft-2.03 / source / gfft-2.03-source.lha / messages.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-02  |  23.0 KB  |  971 lines
  1. /***************************************************************************
  2.  *          Copyright (C) 1994  Charles P. Peterson                  *
  3.  *         4007 Enchanted Sun, San Antonio, Texas 78244-1254             *
  4.  *              Email: Charles_P_Peterson@fcircus.sat.tx.us                *
  5.  *                                                                         *
  6.  *          This is free software with NO WARRANTY.                  *
  7.  *          See gfft.c, or run program itself, for details.              *
  8.  *              Support is available for a fee.                      *
  9.  ***************************************************************************
  10.  *
  11.  * Program:     gfft--General FFT analysis
  12.  * File:        messages.c
  13.  * Purpose:     (most) console messages
  14.  * Author:      Charles Peterson (CPP)
  15.  * History:     3-August-1993 CPP; Created.
  16.  *              30-June-1994 CPP (0.72); Expanded launching script for MORE
  17.  *              6-July-1994 CPP (0.73); call display_file() in more_strings
  18.  *              6-July-1994 CPP (0.74); allow simultaneous MORE sessions
  19.  *              27-July-1994 CPP (1.03); fix COPYING display under ADOS 1.3
  20.  *              12-Aug-1994 CPP (1.11); fix enforcer hit in more_strings
  21.  *              13-January-1995 CPP (1.19) use <string.h> for ANSI compat
  22.  *              17-Jan-1995 CPP (1.20); Size shells nicely
  23.  *              20-Jan-1995 CPP (1.24); Remove enforcer hits during show
  24.  *              20-Jan-1994 CPP (1.23); Use icon tooltypes
  25.  *              15-Feb-1995 CPP (1.43); Show all non-default settings
  26.  *
  27.  * Comments:    This is where message strings are output.
  28.  *              The include file messages.h should ONLY be included here.
  29.  */
  30.  
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <string.h>
  34. #include <ctype.h>    /* tolower */
  35.  
  36. #include "gfft.h"
  37. #include "settings.h"
  38. #include "messages.h"
  39. #include "format.h"
  40.  
  41. #include "wbench.h"
  42. extern struct Window *dialog_window_p;
  43. extern struct Gadget *message_gadgetp;
  44.  
  45. #define CONSOLE_WIDTH 79
  46. #define PAGE_SIZE 20
  47. #define MESSAGE_BUFSIZE 160
  48.  
  49. extern Name_Info_St Gfft_Command[];
  50. extern int Shell_Width;
  51. extern int Shell_Height;
  52.  
  53. static char message___message_buf[MESSAGE_IOBUFFER_SIZE];
  54. static FILE *message___read_file = NULL;
  55. static char **message___strings = NULL;
  56. static int message___string_index = 0;
  57.  
  58. static void display_iterate (char *iterator_func());
  59. static void display_strings (char *messagestrings[]);
  60. static char *next_file_line (void);
  61. static char *next_string (void);
  62. static void message_display (char *message_string, FILE *output_ptr);
  63. static void error_message_display (char *message_string, FILE *output_ptr);
  64. static void more_strings (char **message_strings);
  65.  
  66. #ifdef AMIGA
  67. static void display_file (char *filename, BOOLEAN delete);
  68. #else
  69. static void display_file (FILE *read_file);
  70. #endif
  71.  
  72. static int count = 0;
  73.  
  74. char *banner_message (char *arguments)
  75. {
  76.     char name_string[82];
  77.     int i;
  78.     int name_length;
  79.     int name_delta;
  80.     int name_indent;
  81.     int copyright_length = strlen (Copyright);
  82.     int copyright_delta = CONSOLE_WIDTH - copyright_length;
  83.     int copyright_indent = copyright_delta / 2;
  84.  
  85.     strcpy (name_string, NameAuthor);
  86.     strcat (name_string, VersionData);
  87.     name_length = strlen (name_string);
  88.     name_delta = CONSOLE_WIDTH - name_length;
  89.     name_indent = name_delta / 2;
  90.  
  91.     printf ("\n");
  92.     for (i = 0; i < name_indent; i++) printf (" ");
  93.     printf (name_string);
  94.  
  95.     printf ("\n");
  96.     for (i = 0; i < copyright_indent; i++) printf (" ");
  97.     printf (Copyright);
  98.  
  99.     display_strings (banner_strings);
  100.     return arguments;
  101. }
  102.  
  103. char *about_message (char *arguments)
  104. {
  105.     display_strings (Author_Strings);
  106.     return arguments;
  107. }
  108.  
  109. #define HELP_BUFSIZ 90
  110.  
  111. static char *help_message_with_arguments (char *arguments)
  112. /*
  113.  * Note: the assumption is made that all arguments present are to be
  114.  * used in the help command (even though only one argument is currently
  115.  * supported).  Thus, a help command could not be used at the beginning
  116.  * of a batch command, followed by 'real' commands.  In fact, given the
  117.  * current batch command algorithm, a help command with arguments in
  118.  * batch wouldn't work anyway...the arguments would be assumed to be
  119.  * real commands.
  120.  */
  121. {
  122.     FILE *help_file_ptr;
  123.     FILE *message_file_ptr;
  124.     char help_buf[HELP_BUFSIZ];
  125.     char message_file_name[MAX_PATH];
  126.     int i;
  127.     int length = strlen (arguments);
  128.  
  129. #ifdef AMIGA
  130.     sprintf (message_file_name, "%s%d",
  131.          MESSAGE_FILE_NAME, ++count);
  132.  
  133.     message_file_ptr = fopen (message_file_name, "w");
  134.     if (!message_file_ptr)
  135.     {
  136.     error_message (CANT_CREATE_MESSAGE_FILE);
  137.     RAISE_ERROR (NOTHING_SPECIAL);  /* longjmp outa here! */
  138.     }
  139. #else
  140.     message_file_ptr = stdout;
  141. #endif
  142.       
  143.     if (help_file_ptr = gopen (HelpPathList, HELP_FILE_NAME, "r"))
  144.     {
  145.     while (fgets (help_buf, HELP_BUFSIZ, help_file_ptr))
  146.     {
  147.         if (help_buf[0] == '?')
  148.         {
  149.         for (i = 0; i < length; i++)
  150.         {
  151.             if (tolower (help_buf[i+1]) != tolower (arguments[i]))
  152.               break;
  153.         }
  154.         if (length == i) /* No mismatch */
  155.         {
  156.             BOOLEAN line_output_already = FALSE;
  157.             while (fgets (help_buf, HELP_BUFSIZ, help_file_ptr))
  158.             {
  159.             if (help_buf[0] != ' ' && help_buf[0] != '\n')
  160.             {
  161.                 if (line_output_already) break;
  162.                 continue;
  163.             }
  164.             line_output_already = TRUE;
  165.             fputs (help_buf, message_file_ptr);
  166.             }
  167. #                   ifdef AMIGA
  168.                 fclose (message_file_ptr);
  169.                 display_file (message_file_name, TRUE);
  170. #                   else
  171.                 display_file (message_file_ptr);
  172.                 fclose (message_file_ptr);
  173. #                   endif
  174.             fclose (help_file_ptr);
  175.             return NullString;
  176.         }
  177.         }
  178.     }
  179.     fclose (help_file_ptr);
  180.     fclose (message_file_ptr);
  181.     error_message (HELP_MESSAGE_UNAVAILABLE);
  182.     RAISE_ERROR (NOTHING_SPECIAL);   /* longjmp outa here */
  183.     }
  184.     fclose (message_file_ptr);
  185.     error_message (HELP_FILE_NOT_FOUND);
  186.     RAISE_ERROR (NOTHING_SPECIAL);       /* longjmp outa here */
  187.     return NullString;                   /* shouldn't get here actually */
  188. }
  189.  
  190.  
  191. char *copying_message (char *arguments)
  192. {
  193.     FILE *copying_file;
  194.  
  195.     if (copying_file = gopen (HelpPathList,"COPYING","r"))
  196.     {
  197. #       ifdef AMIGA
  198.  
  199. /* bugfix (1.03)
  200.  * under 1.3, spawned process doesn't inheirit current directory (DAMN!)
  201.  * so, we must copy COPYING into a temporary file so that we know where
  202.  * it is.
  203.  */
  204.     FILE *message_file;
  205.     char buffer[HELP_BUFSIZ];
  206.     char message_file_name[MAX_PATH];
  207.  
  208.     sprintf (message_file_name, "%s%d",
  209.          MESSAGE_FILE_NAME, ++count);
  210.     
  211.     message_file = fopen (message_file_name, "w");
  212.     if (!message_file)
  213.     {
  214.         error_message (CANT_CREATE_MESSAGE_FILE);
  215.         RAISE_ERROR (NOTHING_SPECIAL);  /* longjmp outa here! */
  216.     }
  217.     while (fgets (buffer, HELP_BUFSIZ, copying_file))
  218.     {
  219.         fputs (buffer, message_file);
  220.     }
  221.     fclose (copying_file);
  222.     fclose (message_file);
  223.     display_file (message_file_name, TRUE);
  224.  
  225.  
  226. #       else   /* AMIGA not defined */
  227.         display_file (copying_file);
  228.         fclose (copying_file);
  229. #       endif
  230.  
  231.  
  232.     }
  233.     else
  234.     {
  235.     more_strings (copying_unavailable_strings);
  236.     }
  237.     return arguments;
  238. }
  239.  
  240. char *no_warranty_message (char *arguments)
  241. {
  242.     more_strings (no_warranty_strings);
  243.     return arguments;
  244. }
  245.  
  246. char *question_message (char *arguments)
  247. {
  248.     display_strings (question_message_strings);
  249.     return arguments;
  250. }
  251.  
  252. #define HELP_COLUMNS 3
  253. #if (HELP_COLUMNS == 3)
  254. #define TAB_1 26
  255. #define TAB_2 52
  256. #else
  257. #define TAB_1 20
  258. #define TAB_2 40
  259. #define TAB_3 60
  260. #endif
  261.  
  262. char *help_message (char *arguments)
  263. {
  264. /*
  265.  * I find it easier to read commands if they are listed in multiple columns
  266.  * AND if each column has commands in alphabetical order
  267.  */
  268.     int i;
  269.     int midcommand;
  270.     int end_command_number;
  271.     int col;
  272.     char message_file_name[MAX_PATH];
  273.     FILE *message_file_ptr;
  274.  
  275.     if (arguments[0] != '\0')
  276.     {
  277.     return help_message_with_arguments (arguments);
  278.     }
  279.  
  280. #ifdef AMIGA  /* Use MORE to display in separate shell */
  281.     sprintf (message_file_name, "%s%d",
  282.          MESSAGE_FILE_NAME, ++count);
  283.  
  284.     message_file_ptr = fopen (message_file_name, "w");
  285.     if (!message_file_ptr)
  286.     {
  287.     error_message (CANT_CREATE_MESSAGE_FILE);
  288.     RAISE_ERROR (NOTHING_SPECIAL);  /* longjmp outa here! */
  289.     }
  290. #else
  291.     message_file_ptr = stdout;
  292. #endif
  293.  
  294.     for (i = 0; strlen (Gfft_Command[i].full_string); i++);
  295.     end_command_number = i + 1;
  296.     midcommand = end_command_number / HELP_COLUMNS;
  297.  
  298.     for (i = 0; help_prolog_strings[i]; i++)
  299.     {
  300.     fprintf (message_file_ptr, "%s\n", help_prolog_strings[i]);
  301.     }
  302.  
  303.     for (i = 0; i < midcommand; i++)
  304.     {
  305.     col = 0;
  306.     col += fprintf (message_file_ptr, "%s", Gfft_Command[i].full_string);
  307.     if (i + midcommand < end_command_number)
  308.     {
  309.         fputc (' ', message_file_ptr);
  310.         while (++col < TAB_1) fputc (' ', message_file_ptr);
  311.         col += fprintf (message_file_ptr, "%s",
  312.                 Gfft_Command[i + midcommand].full_string);
  313.         if (i + midcommand*2 < end_command_number)
  314.         {
  315.         fputc (' ', message_file_ptr);
  316.         while (++col < TAB_2) fputc (' ', message_file_ptr);
  317.         col += fprintf (message_file_ptr, "%s",
  318.                 Gfft_Command[i + midcommand*2].full_string);
  319. #if (TAB_COLUMNS == 4)
  320.         if (i + midcommand*3 < end_command_number)
  321.         {
  322.             fputc (' ', message_file_ptr);
  323.             while (++col < TAB_3) fputc (' ', message_file_ptr);
  324.             col += fprintf (message_file_ptr, "%s",
  325.                    Gfft_Command[i + midcommand*3].full_string);
  326.         }
  327. #endif
  328.         }
  329.     }
  330.     fprintf (message_file_ptr,"\n");
  331.     }
  332.     
  333.     for (i = 0; help_epilog_strings[i]; i++)
  334.     {
  335.     fprintf (message_file_ptr, "%s\n", help_epilog_strings[i]);
  336.     }
  337.     if (message_file_ptr != stdout)
  338.     {
  339. #       ifdef AMIGA
  340.         fclose (message_file_ptr);
  341.         display_file (message_file_name, TRUE);
  342. #       else
  343.         display_file (message_file_ptr);
  344.         fclose (message_file_ptr);
  345. #       endif
  346.     }
  347.     return arguments;
  348. }
  349.  
  350. #ifdef AMIGA
  351. static void display_file (char *filename, BOOLEAN delete)
  352. #else
  353. static void display_file (FILE *read_file)
  354. #endif
  355. {
  356. #ifdef AMIGA  /* Run MORE command to display file in new shell */
  357.     char buffer[COMMAND_BUFFER_SIZE];
  358.     char command_file_name[MAX_PATH];
  359.     FILE *comfile_ptr;
  360.  
  361.     sprintf (command_file_name, "%s%d",
  362.          MORE_COMMAND_FILE_NAME, ++count);
  363.  
  364.     comfile_ptr = fopen (command_file_name,"w");
  365.     if (!comfile_ptr)
  366.     {
  367.     error_message (CANT_CREATE_MORE_COMMAND_FILE);
  368.     RAISE_ERROR (NOTHING_SPECIAL);  /* longjmp outa here! */
  369.     }
  370.     fprintf (comfile_ptr, "which >nil: more\n");
  371.     fprintf (comfile_ptr, "if warn\n");
  372.     fprintf (comfile_ptr, "if exists sys:utilities\n");
  373.     fprintf (comfile_ptr, "path >nil: sys:utilities add\n");
  374.     fprintf (comfile_ptr, "endif\n");
  375.     fprintf (comfile_ptr, "endif\n");
  376.     fprintf (comfile_ptr, "more %s\n", filename);
  377.     fprintf (comfile_ptr, "failat 100\n");
  378.     if (delete)
  379.     {
  380.     fprintf (comfile_ptr, "delete >nil: %s QUIET\n", filename);
  381.     }
  382.     fprintf (comfile_ptr, 
  383. ";The following is to delete EARLIER scripts still hanging around.\n");
  384.     fprintf (comfile_ptr, "delete >nil: %s QUIET\n", 
  385.          COMMAND_FILE_WILDCARD);  /* delete OLDer versions */
  386.     fprintf (comfile_ptr, "endcli\n");
  387.     fclose (comfile_ptr);
  388.     sprintf (buffer, 
  389.          "newshell CON:0/0/%d/%d/Gfft-More-Shell from %s",
  390.          Shell_Width, Shell_Height, command_file_name);
  391.     system (buffer);
  392.  
  393. #else /* Display file directly in current shell */
  394.     message___read_file = read_file;
  395.     display_iterate (next_file_line);
  396. #endif
  397. }
  398.  
  399. static void more_strings (char **message_strings)
  400. {
  401. #ifdef AMIGA /* Use MORE command to display strings in new shell */
  402.     FILE *message_file_ptr;
  403.     char message_file_name[MAX_PATH];
  404.     int i;
  405.  
  406.     sprintf (message_file_name, "%s%d",
  407.          MESSAGE_FILE_NAME, ++count);
  408.  
  409.     message_file_ptr = fopen (message_file_name,"w");
  410.     if (!message_file_ptr)
  411.     {
  412.     error_message (CANT_CREATE_MESSAGE_FILE);
  413.     RAISE_ERROR (NOTHING_SPECIAL);  /* longjmp outa here! */
  414.     }
  415.     for (i = 0; message_strings[i]; i++)
  416.     {
  417.     fprintf (message_file_ptr, "%s\n", message_strings[i]);
  418.     }
  419.     fclose (message_file_ptr);
  420.  
  421.     display_file (message_file_name, TRUE);
  422.  
  423. #else /* Display strings in current shell */
  424.     display_strings (message_strings);
  425. #endif
  426. }
  427.  
  428. static void display_strings (char **message_strings)
  429. {
  430.     message___strings = message_strings;
  431.     message___string_index = 0;
  432.     display_iterate (next_string);
  433.     message___strings = NULL;
  434. }
  435.  
  436. static char *next_file_line (void)
  437. {
  438.     int i = 0;
  439.     int c;
  440.     static ff_found = FALSE;
  441.  
  442.     if (ff_found)
  443.     {
  444.     ff_found = FALSE;
  445.     message___message_buf[0] = '\f';
  446.     message___message_buf[1] = '\0';
  447.     return message___message_buf;
  448.     }
  449.     while (EOF != (c = getc (message___read_file)))
  450.     {
  451.     if (c == '\n')
  452.     {
  453.         break;
  454.     }
  455.     if (c == '\f')
  456.     {
  457.         ff_found = TRUE;
  458.         break;
  459.     }
  460.     message___message_buf[i] = (char) c;
  461.     if (++i >= MESSAGE_IOBUFFER_SIZE - 1)
  462.     {
  463.         break;
  464.     }
  465.     }
  466.     message___message_buf[i] = '\0';
  467.     if (c == EOF && i == 0)
  468.     {
  469.     return NULL;
  470.     }
  471.     else
  472.     {
  473.     return message___message_buf;
  474.     }
  475. }
  476.  
  477. static char *next_string (void)
  478. {
  479.     char *string = NULL;
  480.  
  481.     if (message___strings)
  482.     {
  483.     if (message___strings[message___string_index])
  484.     {
  485.         string = message___strings[message___string_index++];
  486.     }
  487.     else
  488.     {
  489.         message___strings = NULL;
  490.     }
  491.     }
  492.     return string;
  493. }
  494.  
  495.  
  496. static void display_iterate (char *iterator_function(void))
  497. {
  498.     char input_line[MESSAGE_IOBUFFER_SIZE];
  499.     char *message_string;
  500.     int i = 0;
  501.  
  502.     while (message_string = (*iterator_function)())
  503.     {
  504.     if (++i > PAGE_SIZE)
  505.     {
  506.         printf ("\n%s",MORE_STRING);
  507.         gets (input_line);
  508.         if (strlen(input_line) > 0 && (input_line[0] == NO_MORE_CHAR_1 ||
  509.         input_line[0]  == NO_MORE_CHAR_2))
  510.         {
  511.         break;
  512.         }
  513.         printf("\n");
  514.         i = 1;
  515.     }
  516.     if (message_string[0] == '\f')
  517.     {
  518.         printf ("\n");
  519.         i = PAGE_SIZE;
  520.     }
  521.     else
  522.     {
  523.         printf ("%s\n",message_string);
  524.     }
  525.     }
  526. }
  527.  
  528. void command_error_message (int message_number, char *bad_charp)
  529. {
  530.     long spaces;
  531.  
  532.     if (Quiet) return;
  533.  
  534.     if (CommandMode != WORKBENCH_MODE)
  535.     {
  536.     spaces = strlen (PROMPT) + (bad_charp - Command);
  537.     if (CommandMode != INTERACTIVE_MODE)
  538.     {
  539.         fprintf (stderr,"%s\n",Command);
  540.         spaces -= strlen (PROMPT);
  541.     }
  542.     for (; spaces > 0; spaces--)
  543.     {
  544.         fprintf (stderr," ");
  545.     }
  546.     fprintf (stderr,"^\n");
  547.     }
  548.     error_message (message_number);
  549. }
  550.  
  551. void error_message (int message_number)
  552. {
  553. /*
  554.  * Since all messages herein are error messages
  555.  * They are all written to stderr (or, output to a window)
  556.  */
  557.     char *message_string;
  558.  
  559.     Error_Count++;
  560.  
  561.     switch (message_number)
  562.     {
  563.     case NO_SUCH_COMMAND:
  564.     message_string = NO_SUCH_COMMAND_S;
  565.     break;
  566.     case OUT_OF_MEMORY:
  567.     message_string = OUT_OF_MEMORY_S;
  568.         break;
  569.     case REQUESTER_STACK_OVERFLOW:
  570.     message_string = REQUESTER_STACK_OVERFLOW_S;
  571.     break;
  572.     case UNSUPPORTED_COMMAND:
  573.     message_string = UNSUPPORTED_COMMAND_S;
  574.     break;
  575.     case MISSING_ARGUMENT:
  576.     message_string = MISSING_ARGUMENT_S;
  577.     break;
  578.     case BAD_ARGUMENT:
  579.     message_string = BAD_ARGUMENT_S;
  580.     break;
  581.     case ALREADY_IN_CLI_MODE:
  582.     message_string = ALREADY_IN_CLI_MODE_S;
  583.     break;
  584.     case BAD_NAME:
  585.     message_string = BAD_NAME_S;
  586.     break;
  587.     case AMBIGUOUS_COMMAND:
  588.     message_string = AMBIGUOUS_COMMAND_S;
  589.     break;
  590.     case BACKUP_CREATED:
  591.     message_string = BACKUP_CREATED_S;
  592.     break;
  593.     case OUTPUT_BACKUP_FAILURE:
  594.     message_string = OUTPUT_BACKUP_FAILURE_S;
  595.     break;
  596.     case CANT_CREATE_OUTPUT_FILE:
  597.     message_string = CANT_CREATE_OUTPUT_FILE_S;
  598.     break;
  599.     case CANT_CLEANUP_BATCH_PLOT:
  600.     message_string = CANT_CLEANUP_BATCH_PLOT_S;
  601.     break;
  602.     case CANT_RE_OUTPUT:
  603.     message_string = CANT_RE_OUTPUT_S;
  604.     break;
  605.     case CANT_RE_PLOT:
  606.     message_string = CANT_RE_PLOT_S;
  607.     break;
  608.     case BACKUP_OVERWRITTEN:
  609.     message_string = BACKUP_OVERWRITTEN_S;
  610.     break;
  611.     case CANT_OPEN_INPUT_FILE:
  612.     message_string = CANT_OPEN_INPUT_FILE_S;
  613.     break;
  614.     case SCANNING_FILE:
  615.     if (CommandMode == WORKBENCH_MODE) return; /* redundant here */
  616.     message_string = SCANNING_FILE_S;
  617.     break;
  618.     case NO_DATA_PRESENT:
  619.     message_string = NO_DATA_PRESENT_S;
  620.     break;
  621.     case PADDING_TAILEND:
  622.     return;   /* Now a non-default option */
  623. /*    message_string = PADDING_TAILEND_S; */
  624. /*    break; */
  625.     case AMBIGUOUS_ARGUMENT:
  626.     message_string = AMBIGUOUS_ARGUMENT_S;
  627.     break;
  628.     case NO_SUCH_ARGUMENT:
  629.     message_string = NO_SUCH_ARGUMENT_S;
  630.     break;
  631.     case NO_NUMERICAL:
  632.     message_string = NO_NUMERICAL_S;
  633.     break;
  634.     case INVALID_NUMBER:
  635.     message_string = INVALID_NUMBER_S;
  636.     break;
  637.     case IGNORING_TAILEND:
  638.     message_string = IGNORING_TAILEND_S;
  639.     break;
  640.     case INSUFFICIENT_DATA:
  641.     message_string = INSUFFICIENT_DATA_S;
  642.     break;
  643.     case FILENAME_TOO_LONG:
  644.     message_string = FILENAME_TOO_LONG_S;
  645.     break;
  646.     case NO_RATE_SPECIFIED:
  647.     message_string = NO_RATE_SPECIFIED_S;
  648.     break;
  649.     case NO_READ_FILE:
  650.     message_string = NO_READ_FILE_S;
  651.     break;
  652.     case UNSUPPORTED_FORMAT:
  653.     message_string = UNSUPPORTED_FORMAT_S;
  654.     break;
  655.     case TOOLTYPE_ERROR:
  656.     message_string = TOOLTYPE_ERROR_S;
  657.     break;
  658.     case STARTUP_FILE_ERROR:
  659.     message_string = STARTUP_FILE_ERROR_S;
  660.     break;
  661.     case CORRUPT_IFF:
  662.     message_string = CORRUPT_IFF_S;
  663.     break;
  664.     case CORRUPT_AVR:
  665.     message_string = CORRUPT_AVR_S;
  666.     break;
  667.     case COMPRESSION_NOT_SUPPORTED:
  668.     message_string = COMPRESSION_NOT_SUPPORTED_S;
  669.     break;
  670.     case ONESHOT_BUT_NOT_8SVX:
  671.     message_string = ONESHOT_BUT_NOT_8SVX_S;
  672.     break;
  673.     case FORMAT_NOT_OK:
  674.     message_string = FORMAT_NOT_OK_S;
  675.     break;
  676.     case NOT_ENOUGH_FRAMES:
  677.     message_string = NOT_ENOUGH_FRAMES_S;
  678.     break;
  679.     case OCTAVE_NOT_PRESENT:
  680.     message_string = OCTAVE_NOT_PRESENT_S;
  681.     break;
  682.     case CORRUPT_AIFF:
  683.     message_string = CORRUPT_AIFF_S;
  684.     break;
  685.     case CORRUPT_AIFC:
  686.     message_string = CORRUPT_AIFC_S;
  687.     break;
  688.     case NO_WRITE_FILE:
  689.     message_string = NO_WRITE_FILE_S;
  690.     break;
  691.     case DB_OF_ZERO:
  692.     message_string = DB_OF_ZERO_S;
  693.     break;
  694.     case NO_FILE_REQSTR:
  695.     message_string = NO_FILE_REQSTR_S;
  696.     break;
  697.     case SPEC_CHANNEL_UNAVAIL:
  698.     message_string = SPEC_CHANNEL_UNAVAIL_S;
  699.     break;
  700.     case INVALID_BINS_SPEC:
  701.     message_string = INVALID_BINS_SPEC_S;
  702.     break;
  703.     case INVALID_INTERLEAVE_SPEC:
  704.     message_string = INVALID_INTERLEAVE_SPEC_S;
  705.     break;
  706.     case INVALID_SMOOTHING_SPEC:
  707.     message_string = INVALID_SMOOTHING_SPEC_S;
  708.     break;
  709.     case INVALID_TIMESEG_PARAMETERS:
  710.     message_string = INVALID_TIMESEG_PARAMETERS_S;
  711.     break;
  712.     case MISSING_TIMESEG_PARAMETERS:
  713.     message_string = MISSING_TIMESEG_PARAMETERS_S;
  714.     break;
  715.     case CANT_CREATE_PLOTTER_FILE:
  716.     message_string = CANT_CREATE_PLOTTER_FILE_S;
  717.     break;
  718.     case CANT_CREATE_MORE_COMMAND_FILE:
  719.     message_string = CANT_CREATE_MORE_COMMAND_FILE_S;
  720.     break;
  721.     case CANT_CREATE_MESSAGE_FILE:
  722.     message_string = CANT_CREATE_MESSAGE_FILE_S;
  723.     break;
  724.     case HELP_MESSAGE_UNAVAILABLE:
  725.     message_string = HELP_MESSAGE_UNAVAILABLE_S;
  726.     break;
  727.     case HELP_FILE_NOT_FOUND:
  728.     message_string = HELP_FILE_NOT_FOUND_S;
  729.     break;
  730.     case CANT_PLOT_FROM_STDOUT:
  731.     message_string = CANT_PLOT_FROM_STDOUT_S;
  732.     break;
  733.     case INVALID_ROTATION_SPEC:
  734.     message_string = INVALID_ROTATION_SPEC_S;
  735.     break;
  736.     case CHANGED_FORMAT_DEP_VALUE:
  737.     message_string = CHANGED_FORMAT_DEP_VALUE_S;
  738.     break;
  739.     case INVALID_CALIBRATION_FILE:
  740.     message_string = INVALID_CALIBRATION_FILE_S;
  741.     break;
  742.     case CANT_OPEN_INTUITION:
  743.     message_string = CANT_OPEN_INTUITION_S;
  744.     break;
  745.     case WINDOW_OPEN_FAILED:
  746.     message_string = WINDOW_OPEN_FAILED_S;
  747.     break;
  748.     default:
  749.     message_string = UNDOCUMENTED_ERROR_S;
  750.     break;
  751.     }
  752.     error_message_display (message_string, stderr);
  753. }
  754.  
  755. static void error_message_display (char *message_string, FILE *output_ptr)
  756. {
  757.     if (Quiet) return;
  758.  
  759. #ifdef AMIGA
  760.     if (CommandMode == WORKBENCH_MODE && dialog_window_p)
  761.     {
  762.     message_requester (dialog_window_p, message_string);
  763.     }
  764.     else
  765. #endif
  766.     {
  767.     fprintf (output_ptr, "%s\n", message_string);
  768.     }
  769. }
  770.  
  771. static void message_display (char *message_string, FILE *output_ptr)
  772. {
  773.     if (Quiet) return;
  774.  
  775. #ifdef AMIGA
  776.     if (CommandMode == WORKBENCH_MODE && dialog_window_p)
  777.     {
  778.     message_gadget__write (message_gadgetp, message_string,
  779.                    dialog_window_p);
  780.     }
  781.     else
  782. #endif
  783.     {
  784.     fprintf (output_ptr, "%s\n", message_string);
  785.     }
  786. }
  787.  
  788. void loop_time_message (double seconds)
  789. {
  790.     char time_string[160];
  791.  
  792.     if (Quiet) return;
  793.  
  794.     sprintf (time_string, 
  795. "FFT loop elapsed time (sec): %-11.5g  Now writing fft data...", 
  796.          seconds);
  797.     message_display (time_string, stdout);
  798. }
  799.  
  800.  
  801. void loop_time_message_done (double seconds)
  802. {
  803.     char time_string[160];
  804.  
  805.     if (Quiet) return;
  806.  
  807.     sprintf (time_string, 
  808. "FFT loop elapsed time (sec): %-11.5g  Ready for next analysis.", 
  809.          seconds);
  810.     message_display (time_string, stdout);
  811. }
  812.  
  813.  
  814. void bins_d_message (unsigned long total_actually_read, 
  815.              unsigned long number_bins)
  816. {
  817.     if (Quiet) return;
  818.  
  819.     /*
  820.      * In workbench mode, gadget shows maximum value all the time
  821.      * (at least, for formatted files)
  822.      */
  823.     if (CommandMode != WORKBENCH_MODE || FileFormat == UNFORMATTED)
  824.     {
  825.     char message_string[MESSAGE_BUFSIZE];
  826.     sprintf (message_string, BINS_DETERMINED_S, 
  827.          total_actually_read, number_bins);
  828.     message_display (message_string, stdout);
  829.     }
  830. }
  831.  
  832. void bins_s_message (void)
  833. {
  834.     char message_string[MESSAGE_BUFSIZE];
  835.  
  836.     if (Quiet) return;
  837.  
  838.     sprintf (message_string, BINS_SELECTED_S, NumberBins);
  839.     message_display (message_string, stdout);
  840. }
  841.  
  842. char *settings_message (char *arguments)
  843. {
  844.     printf ("Synopsis: \n");
  845.     if (ReadPtr == stdin)
  846.     {
  847.     printf (KEYBOARD_INPUT_S);
  848.     }
  849.     else
  850.     {
  851.     if (ReadName && ReadName != NullString)
  852.     {
  853.         printf (INPUT_FILENAME_S, ReadName);
  854.         if (StartByte)
  855.         {
  856.         printf (STARTBYTE_S, StartByte);
  857.         }
  858.     }
  859.     }
  860.     if (WritePtr == stdout)
  861.     {
  862.     printf (OUTPUT_SCREEN_S);
  863.     }
  864.     else if (WriteName && WriteName != NullString)
  865.     {
  866.     printf (OUTPUT_FILENAME_S,WriteName);
  867.     }
  868.     if (Rate)
  869.     {
  870.     printf (SAMPLING_RATE_S);
  871. #ifdef _FFP
  872.     printf ("%-15.8g\n", Rate);
  873. #else
  874.     printf ("%-19.12g\n", Rate);
  875. #endif
  876.     }
  877.     else
  878.     {
  879.     error_message (NO_RATE_SPECIFIED);
  880.     }
  881.     if (Numerical)
  882.     {
  883.     printf (NUMERICAL_RECIPES_USED_S);
  884.     }
  885.     if (Amplitude)
  886.     {
  887.     printf (AMPLITUDE_SPECTRUM_S);
  888.     }
  889.     if (Power)
  890.     {
  891.     printf (POWER_SPECTRUM_S);
  892.     }
  893.     if (!Power && !Amplitude)
  894.     {
  895.     printf (FFT_S);
  896.     }
  897.     else
  898.     {
  899.     if (Mean)
  900.     {
  901.         printf (MEAN_NORMALIZED_S);
  902.     }
  903.     else
  904.     {
  905.         printf (SUMMED_S);
  906.     }
  907.     if (NumberBins < 0)
  908.     {
  909.         printf (DEFAULT_BINS_S);
  910.     }
  911.     else
  912.     {
  913.         printf (BINS_S, NumberBins);
  914.     }
  915.     switch (WindowType)
  916.     {
  917.     case RECTANGLE_WINDOW:
  918.         printf (RECTANGLE_WINDOWS_S);
  919.         break;
  920.     case HANN_WINDOW:
  921.         printf (HANN_WINDOWS_S);
  922.         break;
  923.     case PARZEN_WINDOW:
  924.         printf (PARZEN_WINDOWS_S);
  925.         break;
  926.     case WELCH_WINDOW:
  927.         printf (WELCH_WINDOWS_S);
  928.         break;
  929.     case TRIANGLE_WINDOW:
  930.         printf (TRIANGLE_WINDOWS_S);
  931.         break;
  932.     case HAMMING_WINDOW:
  933.         printf (HAMMING_WINDOWS_S);
  934.         break;
  935.     case BLACKMAN_HARRIS_74DB_WINDOW:
  936.         printf (BLACKMAN_HARRIS_74DB_WINDOWS_S);
  937.         break;
  938.     case BLACKMAN_HARRIS_92DB_WINDOW:
  939.         printf (BLACKMAN_HARRIS_92DB_WINDOWS_S);
  940.         break;
  941.     }
  942.     if (Overlap)
  943.     {
  944.         printf (OVERLAP_S);
  945.     }
  946.     else
  947.     {
  948.         printf (NO_OVERLAP_S);
  949.     }
  950.     if (Interleave > 1)
  951.     {
  952.         printf (INTERLEAVE_S);
  953.     }
  954.     if (Pink)
  955.     {
  956.         printf (PINK_S);
  957.     }
  958.     }
  959.     if (HighFrequency != HIGHEST_FREQUENCY)
  960.     {
  961.     printf (MAX_FREQUENCY_S, HighFrequency);
  962.     }
  963.     if (LowFrequency != LOWEST_FREQUENCY)
  964.     {
  965.     printf (MIN_FREQUENCY_S, LowFrequency);
  966.     }
  967.     printf ("\nList of non-default settings:\n");
  968.     write_settings (stdout, NullString, TRUE, TRUE);
  969.     return arguments;
  970. }
  971.