src_input.c

Go to the documentation of this file.

/*

  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/



static char USMID[] = "\n@(#)5.0_pl/sources/src_input.c 5.5     10/20/99 17:17:46\n";

# include "defines.h"           /* Machine dependent ifdefs */

# include "host.m"              /* Host machine dependent macros.*/
# include "host.h"              /* Host machine dependent header.*/
# include "target.m"            /* Target machine dependent macros.*/
# include "target.h"            /* Target machine dependent header.*/

# include "globals.m"
# include "tokens.m"
# include "sytb.m"
# include "p_globals.m"
# include "src_input.m"
# include "debug.m"

# include "globals.h"
# include "tokens.h"
# include "sytb.h"
# include "p_globals.h"
# include "src_input.h"


/*****************************************************************\
|* function prototypes of static functions declared in this file *|
\*****************************************************************/

static boolean  is_pound_line_dir(void);
static void     fixed_classify_line (void);
static void     fixed_get_stmt (void);
boolean         read_line (boolean);
static void     free_classify_line (void);
static void     free_get_stmt (void);
void            ntr_next_msg_queue(int,int,msg_severities_type,
                                   int,char *, long,int);
static void     move_up_next_msg_queue(void);
static boolean  open_include_file (boolean);
static void     update_global_line (void);
static int      whats_after_paren_group(int *, int *, int);
static int      whats_after_brkt_group(int *, int *, int);
static void     print_nxt_line(void);
static void     classify_line(void);
static boolean  get_nxt_line(void);
static void     pp_get_stmt (void);
static void     shift_to_line_size(int);

static boolean  issue_classify_msg = TRUE;

# ifdef _DEBUG

static void     print_stmt (void);
static void     print_src (void);



/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Print_stmt prints the source input to stderr.                         *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
|* Note:  This routine has been superceded by the print routine in miflib     *|
|*        called CIF_postprocessor (for debugging the front-end, we still     *|
|*        use print_buffered_messages).  print_stmt has been left here in     *|
|*        case we need to go back to this method for any reason.  It only     *|
|*        exists in debug compilers anyway.                                   *|
|*                                                                            *|
\******************************************************************************/

static void print_stmt()

{
   int   idx;
   int   line;
   int   ich2;


   for (line = 1; line <= lines_in_buf; line++) {

      for (idx = 0;
           (((ich2 = stmt_buf[idx + stmt_line_start_idx[line]]) != newline)
                   && (ich2 != eos));
           idx++) {
         fprintf(stderr, "%c", ich2);
      }
      fprintf(stderr, "\n");
   }

   return;

}  /* print_stmt */



/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Print_src is an expanded version of print_stmt that dumps the source  *|
|*      input.  This prints the source form and marks character constants.    *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/
static void print_src()
{
   int   idx;
   int   line;

   if (source_form == Fixed_Form) {
      fprintf(stderr, "Fixed_Form\n");
   }
   else {
      fprintf(stderr, "Free_Form\n");
   }

   for (line = 1; line <= lines_in_buf; line++) {

       fprintf(stderr, "global line num = %d\n", stmt_line_num[line]);
       for (idx = stmt_line_start_idx[line]; idx < stmt_line_end_idx[line];
            idx++) {

          if (stmt_buf[idx] < 0) {
             fprintf(stderr, "^%c", stmt_buf[idx]);
          }
          else {
             fprintf(stderr, "%c", stmt_buf[idx]);
          }
       }
       fprintf(stderr, "\n");
   }
   fprintf(stderr, "*******************************************************\n");

   return;

}  /* print_src */

# endif


/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Init_src is called by compiler initialization in main to open the     *|
|*      source input file and initialize the data structures used by this     *|
|*      module.                                                               *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void init_src_input (void)

{
   TRACE (Func_Entry, "init_src_input", NULL);

   dot_i_fptr = stdout; /* default is stdout */

   if (on_off_flags.save_dot_i) {
      dot_i_fptr = fopen(dot_i_file, "w");
   }

   previous_global_line = 0;

   /* allocate memory for src_stk and set src_stk_idx to 1 */

   CHECK_INITIAL_ALLOC(src_stk, 1);

   /* This field will get updated by update_global_line. */

   SRC_STK_GLOBAL_LINE_IDX(src_stk_idx) = NULL_IDX;
   SRC_STK_PREV_SRC_FORM(src_stk_idx)   = source_form;  /* Init to current */

   /* initialize base entry in src_stk with source file info */

   if (src_file[0] == EOS) {                            /* src file is stdin  */
      SRC_STK_FILE_LINE(SRC_STK_BASE_IDX) = 0;
      SRC_STK_FILE_TYPE(SRC_STK_BASE_IDX) = Stdin_Src;
      SRC_STK_FILE_PTR(SRC_STK_BASE_IDX)  = stdin;
      strcpy (src_file, "'stdin'");                     /* use 'stdin' as name*/
   }
   else {
      SRC_STK_FILE_LINE(SRC_STK_BASE_IDX) = 0;
      SRC_STK_FILE_TYPE(SRC_STK_BASE_IDX) = Input_Src;

      SRC_STK_FILE_PTR(SRC_STK_BASE_IDX) = fopen (src_file, "r");

      if (SRC_STK_FILE_PTR(SRC_STK_BASE_IDX) == NULL) {
         PRINTMSG (0, 49, Log_Error, 0, src_file);      /* Can't open src file*/
         exit_compiler (RC_USER_ERROR);
      }
   }

   if (on_off_flags.output_pound_lines &&
       (on_off_flags.preprocess_only || on_off_flags.save_dot_i)) {
        fprintf(dot_i_fptr, "# 1 \"%s\"\n", src_file);
   }

   /* Make relative path for source file absolute.                            */

   if (src_file[0] != SLASH)
   {
      getcwd (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), MAX_FILE_NAME_SIZE);
      /* Mac getcwd supplies separator */
      strcat (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), "/");
      SRC_STK_FILE_IDX(SRC_STK_BASE_IDX) =
                               strlen(SRC_STK_PATH_NAME(SRC_STK_BASE_IDX));
      strcat (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), src_file);
   }
   else {
      SRC_STK_FILE_IDX(SRC_STK_BASE_IDX) = 0;
      strcpy (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), src_file);
   }

   /* Initialize base entry of global_line_tbl with first line of source file.*/

   update_global_line();
   
   /* Set the line numbers in this entry correctly.                           */
   /* Always set GL_CIF_FILE_ID; it's needed for buffered message output.     */

   GL_GLOBAL_LINE(global_line_tbl_idx)  = 1;
   GL_FILE_LINE(global_line_tbl_idx)    = 1;
   
   /* Initialize idx to start of next stmt, after ;                           */

   starting_pt = NULL_IDX;

   /* Flag controls Ansi msg for line over 72 chars so it is issued once.     */

   have_issued_msg_37           = FALSE;

   havent_issued_tab_ansi       = TRUE;
   havent_issued_at_ansi        = TRUE;
   havent_issued_dollar_ansi    = TRUE;

   nxt_line_start_idx[0] = 0;
   nxt_line_end_idx[0] = 0;
   nxt_line_col[0] = 0;
   nxt_line_num_lines = 1;
   pp_line_idx = 1;

   pp_nxt_line_type[0] = Regular_Line;

   /* Manufacture dummy 0th line of fixed source file in nxt_line buffer.     */

   nxt_line_start_idx[1] = 1;
   nxt_line_end_idx[1] = 2;
   nxt_line[0]     = blank;
   nxt_line[1]     = newline;
   nxt_line[2]     = eos;
   nxt_line_idx    = 1;
   nxt_line_num    = 0;
   nxt_line_type   = Comment_Line;
   PP_LINE_TYPE    = Comment_Line;
   PP_EOL          = 1;

   if (source_form == Fixed_Form) {
      /* set source line size from command line */
      if (cmd_line_flags.line_size_80) {
         line_size = FIXED_SRC_LINE_SIZE_80;
      }
      else if (cmd_line_flags.line_size_132) {
         line_size = FIXED_SRC_LINE_SIZE_132;
      }
      else {
         line_size = FIXED_SRC_LINE_SIZE_72;
      }

      if (! on_off_flags.preprocess_only) {
         fixed_get_stmt ();
      }
   }
   else {
      /* set source line size to standard free form length */
      line_size = FREE_SRC_LINE_SIZE;
      if (! on_off_flags.preprocess_only) {
         expected_line = Regular_Line;
         free_get_stmt ();
      }
   }

   if (change_orig_src_file) {
      /* reset the file name in the src stk and update global line again. */

      if (pound_file[0] != SLASH) {
         getcwd (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), MAX_FILE_NAME_SIZE);
         strcat (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), "/");
         SRC_STK_FILE_IDX(SRC_STK_BASE_IDX) =
                                  strlen(SRC_STK_PATH_NAME(SRC_STK_BASE_IDX));
         strcat (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), pound_file);
      }
      else {
         SRC_STK_FILE_IDX(SRC_STK_BASE_IDX) = 0;
         strcpy (SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), pound_file);
      }

      /* If CIF records have been requested, output the Source File record.  */
      /* Always output a File Name record for the source file.               */

      c_i_f = cif_actual_file;
      SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX) =
         cif_file_name_rec(SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), pound_file);

      if (cif_flags) {
         cif_source_file_rec(SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX),
                             cmd_line_flags.src_form);
      }

      c_i_f = cif_tmp_file;

      cif_file_rec_issued = TRUE;

      global_line_tbl_idx = 0;
      SRC_STK_FILE_LINE(SRC_STK_BASE_IDX) = 0;
      SRC_STK_GLOBAL_LINE_IDX(src_stk_idx) = NULL_IDX;
      update_global_line();

      /* Set the line numbers in this entry correctly.                       */
      /* Always set GL_CIF_FILE_ID; it's needed for buffered message output. */

      GL_CIF_FILE_ID(global_line_tbl_idx)  = 
                                     SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX);
      GL_GLOBAL_LINE(global_line_tbl_idx)  = 1;
      GL_FILE_LINE(global_line_tbl_idx)    = 1;

      if (source_form == Fixed_Form) {
         if (! on_off_flags.preprocess_only) {
            fixed_get_stmt ();
         }
      }
      else {
         if (! on_off_flags.preprocess_only) {
            expected_line = Regular_Line;
            free_get_stmt ();
         }
      }
   }
   else if (! cif_file_rec_issued ) {
      /* If CIF records have been requested, output the Source File record.  */
      /* Always output a File Name record for the source file.               */

      c_i_f = cif_actual_file;
      SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX) =
         cif_file_name_rec(SRC_STK_PATH_NAME(SRC_STK_BASE_IDX), src_file);

      if (cif_flags) {
         cif_source_file_rec(SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX),
                             cmd_line_flags.src_form);
      }

      c_i_f = cif_tmp_file;
      cif_file_rec_issued = TRUE;

      /* Set the line numbers in this entry correctly.                       */
      /* Always set GL_CIF_FILE_ID; it's needed for buffered message output. */

      GL_CIF_FILE_ID(global_line_tbl_idx)  = 
                                SRC_STK_CIF_FILE_ID(SRC_STK_BASE_IDX);
   }

   TRACE (Func_Exit, "init_src_input", SRC_STK_FILE_NAME(SRC_STK_BASE_IDX));

   return;

}  /* init_src_input */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Reset_src_input is called by lex routines to back up the src input    *|
|*      character stream when splitting tokens or when a reparse of the input *|
|*      is requested by the parser.                                           *|
|*                                                                            *|
|*      Reset can only occur within the range of a single statement.          *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      buf_idx                 stmt_buf_idx will be reset to this.           *|
|*      stmt_num                compared to statement_number to ensure that   *|
|*                              we are resetting within the same statement.   *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void reset_src_input (int buf_idx,
                      int stmt_num)

