home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / g77-0.5.15-src.tgz / tar.out / fsf / g77 / f / bad.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  14KB  |  539 lines
  1. /* bad.c -- Implementation File (module.c template V1.0)
  2.    Copyright (C) 1995 Free Software Foundation, Inc.
  3.    Contributed by James Craig Burley (burley@gnu.ai.mit.edu).
  4.  
  5. This file is part of GNU Fortran.
  6.  
  7. GNU Fortran is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU Fortran is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Fortran; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.    Related Modules:
  22.       None
  23.  
  24.    Description:
  25.       Handles the displaying of diagnostic messages regarding the user's source
  26.       files.
  27.  
  28.    Modifications:
  29. */
  30.  
  31. /* If there's a %E or %4 in the messages, set this to at least 5,
  32.    for example.  */
  33.  
  34. #define FFEBAD_MAX_ 6
  35.  
  36. /* Include files. */
  37.  
  38. #include "proj.h"
  39. #include <ctype.h>
  40. #include "bad.h"
  41. #include "com.h"
  42. #include "where.h"
  43.  
  44. /* Externals defined here. */
  45.  
  46. bool ffebad_is_inhibited_ = FALSE;
  47.  
  48. /* Simple definitions and enumerations. */
  49.  
  50. #define FFEBAD_LONG_MSGS_ 1    /* 0 to use short (or same) messages. */
  51.  
  52. /* Internal typedefs. */
  53.  
  54.  
  55. /* Private include files. */
  56.  
  57.  
  58. /* Internal structure definitions. */
  59.  
  60. struct _ffebad_message_
  61.   {
  62.     ffebadSeverity severity;
  63.     char *message;
  64.   };
  65.  
  66. /* Static objects accessed by functions in this module.     */
  67.  
  68. static struct _ffebad_message_ ffebad_messages_[]
  69. =
  70. {
  71. #define FFEBAD_MSGS1(KWD,SEV,MSG) { SEV, MSG },
  72. #if FFEBAD_LONG_MSGS_ == 0
  73. #define FFEBAD_MSGS2(KWD,SEV,LMSG,SMSG) { SEV, SMSG },
  74. #else
  75. #define FFEBAD_MSGS2(KWD,SEV,LMSG,SMSG) { SEV, LMSG },
  76. #endif
  77. #include "bad.def"
  78. #undef FFEBAD_MSGS1
  79. #undef FFEBAD_MSGS2
  80. };
  81.  
  82. static struct
  83.   {
  84.     ffewhereLine line;
  85.     ffewhereColumn col;
  86.     ffebadIndex tag;
  87.   }
  88.  
  89. ffebad_here_[FFEBAD_MAX_];
  90. static char *ffebad_string_[FFEBAD_MAX_];
  91. static ffebadIndex ffebad_order_[FFEBAD_MAX_];
  92. static ffebad ffebad_errnum_;
  93. static ffebadSeverity ffebad_severity_;
  94. static char *ffebad_message_;
  95. static unsigned char ffebad_index_;
  96. static ffebadIndex ffebad_places_;
  97. static bool ffebad_is_temp_inhibited_;    /* Effective setting of
  98.                        _is_inhibited_ for this
  99.                        _start/_finish invocation. */
  100.  
  101. /* Static functions (internal). */
  102.  
  103. static int ffebad_bufputs_ (char buf[], int bufi, char *s);
  104.  
  105. /* Internal macros. */
  106.  
  107. #define ffebad_bufflush_(buf, bufi) \
  108.   (((buf)[bufi] = '\0'), fputs ((buf), stderr), 0)
  109. #define ffebad_bufputc_(buf, bufi, c) \
  110.   (((bufi) == ARRAY_SIZE (buf)) \
  111.    ? (ffebad_bufflush_ ((buf), (bufi)), ((buf)[0] = (c)), 1) \
  112.    : (((buf)[bufi] = (c)), (bufi) + 1))
  113.  
  114.  
  115. static int
  116. ffebad_bufputs_ (char buf[], int bufi, char *s)
  117. {
  118.   for (; *s != '\0'; ++s)
  119.     bufi = ffebad_bufputc_ (buf, bufi, *s);
  120.   return bufi;
  121. }
  122.  
  123. /* ffebad_init_0 -- Initialize
  124.  
  125.    ffebad_init_0();  */
  126.  
  127. void
  128. ffebad_init_0 ()
  129. {
  130.   assert (FFEBAD == ARRAY_SIZE (ffebad_messages_));
  131. }
  132.  
  133. ffebadSeverity
  134. ffebad_severity (ffebad errnum)
  135. {
  136.   return ffebad_messages_[errnum].severity;
  137. }
  138.  
  139. /* ffebad_start_ -- Start displaying an error message
  140.  
  141.    ffebad_start(FFEBAD_SOME_ERROR_CODE);
  142.  
  143.    Call ffebad_start to establish the message, ffebad_here and ffebad_string
  144.    to send run-time data to it as necessary, then ffebad_finish when through
  145.    to actually get it to print (to stderr).
  146.  
  147.    Note: ffebad_start(errnum) turns into ffebad_start_(FALSE,errnum).  No
  148.    outside caller should call ffebad_start_ directly (as indicated by the
  149.    trailing underscore).
  150.  
  151.    Call ffebad_start to start a normal message, one that might be inhibited
  152.    by the current state of statement guessing.    Call ffebad_start_lex
  153.    instead to start a message that is global to all statement guesses and
  154.    happens only once for all guesses (i.e. the lexer).
  155.  
  156.    sev and message are overrides for the severity and messages when errnum
  157.    is FFEBAD, meaning the caller didn't want to have to put a message in
  158.    bad.def to produce a diagnostic.  */
  159.  
  160. bool
  161. ffebad_start_ (bool lex_override, ffebad errnum, ffebadSeverity sev,
  162.            char *message)
  163. {
  164.   unsigned char i;
  165.  
  166.   if (ffebad_is_inhibited_ && !lex_override)
  167.     {
  168.       ffebad_is_temp_inhibited_ = TRUE;
  169.       return FALSE;
  170.     }
  171.  
  172.   if (errnum != FFEBAD)
  173.     {
  174.       ffebad_severity_ = ffebad_messages_[errnum].severity;
  175.       ffebad_message_ = ffebad_messages_[errnum].message;
  176.     }
  177.   else
  178.     {
  179.       ffebad_severity_ = sev;
  180.       ffebad_message_ = message;
  181.     }
  182.  
  183. #if FFECOM_targetCURRENT == FFECOM_targetGCC
  184.   {
  185.     extern int inhibit_warnings;    /* From toplev.c. */
  186.  
  187.     switch (ffebad_severity_)
  188.       {                /* Tell toplev.c about this message. */
  189.       case FFEBAD_severityINFORMATIONAL:
  190.       case FFEBAD_severityTRIVIAL:
  191.     if (inhibit_warnings)
  192.       {            /* User wants no warnings. */
  193.         ffebad_is_temp_inhibited_ = TRUE;
  194.         return FALSE;
  195.       }
  196.     /* Fall through.  */
  197.       case FFEBAD_severityWARNING:
  198.       case FFEBAD_severityPECULIAR:
  199.       case FFEBAD_severityPEDANTIC:
  200.     if ((ffebad_severity_ != FFEBAD_severityPEDANTIC)
  201.         || !flag_pedantic_errors)
  202.       {
  203.         if (count_error (1) == 0)
  204.           {            /* User wants no warnings. */
  205.         ffebad_is_temp_inhibited_ = TRUE;
  206.         return FALSE;
  207.           }
  208.         break;
  209.       }
  210.     /* Fall through (PEDANTIC && flag_pedantic_errors).  */
  211.       case FFEBAD_severityFATAL:
  212.       case FFEBAD_severityWEIRD:
  213.       case FFEBAD_severitySEVERE:
  214.       case FFEBAD_severityDISASTER:
  215.     count_error (0);
  216.     break;
  217.  
  218.       default:
  219.     break;
  220.       }
  221.   }
  222. #endif
  223.  
  224.   ffebad_is_temp_inhibited_ = FALSE;
  225.   ffebad_errnum_ = errnum;
  226.   ffebad_index_ = 0;
  227.   ffebad_places_ = 0;
  228.   for (i = 0; i < FFEBAD_MAX_; ++i)
  229.     {
  230.       ffebad_string_[i] = NULL;
  231.       ffebad_here_[i].line = ffewhere_line_unknown ();
  232.       ffebad_here_[i].col = ffewhere_column_unknown ();
  233.     }
  234.  
  235.   return TRUE;
  236. }
  237.  
  238. /* ffebad_here -- Establish source location of some diagnostic concern
  239.  
  240.    ffebad_here(ffebadIndex i,ffewhereLine line,ffewhereColumn col);
  241.  
  242.    Call ffebad_start to establish the message, ffebad_here and ffebad_string
  243.    to send run-time data to it as necessary, then ffebad_finish when through
  244.    to actually get it to print (to stderr).  */
  245.  
  246. void
  247. ffebad_here (ffebadIndex index, ffewhereLine line, ffewhereColumn col)
  248. {
  249.   ffewhereLineNumber line_num;
  250.   ffewhereLineNumber ln;
  251.   ffewhereColumnNumber col_num;
  252.   ffewhereColumnNumber cn;
  253.   ffebadIndex i;
  254.   ffebadIndex j;
  255.  
  256.   if (ffebad_is_temp_inhibited_)
  257.     return;
  258.  
  259.   assert (index < FFEBAD_MAX_);
  260.   if (ffewhere_line_is_unknown (line))
  261.     {
  262.       ffebad_here_[index].line = line;
  263.       ffebad_here_[index].col = ffewhere_column_unknown ();
  264.       ffebad_here_[index].tag = FFEBAD_MAX_;
  265.       return;
  266.     }
  267.   ffebad_here_[index].line = ffewhere_line_use (line);
  268.   ffebad_here_[index].col = ffewhere_column_use (col);
  269.   ffebad_here_[index].tag = 0;    /* For now, though it shouldn't matter. */
  270.  
  271.   /* Sort the source line/col points into the order they occur in the source
  272.      file.  Deal with duplicates appropriately. */
  273.  
  274.   line_num = ffewhere_line_number (line);
  275.   col_num = ffewhere_column_number (col);
  276.  
  277.   /* Determine where in the ffebad_order_ array this new place should go. */
  278.  
  279.   for (i = 0; i < ffebad_places_; ++i)
  280.     {
  281.       ln = ffewhere_line_number (ffebad_here_[ffebad_order_[i]].line);
  282.       cn = ffewhere_column_number (ffebad_here_[ffebad_order_[i]].col);
  283.       if (line_num < ln)
  284.     break;
  285.       if (line_num == ln)
  286.     {
  287.       if (col_num == cn)
  288.         {
  289.           ffebad_here_[index].tag = i;
  290.           return;        /* Shouldn't go in, has equivalent. */
  291.         }
  292.       else if (col_num < cn)
  293.         break;
  294.     }
  295.     }
  296.  
  297.   /* Before putting new place in ffebad_order_[i], first increment all tags
  298.      that are i or greater. */
  299.  
  300.   if (i != ffebad_places_)
  301.     {
  302.       for (j = 0; j < FFEBAD_MAX_; ++j)
  303.     {
  304.       if (ffebad_here_[j].tag >= i)
  305.         ++ffebad_here_[j].tag;
  306.     }
  307.     }
  308.  
  309.   /* Then slide all ffebad_order_[] entries at and above i up one entry. */
  310.  
  311.   for (j = ffebad_places_; j > i; --j)
  312.     ffebad_order_[j] = ffebad_order_[j - 1];
  313.  
  314.   /* Finally can put new info in ffebad_order_[i]. */
  315.  
  316.   ffebad_order_[i] = index;
  317.   ffebad_here_[index].tag = i;
  318.   ++ffebad_places_;
  319. }
  320.  
  321. /* Establish string for next index (always in order) of message
  322.  
  323.    ffebad_string(char *string);
  324.  
  325.    Call ffebad_start to establish the message, ffebad_here and ffebad_string
  326.    to send run-time data to it as necessary, then ffebad_finish when through
  327.    to actually get it to print (to stderr).  Note: don't trash the string
  328.    until after calling ffebad_finish, since we just maintain a pointer to
  329.    the argument passed in until then.  */
  330.  
  331. void
  332. ffebad_string (char *string)
  333. {
  334.   if (ffebad_is_temp_inhibited_)
  335.     return;
  336.  
  337.   assert (ffebad_index_ != FFEBAD_MAX_);
  338.   ffebad_string_[ffebad_index_++] = string;
  339. }
  340.  
  341. /* ffebad_finish -- Display error message with where & run-time info
  342.  
  343.    ffebad_finish();
  344.  
  345.    Call ffebad_start to establish the message, ffebad_here and ffebad_string
  346.    to send run-time data to it as necessary, then ffebad_finish when through
  347.    to actually get it to print (to stderr).  */
  348.  
  349. void
  350. ffebad_finish ()
  351. {
  352. #define MAX_SPACES 132
  353.   static char *spaces
  354.   = "...>\
  355. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  356. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  357. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  358. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  359. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  360. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  361. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  362. \040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\
  363. \040\040\040";            /* MAX_SPACES - 1 spaces. */
  364.   ffewhereLineNumber last_line_num;
  365.   ffewhereLineNumber ln;
  366.   ffewhereLineNumber rn;
  367.   ffewhereColumnNumber last_col_num;
  368.   ffewhereColumnNumber cn;
  369.   ffewhereColumnNumber cnt;
  370.   ffewhereLine l;
  371.   ffebadIndex bi;
  372.   unsigned short i;
  373.   char pointer;
  374.   char c;
  375.   char *s;
  376.   char *fn;
  377.   static char buf[1024];
  378.   int bufi;
  379.   int index;
  380.  
  381.   if (ffebad_is_temp_inhibited_)
  382.     return;
  383.  
  384.   switch (ffebad_severity_)
  385.     {
  386.     case FFEBAD_severityINFORMATIONAL:
  387.       s = "note:";
  388.       break;
  389.  
  390.     case FFEBAD_severityWARNING:
  391.       s = "warning:";
  392.       break;
  393.  
  394.     case FFEBAD_severitySEVERE:
  395.       s = "fatal:";
  396.       break;
  397.  
  398.     default:
  399.       s = "";
  400.       break;
  401.     }
  402.  
  403.   /* Display the annoying source references. */
  404.  
  405.   last_line_num = 0;
  406.   last_col_num = 0;
  407.  
  408.   for (bi = 0; bi < ffebad_places_; ++bi)
  409.     {
  410.       if (ffebad_places_ == 1)
  411.     pointer = '^';
  412.       else
  413.     pointer = '1' + bi;
  414.  
  415.       l = ffebad_here_[ffebad_order_[bi]].line;
  416.       ln = ffewhere_line_number (l);
  417.       rn = ffewhere_line_filelinenum (l);
  418.       cn = ffewhere_column_number (ffebad_here_[ffebad_order_[bi]].col);
  419.       fn = ffewhere_line_filename (l);
  420.       if (ln != last_line_num)
  421.     {
  422.       if (bi != 0)
  423.         fputc ('\n', stderr);
  424.       fprintf (stderr,
  425. #if 0
  426.            "Line %" ffewhereLineNumber_f "u of %s:\n   %s\n   %s%c",
  427.            rn, fn,
  428. #else
  429.            /* the trailing space on the <file>:<line>: line
  430.               fools emacs19 compilation mode into finding the
  431.               report */
  432.            "%s:%" ffewhereLineNumber_f "u: %s\n   %s\n   %s%c",
  433.            fn, rn,
  434. #endif
  435.            s,
  436.            ffewhere_line_content (l),
  437.            &spaces[cn > MAX_SPACES ? 0 : MAX_SPACES - cn + 4],
  438.            pointer);
  439.       last_line_num = ln;
  440.       last_col_num = cn;
  441.       s = "(continued:)";
  442.     }
  443.       else
  444.     {
  445.       cnt = cn - last_col_num;
  446.       fprintf (stderr,
  447.            "%s%c", &spaces[cnt > MAX_SPACES
  448.                    ? 0 : MAX_SPACES - cnt + 4],
  449.            pointer);
  450.       last_col_num = cn;
  451.     }
  452.     }
  453.   if (ffebad_places_ == 0)
  454.     {
  455.       char c;
  456.  
  457.       /* Didn't output "warning:" string, capitalize it for message.  */
  458.       if ((s != NULL) && isalpha (s[0]) && islower (s[0]))
  459.     c = toupper (s[0]);
  460.       else
  461.     c = s[0];
  462.       fprintf (stderr, "%c%s ", c, &s[1]);
  463.     }
  464.   else
  465.     fputc ('\n', stderr);
  466.  
  467.   /* Release the ffewhere info. */
  468.  
  469.   for (bi = 0; bi < FFEBAD_MAX_; ++bi)
  470.     {
  471.       ffewhere_line_kill (ffebad_here_[bi].line);
  472.       ffewhere_column_kill (ffebad_here_[bi].col);
  473.     }
  474.  
  475.   /* Now display the message. */
  476.  
  477.   bufi = 0;
  478.   for (i = 0; (c = ffebad_message_[i]) != '\0'; ++i)
  479.     {
  480.       if (c == '%')
  481.     {
  482.       c = ffebad_message_[++i];
  483.       if (isalpha (c) && isupper (c))
  484.         {
  485.           index = c - 'A';
  486.  
  487.           if ((index < 0) || (index >= FFEBAD_MAX_))
  488.         {
  489.           bufi = ffebad_bufputs_ (buf, bufi, "[REPORT BUG!!] %");
  490.           bufi = ffebad_bufputc_ (buf, bufi, c);
  491.         }
  492.           else
  493.         {
  494.           s = ffebad_string_[index];
  495.           if (s == NULL)
  496.             bufi = ffebad_bufputs_ (buf, bufi, "[REPORT BUG!!]");
  497.           else
  498.             bufi = ffebad_bufputs_ (buf, bufi, s);
  499.         }
  500.         }
  501.       else if (isdigit (c))
  502.         {
  503.           index = c - '0';
  504.  
  505.           if ((index < 0) || (index >= FFEBAD_MAX_))
  506.         {
  507.           bufi = ffebad_bufputs_ (buf, bufi, "[REPORT BUG!!] %");
  508.           bufi = ffebad_bufputc_ (buf, bufi, c);
  509.         }
  510.           else
  511.         {
  512.           pointer = ffebad_here_[index].tag + '1';
  513.           if (pointer == FFEBAD_MAX_ + '1')
  514.             pointer = '?';
  515.           else if (ffebad_places_ == 1)
  516.             pointer = '^';
  517.           bufi = ffebad_bufputc_ (buf, bufi, '(');
  518.           bufi = ffebad_bufputc_ (buf, bufi, pointer);
  519.           bufi = ffebad_bufputc_ (buf, bufi, ')');
  520.         }
  521.         }
  522.       else if (c == '\0')
  523.         break;
  524.       else if (c == '%')
  525.         bufi = ffebad_bufputc_ (buf, bufi, '%');
  526.       else
  527.         {
  528.           bufi = ffebad_bufputs_ (buf, bufi, "[REPORT BUG!!]");
  529.           bufi = ffebad_bufputc_ (buf, bufi, '%');
  530.           bufi = ffebad_bufputc_ (buf, bufi, c);
  531.         }
  532.     }
  533.       else
  534.     bufi = ffebad_bufputc_ (buf, bufi, c);
  535.     }
  536.   bufi = ffebad_bufputc_ (buf, bufi, '\n');
  537.   bufi = ffebad_bufflush_ (buf, bufi);
  538. }
  539.