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