{
   char  ch;
   int   i;

   TRACE (Func_Entry, "reset_src_input", NULL);

   /* These checks can be placed under _DEBUG later. For   */
   /* now, however, I want them executed in both compilers */

   /* Attempt to set src to line not in buffer */

   if (stmt_num != statement_number && !in_action_stmt_of_if_where_or_forall) {
      PRINTMSG (stmt_line_num[stmt_line_idx], 207, Internal, 1);
   }

   if (buf_idx < 0) {
      PRINTMSG (stmt_line_num[stmt_line_idx], 626, Internal, 1, 
                "valid buf_idx",
                "reset_src_input");
   }

   stmt_line_idx = 0;

   if (buf_idx == 0) {
      stmt_line_idx = 1;
   }
   else {
      for (i = 1; i <= lines_in_buf; i++) {
         if (buf_idx >= stmt_line_start_idx[i] &&
             buf_idx <= stmt_line_end_idx[i]) {
            stmt_line_idx = i;
            break;
         }
      }
   }

# ifdef _DEBUG
   if (stmt_line_idx == 0) {
      PRINTMSG(1,626,Internal,1,
               "valid stmt_line_idx",
               "reset_src_input");
   }
# endif

   stmt_buf_idx = buf_idx;

   if (stmt_buf_idx == 0 ||
       stmt_buf[stmt_buf_idx] == '\0' ||
       stmt_buf[stmt_buf_idx] == '\n') {
      ch = ' ';
   }
   else {
      ch = stmt_buf[stmt_buf_idx];
   }

   if (islower(ch)) {                               /* lowercase char     */
      ch = TOUPPER(ch);                             /* cnvrt lwr to upr   */
   }

   LA_CH_VALUE  = ch;
   LA_CH_LINE   = stmt_line_num[stmt_line_idx];
   LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
   LA_CH_BUF_IDX = stmt_buf_idx;
   LA_CH_STMT_NUM = statement_number;
   LA_CH_CLASS  = (ch == (char) EOF) ? Ch_Class_EOF : ch_class[LA_CH_VALUE];

   TRACE (Func_Exit, "reset_src_input", NULL);

   return;

}  /* reset_src_input */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Fixed_get_char is called to obtain the next non-space character from  *|
|*      the source line buffer when outside a character literal context.      *|
|*                                                                            *|
|*      Lowercase letters are converted to uppercase.  End of statement       *|
|*      causes an EOS to be returned.                                         *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      la_ch                   next look ahead character from source line    *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void fixed_get_char (void)

{
   char ch;
   int  ich;


   TRACE (Func_Entry, "fixed_get_char", NULL);

   /* if previous la_ch was end of stmt, then get next stmt */

   if (LA_CH_VALUE == EOS) {
      stmt_end_line = LA_CH_LINE;
      stmt_end_col  = LA_CH_COLUMN - 1;

      if (change_source_form) {
         change_source_form = FALSE;
         line_size = FREE_SRC_LINE_SIZE;
         expected_line = Regular_Line;
         get_char = free_get_char;
         get_char_literal = free_get_char_literal;
         source_form = Free_Form;
      
         free_get_char ();

         TRACE (Func_Exit, "fixed_get_char",
                           ch_str[(unsigned char)LA_CH_VALUE]);

         return;
      }

      fixed_get_stmt ();                                /* get next src line  */

      /* the only time that stmt_buf_type is comment is EOF of include file */
      while (stmt_buf_type == Comment_Line) {
         if (change_source_form) {
            change_source_form = FALSE;
            line_size = FREE_SRC_LINE_SIZE;
            expected_line = Regular_Line;
            get_char = free_get_char;
            get_char_literal = free_get_char_literal;
            source_form = Free_Form;

            free_get_char ();
   
            TRACE (Func_Exit, "fixed_get_char",
                               ch_str[(unsigned char)LA_CH_VALUE]);

            return;
         }
         else {
            fixed_get_stmt ();
         }
      }


      ich = stmt_buf[stmt_buf_idx + 1];

      while (((ich == newline)               |
               (ich == semi_colon)           |
               (ich == bang))                                 &&
             (stmt_line_idx >= lines_in_buf))                 {

         fixed_get_stmt ();

         while (stmt_buf_type == Comment_Line) {
            if (change_source_form) {
               change_source_form = FALSE;
               line_size = FREE_SRC_LINE_SIZE;
               expected_line = Regular_Line;
               get_char = free_get_char;
               get_char_literal = free_get_char_literal;
               source_form = Free_Form;

               free_get_char ();
  
               TRACE (Func_Exit, "fixed_get_char",
                                  ch_str[(unsigned char)LA_CH_VALUE]);

               return;
            }
            else {
               fixed_get_stmt ();
            }
         }

         ich = stmt_buf[stmt_buf_idx + 1];
      }

      if (stmt_buf_type == Dir_Line) {                  /* directive line     */
         ch = stmt_buf[stmt_buf_idx];         /* next src character */

         if (islower(ch)) {
            ch = TOUPPER(ch);
         }

         LA_CH_VALUE  = ch;
         LA_CH_LINE   = stmt_line_num[stmt_line_idx];   /* global line num    */
         LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
         LA_CH_BUF_IDX = stmt_buf_idx;
         LA_CH_STMT_NUM = statement_number;

         switch (stmt_prefix_len) {
         case 1 :
            LA_CH_CLASS  = Ch_Class_Dir1;               /* directive class    */
            break;
         case 2 :
            LA_CH_CLASS  = Ch_Class_Dir2;               /* directive class    */
            break;
         case 3 :
            LA_CH_CLASS  = Ch_Class_Dir3;               /* directive class    */
            break;
         case 4 :
            LA_CH_CLASS  = Ch_Class_Dir4;               /* directive class    */
            break;
         case 7 :
            /* eraxxon: OpenAD directive */
            LA_CH_CLASS  = Ch_Class_Dir7;               /* directive class    */
            break;
         }

         TRACE (Func_Exit, "fixed_get_char", 
                           ch_str[(unsigned char) LA_CH_VALUE]);

         return;
      }
   }

   /* find next significant char if there is one */

   do {
      ich = stmt_buf[++stmt_buf_idx];                   /* next src character */

      if (stmt_buf_idx == stmt_buf_EOS_idx) {
         ich = eos;
      }
      else if (stmt_buf_idx == stmt_line_end_idx[stmt_line_idx]) {

         if (stmt_line_idx < lines_in_buf) {            /* stmt continues     */
            ++stmt_line_idx;
            stmt_buf_idx = stmt_line_start_idx[stmt_line_idx] 
                           + stmt_line_offset[stmt_line_idx];

            ich = blank;                                /* loop again         */
         }
         else {                                         /* end of statement   */
            ich = eos;                                  /* cnvrt \n,'!' to EOS*/
         }
      }
   }
   while ((ich == blank) | (ich == tab));               /* skip white space   */

   LA_CH_LINE   = stmt_line_num[stmt_line_idx];        /* global line num    */
   LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
   LA_CH_BUF_IDX = stmt_buf_idx;
   LA_CH_STMT_NUM = statement_number;


   if (havent_issued_at_ansi && ich == at_sign) {
      havent_issued_at_ansi = FALSE;
      ntr_msg_queue(LA_CH_LINE, 900, Ansi,
                    LA_CH_COLUMN,
                    (char *)NULL,
                    0,
                    NO_ARG);
   }
   
   if (havent_issued_dollar_ansi && ich == dollar) {
      havent_issued_dollar_ansi = FALSE;
      ntr_msg_queue(LA_CH_LINE, 901, Ansi,
                    LA_CH_COLUMN,
                    (char *)NULL,
                    0,
                    NO_ARG);
   }

   ch = ich;

   if (islower(ch)) {                                   /* lowercase char     */
      ch = TOUPPER(ch);                                 /* cnvrt lwr to upr   */
   }

   LA_CH_VALUE = ch;                                    /* next look ahead ch */
   LA_CH_CLASS = (ch == (char) EOF) ? Ch_Class_EOF : ch_class[LA_CH_VALUE];

   TRACE (Func_Exit, "fixed_get_char", ch_str[(unsigned char) LA_CH_VALUE]);

   return;

}  /* fixed_get_char */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Fixed_get_char_literal is called to obtain the next character from    *|
|*      the source line buffer when inside a character literal context.       *|
|*      End of statement causes an EOS to be returned.                        *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      la_ch                   next look ahead character from source line    *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void fixed_get_char_literal (void)

{
   char ch;
   int  ich;


   TRACE (Func_Entry, "fixed_get_char_literal", NULL);

   ich = stmt_buf[++stmt_buf_idx];                      /* next src character */

   if (stmt_buf_idx == stmt_line_end_idx[stmt_line_idx]) {

      if (stmt_line_idx < lines_in_buf) {               /* check for cont line*/
         ++stmt_line_idx;
         stmt_buf_idx = stmt_line_start_idx[stmt_line_idx]
                        + stmt_line_offset[stmt_line_idx];

         ich = stmt_buf[++stmt_buf_idx];                /* next src character */
      }
      else {                                            /* end of statement   */
         ich = eos;                                     /* cnvrt \n to EOS    */
      }
   }

   ch = ich;
   LA_CH_VALUE  = ch;                                   /* next look ahead ch */
   LA_CH_LINE   = stmt_line_num[stmt_line_idx];
   LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
   LA_CH_BUF_IDX = stmt_buf_idx;
   LA_CH_STMT_NUM = statement_number;
   LA_CH_CLASS  = (ch == (char) EOF) ? Ch_Class_EOF : ch_class[LA_CH_VALUE];

   TRACE (Func_Exit, "fixed_get_char_literal", 
                     ch_str[(unsigned char) LA_CH_VALUE]);

   return;

}  /* fixed_get_char_literal */


/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Free_get_char is called to obtain the next character from the source  *|
|*      line buffer when outside a character literal context.  Space chars    *|
|*      are returned here since they are significant in free source form.     *|
|*                                                                            *|
|*      Lowercase letters are converted to uppercase.  End of statement       *|
|*      causes an EOS to be returned.                                         *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      la_ch                   next look ahead character from source line    *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void free_get_char (void)

{
   char ch;
   int  ich;

   
   TRACE (Func_Entry, "free_get_char", NULL);

   sig_blank = FALSE;

   /* If previous la_ch was end of stmt, then get next stmt.                  */

   if (LA_CH_VALUE == EOS) {
      stmt_end_line = LA_CH_LINE;
      stmt_end_col  = LA_CH_COLUMN - 1;

      if (change_source_form) {
         change_source_form = FALSE;

         if (cmd_line_flags.line_size_80) {
            line_size = FIXED_SRC_LINE_SIZE_80;
         }
         else if (cmd_line_flags.line_size_132) {
            line_size = FIXED_SRC_LINE_SIZE_132;
         }
         else {
            line_size = FIXED_SRC_LINE_SIZE_72;
         }
         get_char = fixed_get_char;
         get_char_literal = fixed_get_char_literal;
         source_form = Fixed_Form;

         fixed_get_char ();

         TRACE (Func_Exit, "free_get_char", 
                           ch_str[(unsigned char) LA_CH_VALUE]);

         return;
      }

      free_get_stmt ();

      /* the only time that stmt_buf_type is comment is EOF of include file */
      while (stmt_buf_type == Comment_Line) {
         if (change_source_form) {
            change_source_form = FALSE;

            if (cmd_line_flags.line_size_80) {
               line_size = FIXED_SRC_LINE_SIZE_80;
            }
            else if (cmd_line_flags.line_size_132) {
               line_size = FIXED_SRC_LINE_SIZE_132;
            }
            else {
               line_size = FIXED_SRC_LINE_SIZE_72;
            }

            get_char = fixed_get_char;
            get_char_literal = fixed_get_char_literal;
            source_form = Fixed_Form;

            fixed_get_char ();

            TRACE (Func_Exit, "free_get_char", 
                              ch_str[(unsigned char) LA_CH_VALUE]);

            return;
         }
         else {
            free_get_stmt ();
         }
      }

      ich = stmt_buf[stmt_buf_idx + 1];

      while (((ich == newline)     |
              (ich == semi_colon)  |
               (ich == bang))                                 &&
             (stmt_line_idx >= lines_in_buf))                 {

         free_get_stmt ();

         while (stmt_buf_type == Comment_Line) {
            if (change_source_form) {
               change_source_form = FALSE;

               if (cmd_line_flags.line_size_80) {
                  line_size = FIXED_SRC_LINE_SIZE_80;
               }
               else if (cmd_line_flags.line_size_132) {
                  line_size = FIXED_SRC_LINE_SIZE_132;
               }
               else {
                  line_size = FIXED_SRC_LINE_SIZE_72;
               }

               get_char = fixed_get_char;
               get_char_literal = fixed_get_char_literal;
               source_form = Fixed_Form;

               fixed_get_char ();

               TRACE (Func_Exit, "free_get_char",
                                 ch_str[(unsigned char) LA_CH_VALUE]);

               return;
            }
            else {
               free_get_stmt ();
            }
         }

         ich = stmt_buf[stmt_buf_idx + 1];
      }


      if (stmt_buf_type == Dir_Line) {                  /* directive line     */
         ch = stmt_buf[stmt_buf_idx];         /* next src character */

         if (islower(ch)) {
            ch = TOUPPER(ch);
         }

         LA_CH_VALUE  = ch;
         LA_CH_LINE   = stmt_line_num[stmt_line_idx];
         LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
         LA_CH_BUF_IDX = stmt_buf_idx;
         LA_CH_STMT_NUM = statement_number;

         switch (stmt_prefix_len) {
         case 1 :
            LA_CH_CLASS  = Ch_Class_Dir1;               /* directive class    */
            break;
         case 2 :
            LA_CH_CLASS  = Ch_Class_Dir2;               /* directive class    */
            break;
         case 3 :
            LA_CH_CLASS  = Ch_Class_Dir3;               /* directive class    */
            break;
         case 4 :
            LA_CH_CLASS  = Ch_Class_Dir4;               /* directive class    */
            break;
         case 7 :
            /* eraxxon: OpenAD directive */
            LA_CH_CLASS  = Ch_Class_Dir7;               /* directive class    */
            break;
         }

         TRACE (Func_Exit, "free_get_char",
                           ch_str[(unsigned char) LA_CH_VALUE]);

         return;
      }
   }

   /* handling of continued lines must be in a loop to process special cases. */
   /* beginning of line cases, '& \n' and '& !' have been detected and        */
   /* reported by free_classify_line.  end of line case, 'text & text' is     */
   /* detected here.  The '&' is considered part of the token string.         */
   /* a last special case, '&&' is handled here.  It is treated as both a     */
   /* continuation and continued line with zero characters of the token.      */

   ich = stmt_buf[++stmt_buf_idx];                      /* next src character */

   if (ich == blank  ||  ich == tab) {                  /* skip no-op blanks  */

      do {
         ich = stmt_buf[++stmt_buf_idx];                /* next src character */
      }
      while (ich == blank  ||  ich == tab);             /* skip white space   */

      sig_blank = TRUE;
   }

   if (stmt_buf_idx == stmt_buf_EOS_idx) {
      ich = eos;
   }
   else if (stmt_buf_idx == stmt_line_end_idx[stmt_line_idx]) {

      if (stmt_line_idx < lines_in_buf) {         /* stmt continues     */
         ++stmt_line_idx;
         stmt_buf_idx = stmt_line_start_idx[stmt_line_idx]
                        + stmt_line_offset[stmt_line_idx];
         ich = stmt_buf[++stmt_buf_idx];
      }
      else {
         ich = eos;
      }

      if (ich == blank  ||  ich == tab) {               /* skip no-op blanks  */

         do {
            ich = stmt_buf[++stmt_buf_idx];             /* next src character */
         }
         while (ich == blank  ||  ich == tab);          /* skip white space   */

         sig_blank = TRUE;
      }
      
      if (stmt_buf_idx == stmt_buf_EOS_idx) {
         ich = eos;
      }
   }

   LA_CH_LINE   = stmt_line_num[stmt_line_idx];
   LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
   LA_CH_BUF_IDX = stmt_buf_idx;
   LA_CH_STMT_NUM = statement_number;

   if (havent_issued_at_ansi && ich == at_sign) {
      havent_issued_at_ansi = FALSE;
      ntr_msg_queue(LA_CH_LINE, 900, Ansi,
                    LA_CH_COLUMN,
                    (char *)NULL,
                    0,
                    NO_ARG);
   }

   if (havent_issued_dollar_ansi && ich == dollar) {
      havent_issued_dollar_ansi = FALSE;
      ntr_msg_queue(LA_CH_LINE, 901, Ansi,
                    LA_CH_COLUMN,
                    (char *)NULL,
                    0,
                    NO_ARG);
   }

   ch = ich;

   if (islower(ch)) {                                   /* lowercase char     */
      ch = TOUPPER(ch);                                 /* cnvrt lwr to upr   */
   }

   LA_CH_VALUE = ch;                                    /* next look ahead ch */
   LA_CH_CLASS = (ch == (char) EOF) ? Ch_Class_EOF : ch_class[LA_CH_VALUE];

   TRACE (Func_Exit, "free_get_char",
                     ch_str[(unsigned char) LA_CH_VALUE]);

   return;

}  /* free_get_char */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Free_get_char_literal is called to obtain the next character from     *|
|*      the source line buffer when inside a character literal context.       *|
|*      End of statement causes an EOS to be returned.                        *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      la_ch                   next look ahead character from source line    *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

void free_get_char_literal (void)

{
   char ch;
   int  ich;


   TRACE (Func_Entry, "free_get_char_literal", NULL);

   /*  ? */
   /* handling of continued lines must be in a loop to process special cases. */
   /* beginning of line cases, '& \n' and '& !' have been detected and        */
   /* reported by free_classify_line.  end of line case, 'text & text' is     */
   /* detected here.  The '&' is considered part of the character literal.    */
   /* a last special case, '&&' is handled here.  It is treated as both a     */
   /* continuation and continued line with zero characters of the literal.    */
   /*  ? */

   ich = stmt_buf[++stmt_buf_idx];                      /* next src character */


   if (stmt_buf_idx == stmt_line_end_idx[stmt_line_idx]) {

      if (stmt_line_idx < lines_in_buf) {
         ++stmt_line_idx;
         stmt_buf_idx = stmt_line_start_idx[stmt_line_idx]
                        + stmt_line_offset[stmt_line_idx];

         ich = stmt_buf[++stmt_buf_idx];
      }
      else {
         ich = eos;
      }
   }
        
   ch = ich;

   LA_CH_VALUE  = ch;                                   /* next look ahead ch */
   LA_CH_LINE   = stmt_line_num[stmt_line_idx];
   LA_CH_COLUMN = stmt_buf_col[stmt_buf_idx];
   LA_CH_BUF_IDX = stmt_buf_idx;
   LA_CH_STMT_NUM = statement_number;
   LA_CH_CLASS  = (ch == (char) EOF) ? Ch_Class_EOF : ch_class[LA_CH_VALUE];

   TRACE (Func_Exit, "free_get_char_literal",
                     ch_str[(unsigned char) LA_CH_VALUE]);

   return;

}  /* free_get_char_literal */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Fixed_get_stmt obtains the next src input stmt.  It will fill         *|
|*      stmt_buf array with a full statement using repeated calls to          *|
|*      read_line.                                                            *|
|*                                                                            *|
|*      The line is classified as a comment, include, dir, regular, or        *|
|*      continuation line by calling fixed_classify_line.  Checks involving   *|
|*      relationships between lines (eg. continued followed by continuation)  *|
|*      are performed here.  Comment and include lines are not returned.      *|
|*      Character constants are marked.                                       *|
|*                                                                            *|
|*      An EOF line is returned when end of the input source file is          *|
|*      encountered.  Include lines cause a file switch.  End of include      *|
|*      files are treated as comments.                                        *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

static void fixed_get_stmt (void)
{
   int idx;
   int line_counter = 1;
   int loc_stmt_num;
   int save_idx;
   int stmt_buf_EOS;
   

   TRACE (Func_Entry, "fixed_get_stmt", NULL);

   /* Issue any deferred src_input messages.                                  */

   issue_deferred_msgs();


   if (stmt_buf_type == EOF_Line) {
      /* Attempt to read past end of file */
      PRINTMSG (0, 50, Internal, 1);                    /* all done now       */
   }

   stmt_line_idx = NULL_IDX;                            /* line array index   */
   stmt_buf_idx = NULL_IDX;                             /* global stmt buf idx*/
   lines_in_buf = 0;                                    /* total lines in buf */

   label_ok = FALSE;

   /* loop while stmt continues */
   do {

      save_idx = 0;

      /* add nxt_line to stmt_buf */

      stmt_line_num[++stmt_line_idx] = nxt_line_num;

      /* stmt_line_offset holds offset to first significant char of line */

      if (starting_pt) {
         stmt_line_offset[stmt_line_idx] = starting_pt - 2;
         label_ok = FALSE;
      }
      else {
         stmt_line_offset[stmt_line_idx] = nxt_line_idx - 1;
         starting_pt = nxt_line_idx;

         if (nxt_line_label) {
            label_ok = TRUE;
         }
      }
   
      /* stmt_line_start_idx points to where line starts in stmt_buf */

      stmt_line_start_idx[stmt_line_idx] = line_counter;

      /* stmt_line_end_idx points to newline or bang */

      stmt_line_end_idx[stmt_line_idx] = nxt_line_EOL + line_counter - 1;

      /* record the statement type                                 */

      if (nxt_line_type != Continuation_Line      &&
          nxt_line_type != Dir_Continuation_Line) {
         stmt_buf_type = nxt_line_type;

         if (nxt_line_type == Dir_Line) {
            stmt_prefix_len = nxt_line_prefix_len;
            stmt_buf_dir_prefix = nxt_line_dir_prefix;
         }

         if (stmt_buf_type != Comment_Line &&
             stmt_buf_type != Pound_Src_Line &&
             stmt_buf_type != Pound_Include_Exit_Line) {
            INCREMENT_STATEMENT_NUMBER;
         }
      }

      if (stmt_buf_type == Dir_Line) {
         line_dir_prefix[stmt_line_idx] = nxt_line_actual_dir_prefix;
      }

      move_up_next_msg_queue();

      /* copy nxt_line to proper part of stmt_buf, backwards       */

      stmt_buf_idx = line_counter + nxt_line_EOL - 1;
      line_counter += nxt_line_EOL;
      
      for (idx = nxt_line_EOL; idx > 0; idx --) {
         stmt_buf[stmt_buf_idx] = nxt_line[NXT_COL(idx)];
         stmt_buf_col[stmt_buf_idx] = nxt_line_col[NXT_COL(idx)];
         stmt_buf_idx--;

         if (havent_issued_tab_ansi && 
             idx < nxt_line_EOL     &&
             nxt_line[NXT_COL(idx)] == tab) {
            havent_issued_tab_ansi = FALSE;
            ntr_msg_queue(nxt_line_num, 899, Ansi,
                          idx,
                          (char *)NULL,
                          0,
                          NO_ARG);
         }

         if (nxt_line[NXT_COL(idx)] == semi_colon &&
             stmt_buf_type != Dir_Line) {
            if ((idx > starting_pt) && (idx < nxt_line_EOL)) {
               save_idx = idx;
            }
         }
      }

      idx = 0;
      lines_in_buf++;

      /* save_idx is the point in nxt_line where the next ';' is */
      /* If there is a semi_colon then I don't replace nxt_line  */
      /* or classify it again. I simply recopy nxt_line into the */
      /* stmt_buf and start processing after the ;.              */
      /* Must check if nxt_line_type is a comment line because   */
      /* when an include file ends, comment lines come through.  */

      if (save_idx &&
          nxt_line_type != Comment_Line) {

         stmt_buf_EOS = save_idx;
         idx = save_idx;
         while ((nxt_line[NXT_COL(idx)] == semi_colon) |
                (nxt_line[NXT_COL(idx)] == blank)      |
                (nxt_line[NXT_COL(idx)] == tab))       {
            idx++;
         }

         /* starting_pt is the idx I start processing the next time around */

         starting_pt        = idx;
         nxt_line_type      = Regular_Line;
         continuation_count = 0;                /* clear cont counter */
         include_found      = FALSE;    /* and include flags  */
         include_complete   = FALSE;
      }
      else {
         stmt_buf_EOS = nxt_line_EOL;
         starting_pt = NULL_IDX;
      }

      /* don't read past end of source file            */
      /* and don't get new nxt_line if had semi-colon. */

      if ((stmt_buf_type != EOF_Line) &&
          (starting_pt == NULL_IDX))       {

         /* get next line from src input file */
         do {
            nxt_line_type = Regular_Line;

            if (get_nxt_line ()) {              /* read next src line */

               if (include_switch) {
                  update_global_line();         /* enter global_line_tbl  */
                  include_switch = FALSE;
               }

               if (issue_pound_exit_line) {
                  OUTPUT_POUND_INCLUDE_EXIT_LINE(curr_glb_line);
                  issue_pound_exit_line = FALSE;
               }

               nxt_line_mp_line = FALSE;

               if (nxt_line_type != Cond_Comp_Line) {
                  PP_ORIG_SIZE = line_size;
                  classify_line();
               }

               if (on_off_flags.save_dot_i) {

                  if (ignore_source_line ||
                      nxt_line_type == Cond_Comp_Line ||
                      nxt_line_type == Include_Line) {

                     /* print blank line */
                     fprintf(dot_i_fptr, "\n");
                     previous_global_line++;
                  }
                  else {
                     print_nxt_line();
                  }
               }

               switch (nxt_line_type) {
                  case Comment_Line:                    /* ignore comments    */
                     break;

                  case Cond_Comp_Line:
                     if (parse_cc_line()) {

                        /* if result is true, then it was an include line */

                        nxt_line_type = Include_Line;
                        include_stmt_file_line = SRC_STK_FILE_LINE(src_stk_idx);

                        if (open_include_file (TRUE)) {
                           include_found  = TRUE;      /* flag begin of file */
                           include_switch = TRUE;      /* flag file switch   */
                        }
                     }
                     else {
                        nxt_line_type = Comment_Line;
                     }
                     angle_brkt_include = FALSE;
                     break;

                  case Dir_Line:
                  case Regular_Line:
                     continuation_count = 0;            /* clear cont counter */
                     include_found      = FALSE;        /* and include flags  */
                     include_complete   = FALSE;
                     break;

                  case Continuation_Line:
                  case Dir_Continuation_Line:

                     if (++continuation_count == MAX_ANSI_FIXED_LINES) {

                        /* Too many continuation lines is non-standard. */

                        ntr_msg_queue(nxt_line_num, 52, Ansi, 
                                      CONTINUE_COLUMN,
                                      "fixed",
                                      (MAX_ANSI_FIXED_LINES - 1), 
                                      ARG_STR_ARG);
                     }

                     if (continuation_count == MAX_FIXED_LINES) {

                        /* this is it. I cn give ya na more powr cap'n */

                        ntr_msg_queue(nxt_line_num, 524, Error,
                                      CONTINUE_COLUMN,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
                     }

                     if (continuation_count >= MAX_FIXED_LINES) {
                        nxt_line_type = Comment_Line;
                        break;
                     }

                     if (stmt_buf_type == Dir_Line           &&
                         nxt_line_type == Continuation_Line) {

                        /* Invalid continuation of comment or directive */

                        ntr_msg_queue(nxt_line_num, 51, Error,
                                      CONTINUE_COLUMN,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
                     }

                     if (include_found) {
                        include_found = FALSE;

                        /* First line of included file must not be a cont line*/

                        ntr_msg_queue(nxt_line_num, 53, Error,
                                      CONTINUE_COLUMN,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
                     }

                     if (include_complete) {
                        include_complete = FALSE;

                        /* Next line of file after include must not be a cont */

                        ntr_msg_queue(nxt_line_num, 54, Error,
                                      CONTINUE_COLUMN,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
                     }

                     if (cif_flags & MISC_RECS) {
                        cif_cont_line_rec(
                           (nxt_line_type == Continuation_Line) ? 0 : 1,
                           nxt_line_num);
                     }
 
                     break;

                  case Pound_Src_Line:
                     break;

                  case Pound_Include_Exit_Line:
                     include_complete = TRUE;
                     nxt_line_type         = Comment_Line;
                     curr_glb_line--;
                     SRC_STK_FILE_LINE(src_stk_idx)--;
                     GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                               SRC_STK_FILE_LINE(src_stk_idx);
                     set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));

                     if (source_form != SRC_STK_PREV_SRC_FORM(src_stk_idx)) {
                        change_source_form = TRUE;
                     }
                     POP_SRC;
                     include_switch = TRUE;
                     break;

                  case Pound_Include_Enter_Line:
                  case Include_Line:

                     include_stmt_file_line = SRC_STK_FILE_LINE(src_stk_idx);

                     if (open_include_file (FALSE)) {
                        include_found  = TRUE;          /* flag begin of file */
                        include_switch = TRUE;          /* flag file switch   */
                     }

                     break;
               }  /* switch */
            }
            else {                                      /* EOF on source file */

               /* need to bump pp_line_idx since classify_line was not called */

               if (cmd_line_flags.pp_macro_expansion) {
                  pp_line_idx++;
               }

               /* check for termination of include file */

               if (src_stk_idx > SRC_STK_BASE_IDX) {    /* curr src is include*/
                  include_complete = TRUE;              /* flag end of file   */
                  nxt_line_type    = Comment_Line;      /* make EOF a comment */
                  nxt_line_EOL = 2;
                  curr_glb_line--;            /* don't count this line */

                  GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                            SRC_STK_FILE_LINE(src_stk_idx);
                  set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));

                  if (source_form != SRC_STK_PREV_SRC_FORM(src_stk_idx)) {
                     change_source_form = TRUE;
                  }
                  POP_SRC;
                  include_switch = TRUE;                /* flag file switch   */
                  issue_pound_exit_line = TRUE;
                  break;
               }
               else {                                   /* curr src is input  */
                  GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                            SRC_STK_FILE_LINE(src_stk_idx);
                  set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));
                  nxt_line_type = EOF_Line;             /* end of compilation */
                  nxt_line_EOL = 2;
               }
            }
         }
         while (nxt_line_type == Comment_Line | 
                nxt_line_type == Include_Line |
                nxt_line_type == Pound_Include_Enter_Line);

      }
   }
   while (nxt_line_type == Continuation_Line || 
          nxt_line_type == Dir_Continuation_Line);

   if (prev_statement_number != statement_number) {
      loc_stmt_num = statement_number;
      statement_number = prev_statement_number;
      prev_statement_number = loc_stmt_num;
   }

   stmt_buf_EOS_idx = stmt_line_start_idx[lines_in_buf] + stmt_buf_EOS - 1;
   stmt_EOS_la_ch.line = stmt_line_num[lines_in_buf];
   stmt_EOS_la_ch.column = stmt_buf_col[stmt_buf_EOS_idx];
   stmt_EOS_la_ch.stmt_buf_idx = stmt_buf_EOS_idx;
   stmt_EOS_la_ch.stmt_num = statement_number;

   stmt_buf_idx = stmt_line_offset[1] + 1;
   stmt_line_idx = SRC_STK_BASE_IDX;

   PRINT_STMT_SRC();    /* If DEBUG and -u src or -u stmt set print source */

   TRACE (Func_Exit, "fixed_get_stmt", NULL);

   return;

}  /* fixed_get_stmt */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Reads next line of source characters from source file into source     *|
|*      buffer.  A line is delimited by a new line character followed by EOS. *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      TRUE if source input line was read, FALSE on EOF or error.            *|
|*                                                                            *|
\******************************************************************************/

boolean read_line (boolean      cc_continuation_line)

{
   int          ch;
   int          i;
   int          k;
   int          limit;
   boolean      result          = TRUE;                 /* assume success     */


   TRACE (Func_Entry, "read_line", NULL);

   if (extra_nxt_line != 0 &&
       nxt_line_num_lines == 0) {

      /* just move the extra line into the first line spot */

      nxt_line_num_lines++;

      if (pp_nxt_line_type[extra_nxt_line] == EOF_Line) {
         nxt_line_start_idx[1] = 1;
         nxt_line_end_idx[1] = 2;
         nxt_line[1]  = EOF;
         nxt_line[2]  = eos;
         pp_nxt_line_length[1] = 1;
         pp_nxt_line_type[1] = EOF_Line;
         pp_nxt_line_idx[1] = NULL_IDX;
         result       = FALSE;                         /* return EOF result  */
      }
      else {
         k = 0;
         for (i = nxt_line_start_idx[extra_nxt_line]; 
              i <= nxt_line_end_idx[extra_nxt_line]; 
              i++) {

            nxt_line[++k] = (nxt_line[i] & 0xFF);
            nxt_line_col[k] = nxt_line_col[i];
         }
         nxt_line_start_idx[1] = 1;
         nxt_line_end_idx[1] = k;
         pp_nxt_line_length[1] = k-1;
      }

      pp_nxt_line_num[1] = pp_nxt_line_num[extra_nxt_line];
      pp_nxt_line_mp_line[1] = pp_nxt_line_mp_line[extra_nxt_line];

      if (pp_nxt_line_type[extra_nxt_line] == Include_Line) {
         nxt_line_type = Include_Line;
      }

      extra_nxt_line = NULL_IDX;

      goto EXIT;
   }

   /* copy max number characters in the next line to the source input buffer  */

   ch = getc(SRC_STK_FILE_PTR(src_stk_idx));

   if (on_off_flags.preprocess &&
       ch != newline && 
       ch != EOF     &&
       (ch == '#' || cc_continuation_line)) {

      limit = MAX_STMT_CHAR_SIZE - 4;

      if (! cc_continuation_line) {
         cc_stmt_buf_idx = NULL_IDX;
         cc_stmt_buf_num_lines = 0;
      }

      cc_stmt_buf_line[++cc_stmt_buf_num_lines].line = ++curr_glb_line;
      cc_stmt_buf_line[cc_stmt_buf_num_lines].start_idx = cc_stmt_buf_idx;
      SRC_STK_FILE_LINE(src_stk_idx)++;

      cc_stmt_buf[++cc_stmt_buf_idx] = ch;

      while ((ch = getc(SRC_STK_FILE_PTR(src_stk_idx))) != newline &&
             ch != EOF){

         if (limit > 0) {
            cc_stmt_buf[++cc_stmt_buf_idx] = ch;
            limit--;
         }
      }

      cc_stmt_buf[++cc_stmt_buf_idx] = newline;
      cc_stmt_buf[++cc_stmt_buf_idx] = eos;

      nxt_line_type = Cond_Comp_Line;

      goto EXIT;
   }

   nxt_line_start_idx[nxt_line_num_lines + 1] =
                              nxt_line_end_idx[nxt_line_num_lines] + 1;

   nxt_line_num_lines++;

   for (i = nxt_line_start_idx[nxt_line_num_lines] - 1;
        i <= nxt_line_start_idx[nxt_line_num_lines] + line_size;
        i++) {
      nxt_line_col[i] = (i - nxt_line_start_idx[nxt_line_num_lines]) + 1;
   }

   nxt_line_idx = nxt_line_start_idx[nxt_line_num_lines] - 1;

   if (ch != newline && ch != EOF) {
      limit = nxt_line_idx + FREE_SRC_LINE_SIZE;

      nxt_line[++nxt_line_idx] = ch;

      while ((ch = getc(SRC_STK_FILE_PTR(src_stk_idx))) != newline &&
             ch != EOF){

         if (nxt_line_idx < limit) { 
            nxt_line[++nxt_line_idx] = ch;
         }
      }
   }


   if (nxt_line_idx > 
                   (nxt_line_start_idx[nxt_line_num_lines] - 1) + line_size) {

      nxt_line_idx = (nxt_line_start_idx[nxt_line_num_lines] - 1) + line_size;
   }

   if (nxt_line_idx == nxt_line_start_idx[nxt_line_num_lines] - 1 &&
       ch == EOF) {
      /* file ends with '\n'*/
      nxt_line[nxt_line_start_idx[nxt_line_num_lines]]  = EOF;
      nxt_line[nxt_line_start_idx[nxt_line_num_lines] + 1]  = eos;
      pp_nxt_line_length[nxt_line_num_lines] = 1;
      nxt_line_end_idx[nxt_line_num_lines] = 
                            nxt_line_start_idx[nxt_line_num_lines] + 1;
      pp_nxt_line_num[nxt_line_num_lines] = ++curr_glb_line;
      pp_nxt_line_type[nxt_line_num_lines] = EOF_Line;
      pp_nxt_line_idx[nxt_line_num_lines] = NULL_IDX;
      result       = FALSE;                             /* return EOF result  */
   }
   else {                                               /* return next line   */
      if (source_form == Fixed_Form) {
         /* pad to continue col*/
         while (nxt_line_idx < 
              (nxt_line_start_idx[nxt_line_num_lines] - 1) + CONTINUE_COLUMN) { 
            nxt_line[++nxt_line_idx] = blank; 
         }
      }

      pp_nxt_line_num[nxt_line_num_lines] = ++curr_glb_line;
      SRC_STK_FILE_LINE(src_stk_idx)++;                 /* upd file line num  */

      nxt_line[++nxt_line_idx] = newline;               /* end line w/ \n/EOS */
      pp_nxt_line_length[nxt_line_num_lines] = nxt_line_idx - 
                                   (nxt_line_start_idx[nxt_line_num_lines] - 1);
      nxt_line[++nxt_line_idx] = eos;
      nxt_line_end_idx[nxt_line_num_lines] = nxt_line_idx;

      if (pp_nxt_line_length[nxt_line_num_lines] > 73 && 
          source_form == Fixed_Form &&
          ! have_issued_msg_37 &&
          issue_classify_msg) {
         have_issued_msg_37 = TRUE;
         ntr_next_msg_queue(curr_glb_line, 37, Ansi,
                       0,
                       (char *)NULL,
                       0,
                       NO_ARG);
      }


# if 0

      /* LRR:  The following code to issue message 55 is being #ifdef'd out   */
      /* because we can think of no reason for it being here, but I don't     */
      /* want to lose it entirely in case in the future we do find a need for */
      /* it.  It does nothing to fix the file anyway.  The newline has already*/
      /* been inserted by code above this.  And if message 55 ever does get   */
      /* issued, the message handler can't process it correctly because it    */
      /* hits the EOF before it increments its line counter which makes it    */
      /* look like it could not find the source line.  See SPR 84130.         */

      if (ch == EOF) { /* File line does not end with newline. */
         PRINTMSG (curr_glb_line, 55, Warning, 0);
      }

# endif


   }

EXIT:

   TRACE (Func_Exit, "read_line", NULL);

   return (result);

}  /* read_line */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      <description>                                                         *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

static boolean is_pound_line_dir(void)

{
   int          ch;
   boolean      dir = FALSE;
   int          idx;

   TRACE (Func_Entry, "is_pound_line_dir", NULL);

   ch = nxt_line[NXT_COL(1)];                          /* column 1 char      */

   if (ch == pound) {
      idx = NXT_COL(2);
      ch = nxt_line[idx];

      while (ch == blank | ch == tab) {
         idx++;
         ch = nxt_line[idx];
      }

      if (isdigit(ch)) {
         dir = TRUE;
      }
   }

   TRACE (Func_Exit, "is_pound_line_dir", NULL);

   return(dir);

}  /* is_pound_line_dir */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      The line in the input buffer is classified as a comment, include,     *|
|*      dir, continuation, or regular line.  Fixed source form rules apply.   *|
|*      Character constants are marked with a set sign bit in each character. *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

static void fixed_classify_line (void)

{
   int     ch;
   char    form[4] = "    ";
   char    ch_tmp;
   int     cont_col;
   char    delim;
   char    err_str[2];
   int     i;
   int     ich;
   int     idx;
   int     incl_idx;
   boolean label;
   int     line_num;
   char    line_num_str[24];
   int     nxt_idx;
   int     save_curr_glb_line;

   TRACE (Func_Entry, "fixed_classify_line", NULL);

   PP_EOL = nxt_line_end_idx[pp_line_idx] - 1;

START:

   cont_col = NXT_COL(CONTINUE_COLUMN);

   PP_IDX = NXT_COL(0);
   PP_LABEL = FALSE;

   ch = nxt_line[NXT_COL(1)];

# ifdef _FRONTEND_CONDITIONAL_COMP
   if (ch == pound &&
       on_off_flags.preprocess) {

      PP_LINE_TYPE = Cond_Comp_Line;
   } else
# endif
   if (is_pound_line_dir()) {
      PP_IDX = NXT_COL(2);
      ch = nxt_line[PP_IDX];

      while (ch == blank | ch == tab) {
         PP_IDX++;
         ch = nxt_line[PP_IDX];
      }

      if (isdigit(ch)) {
         idx = 0;
         line_num_str[idx++] = ch;
         ch = nxt_line[++PP_IDX];
         while (isdigit(ch)) {
            line_num_str[idx++] = ch;
            ch =  nxt_line[++PP_IDX];
         }

         line_num_str[idx] = '\0';
         line_num = atoi(line_num_str);

         while (ch == blank | ch == tab) {
            PP_IDX++;
            ch = nxt_line[PP_IDX];
         }

         if (ch == quote | ch == db_quote) {
            char_delim = ch;
            ch =  nxt_line[++PP_IDX];

            idx = 0;
            while (ch != char_delim) {
               include_file[idx++] = ch;
               ch =  nxt_line[++PP_IDX];
            }
            include_file[idx] = '\0';

            ch =  nxt_line[++PP_IDX];
            while (ch == blank | ch == tab) {
               PP_IDX++;
               ch = nxt_line[PP_IDX];
            }

            if (ch == '1') {
               PP_LINE_TYPE = Pound_Include_Enter_Line;
            }
            else if (ch == '2') {
               PP_LINE_TYPE = Pound_Include_Exit_Line;
            }
            else {
               PP_LINE_TYPE = Comment_Line;

               /* reset the curr_glb_line */
               /* line_num is a file line, not a global line */

               save_curr_glb_line = curr_glb_line;
               curr_glb_line = line_num + GL_GLOBAL_LINE(global_line_tbl_idx) -
                             GL_FILE_LINE(global_line_tbl_idx);
               curr_glb_line--;

               if (first_pound_line) {
                  PP_LINE_TYPE = Pound_Src_Line;
                  change_orig_src_file = TRUE;
                  strcpy(pound_file, include_file);
               }
               else {
                  SRC_STK_FILE_LINE(src_stk_idx) +=
                                 curr_glb_line - save_curr_glb_line;
               }
            }

            first_pound_line = FALSE;

         }
         else if (ch == newline) {

            PP_LINE_TYPE = Comment_Line;

            /* reset the curr_glb_line */
            /* line_num is a file line, not a global line */

            save_curr_glb_line = curr_glb_line;
            curr_glb_line = line_num + GL_GLOBAL_LINE(global_line_tbl_idx) -
                          GL_FILE_LINE(global_line_tbl_idx);
            curr_glb_line--;

            SRC_STK_FILE_LINE(src_stk_idx) +=
                           curr_glb_line - save_curr_glb_line;

            first_pound_line = FALSE;
         }
         else {
            PP_LINE_TYPE = Comment_Line;
         }
      }
      else {
         PP_LINE_TYPE = Comment_Line;
      }
   }
   else if (ignore_source_line) {
      PP_LINE_TYPE = Comment_Line;
   }
# ifdef _D_LINES_SUPPORTED
   else if (ch == uc_d | ch == lc_d) {
      /* this is a debug line. */

      if (on_off_flags.d_lines) {
         nxt_line[NXT_COL(1)] = ' ';
         goto START;
      }
      else {
         PP_LINE_TYPE = Comment_Line;
      }
   }
# endif
   else if (ch == uc_c |  ch == lc_c | ch == bang | ch == star) {

      if (((ch = nxt_line[NXT_COL(2)]) == uc_d   || ch == lc_d) &&
          ((ch = nxt_line[NXT_COL(3)]) == uc_i   || ch == lc_i) &&
          ((ch = nxt_line[NXT_COL(4)]) == uc_r   || ch == lc_r) &&
          ((ch = nxt_line[NXT_COL(5)]) == dollar || ch == at_sign)) {

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(5)]);


         if (nxt_line[NXT_COL(6)] == zero) {
            nxt_line[NXT_COL(6)] = blank;
         }

         if ((ch = nxt_line[NXT_COL(6)]) != blank  && ch != tab) {
            
            if (IS_DIR_CONTINUATION(Cdir_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cdir_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {
            PP_IDX = NXT_COL(2);                        /* skip 'C' char      */
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cdir_Dir;
            PP_ACTUAL_DIR_PREFIX = Cdir_Dir;
            in_format = FALSE;
            idx = NXT_COL(6);
            do {
               ch = nxt_line[++idx];
            }
            while (ch == blank | ch == tab);

            if (ch == lc_f | ch == uc_f) {
               i = 0;
               while (i < 4) {
                  ch = nxt_line[++idx];
   
                  if (ch == newline) {
                     break;
                  }

                  if (! (ch == blank | ch == tab)) {
                     if (islower(ch)) {
                        form[i] = TOUPPER(ch);
                     }
                     else {
                        form[i] = ch;
                     }
                     i++;
                  }
               }

               if (strncmp(form, "REE ", 4) == 0 &&
                   !disregard_directive[Tok_Dir_Free-Tok_Dir_Start]) {
                  PP_CHANGE_SOURCE_FORM = TRUE;
               }
            }           
         }
      }
      else if (((ch = nxt_line[NXT_COL(2)]) == uc_m   || ch == lc_m) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_i   || ch == lc_i) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_c   || ch == lc_c) &&
               ((ch = nxt_line[NXT_COL(5)]) == dollar || ch == at_sign)) {

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(5)]);


         if ((ch = nxt_line[NXT_COL(6)]) != blank  && ch != tab) {
  
            if (IS_DIR_CONTINUATION(Cmic_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cmic_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                        /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cmic_Dir;
            PP_ACTUAL_DIR_PREFIX = Cmic_Dir;

            idx = NXT_COL(6);
         }
      }
      else if (((ch = nxt_line[NXT_COL(2)]) == dollar) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_o   || ch == lc_o) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_m   || ch == lc_m) &&
               ((ch = nxt_line[NXT_COL(5)]) == uc_p   || ch == lc_p)) {

         /* C$omp */

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);

         if (nxt_line[NXT_COL(6)] == zero) {
            nxt_line[NXT_COL(6)] = blank;
         }

         if ((ch = nxt_line[NXT_COL(6)]) != blank && ch != tab) {

            if (IS_DIR_CONTINUATION(Comp_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Comp_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Comp_Dir;
            PP_ACTUAL_DIR_PREFIX = Comp_Dir;

            idx = NXT_COL(6);

# if ! defined(_TARGET_OS_MAX)
            if (! dump_flags.open_mp &&
                ! on_off_flags.preprocess_only) {
               PP_LINE_TYPE = Comment_Line;
            }
# endif
         }
      }
# if defined(GENERATE_WHIRL)
      else if (((ch = nxt_line[NXT_COL(2)]) == dollar) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_s   || ch == lc_s) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_g   || ch == lc_g) &&
               ((ch = nxt_line[NXT_COL(5)]) == uc_i   || ch == lc_i)) {

         /* C$sgi */

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);

         if (nxt_line[NXT_COL(6)] == zero) {
            nxt_line[NXT_COL(6)] = blank;
         }

         if ((ch = nxt_line[NXT_COL(6)]) != blank && ch != tab) {

            if (IS_DIR_CONTINUATION(Comp_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Csgi_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Comp_Dir;
            PP_ACTUAL_DIR_PREFIX = Csgi_Dir;

            idx = NXT_COL(6);

            if (! dump_flags.open_mp &&
                ! on_off_flags.preprocess_only) {
               PP_LINE_TYPE = Comment_Line;
            }
         }
      }
      else if (((ch = nxt_line[NXT_COL(2)]) == dollar) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_o   || ch == lc_o) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_p   || ch == lc_p) &&
               ((ch = nxt_line[NXT_COL(5)]) == uc_e   || ch == lc_e) &&
               ((ch = nxt_line[NXT_COL(6)]) == uc_n   || ch == lc_n) &&
               ((ch = nxt_line[NXT_COL(7)]) == uc_a   || ch == lc_a) &&
               ((ch = nxt_line[NXT_COL(8)]) == uc_d   || ch == lc_d)) {
        
         /* eraxxon: OpenAD directive */
         /* C$OpenAD */

         PP_PREFIX_LEN = 7;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);

         if (nxt_line[NXT_COL(9)] == zero) {
            nxt_line[NXT_COL(9)] = blank;
         }

         if ((ch = nxt_line[NXT_COL(9)]) != blank && ch != tab) {

            if (IS_DIR_CONTINUATION(Copenad_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Copenad_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(9);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Copenad_Dir;
            PP_ACTUAL_DIR_PREFIX = Copenad_Dir;

            idx = NXT_COL(9);
         }
      }
# endif
      else if (((ch = nxt_line[NXT_COL(2)]) == dollar) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_p   || ch == lc_p) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_a   || ch == lc_a) &&
               ((ch = nxt_line[NXT_COL(5)]) == uc_r   || ch == lc_r)) {

         /* C$par */

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);

         if ((ch = nxt_line[NXT_COL(6)]) == amp) {

            if (IS_DIR_CONTINUATION(Cpar_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cpar_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cpar_Dir;
            PP_ACTUAL_DIR_PREFIX = Cpar_Dir;

            idx = NXT_COL(6);

            if ((! dump_flags.mp  &&
                 ! on_off_flags.preprocess_only) ||
                ! is_par_directive(idx)) {
               PP_LINE_TYPE = Comment_Line;
            }
         }
      }
      else if (((ch = nxt_line[NXT_COL(2)]) == star) &&
               ((ch = nxt_line[NXT_COL(3)]) == dollar) &&
               ((ch = nxt_line[NXT_COL(4)]) == star)) {

         /* C*$* */

         PP_PREFIX_LEN = 3;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(3)]);


         if ((ch = nxt_line[NXT_COL(5)]) == amp) {

            if (IS_DIR_CONTINUATION(Cstar_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cstar_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(5);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cstar_Dir;
            PP_ACTUAL_DIR_PREFIX = Cstar_Dir;

            idx = NXT_COL(5);

# if defined(GENERATE_WHIRL)
            if (! is_star_directive(idx)) {
               PP_LINE_TYPE = Comment_Line;
            }
# else
            if ((! dump_flags.mp &&
                 ! on_off_flags.preprocess_only) ||
                ! is_star_directive(idx)) {
               PP_LINE_TYPE = Comment_Line;
            }
# endif
         }
      }
      else if ((ch = nxt_line[NXT_COL(2)]) == dollar) {

         /* C$ */

         PP_PREFIX_LEN = 1;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);


         if ((ch = nxt_line[NXT_COL(3)]) == amp &&
             dump_flags.mp) {

            if (IS_DIR_CONTINUATION(Cdollar_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cdollar_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(3);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                   /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cdollar_Dir;
            PP_ACTUAL_DIR_PREFIX = Cdollar_Dir;

            idx = NXT_COL(3);

            if (dump_flags.mp &&
                is_dollar_directive(idx)) {
               /* intentionally blank */
            }
            else {
                
               ch = nxt_line[NXT_COL(3)];

               if (ch == ' '  ||
                   ch == '\t' ||
                   isdigit(ch)) {

                  PP_MP_LINE = TRUE;
               }

               if ((dump_flags.mp ||
                    dump_flags.open_mp ||
                    on_off_flags.preprocess_only) &&
                   ! cmd_line_flags.disregard_conditional_omp &&
                   PP_MP_LINE) {

                  nxt_line[NXT_COL(1)] = ' ';
                  nxt_line[NXT_COL(2)] = ' ';
                  goto START;
               }
               else {
                  PP_LINE_TYPE = Comment_Line;
                  PP_MP_LINE = FALSE;
               }
            }
         }
      }
# ifdef _DEBUG
      else if (((ch = nxt_line[NXT_COL(2)]) == uc_d   || ch == lc_d) &&
               ((ch = nxt_line[NXT_COL(3)]) == uc_b   || ch == lc_b) &&
               ((ch = nxt_line[NXT_COL(4)]) == uc_g   || ch == lc_g) &&
               ((ch = nxt_line[NXT_COL(5)]) == dollar)) {

         PP_PREFIX_LEN = 4;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */

         MARK_CHAR_CONST(nxt_line[NXT_COL(5)]);

         if ((ch = nxt_line[NXT_COL(6)]) != blank  && ch != tab) {
  
            if (IS_DIR_CONTINUATION(Cdbg_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cdbg_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(6);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(2);                        /* skip 'C' char      */
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cdbg_Dir;
            PP_ACTUAL_DIR_PREFIX = Cdbg_Dir;

            idx = NXT_COL(6);
         }
      }
# endif
      else {
         PP_LINE_TYPE = Comment_Line;
      }
   }
   else if (ch == star) {
      if ((ch = nxt_line[NXT_COL(2)]) == dollar &&
          (ch = nxt_line[NXT_COL(3)]) == star) {

         /* *$* */

         PP_PREFIX_LEN = 3;

         first_line = FALSE;

         /* mark the sign bit of the dollar or at_sign */
         MARK_CHAR_CONST(nxt_line[NXT_COL(2)]);


         if ((ch = nxt_line[NXT_COL(4)]) == amp) {

            if (IS_DIR_CONTINUATION(Cstar_Dir)) {

               PP_LINE_TYPE = Dir_Continuation_Line;
               PP_ACTUAL_DIR_PREFIX = Cstar_Dir;
               in_format = FALSE;
               PP_IDX  = NXT_COL(4);
            }
            else {
               PP_LINE_TYPE = Comment_Line;
            }
         }
         else {

            PP_IDX = NXT_COL(1);
            in_format = FALSE;
            PP_LINE_TYPE = Dir_Line;
            PP_DIR_PREFIX = Cstar_Dir;
            PP_ACTUAL_DIR_PREFIX = Cstar_Dir;

            idx = NXT_COL(4);

# if defined(GENERATE_WHIRL)
            if (! is_star_directive(idx)) {
               PP_LINE_TYPE = Comment_Line;
            }
# else
            if ((! dump_flags.mp &&
                 ! on_off_flags.preprocess_only) ||
                ! is_star_directive(idx)) {
               PP_LINE_TYPE = Comment_Line;
            }
# endif
         }
      }
      else {
         PP_LINE_TYPE = Comment_Line;
      }
   }
   else if (ch == bang  |  ch == star) {                /* column 1 '!' | '*' */
      PP_LINE_TYPE = Comment_Line;
   }
   else {                                               /* columns 2-72|80    */
      /* check for tab expansion character in label or continuation field */
      do {
         if (nxt_line[++PP_IDX] == tab) {

            /* DEC rules for tab expansion apply in label field */
            /*          C2345678     ->  C2345678               */
            /*          t1 + 27      ->       1 + 27            */
            /*           tI = 3      ->        I = 3            */
            /*          10tJ=5       ->  10    J=5              */
            /* where 't' is a tab character expanded to blanks  */

            if (IS_1TO9(nxt_line[PP_IDX+1])) { /* digits '1'..'9'   */
               cont_col = PP_IDX+1;
            }
            else {                                      /* stmt in next col   */
               cont_col = PP_IDX;
            }
         }
      }
      while (PP_IDX < cont_col);

      if (nxt_line[cont_col] == zero) {         /* '0' NOT a continue */
         nxt_line[cont_col] = blank;            /* convert to a blank */
      }

      PP_IDX = NXT_COL(NULL_IDX);                       /* beginning of line  */

      do {                                              /* find 1st non-blank */
         ch = nxt_line[++PP_IDX];
      }
      while (ch == blank  |  ch == tab);                /* skip white space   */
      
      if (ch == newline) {                              /* blank line         */
         PP_EOL = PP_IDX;
         PP_LINE_TYPE = Comment_Line;
      }
      else if (ch == bang) {                            /* comment ?          */
         if (PP_IDX == cont_col) {              /* continuation col   */
            PP_LINE_TYPE = Continuation_Line;
         }
         else {
            PP_LINE_TYPE = Comment_Line;
         }
      }
      else if (PP_IDX > cont_col) {             /* statement columns  */
         PP_IDX--;                              /* restore position   */
         PP_LINE_TYPE = Regular_Line;
         format_idx = -1;
         in_format = FALSE;
      }
      else if (PP_IDX < cont_col) {             /* label columns      */

         label = TRUE;

         /* verify that we've got numbers here */
         i = PP_IDX;
         while (i < cont_col) {

            if (nxt_line[i] == blank || 
                nxt_line[i] == tab   ||
                (nxt_line[i] >= zero && nxt_line[i] <= nine)) {
            
               i++;
            }
            else {
               label = FALSE;
               break;
            }
         }  

         if (label) {

            if (nxt_line[cont_col] != blank  && /* continuation too ? */
                nxt_line[cont_col] != tab)   {

               /* Continuation line must not contain a label. */

               if (issue_classify_msg) {
                  ntr_next_msg_queue(PP_LINE_NUM, 56, Error,
                                nxt_line_col[PP_IDX], 
                                (char *)NULL,
                                0,
                                NO_ARG);
               }

               PP_IDX  = cont_col;              /* set position       */
               PP_LINE_TYPE = Continuation_Line;
            }
            else {
               PP_LABEL = TRUE;
               PP_IDX--;                          /* restore position   */
               PP_LINE_TYPE = Regular_Line;
               format_idx    = 0;                       /* format possible    */
               in_format     = FALSE;
            }
         }
         else {

            /* Invalid characters found in label field. */

            if (issue_classify_msg) {
               ntr_next_msg_queue(PP_LINE_NUM, 400, Error,
                             nxt_line_col[PP_IDX],
                             (char *)NULL,
                             0,
                             NO_ARG);
            }

            if (nxt_line[cont_col] != blank  && /* continuation too ? */
                nxt_line[cont_col] != tab)   {
               PP_IDX  = cont_col;                /* set position       */
               PP_LINE_TYPE = Continuation_Line;
            }
            else {
               PP_IDX  = cont_col;                /* set position       */
               PP_LINE_TYPE = Regular_Line;
               format_idx    = -1;                      /* no label, no format*/
               in_format     = FALSE;
            }
         }
      }
      else {                                            /* continuation col   */
         PP_LINE_TYPE = Continuation_Line;

         if (! valid_f90_char[nxt_line[cont_col]] &&
             issue_classify_msg) {
            err_str[0] = nxt_line[cont_col];
            err_str[1] = '\0';
            ntr_next_msg_queue(PP_LINE_NUM, 799, Ansi, 
                          nxt_line_col[cont_col],
                          err_str,
                          0,
                          STR_ARG);
         }
      }

      if (first_line && PP_LINE_TYPE != Comment_Line) {

         if (PP_LINE_TYPE == Continuation_Line && issue_classify_msg) {
            ntr_next_msg_queue(PP_LINE_NUM, 211, Error,
                          nxt_line_col[cont_col],
                          (char *)NULL,
                          0,
                          NO_ARG);
         }

         first_line = FALSE;
      }
   }

   if (PP_LINE_TYPE == Regular_Line          |
       PP_LINE_TYPE == Dir_Line              |
       PP_LINE_TYPE == Dir_Continuation_Line |
       PP_LINE_TYPE == Continuation_Line)    {
      idx = NXT_COL(0);

      if (PP_LINE_TYPE != Continuation_Line      &&
          PP_LINE_TYPE != Dir_Continuation_Line) {
         previous_char = 0;
      }

      /* check for possible format stmt first.         */
      /* Format_idx is both a flag and an array index. */
      /* It is set to -1 when not expecting possible   */
      /* format stmt, set to 0 after encountering a    */
      /* label, and then is incremented up to 7 to test*/
      /* each letter in the string.                    */

      if (format_idx >= 0) {

         if (PP_IDX > cont_col) {
            idx = PP_IDX;
         }
         else {
            idx = cont_col;
         }

         ich = nxt_line[idx];
         while ((format_idx < 7) && (ich)) {

            do {
               ich = nxt_line[++idx];
            }
            while (ich == blank  |  ich == tab);

            if ((ich == newline) | (ich == bang)) {
               PP_EOL = idx;
               break;
            }
            if (! ((ich == format_str[format_idx][0]) |
                   (ich == format_str[format_idx][1]))) {
               format_idx = -1;
               idx--;
               break;
            }
            format_idx++;

         }

         if (format_idx == 7) {
            /* must be format stmt */
            in_format = TRUE;
            format_idx = -1;
            previous_char = ich;
         }
      } /* check for format line */

   /* mark all characters in character constant */
      if (format_idx < 0) {

         if (PP_LINE_TYPE != Continuation_Line      &&
             PP_LINE_TYPE != Dir_Continuation_Line) {
            char_delim = 0;
            digit_start = 0;
            seen_lp_eq_slash = FALSE;
         }

         if (idx == NXT_COL(0)) {
            idx = PP_IDX;
         }

         if (PP_LINE_TYPE == Continuation_Line &&
             prev_char_delim != 0               &&
             idx == cont_col                    &&
             nxt_line[idx + 1] == prev_char_delim) {

            /* set the character context flag on both this char */
            /* and the last one on the previous line.           */

            if (nxt_line_num_lines > 1) {
               MARK_CHAR_CONST(nxt_line[prev_char_delim_idx]);
            }
            else {
               MARK_CHAR_CONST(stmt_buf[stmt_line_start_idx[lines_in_buf] + 
                                     prev_char_delim_idx - 1]);
            }
            idx++;
            MARK_CHAR_CONST(nxt_line[idx]);
            nxt_line[idx] |= (1 << 9);

            /* reset char_delim to the previous char_delim */
            /* we are still in character context.          */

            char_delim = prev_char_delim;
         }

         prev_char_delim = 0;

         /* Char_delim will hold either the character that     */
         /* is the string delimiter, or negative the hollerith */
         /* count.                                             */

         do {
            while (char_delim == 0) {
               ich = nxt_line[++idx];

               /* skip thru blanks  */

               while ((ich == blank) |
                      (ich == tab))  {
                  ich = nxt_line[++idx];
               }

               /* Make tests on significant character.*/
               /* These tests are order sensitive!!   */

               if ((ich == newline) |
                   (ich == bang))   {           /* done for now. */
                  PP_EOL = idx;
                  idx = 0;
                  break;
               } 

               else if (ich == semi_colon) {            /* end of stmt   */
                  digit_start = 0;
                  in_format = FALSE;
                  seen_lp_eq_slash = FALSE;
               }

               else if ((ich == quote)     |
                        (ich == db_quote)) {            /* begin of ch const */
                  char_delim = ich;
                  digit_start = 0;
               }

               else if ((in_format) && (ich == star)) { /* also ch const */
                  char_delim = ich;
                  digit_start = 0;
               }

               else if (ich != EOF && 
                        ch_class[(char)ich] == Ch_Class_Digit) { /*possible holl*/

                  if (digit_start == 0) {

                     if (PP_LINE_TYPE != Continuation_Line      &&
                         PP_LINE_TYPE != Dir_Continuation_Line) {
                        digit_start = idx;
                     } 
                     else if (nxt_line_num_lines > 1) {
                        digit_start = idx;
                     }
                     else {
                        digit_start = stmt_line_end_idx[lines_in_buf] + idx;
                     }
                     num_idx = 0;
                  }
                  else {
                     num_idx++;
                  }
                  if (num_idx <= 4) {
                     num_str[num_idx] = ich;
                     num_str[num_idx + 1] = '\0';
                  }
                  /* if num_idx > 4 we've got some sort of error */
                  
                  continue;
               }

               else if ((ich == lparen) |      /* record weve seen these */
                        (ich == equal)  |
                        (ich == slash)) {
                  seen_lp_eq_slash = TRUE;
                  digit_start = 0;
               }

               /* check for hollerith, already seen number, (not label) */

               else if ((digit_start) && (previous_char)) {
                  if (in_format) {
                     if ((ich == lc_h) | (ich == uc_h)) {
                        /* have hollerith */
                        sscanf(num_str, "%d",&char_delim);
                        char_delim = - char_delim;
                     }
                  }
                  else if ((ich == lc_h)  |
                           (ich == lc_r)  |
                           (ich == lc_l)  |
                           (ich == uc_h)  |
                           (ich == uc_r)  |
                           (ich == uc_l)) {

                     if (previous_char == star) {

                        if (seen_lp_eq_slash) {
                           sscanf(num_str,"%d",&char_delim);
                           char_delim = - char_delim;
                        }
                     }
                     else if (previous_char == EOF) {

                        /* definately have hollerith */

                        sscanf(num_str,"%d",&char_delim);
                        char_delim = - char_delim;  
                     }
                     else if (ch_class[previous_char] != Ch_Class_Letter &&
                              previous_char != dollar &&
                              previous_char != at_sign &&
                              previous_char != underscore) {
                           sscanf(num_str,"%d",&char_delim);
                           char_delim = - char_delim;  
                     }
                  }
                  digit_start = 0;

               } /* if digit_start */

               /* end of tests, record this sig char     */

               previous_char = ich;

            } /* while (char_delim == 0) */
            

            /* found char constant so mark the characters */

            if (char_delim) {
               previous_char = ' ';

               /* char_delim < 0 means hollerith, - (length) is stored */

               if (char_delim < 0) {
                  /* I've got hollerith */
                  /* idx => h, r, or l */
                  for (; char_delim < 0; char_delim++) {
                     if (nxt_line[++idx] == newline) {
                        if (idx <= NXT_COL(PP_ORIG_SIZE)) {
                           shift_to_line_size((NXT_COL(PP_ORIG_SIZE)-idx)+1);
                           nxt_line[idx] = marked_blank;
                           for (i = idx + 1; i <= NXT_COL(PP_ORIG_SIZE); i++) {
                              nxt_line[i] = blank;
                           }
                           nxt_line[i] = newline;
                           PP_EOL = NXT_COL(PP_ORIG_SIZE) + 1;
                        }
                        else {
                           PP_EOL = idx;
                           idx = 0;
                           break;
                        }
                     }
                     else {
                        MARK_CHAR_CONST(nxt_line[idx]);
                     }
                  } /* for */
               }
               else {
                  
                  /* char_delim holds delimiter  */

                  while (TRUE) {
                     if (nxt_line[++idx] == newline) {
                        if (idx <= NXT_COL(PP_ORIG_SIZE)) {
                           shift_to_line_size((NXT_COL(PP_ORIG_SIZE)-idx)+1);
                           /* pad with blanks */
                           for (; idx <= NXT_COL(PP_ORIG_SIZE); idx++) {
                              nxt_line[idx] = marked_blank;
                           }
                           nxt_line[idx] = newline;
                        }
                        PP_EOL = NXT_COL(PP_ORIG_SIZE) + 1;
                        idx = 0;
                        break;
                     }
                     else if (nxt_line[idx] == char_delim) {
                        if (nxt_line[idx + 1] == char_delim) {
                           MARK_CHAR_CONST(nxt_line[idx]);
                           ++idx;
                           MARK_CHAR_CONST(nxt_line[idx]);
                           nxt_line[idx] |= (1 << 9);
                        }
                        else if (nxt_line[idx + 1] == newline &&
                                 idx == NXT_COL(PP_ORIG_SIZE)) {

                           prev_char_delim = char_delim;
                           prev_char_delim_idx = idx;
                           char_delim = 0;
                           break;
                        }
                        else {
                           /* end of char constant */
                           char_delim = 0;
                           break;
                        }
                     } else {
                        MARK_CHAR_CONST(nxt_line[idx]);
                     }
                  } /* while (1) */
               }

            } /* if char_delim != 0 */
         }
         while (idx);

      } /* if format_idx < 0 .... mark character constants */
   }  /* if reg or continue line */

   /* check regular lines for INCLUDE "filename" line */
   if (PP_LINE_TYPE == Regular_Line) {
      nxt_idx = cont_col;                               /* beginning of stmt  */

      do {                                              /* get 1st non-blank  */
         ch = nxt_line[++nxt_idx];
      }
      while (ch == blank  |  ch == tab);                /* skip white space   */

      if (ch == uc_i |  ch == lc_i) {           /* possible include   */
         incl_idx = NULL_IDX;

         do {
            ch_tmp = ch;
            if (islower(ch_tmp)) {                      /* lowercase char     */
               ch = TOUPPER(ch_tmp);                    /* cnvrt lwr to upr   */
            }
            include_file[incl_idx++] = ch;

            do {                                        /* get next non-blank */
               ch = nxt_line[++nxt_idx];
            }
            while (ch == blank  |  ch == tab);  /* skip white space   */
         }
         while (incl_idx < 7     &&  ch != eos);        /* get 7 chars or EOS */

         include_file[incl_idx] = EOS;          /* terminate text str */
 
         if (EQUAL_STRS(include_file, "INCLUDE")) {     /* match INCLUDE str  */
            if (ch == quote  |  ch == db_quote) {       /* have include line  */
               PP_LINE_TYPE = Comment_Line;

               /* get requested file name */
               delim       = ch;                        /* save delimiter     */
               incl_idx = NULL_IDX;

               while ((ch = nxt_line[++nxt_idx]) != delim && ch != eos) {
                  if (incl_idx < MAX_FILE_NAME_SIZE) {
                     include_file[incl_idx++] = ch;
                  }
                  else if (incl_idx == MAX_FILE_NAME_SIZE) {

                     /* Include file name length exceeds maximum. */

                     ntr_next_msg_queue(PP_LINE_NUM, 57, Error,
                                   nxt_line_col[nxt_idx],
                                   (char *)NULL,
                                   (MAX_FILE_NAME_SIZE - 1),
                                   ARG_ARG);
                  }
               }
               include_file[incl_idx] = eos;            /* terminate file name*/

               if (incl_idx == NULL_IDX) { /* Include file name missing. */
                  ntr_next_msg_queue(PP_LINE_NUM, 58, Error,
                                nxt_line_col[nxt_idx], 
                                (char *)NULL,
                                0,
                                NO_ARG);
               }
               else if (ch == eos) { /* Missing delimiter on include file name*/
                  ntr_next_msg_queue(PP_LINE_NUM, 59, Error,
                                nxt_line_col[NXT_COL(PP_ORIG_SIZE)],
                                (char *)NULL,
                                0,
                                NO_ARG);
               }
               else {                           /* check for comments */

                  do {
                     ch = nxt_line[++nxt_idx];
                  }
                  while (ch == blank     |  ch == tab);/* skip white space   */

                  if (ch != newline  &&  ch != bang) {  /* end of line     */

                     /* Text following include file name is not a comment. */

                     ntr_next_msg_queue(PP_LINE_NUM, 60, Error,
                                   nxt_line_col[nxt_idx],
                                   (char *)NULL,
                                   0,
                                   NO_ARG);
                  }
                  else if (PP_IDX < cont_col) { /* check for label   */

                     /* Include line must not contain a statement label. */

                     ntr_next_msg_queue(PP_LINE_NUM, 61, Error,
                                   nxt_line_col[PP_IDX],
                                   (char *)NULL,
                                   0,
                                   NO_ARG);
                  }
                  else {                                /* valid include line */
                     PP_LINE_TYPE = Include_Line;
                  }
               }  /* else */
            }  /* if */
         }  /* if */
      }  /* if */
   }     /* if */

   if (!issue_obsolete_src_form_msg && !PP_CHANGE_SOURCE_FORM &&
       issue_classify_msg) {
      issue_obsolete_src_form_msg = TRUE;
      ntr_next_msg_queue(PP_LINE_NUM, 1582, Comment, 0,
                         (char *)NULL,
                         0,
                         NO_ARG);
   }

   TRACE (Func_Exit, "fixed_classify_line", line_type_str[PP_LINE_TYPE]);

   return;

}  /* fixed_classify_line */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      Calls read_line to get the next line image from the currently         *|
|*      active source file.  An EOF line is returned when end of the input    *|
|*      source file is encountered.  Include lines cause a file switch.       *|
|*      End of include files are treated as comments.                         *|
|*                                                                            *|
|*      The line is classified as a comment, include, dir, regular, or        *|
|*      continuation line by calling free_classify_line.  Checks involving    *|
|*      relationships between lines (eg. continued followed by continuation)  *|
|*      are performed here.  Comment and include lines are not returned.      *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      expected_line           Regular_Line or Continuation_Line expected.   *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

static void free_get_stmt (void)

{
   int idx;
   int line_counter = 1;
   int loc_stmt_num;
   int save_idx;
   int stmt_buf_EOS;

   TRACE (Func_Entry, "free_get_stmt", NULL);

   /* Issue any deferred src_input messages.                                  */

   issue_deferred_msgs();


   if (stmt_buf_type == EOF_Line) {
      /* Attempt to read past end of file */
      PRINTMSG (0, 50, Internal, 0);                    /* all done now       */
   }

   stmt_line_idx = NULL_IDX;
   stmt_buf_idx = NULL_IDX;
   lines_in_buf = 0;
   label_ok = TRUE;

   /* loop while stmt continues */
   do {

      save_idx = 0;

      /* add nxt_line to stmt_buf */

      stmt_line_num[++stmt_line_idx] = nxt_line_num;

      /* stmt_line_offset holds offset to first significant char of line */

      if (starting_pt) {
         stmt_line_offset[stmt_line_idx] = starting_pt - 2;
      }
      else {
         stmt_line_offset[stmt_line_idx] = nxt_line_idx - 1;
      }

      /* stmt_line_start_idx points to where line starts in stmt_buf */

      stmt_line_start_idx[stmt_line_idx] = line_counter;

      /* stmt_line_end_idx points to newline, bang or ampersand */

      stmt_line_end_idx[stmt_line_idx] = nxt_line_EOL + line_counter - 1;

      /* record the statement type                                 */

      if (nxt_line_type != Continuation_Line      &&
          nxt_line_type != Dir_Continuation_Line) {
         stmt_buf_type = nxt_line_type;

         if (nxt_line_type == Dir_Line) {
            stmt_prefix_len = nxt_line_prefix_len;
            stmt_buf_dir_prefix = nxt_line_dir_prefix;
         }

         if (stmt_buf_type != Comment_Line &&
             stmt_buf_type != Pound_Src_Line &&
             stmt_buf_type != Pound_Include_Exit_Line) {
            INCREMENT_STATEMENT_NUMBER;
         }
      }

      if (stmt_buf_type == Dir_Line) {
         line_dir_prefix[stmt_line_idx] = nxt_line_actual_dir_prefix;
      }

      move_up_next_msg_queue();

      /* copy nxt_line to proper part of stmt_buf, backwards       */

      stmt_buf_idx = line_counter + nxt_line_EOL - 1;
      line_counter += nxt_line_EOL;

      for (idx = nxt_line_EOL; idx > 0; idx --) {
         stmt_buf[stmt_buf_idx] = nxt_line[NXT_COL(idx)];
         stmt_buf_col[stmt_buf_idx] = nxt_line_col[NXT_COL(idx)];
         stmt_buf_idx--;

         if (havent_issued_tab_ansi &&
             idx < nxt_line_EOL     &&
             nxt_line[NXT_COL(idx)] == tab) {
            havent_issued_tab_ansi = FALSE;
            ntr_msg_queue(nxt_line_num, 899, Ansi,
                          nxt_line_col[NXT_COL(idx)],
                          (char *)NULL,
                          0,
                          NO_ARG);
         }

         if (nxt_line[NXT_COL(idx)] == semi_colon &&
             stmt_buf_type != Dir_Line) {
            if ((idx > starting_pt) && (idx < nxt_line_EOL)) {
               save_idx = idx;
            }
         }
      }
 
      lines_in_buf++;

      /* save_idx is the point in nxt_line where the next ';' is */
      /* If there is a semi_colon then I don't replace nxt_line  */
      /* or classify it again. I simply recopy nxt_line into the */
      /* stmt_buf and start processing after the ;.              */
      /* Must check if nxt_line_type is a comment line because   */
      /* when an include file ends, comment lines come through.  */

      if (save_idx &&
          nxt_line_type != Comment_Line) {

         stmt_buf_EOS = save_idx;
         idx = save_idx;
         while ((nxt_line[NXT_COL(idx)] == semi_colon) |
                (nxt_line[NXT_COL(idx)] == blank)      |
                (nxt_line[NXT_COL(idx)] == tab))       {
            idx++;
         }

         /* starting_pt is the idx I start processing the next time around */

         starting_pt        = idx;
         nxt_line_type      = Regular_Line;
         continuation_count = 0;                /* clear cont counter */
         include_found      = FALSE;    /* and include flags  */
         include_complete   = FALSE;
      }
      else {
         stmt_buf_EOS = nxt_line_EOL;
         starting_pt = NULL_IDX;
      }


      /* don't read past end of source file */
      /* and don't get new nxt_line if had semi-colon. */

      if ((stmt_buf_type != EOF_Line) &&
          (starting_pt == NULL_IDX))       {

         /* get next line from src input file */
         do {

            nxt_line_type = Regular_Line;

            if (get_nxt_line ()) {              /* read next src line */

               if (include_switch) {
                  update_global_line ();        /* enter global_line_tbl */
                  include_switch = FALSE;
               }

               if (issue_pound_exit_line) {
                  OUTPUT_POUND_INCLUDE_EXIT_LINE(curr_glb_line);
                  issue_pound_exit_line = FALSE;
               }
   
               nxt_line_mp_line = FALSE;

               if (nxt_line_type != Cond_Comp_Line) {
                  PP_ORIG_SIZE = line_size;
                  classify_line();
               }

               if (on_off_flags.save_dot_i) {

                  if (ignore_source_line ||
                      nxt_line_type == Cond_Comp_Line ||
                      nxt_line_type == Include_Line) {

                     /* print blank line */
                     fprintf(dot_i_fptr, "\n");
                     previous_global_line++;
                  }
                  else {
                     print_nxt_line();
                  }
               }

               switch (nxt_line_type) {
                  case Comment_Line:                    /* ignore comments    */
                     break;
   
                  case Cond_Comp_Line:
                     if (parse_cc_line()) {

                        /* if result is true, then it was an include line */

                        nxt_line_type = Include_Line;
                        include_stmt_file_line = SRC_STK_FILE_LINE(src_stk_idx);

                        if (open_include_file (TRUE)) {
                           include_found  = TRUE;      /* flag begin of file */
                           include_switch = TRUE;      /* flag file switch   */
                        }
                     }
                     else {
                        nxt_line_type = Comment_Line;
                     }
                     angle_brkt_include = FALSE;
                     break;

                  case Dir_Line:
                  case Regular_Line:
                     continuation_count = 0;            /* clear cont counter */
                     include_found           = FALSE;   /* and include flags  */
                     include_complete   = FALSE;
                     break;
   
                  case Continuation_Line:
                  case Dir_Continuation_Line:

                     if (++continuation_count == MAX_ANSI_FREE_LINES) {

                      /* Too many continuation lines is non-standard in form. */

                        ntr_msg_queue(nxt_line_num, 52, Ansi,
                                      nxt_line_idx,
                                      "free",
                                      (MAX_ANSI_FREE_LINES - 1),
                                      ARG_STR_ARG);
                     }

                     if (continuation_count == MAX_FREE_LINES) {

                        /* this is it. I cn give ya na more powr cap'n */

                        ntr_msg_queue(nxt_line_num, 525, Error,
                                      CONTINUE_COLUMN,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
                     }

                     if (continuation_count >= MAX_FREE_LINES) {
                        nxt_line_type = Comment_Line;
                        break;
                     }
   
                     if (include_found) {

                       /* First line of included file must not be a cont line */
   
                        ntr_msg_queue(nxt_line_num, 53, Error,
                                      nxt_line_idx,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
   
                        include_found = FALSE;
                     }
       
                     if (include_complete) {

                     /* Nxt line of file after include must not be a cont line*/
   
                        ntr_msg_queue(nxt_line_num, 54, Error,
                                      nxt_line_idx,
                                      (char *)NULL,
                                      0,
                                      NO_ARG);
   
                        include_complete = FALSE;
                     }

                     if (cif_flags & MISC_RECS) {
                        cif_cont_line_rec(
                           (nxt_line_type == Continuation_Line) ? 0 : 1,
                           nxt_line_num);
                     }

                     break;
       
                  case Pound_Src_Line:
                     break;

                  case Pound_Include_Exit_Line:
                     include_complete = TRUE;
                     nxt_line_type         = Comment_Line;
                     curr_glb_line--;
                     SRC_STK_FILE_LINE(src_stk_idx)--;
                     GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                               SRC_STK_FILE_LINE(src_stk_idx);
                     set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));

                     if (source_form != SRC_STK_PREV_SRC_FORM(src_stk_idx)) {
                        change_source_form = TRUE;
                     }
                     POP_SRC;
                     include_switch = TRUE;
                     break;

                  case Pound_Include_Enter_Line:
                  case Include_Line:

                     include_stmt_file_line = SRC_STK_FILE_LINE(src_stk_idx);

                     if (open_include_file (FALSE)) {
                        include_found  = TRUE;          /* flag begin of file */
                        include_switch = TRUE;          /* flag file switch   */
                     }
                     break;
               }  /* switch */
            }
            else {                                      /* EOF on source file */

               /* need to bump pp_line_idx since classify_line was not called */

               if (cmd_line_flags.pp_macro_expansion) {
                  pp_line_idx++;
               }

               if (expected_line == Continuation_Line) {
                  ntr_msg_queue(stmt_line_num[lines_in_buf], 539, Error, 
                                stmt_line_end_idx[lines_in_buf] - 
                                          stmt_line_start_idx[lines_in_buf] + 1,
                                (char *)NULL,
                                0,
                                NO_ARG);
               }

               /* check for termination of include file */

               if (src_stk_idx > SRC_STK_BASE_IDX) {    /* curr src is include*/
                  include_complete      = TRUE;         /* flag end of file   */
                  nxt_line_type         = Comment_Line; /* make EOF a comment */
                  nxt_line_EOL = 2;
                  curr_glb_line--;            /* don't count this line */
   
                  GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                            SRC_STK_FILE_LINE(src_stk_idx);
                  set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));

                  if (source_form != SRC_STK_PREV_SRC_FORM(src_stk_idx)) {
                     change_source_form = TRUE;
                  }
                  POP_SRC;
                  include_switch = TRUE;                /* flag file switch   */
                  issue_pound_exit_line = TRUE;
                  break;
               }
               else {                                   /* curr src is input  */
                  GL_SOURCE_LINES(SRC_STK_GLOBAL_LINE_IDX(src_stk_idx)) =
                            SRC_STK_FILE_LINE(src_stk_idx);
                  set_related_gl_source_lines(
                                     SRC_STK_GLOBAL_LINE_IDX(src_stk_idx));
                  nxt_line_type = EOF_Line;             /* end of compilation */
                  nxt_line_EOL = 2;
               }
            }
         }
         while (nxt_line_type == Comment_Line | 
                nxt_line_type == Include_Line |
                nxt_line_type == Pound_Include_Enter_Line);
      }
   }
   while (nxt_line_type == Continuation_Line ||
          nxt_line_type == Dir_Continuation_Line);

   if (prev_statement_number != statement_number) {
      loc_stmt_num = statement_number;
      statement_number = prev_statement_number;
      prev_statement_number = loc_stmt_num;
   }

   stmt_buf_EOS_idx = stmt_line_start_idx[lines_in_buf] + stmt_buf_EOS - 1;
   stmt_EOS_la_ch.line = stmt_line_num[lines_in_buf];
   stmt_EOS_la_ch.column = stmt_buf_col[stmt_buf_EOS_idx];
   stmt_EOS_la_ch.stmt_buf_idx = stmt_buf_EOS_idx;
   stmt_EOS_la_ch.stmt_num = statement_number;

   stmt_buf_idx = stmt_line_offset[1] + 1;
   stmt_line_idx = SRC_STK_BASE_IDX;

   PRINT_STMT_SRC();    /* If DEBUG and -u src or -u stmt set print source */

   TRACE (Func_Exit, "free_get_stmt", NULL);

   return;

}  /* free_get_stmt */

/******************************************************************************\
|*                                                                            *|
|* Description:                                                               *|
|*      The line in the input buffer is classified as a comment, include,     *|
|*      dir, continuation or regular line.  Free source form rules apply.     *|
|*                                                                            *|
|* Input parameters:                                                          *|
|*      expected_line           Regular_Line or Continuation_Line expected.   *|
|*                                                                            *|
|* Output parameters:                                                         *|
|*      NONE                                                                  *|
|*                                                                            *|
|* Returns:                                                                   *|
|*      NOTHING                                                               *|
|*                                                                            *|
\******************************************************************************/

static void free_classify_line (void)

{
   int          ch;
   char         delim;
   char         form[5] = "     ";
   boolean      had_amp = FALSE;
   int          i;
   int          ich;
   int          idx;
   int          incl_idx;
   boolean      label_found     = FALSE;
   int          line_num;
   char         line_num_str[24];
   int          save_curr_glb_line;
   int          src_idx;
   int          sv_amp;



   TRACE (Func_Entry, "free_classify_line", NULL);

   PP_EOL = nxt_line_end_idx[pp_line_idx] - 1;
   PP_EXPECTED_LINE = expected_line;


START:

   ch = nxt_line[NXT_COL(1)];

# ifdef _FRONTEND_CONDITIONAL_COMP
   if (ch == pound  &&
       on_off_flags.preprocess) {

      PP_LINE_TYPE = Cond_Comp_Line;
   } else
# endif
   if (is_pound_line_dir()) {
      PP_IDX = NXT_COL(2);
      ch = nxt_line[PP_IDX];

      while (ch == blank | ch == tab) {
         PP_IDX++;
         ch = nxt_line[PP_IDX];
      }

      if (isdigit(ch)) {
         idx = 0;
         line_num_str[idx++] = ch;
         ch = nxt_line[++PP_IDX];
         while (isdigit(ch)) {
            line_num_str[idx++] = ch;
            ch =  nxt_line[++PP_IDX];
         }

         line_num_str[idx] = '\0';
         line_num = atoi(line_num_str);

         while (ch == blank | ch == tab) {
            PP_IDX++;
            ch = nxt_line[PP_IDX];
         }

         if (ch == quote | ch == db_quote) {
            char_delim = ch;
            ch =  nxt_line[++PP_IDX];

            idx = 0;
            while (ch != char_delim) {
               include_file[idx++] = ch;
               ch =  nxt_line[++PP_IDX];
            }
            include_file[idx] = '\0';

            ch =  nxt_line[++PP_IDX];
            while (ch == blank | ch == tab) {
               PP_IDX++;
               ch = nxt_line[PP_IDX];
            }

            if (ch == '1') {
               PP_LINE_TYPE = Pound_Include_Enter_Line;
            }
            else if (ch == '2') {
               PP_LINE_TYPE = Pound_Include_Exit_Line;
            }
            else {
               PP_LINE_TYPE = Comment_Line;

               /* reset the curr_glb_line */
               /* line_num is a file line, not a global line */

               save_curr_glb_line = curr_glb_line;
               curr_glb_line = line_num + GL_GLOBAL_LINE(global_line_tbl_idx) -
                             GL_FILE_LINE(global_line_tbl_idx);
               curr_glb_line--;

               if (first_pound_line) {
                  PP_LINE_TYPE = Pound_Src_Line;
                  change_orig_src_file = TRUE;
                  strcpy(pound_file, include_file);
               }
               else {
                  SRC_STK_FILE_LINE(src_stk_idx) +=
                                 curr_glb_line - save_curr_glb_line;
               }
            }

            first_pound_line = FALSE;

         }
         else if (ch == newline) {

            PP_LINE_TYPE = Comment_Line;

            /* reset the curr_glb_line */
            /* line_num is a file line, not a global line */

            save_curr_glb_line = curr_glb_line;
            curr_glb_line = line_num + GL_GLOBAL_LINE(global_line_tbl_idx) -
                          GL_FILE_LINE(global_line_tbl_idx);
            curr_glb_line--;

            SRC_STK_FILE_LINE(src_stk_idx) +=
                           curr_glb_line - save_curr_glb_line;

            first_pound_line = FALSE;
         }
         else {
            PP_LINE_TYPE = Comment_Line;
         }
      }
      else {
         PP_LINE_TYPE = Comment_Line;
      }
   }
   else if (ignore_source_line) {
      PP_LINE_TYPE = Comment_Line;
   }
   else {

   PP_IDX = NXT_COL(