Open64: osprey/crayf90/fe90/cmd

00001 /*
00002  *  Copyright (C) 2006. QLogic Corporation. All Rights Reserved.
00003  */
00004 
00005 /*
00006  * Copyright 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00007  */
00008 
00009 /*
00010 
00011   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00012 
00013   This program is free software; you can redistribute it and/or modify it
00014   under the terms of version 2 of the GNU General Public License as
00015   published by the Free Software Foundation.
00016 
00017   This program is distributed in the hope that it would be useful, but
00018   WITHOUT ANY WARRANTY; without even the implied warranty of
00019   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00020 
00021   Further, this software is distributed without any warranty that it is
00022   free of the rightful claim of any third person regarding infringement 
00023   or the like.  Any license provided herein, whether implied or 
00024   otherwise, applies only to this software file.  Patent licenses, if 
00025   any, provided herein do not apply to combinations of this program with 
00026   other software, or any other product whatsoever.  
00027 
00028   You should have received a copy of the GNU General Public License along
00029   with this program; if not, write the Free Software Foundation, Inc., 59
00030   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00031 
00032   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00033   Mountain View, CA 94043, or:
00034 
00035   http://www.sgi.com
00036 
00037   For further information regarding this notice, see:
00038 
00039   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00040 
00041 */
00042 
00043 
00044 
00045 static char USMID[] = "\n@(#)5.0_pl/sources/cmd_line.c  5.16  10/20/99 17:17:46\n";
00046 #ifdef KEY /* Bug 5089 */
00047 #include <libgen.h>
00048 #endif /* KEY Bug 5089 */
00049 # include "defines.h"   /* Machine dependent ifdefs */
00050 
00051 # include "host.m"    /* Host machine dependent macros.*/
00052 # include "host.h"    /* Host machine dependent header.*/
00053 # include "target.m"    /* Target machine dependent macros.*/
00054 # include "target.h"    /* Target machine dependent header.*/
00055 
00056 # include "globals.m"
00057 # include "tokens.m"
00058 # include "sytb.m"
00059 # include "src_input.m"
00060 # include "cmd_line.m"
00061 # include "debug.m"
00062 
00063 # include "globals.h"
00064 # include "tokens.h"
00065 # include "sytb.h"
00066 # include "cmd_line.h"
00067 #ifdef KEY /* F2003 */
00068 # include "defs.h"
00069 # include "config_targ.h"
00070 #endif /* KEY F2003 */
00071 
00072 /*****************************************************************\
00073 |* function prototypes of static functions declared in this file *|
00074 \*****************************************************************/
00075 
00076 extern  char                    release_level[];
00077 extern  char                    frontend_version[];
00078 
00079 
00080 static  void dump_help_screen (void);
00081 static  void init_cmd_line    (void);
00082 static  void process_A_option (char *);
00083 static  void process_a_option (char *);
00084 static  void process_b_option (char *);
00085 static  void process_C_option (char *, char *[]);
00086 static  void process_d_option (char *);
00087 static  void process_e_option (char *);
00088 static  void process_f_option (char *);
00089 static  void process_G_option (char *);
00090 static  void process_i_option (char *);
00091 static  void process_J_option (char *);
00092 static  void process_k_option (char *);
00093 static  void process_m_option (char *);
00094 static  void process_M_option (char *);
00095 static  void process_N_option (char *);
00096 static  void process_O_option (char *, int);
00097 static  void add_to_fp_table  (char *, int *, int);
00098 static  void process_P_option (char *);
00099 static  void process_q_option (char *);
00100 static  void process_r_option (char *);
00101 static  void process_R_option (char *);
00102 static  void process_s_option (char *);
00103 static  void process_S_option (char *);
00104 static  void process_t_option (char *);
00105 static  void process_u_option (char *);
00106 static  void process_v_option (char *);
00107 static  void process_x_option (char *);
00108 static  void process_X_option (char *);
00109 static  void process_Y_option (char *);
00110 static  void set_prog_file_names (char *argv[]);
00111 static  void validate_O_option (void);
00112 static  void validate_G_option (void);
00113 static  void validate_R_option (void);
00114 static  void validate_s_option (void);
00115 static  void process_D_option(char *);
00116 static  void process_U_option(char *);
00117 extern  void process_v_dbg_flags(char *);
00118 static  void set_system_module_path( void );
00119 static  void process_reshape_array(char *);
00120 static  void dump_options(void);
00121 
00122 /******************************************************************************\
00123 |*                        *|
00124 |* Description:                     *|
00125 |*  Process_cmd_line is called to accept and validate command line        *|
00126 |*  options and arguments to change compiler flags.           *|
00127 |*                        *|
00128 |* Input parameters:                    *|
00129 |*  argc      number of command line arguments        *|
00130 |*  argv      argument strings            *|
00131 |*  nlspath     value of getenv(NLSPATH)          *|
00132 |*                        *|
00133 |* Output parameters:                   *|
00134 |*  NONE                      *|
00135 |*                        *|
00136 |* Returns:                     *|
00137 |*  NOTHING                     *|
00138 |*                        *|
00139 \******************************************************************************/
00140   
00141 #ifdef KEY /* Bug 5089 */
00142 void  process_cmd_line(int   argc, char *argv[], char *nlspath)
00143 #else /* KEY Bug 5089 */
00144 void  process_cmd_line(int   argc, char *argv[])
00145 #endif /* KEY Bug 5089 */
00146 {
00147    char   err_char;
00148    int    err_ind;
00149    extern char *optarg;         /* defined in getopt  */
00150    extern int opterr;         /* defined in getopt  */
00151    extern int optind;         /* defined in getopt  */
00152    extern int optopt;         /* defined in getopt  */
00153    int    option;
00154    int    i;
00155 
00156    int    save_argc;
00157 
00158 
00159 /******************************************************************************/
00160 /*                        */
00161 /* NOTE:                      */
00162 /*    To add a new commandline option to the compiler, you must add the letter*/
00163 /*    to opt_string.  Any letter you add must go in the list alphabetically.  */
00164 /*    Those that have args must have a colon follwing.  Those that do not have*/
00165 /*    args must NOT have a colon following.  Currently they are -g, -V and -Z */
00166 /*                        */
00167 /******************************************************************************/
00168 
00169    char *opt_string="a:b:d:e:f:ghi:k:m:p:q:r:s:t:u:v:x:"
00170                     "A:C:D:FG:I:J:M:N:O:P:R:S:T:U:Y:X:VZ";
00171 
00172    char  str[7];
00173 
00174 
00175    TRACE (Func_Entry, "process_cmd_line", NULL);
00176 
00177    save_argc = argc;
00178 
00179    opterr = 0;            /* disable lib msgs   */
00180 
00181    init_cmd_line ();
00182 
00183 # ifdef _DEBUG
00184 # ifdef _ENABLE_FEI
00185    str[0] = 'N';
00186    str[1] = '\0';
00187    process_v_dbg_flags (str); /* pass -vN always */
00188 # endif
00189 # endif
00190 
00191    err_ind = optind;
00192 
00193    while ((option = getopt (argc, argv, opt_string)) != EOF) {
00194 
00195       switch (option) {
00196 
00197          case 'a':          /* memory options     */
00198       process_a_option (optarg);
00199             break;
00200 
00201    case 'b':          /* binary file name   */
00202       process_b_option (optarg);
00203       break;
00204 
00205    case 'd':          /* off flags        */
00206       process_d_option (optarg);
00207       break;
00208 
00209    case 'e':          /* on flags       */
00210       process_e_option (optarg);
00211       break;
00212     
00213    case 'f':          /* source form        */
00214       process_f_option (optarg);
00215       break;
00216     
00217    case 'g':          /* -G 0               */
00218             cmd_line_flags.debug_lvl = Debug_Lvl_0;
00219       break;
00220 
00221          case 'h':
00222             dump_options();
00223       return; 
00224     
00225    case 'i':          /* integer size       */
00226       process_i_option (optarg);
00227       break;
00228 
00229          case 'k':          /* Solaris profiling  */
00230       process_k_option (optarg);
00231             break;
00232 
00233       /* When the -l option is implemented (to specify what file the CIF      */
00234       /* output should go to), also update cif_misc_compiler_opts_rec in      */
00235       /* cif.c.                     */
00236       /*                      */
00237       /* case 'l':             CIF name       */
00238       /*    break;                    */
00239 
00240    case 'm':          /* msg level suppr'd  */
00241       process_m_option (optarg);
00242       break;
00243 
00244    case 'O':          /* optimization opts  */
00245             process_O_option (optarg, argc);
00246       break;
00247 
00248    case 'p':          /* module path name  */
00249       add_to_fp_table (optarg, &module_path_idx, option);
00250       break;
00251 
00252    case 'q':          /* expression eval    */
00253       process_q_option (optarg);
00254       break;
00255 
00256    case 'r':          /* list options       */
00257       process_r_option (optarg);
00258       break;
00259 
00260    case 'R':          /* runtime checking   */
00261       process_R_option (optarg);
00262       break;
00263 
00264    case 's':          /* type size option   */
00265       process_s_option (optarg);
00266       break;
00267 
00268    case 'S':          /* cal file name      */
00269       process_S_option (optarg);
00270       break;
00271 
00272    case 't':          /* truncate bits      */
00273       process_t_option (optarg);
00274       break;
00275 
00276    case 'u':          /* debug dump flags   */
00277       process_u_option (optarg);
00278       break;
00279 
00280          case 'v':          /* PDGCS debug opts   */
00281             process_v_option (optarg);
00282             break;
00283 
00284          case 'A':          /* implicit use       */
00285       process_A_option (optarg);
00286             break;
00287 
00288    case 'C':          /* CIF flags        */
00289       process_C_option (optarg, argv);
00290       break;
00291 
00292          case 'D':          /* DEFINE */
00293 # ifdef _FRONTEND_CONDITIONAL_COMP
00294             process_D_option (optarg);
00295 # endif
00296             break;
00297 
00298    case 'x':          /* disregard CDIRs    */
00299       process_x_option (optarg);
00300       break;
00301 
00302    case 'F':          /* fortran macro exp */
00303 # ifdef _FRONTEND_CONDITIONAL_COMP
00304       cmd_line_flags.pp_macro_expansion = TRUE;
00305             on_off_flags.preprocess = TRUE;
00306 # endif
00307       break;
00308     
00309     
00310    case 'G':          /* debug option       */
00311       process_G_option (optarg);
00312       break;
00313     
00314    case 'I':          /* include option     */
00315             add_to_fp_table(optarg, &include_path_idx, option);
00316       break;
00317 
00318    case 'J':          /* .mod output locate */
00319       process_J_option (optarg);
00320       break;
00321 
00322    case 'M':          /* disable msg numbers*/
00323       process_M_option (optarg);
00324       break;
00325     
00326    case 'N':          /* fixed line size    */
00327       process_N_option (optarg);
00328       break;
00329 
00330    case 'P':          /* position independ  */
00331       process_P_option (optarg);
00332       break;
00333     
00334          case 'U':          /* UNDEF */
00335 # ifdef _FRONTEND_CONDITIONAL_COMP
00336             process_U_option (optarg);
00337 # endif
00338             break;
00339 
00340    case 'V':          /* version option     */
00341             cmd_line_flags.verify_option = TRUE;
00342       break;
00343 
00344    case 'X':          /* MPP num PE's opt   */
00345       process_X_option (optarg);
00346       break;
00347 
00348    case 'Y':
00349       process_Y_option (optarg);      /* ccg debug options  */
00350       break;
00351 
00352 # ifdef _F_MINUS_MINUS
00353          case 'Z':
00354             cmd_line_flags.co_array_fortran = TRUE;
00355             dump_flags.f_minus_minus    = TRUE;
00356             dump_flags.fmm1     = TRUE;
00357           break;
00358 # endif
00359 
00360    default:     /* Command line has an invalid option. */
00361 
00362             err_char = argv[err_ind][1];
00363 
00364             if (err_char == 'O') {
00365 
00366                /* Accept -O with no arguments.  It means use defaults. */
00367                /* Intentionally blank */
00368 
00369                ntr_msg_queue(0, 1221, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00370             }
00371             else {
00372                err_char = optopt;
00373                ntr_msg_queue(0, 77, Log_Error, 0, 
00374                              (char *) NULL, optopt, ARG_ARG);
00375             }
00376       break;
00377       }  /* switch */
00378 
00379       err_ind = optind;
00380    }  /* while */
00381 
00382 #  ifdef KEY /* Bug 4210 */
00383    /* We want to prepend the module-creation directory to the module-search-path
00384     * list. Note that the SGI command-line processing turns each -Idir option
00385     * into a -include=dir option plus a -pdir option. Here we want to imitate
00386     * the -pdir processing, except we prepend instead of appending.
00387     */
00388    add_to_fp_table(mod_out_path, &module_path_idx, 'J');
00389 #  endif /* KEY Bug 4210 */
00390 #  ifdef KEY /* Bug 5545 */
00391    /* Append /usr/include to include-search-path list, so that ftpp behaves
00392     * like cpp */
00393    add_to_fp_table("/usr/include", &include_path_idx, 'I');
00394 #  endif /* KEY Bug 5545 */
00395 #ifdef KEY /* Bug 5089 */
00396    /* If -intrinsic_module_path was not set but the NLSPATH environment
00397     * variable is set, use the last directory in NLSPATH (the driver
00398     * appends to any user-set NLSPATH the directory containing the file
00399     * cf95.cat, which also contains IEEE*.mod.) We ignore any user-specified
00400     * directory, which might have nothing to do with pathf90; a user who
00401     * wants to override the driver's choice should use -intrinsic_module_path.
00402     */
00403    if (NULL_IDX == intrinsic_module_path_idx && nlspath && *nlspath) {
00404      char *path = strrchr(nlspath, ':');
00405      path = path ? (path + 1) : nlspath;
00406 #    define DIR_M32 "/32"
00407      char *copy = malloc(strlen(path) + sizeof DIR_M32);
00408      add_to_fp_table(
00409        strcat(dirname(strcpy(copy, path)), (Is_Target_32bit() ? "/32" : "")),
00410        &intrinsic_module_path_idx, 'p');
00411      free(copy);
00412    }
00413 #endif /* KEY Bug 5089 */
00414 
00415 # ifdef _DEBUG
00416    if (dump_flags.help_dbg) {
00417       dump_help_screen();
00418    }
00419 # endif
00420 
00421    if (argc == 2  &&  cmd_line_flags.verify_option) {
00422 
00423       /* cft90 call only requests compiler version info.    */
00424       /* message will be produced by init_compiler in main. */
00425    }
00426    else {
00427 
00428       if (on_off_flags.MPP_apprentice) {
00429          cif_flags = cif_flags | ALL_RECS      |
00430                                  XREF_RECS     | MISC_RECS |
00431                                  MESSAGE_RECS  | INFO_RECS |
00432                                  BASIC_RECS    | COMPILER_RECS;
00433       }
00434 
00435 #     if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
00436 
00437          if (dump_flags.cray_compatible) {
00438             cmd_line_flags.s_default64 = TRUE;
00439          }
00440 #     endif
00441 
00442       if (on_off_flags.all_debug) {  /* Turn on all debugging options. */
00443 
00444          /* -eD implies -O0 -G0 -ei -m2 -RabcsCE -rl */
00445 
00446          opt_flags.support_lvl      = 0;
00447          cmd_line_flags.debug_lvl   = Debug_Lvl_0;
00448          on_off_flags.indef_init    = TRUE;
00449          cmd_line_flags.msg_lvl_suppressed  = Caution_Lvl;
00450          cmd_line_flags.runtime_argument        = TRUE;
00451          cmd_line_flags.runtime_bounds          = TRUE;
00452          cmd_line_flags.runtime_conformance     = TRUE;
00453          cmd_line_flags.runtime_substring       = TRUE;
00454          cmd_line_flags.runtime_ptr_chk         = TRUE;
00455          cmd_line_flags.runtime_arg_call        = TRUE;
00456          cmd_line_flags.runtime_arg_entry       = TRUE;
00457          cif_flags = cif_flags | ALL_RECS      |
00458                                  XREF_RECS     | MISC_RECS |
00459                                  MESSAGE_RECS  | INFO_RECS |
00460                                  BASIC_RECS    | COMPILER_RECS;
00461          cif_C_opts = cif_C_opts | ALL_RECS;
00462 
00463          if (on_off_flags.zero_init) {  /* Conflict - issue warning */
00464             on_off_flags.zero_init = FALSE;
00465             ntr_msg_queue(0, 1313, Log_Warning, 0, "ei\ne0", 0,MULT_STR_ARG);
00466          }
00467 
00468          if (! set_scalar_option) {
00469             opt_flags.scalar_lvl = Scalar_Lvl_0;
00470          }
00471 
00472 #        if defined(_ACCEPT_VECTOR)
00473 
00474          if (! set_vector_option) {
00475             opt_flags.vector_lvl = Vector_Lvl_0;
00476          }
00477 
00478 #        endif
00479 
00480 #        if defined(_ACCEPT_TASK)
00481 
00482          if (! set_task_option) {
00483             opt_flags.task_lvl = Task_Lvl_0;
00484          }
00485 #        endif
00486 
00487 #        if defined(_ACCEPT_STREAM)
00488 
00489          if (! set_stream_option) {
00490             opt_flags.stream_lvl = Stream_Lvl_0;
00491          }
00492 
00493 #        endif
00494       }
00495 
00496       /* Validate G before O, because G can override O levels. */
00497 
00498       if (cmd_line_flags.debug_lvl < No_Debugging) {
00499          validate_G_option ();
00500       }
00501 
00502       validate_O_option ();
00503       validate_R_option ();
00504       validate_s_option ();
00505 
00506       if (cmd_line_flags.align32 && cmd_line_flags.align64) {
00507          cmd_line_flags.align32   = FALSE;
00508          ntr_msg_queue(0, 1353, Log_Warning, 0, 
00509                        "-a align32\n-a align64\n-a align32",
00510                        0, MULT_STR_ARG);
00511       }
00512 
00513       if (target_ieee) {
00514 
00515          if (set_ieeeconform_option && opt_flags.ieeeconform && 
00516              !on_off_flags.eu) {
00517             on_off_flags.eu = FALSE;
00518 
00519             if (set_eu_option) {  /* -du has been specified. */
00520                ntr_msg_queue(0, 1215, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00521             }
00522             else {                /* -du is default. */
00523                ntr_msg_queue(0, 1216, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00524             }
00525          }
00526 
00527          if (opt_flags.ieeeconform) {
00528             on_off_flags.reciprical_divide = FALSE;
00529          }
00530          else {
00531             on_off_flags.reciprical_divide = !on_off_flags.eu;
00532          }
00533       }
00534       else {
00535          on_off_flags.round_integer_divide = on_off_flags.eu;
00536       }
00537 
00538       if (on_off_flags.assembly_listing_file && !cmd_line_flags.binary_output) {
00539          cmd_line_flags.binary_output = TRUE;
00540          ntr_msg_queue(0, 913, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00541       }
00542 
00543       if (cmd_line_flags.co_array_fortran) {
00544 # if defined(_TASK_COMMON_EXTENSION)
00545          cmd_line_flags.taskcommon  = TRUE;
00546 # endif
00547          opt_flags.task_lvl   = Task_Lvl_0;
00548       }
00549 
00550 # if defined(_NO_BINARY_OUTPUT)
00551       binary_output = FALSE;
00552       assembly_output = cmd_line_flags.binary_output ||
00553                           cmd_line_flags.assembly_output;
00554 # else
00555       binary_output = cmd_line_flags.binary_output;
00556       assembly_output = cmd_line_flags.assembly_output;
00557 # endif
00558 
00559 /*
00560       if (no_preprocessing) {
00561          on_off_flags.preprocess = FALSE;
00562          on_off_flags.preprocess_only = FALSE;
00563          on_off_flags.save_dot_i = FALSE;
00564       }
00565 */
00566 
00567       set_prog_file_names (argv);
00568 
00569       if (optind < (argc-1)) { /* Options not allowed after input file name. */
00570          ntr_msg_queue(0, 79, Log_Error, 0, (char *) NULL, 0, NO_ARG);
00571       }
00572    }
00573 
00574    if (cmd_line_flags.mod_out_path && !on_off_flags.module_to_mod) {
00575 
00576       /* Must specify -em to specify -J */
00577 
00578       ntr_msg_queue(0, 1658, Log_Error, 0, (char *) NULL, 0, NO_ARG);
00579    }
00580 
00581    PRINT_CMD_LINE_TBLS;  /* Will print if -u cmd is specified for a DEBUG comp*/
00582 
00583    if (dump_flags.show_cmd_line) {
00584       printf("\n");
00585       for (i = 0; i < save_argc; i++) {
00586          printf("%s ", argv[i]);
00587       }
00588       printf("\n\n");
00589    }
00590 
00591    issue_deferred_msgs();
00592 
00593    TRACE (Func_Exit, "process_cmd_line", NULL);
00594 
00595    return;
00596   
00597 }  /* process_cmd_line */
00598 
00599 
00600 /******************************************************************************\
00601 |*                        *|
00602 |* Description:                     *|
00603 |*  Validate_G_option is called to check the combination of debug options *|
00604 |*  and optimization options.               *|
00605 |*                        *|
00606 |* Input parameters:                    *|
00607 |*  NONE                      *|
00608 |*                        *|
00609 |* Output parameters:                   *|
00610 |*  NONE                      *|
00611 |*                        *|
00612 |* Returns:                     *|
00613 |*  NOTHING                     *|
00614 |*                        *|
00615 \******************************************************************************/
00616 
00617 static void validate_G_option (void)
00618 {
00619 /* KAY - This routine needs help.  It doesn't appear to be finished. */
00620 
00621    int    correct_scalar_lvl;
00622    int    correct_vector_lvl;
00623    int    correct_task_lvl;
00624    int    debug_lvl;
00625 
00626 
00627    TRACE (Func_Entry, "validate_G_option", NULL);
00628 
00629    if (!cmd_line_flags.binary_output) {
00630 
00631 # if !defined(_NO_BINARY_OUTPUT)
00632 
00633       /* Warning - binary output needs to be on for debugging. */
00634 
00635       ntr_msg_queue(0, 82, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00636       cmd_line_flags.assembly_output  = FALSE;
00637       cmd_line_flags.binary_output  = TRUE;
00638 # endif
00639 
00640    }
00641 
00642    switch (cmd_line_flags.debug_lvl) {
00643    case Debug_Lvl_0:
00644 
00645       if (set_scalar_option && opt_flags.scalar_lvl > Scalar_Lvl_0) {
00646          ntr_msg_queue(0, 1536, Log_Warning, 0,
00647                        scalar_lvl_str[Scalar_Lvl_0], 
00648                        Debug_Lvl_0, STR_ARG_ARG);
00649       }
00650 
00651       if (set_vector_option && opt_flags.vector_lvl > Vector_Lvl_0) {
00652         ntr_msg_queue(0, 1536, Log_Warning, 0,
00653                        vector_lvl_str[Vector_Lvl_0], 
00654                        Debug_Lvl_0, STR_ARG_ARG);
00655       }
00656 
00657       if (set_stream_option && opt_flags.stream_lvl > Stream_Lvl_0) {
00658          ntr_msg_queue(0, 1536, Log_Warning, 0,
00659                        stream_lvl_str[Stream_Lvl_0], 
00660                        Debug_Lvl_0, STR_ARG_ARG);
00661       }
00662 
00663       if (set_task_option && opt_flags.task_lvl > Task_Lvl_0) {
00664          ntr_msg_queue(0, 1536, Log_Warning, 0,
00665                        task_lvl_str[Task_Lvl_0], 
00666                        Debug_Lvl_0, STR_ARG_ARG);
00667       }
00668 
00669       if (set_support_lvl_option && opt_flags.support_lvl > 0) {
00670          ntr_msg_queue(0, 1536, Log_Warning, 0,
00671                        "-O0", Debug_Lvl_0, STR_ARG_ARG);
00672       }
00673 
00674       if (opt_flags.inline_lvl > Inline_Lvl_0 ||
00675           set_inlinefrom_option) {
00676          ntr_msg_queue(0, 1199, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00677       }
00678 
00679       cmd_line_flags.do_UDB_checks  = opt_flags.scalar_lvl > Scalar_Lvl_0;
00680       opt_flags.scalar_lvl    = Scalar_Lvl_0;
00681       opt_flags.stream_lvl    = Stream_Lvl_0;
00682       opt_flags.vector_lvl    = Vector_Lvl_0;
00683       opt_flags.task_lvl    = Task_Lvl_0;
00684       opt_flags.inline_lvl    = Inline_Lvl_0; 
00685       opt_flags.support_lvl   = 0;
00686 
00687       if (set_aggress_option) {
00688          ntr_msg_queue(0, 1069, Log_Warning, 0,
00689                        "aggress", Debug_Lvl_0, STR_ARG_ARG);
00690       }
00691 
00692       if (set_bottom_load_option) {
00693          ntr_msg_queue(0, 1069, Log_Warning, 0,
00694                        "bl", Debug_Lvl_0, STR_ARG_ARG);
00695       }
00696 
00697       if (set_loop_align_option) {
00698          ntr_msg_queue(0, 1069, Log_Warning, 0,
00699                        "loopalign", Debug_Lvl_0, STR_ARG_ARG);
00700       }
00701 
00702       if (set_pattern_option) {
00703          ntr_msg_queue(0, 1069, Log_Warning, 0,
00704                        "pattern", Debug_Lvl_0, STR_ARG_ARG);
00705       }
00706 
00707       if (set_pipeline_option) {
00708          ntr_msg_queue(0, 1069, Log_Warning, 0,
00709                        "pipeline", Debug_Lvl_0, STR_ARG_ARG);
00710       }
00711 
00712       if (set_recurrence_option) {
00713          ntr_msg_queue(0, 1069, Log_Warning, 0,
00714                        "recurrence", Debug_Lvl_0, STR_ARG_ARG);
00715       }
00716 
00717       if (set_vsearch_option) {
00718          ntr_msg_queue(0, 1069, Log_Warning, 0,
00719                        "vsearch", Debug_Lvl_0, STR_ARG_ARG);
00720       }
00721 
00722       if (set_zeroinc_option) {
00723          ntr_msg_queue(0, 1069, Log_Warning, 0,
00724                        "zeroinc", Debug_Lvl_0, STR_ARG_ARG);
00725       }
00726 
00727       opt_flags.aggress   = FALSE;
00728       opt_flags.bottom_load = FALSE;
00729       opt_flags.loopalign = FALSE;
00730       opt_flags.recurrence  = FALSE;
00731       opt_flags.pattern   = FALSE;
00732       opt_flags.pipeline_lvl  = 0;
00733       opt_flags.vsearch   = FALSE;
00734       opt_flags.zeroinc   = FALSE;
00735       set_debug_option    = TRUE;
00736       break;
00737 
00738 
00739    case Debug_Lvl_1:
00740 
00741       debug_lvl     = Debug_Lvl_1;
00742       set_debug_option    = TRUE;
00743 
00744       if (opt_flags.scalar_lvl > Scalar_Lvl_2) {
00745 
00746          if (set_scalar_option) {
00747             ntr_msg_queue(0, 1536, Log_Warning, 0,
00748                           scalar_lvl_str[Scalar_Lvl_2], 
00749                           Debug_Lvl_1, STR_ARG_ARG);
00750          }
00751          opt_flags.scalar_lvl = Scalar_Lvl_2;
00752       }
00753 
00754       if (opt_flags.inline_lvl > Inline_Lvl_0 ||
00755           set_inlinefrom_option) {
00756          opt_flags.inline_lvl = Inline_Lvl_0; 
00757          ntr_msg_queue(0, 1199, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
00758       }
00759 
00760 # if defined(_ACCEPT_STREAM)
00761 
00762       if (opt_flags.stream_lvl > Stream_Lvl_1) {
00763 
00764          if (set_stream_option) {
00765             ntr_msg_queue(0, 1536, Log_Warning, 0,
00766                           stream_lvl_str[Stream_Lvl_1], 
00767                           Debug_Lvl_1, STR_ARG_ARG);
00768          }
00769 
00770          opt_flags.stream_lvl = Stream_Lvl_1;
00771       }
00772 # endif
00773 
00774 
00775 # if defined(_ACCEPT_VECTOR)
00776 
00777       if (opt_flags.vector_lvl > Vector_Lvl_1) {
00778 
00779          if (set_vector_option) {
00780             ntr_msg_queue(0, 1536, Log_Warning, 0,
00781                           vector_lvl_str[Vector_Lvl_1], 
00782                           Debug_Lvl_1, STR_ARG_ARG);
00783          }
00784 
00785          opt_flags.vector_lvl = Vector_Lvl_1;
00786       }
00787 # endif
00788 
00789       if (set_support_lvl_option && opt_flags.support_lvl > 1) {
00790          ntr_msg_queue(0, 1536, Log_Warning, 0,
00791                        "-O1", Debug_Lvl_1, STR_ARG_ARG);
00792          opt_flags.support_lvl  = 1;
00793       }
00794 
00795       break;
00796 
00797 
00798    case Debug_Lvl_2:
00799 
00800       set_debug_option    = TRUE;
00801       correct_vector_lvl  = Vector_Lvl_3;
00802       correct_task_lvl    = Task_Lvl_3;
00803       correct_scalar_lvl  = Scalar_Lvl_3;
00804       debug_lvl     = Debug_Lvl_2;
00805       break;
00806 
00807    case Debug_Lvl_3:
00808 
00809       /* Ignore these for now.  gsf says -G doesn't affect levels */
00810 
00811       correct_vector_lvl  = Vector_Lvl_3;
00812       correct_task_lvl    = Task_Lvl_3;
00813       correct_scalar_lvl  = Scalar_Lvl_3;
00814       debug_lvl     = Debug_Lvl_3;
00815       break;
00816    }
00817 
00818    TRACE (Func_Exit, "validate_G_option", NULL);
00819 
00820    return;
00821 
00822 }  /* validate_G_option */
00823 
00824 /******************************************************************************\
00825 |*                        *|
00826 |* Description:                     *|
00827 |*  <description>                   *|
00828 |*                        *|
00829 |* Input parameters:                    *|
00830 |*  NONE                      *|
00831 |*                        *|
00832 |* Output parameters:                   *|
00833 |*  NONE                      *|
00834 |*                        *|
00835 |* Returns:                     *|
00836 |*  NOTHING                     *|
00837 |*                        *|
00838 \******************************************************************************/
00839 
00840 static void validate_R_option( void )
00841 
00842 {
00843 
00844 
00845    TRACE (Func_Entry, "validate_R_option", NULL);
00846 
00847    if (cmd_line_flags.runtime_arg_count_only &&
00848        ! cmd_line_flags.runtime_argument &&
00849        ! cmd_line_flags.runtime_arg_call &&
00850        ! cmd_line_flags.runtime_arg_entry) {
00851 
00852       cmd_line_flags.runtime_argument = TRUE;
00853    }
00854 
00855    TRACE (Func_Exit, "validate_R_option", NULL);
00856 
00857    return;
00858 
00859 }  /* validate_R_option */
00860 
00861 /******************************************************************************\
00862 |*                        *|
00863 |* Description:                     *|
00864 |*  Init_flags is called to set all flag structs to their default values. *|
00865 |*  These flags control the compiler.  The user is able to change any of  *|
00866 |*  these flag values through commmand line options and compiler        *|
00867 |*  directives.                   *|
00868 |*                        *|
00869 |* Input parameters:                    *|
00870 |*  NONE                      *|
00871 |*                        *|
00872 |* Output parameters:                   *|
00873 |*  NONE                      *|
00874 |*                        *|
00875 |* Returns:                     *|
00876 |*  NOTHING                     *|
00877 |*                        *|
00878 \******************************************************************************/
00879      
00880 static void init_cmd_line (void)
00881  
00882 {
00883    int  idx;
00884    char *u_option;
00885 
00886    TRACE (Func_Entry, "init_cmd_line", NULL);
00887 
00888 # if defined(_ACCEPT_STREAM)
00889 # if defined(_TARGET_SV2)
00890      accept_stream = TRUE;
00891 # else
00892      accept_stream = target_sv1;
00893 # endif
00894 # endif
00895 
00896    set_support_lvl_option = FALSE;
00897 
00898    /* Set defaults for CIF option flags.                                      */
00899    cif_flags              = 0;
00900    cif_C_opts     = 0;
00901 
00902    /* set defaults for command line level option flags */
00903 
00904    cmd_line_flags.dalign    = (cft90_dash_a_dalign_option == 1);
00905    cmd_line_flags.align32   = FALSE;
00906    cmd_line_flags.align64   = FALSE;
00907                 /* -a  dalign */
00908    cmd_line_flags.taskcommon    = FALSE;    /*-ataskcommon*/
00909    cmd_line_flags.static_threadprivate  = FALSE;    /*-astatic_th */
00910    cmd_line_flags.solaris_profile = FALSE;    /* -k  s/g    */
00911 
00912    cmd_line_flags.binary_output   = TRUE;     /* -b  name   */
00913    cmd_line_flags.assembly_output = FALSE;    /* -s  name   */
00914 
00915    cmd_line_flags.runtime_argument  = FALSE;    /* -R a       */
00916    cmd_line_flags.runtime_arg_call  = FALSE;    /* -R C       */
00917    cmd_line_flags.runtime_arg_entry = FALSE;    /* -R E       */
00918    cmd_line_flags.runtime_arg_count_only= FALSE;    /* -R n       */
00919    cmd_line_flags.runtime_bounds  = FALSE;    /* -R b       */
00920    cmd_line_flags.runtime_conformance = FALSE;    /* -R c       */
00921    cmd_line_flags.runtime_intrinsics  = FALSE;    /* -R i       */
00922    cmd_line_flags.runtime_substring = FALSE;    /* -R s       */
00923    cmd_line_flags.runtime_ptr_chk = FALSE;    /* -R p       */
00924    cmd_line_flags.s_float64   = FALSE;    /*-s float64  */
00925    cmd_line_flags.s_default32   = FALSE;    /*-s default32*/
00926    cmd_line_flags.s_default64   = FALSE;    /*-s default64*/
00927    cmd_line_flags.s_cf77types   = FALSE;    /*-s cf77types*/
00928    cmd_line_flags.s_integer8    = FALSE;    /*-s integer8 */
00929    cmd_line_flags.s_logical8    = FALSE;    /*-s logical8 */
00930    cmd_line_flags.s_real8   = FALSE;    /*-s real8    */
00931    cmd_line_flags.s_complex8    = FALSE;    /*-s complex8 */
00932    cmd_line_flags.s_doubleprecision16 = FALSE;    /*-s doublep  */
00933    cmd_line_flags.s_doublecomplex16 = FALSE;    /*-s doublec  */
00934 
00935 # if defined(_TARGET_SV2) || \
00936        ((defined(_HOST_OS_IRIX) || defined(_HOST_OS_LINUX) || defined(_HOST_OS_DARWIN)) && defined(_TARGET_OS_UNICOS))
00937    cmd_line_flags.s_pointer8    = TRUE;     /*-s pointer8 */
00938 # else
00939    cmd_line_flags.s_pointer8    = FALSE;    /*-s pointer8 */
00940 # endif
00941    cmd_line_flags.src_form    = Fixed_Form;
00942    cmd_line_flags.disregard_all_mpp_cdirs = FALSE;  /* -x mpp     */
00943    cmd_line_flags.disregard_all_directives  = FALSE;  /* -x all     */
00944    cmd_line_flags.disregard_all_dirs    = FALSE;  /* -x dir     */
00945    cmd_line_flags.disregard_all_mics    = FALSE;  /* -x mic     */
00946    cmd_line_flags.disregard_all_mips    = FALSE;        /* -x SGI     */
00947    cmd_line_flags.disregard_all_omps    = FALSE;        /* -x omp     */
00948    cmd_line_flags.disregard_conditional_omp = FALSE;        /* -x cond_.. */
00949    cmd_line_flags.msg_lvl_suppressed  = (msg_lvl_type) cft90_dash_m_option;
00950    cmd_line_flags.truncate_bits   = 0;      /* -t  0      */
00951    cmd_line_flags.implicit_use_idx  = NULL_IDX;
00952    cmd_line_flags.debug_lvl   = (debug_lvl_type) 
00953                                            cft90_dash_G_debug_option;
00954 
00955    cmd_line_flags.mod_out_path    = FALSE;    /* -J         */
00956    cmd_line_flags.dwarf_debug   = FALSE;    /* -Gd        */
00957    cmd_line_flags.num_msgs_suppressed = 0;      /* num -M msgs*/
00958    cmd_line_flags.line_size_80    = (cft90_dash_N_option == 80);
00959    cmd_line_flags.line_size_132         = (cft90_dash_N_option == 132);
00960    cmd_line_flags.verify_option   = FALSE;    /* -V  FALSE  */
00961    cmd_line_flags.malleable   = FALSE;    /* -Xm FALSE  */
00962    cmd_line_flags.MPP_num_pes   = cft90_dash_X_option;  /* -X n$pes   */
00963    cmd_line_flags.integer_32    = FALSE;
00964    cmd_line_flags.co_array_fortran  = FALSE;
00965    cmd_line_flags.pp_macro_expansion  = FALSE;
00966 
00967    /* Set defaults for -e / -d option flags */
00968 
00969    on_off_flags.abort_if_any_errors = (cft90_dash_e_a_option == 1);
00970 
00971    /* Hard code this as turned on by default for now because we want IEEE     */
00972    /* intrinsics to always be recognized.  Leave the option here in case      */
00973    /* customers scream too much about name space encroachment.          */
00974 
00975    on_off_flags.pad_char_literals = FALSE;    /* -dc FALSE  */
00976    on_off_flags.ieee      = TRUE;     /* -ee TRUE   */
00977    on_off_flags.flowtrace_option  = FALSE;    /* -ef FALSE  */
00978    on_off_flags.assembly_listing_file = FALSE;    /* -eg FALSE  */
00979 
00980 # if defined(_INTEGER_1_AND_2) && !defined(_ACCEPT_CMD_ed_h)
00981    on_off_flags.integer_1_and_2   = TRUE;
00982 # else
00983    on_off_flags.integer_1_and_2   = FALSE;
00984 # endif
00985 
00986    on_off_flags.indef_init    = (cft90_dash_e_i_option == 1);
00987    on_off_flags.exec_doloops_once = FALSE;    /* -ej FALSE  */
00988    on_off_flags.module_to_mod   = (cft90_dash_e_m_option == 1);
00989    on_off_flags.issue_ansi_messages = (cft90_dash_e_n_option == 1);
00990    on_off_flags.enable_double_precision = (cft90_dash_e_p_option == 1);
00991    on_off_flags.abort_on_100_errors = TRUE;     /* -eq TRUE   */
00992    on_off_flags.round_mult_operations = (cft90_dash_e_r_option == 1);
00993    on_off_flags.alloc_autos_on_stack  = (cft90_dash_e_t_option == 1);
00994 
00995    /* This gets translated into reciprical divide /strong round flag */
00996    /* in process_cmd_line.   For now, turn them all off.             */
00997 
00998    on_off_flags.eu      = (cft90_dash_e_u_option == 1);
00999    on_off_flags.reciprical_divide = FALSE;
01000    on_off_flags.round_integer_divide  = FALSE;
01001    on_off_flags.recognize_minus_zero  = FALSE;
01002    on_off_flags.zero_init   = FALSE;
01003    on_off_flags.save_all_vars   = (cft90_dash_e_v_option == 1);
01004    on_off_flags.MPP_apprentice    = FALSE;    /* -dA        */
01005    on_off_flags.shared_to_private_coer  = FALSE;    /* -dC        */
01006    on_off_flags.all_debug   = FALSE;    /* -dD        */
01007    on_off_flags.top_test_shortloops = FALSE;    /* -dL        */
01008    on_off_flags.second_underscore = TRUE;     /* -eN        */
01009    on_off_flags.underscoring      = TRUE;     /* -eU        */
01010    on_off_flags.allow_leading_uscore    = FALSE;                /* -dQ        */
01011    on_off_flags.output_pound_lines      = TRUE;                 /* -dP        */
01012    on_off_flags.preprocess_only         = FALSE;                /*            */
01013    on_off_flags.preprocess              = FALSE;
01014    on_off_flags.save_dot_i              = FALSE;                /* -ek        */
01015    on_off_flags.recursive   = FALSE;    /* -dR        */
01016    on_off_flags.atexpert    = FALSE;    /* -dX        */
01017    on_off_flags.upper_case_names  = FALSE;
01018    on_off_flags.d_lines                 = FALSE;
01019  
01020    /* Set defaults for -O option flags.               */
01021 
01022    /* If these options vary depending on platform, use cmd_line.h and the     */
01023    /* cft90_dash_O method to initialize.  That way all platform information   */
01024    /* for commandline initialization is in one place.                         */
01025 
01026    opt_flags.aggress      = (cft90_dash_O_aggress_option == 1);
01027    opt_flags.bottom_load    = (cft90_dash_O_bl_option == 1);
01028    opt_flags.set_fastint_option   = FALSE;
01029    opt_flags.set_nofastint_option = FALSE;
01030    opt_flags.set_allfastint_option  = FALSE;
01031    opt_flags.ieeeconform    = (cft90_dash_O_ieeeconform_option==1);
01032    opt_flags.inline_lvl     = Inline_Lvl_0;
01033    opt_flags.extent_assert    = FALSE;
01034    opt_flags.short_circuit_lvl    = Short_Circuit_Present;
01035    opt_flags.jump     = (cft90_dash_O_jump_option == 1);
01036    opt_flags.loopalign      = (cft90_dash_O_loopalign_option == 1);
01037    opt_flags.modinline      = FALSE;
01038    opt_flags.msgs     = FALSE;
01039    opt_flags.neg_msgs     = FALSE;
01040    opt_flags.nointerchange    = FALSE;
01041    opt_flags.opt_info     = FALSE;
01042    opt_flags.over_index     = (cft90_dash_O_overindex_option == 1);
01043    opt_flags.pattern      = (cft90_dash_O_pattern_option == 1);
01044    opt_flags.pipeline_lvl   = 0;
01045    opt_flags.recurrence     = (cft90_dash_O_recurrence_option == 1);
01046    opt_flags.taskinner      = (cft90_dash_O_taskinner_option == 1);
01047    opt_flags.threshold      = (cft90_dash_O_threshold_option == 1);
01048    opt_flags.vsearch      = (cft90_dash_O_vsearch_option == 1);
01049    opt_flags.zeroinc      = (cft90_dash_O_zeroinc_option == 1);
01050    opt_flags.support_lvl    = cft90_dash_O_support_option;
01051    opt_flags.scalar_lvl     = cft90_dash_O_scalar_option;
01052    opt_flags.split_lvl                  = cft90_dash_O_split_option;
01053    opt_flags.vector_lvl     = cft90_dash_O_vector_option;
01054    opt_flags.task_lvl                   = cft90_dash_O_task_option;
01055    opt_flags.unroll_lvl     = cft90_dash_O_unroll_option;
01056    opt_flags.reshape_idx    = NULL_IDX;
01057    opt_flags.reshape      = FALSE;
01058    opt_flags.reshape_all_arrays   = FALSE;
01059    opt_flags.matmul_inline    = FALSE;
01060    opt_flags.mv_matmul_inline   = FALSE;
01061  
01062    /* Set defaults for -x option flags.               */
01063 
01064    for (idx = 0; idx < (Tok_Dir_End-Tok_Dir_Start); idx++) {
01065       disregard_directive[idx]  = FALSE;
01066    }
01067 
01068    for (idx = 0; idx < (Tok_Mic_End-Tok_Mic_Start); idx++) {
01069       disregard_mics[idx] = FALSE;
01070    }
01071 
01072    for (idx = 0; idx < (Tok_SGI_Dir_End-Tok_SGI_Dir_Start); idx++) {
01073       disregard_mips[idx] = FALSE;
01074    }
01075 
01076    for (idx = 0; idx < (Tok_Open_Mp_Dir_End-Tok_Open_Mp_Dir_Start); idx++) {
01077       disregard_open_mp[idx]  = FALSE;
01078    }
01079 
01080    /* set defaults for -u option flags */
01081    dump_flags.pvp_test      = 0;
01082    dump_flags.blk_stk     = FALSE;
01083    dump_flags.bd_tbl      = FALSE;
01084    dump_flags.cmd_line_tbls   = FALSE;
01085    dump_flags.cn_tbl      = FALSE;
01086    dump_flags.fp_tbl      = FALSE;
01087    dump_flags.ftrace_info   = FALSE;
01088    dump_flags.gl_tbl      = FALSE;
01089    dump_flags.intrin_tbl    = FALSE;
01090    dump_flags.ir1_tbl     = FALSE;
01091    dump_flags.ir2_tbl     = FALSE;
01092    dump_flags.ir3_tbl     = FALSE;
01093    dump_flags.ir4_tbl     = FALSE;
01094    dump_flags.mem_report    = FALSE;
01095    dump_flags.mod_version   = FALSE;
01096    dump_flags.mtrace_info   = FALSE;
01097    dump_flags.name_tbls     = FALSE;
01098    dump_flags.pdgcs     = FALSE;
01099    dump_flags.pdt_dump      = FALSE;
01100    dump_flags.sb_tbl      = FALSE;
01101    dump_flags.scp_tbl     = FALSE;
01102    dump_flags.src_dmp     = FALSE;
01103    dump_flags.std_err     = FALSE;
01104    dump_flags.stmt_dmp      = FALSE;
01105    dump_flags.sytb      = FALSE;
01106    dump_flags.typ_tbl     = FALSE;
01107    dump_flags.defines     = FALSE;
01108    dump_flags.constant_bits   = FALSE;
01109    dump_flags.abort_on_ansi             = FALSE;
01110    dump_flags.no_dimension_padding  = FALSE;
01111    dump_flags.no_module_output    = FALSE;
01112    dump_flags.f_minus_minus   = FALSE;
01113    dump_flags.fmm1      = FALSE;
01114    dump_flags.fmm2      = FALSE;
01115    dump_flags.show_cmd_line   = FALSE;
01116    dump_flags.mp      = FALSE;
01117    dump_flags.open_mp     = FALSE;
01118    dump_flags.dsm     = FALSE;
01119    dump_flags.cray_compatible   = FALSE;
01120    dump_flags.pack_half_word    = FALSE;
01121 #ifdef KEY /* Bug 8117 */
01122    dump_flags.arg_passing   = FALSE;
01123 #endif /* KEY Bug 8117 */
01124 
01125    /* Set defaults for -Y CCG option flags.                                   */
01126 
01127    ccg_dump_flags             = 0;       /* All FALSE */
01128 
01129 
01130    /* Clear the message tables.   */
01131 
01132    for (idx = 0; idx < MAX_MSG_SIZE; idx++) {
01133       message_suppress_tbl[idx] = 0L;
01134       message_error_tbl[idx]  = 0L;
01135       message_warning_tbl[idx]  = 0L;
01136    }
01137 
01138    u_option = getenv("FE_DASH_U_OPTION");
01139 
01140    if (u_option != NULL) {
01141       process_u_option(u_option);
01142    }
01143 
01144    TRACE (Func_Exit, "init_cmd_line", NULL);
01145 
01146    return;
01147 
01148 }  /* init_cmd_line */
01149 
01150 
01151 /******************************************************************************\
01152 |*                        *|
01153 |* Description:                     *|
01154 |*  Process_c_option handles command line CIF options passed via argv     *|
01155 |*  (c switch).                   *|
01156 |*                        *|
01157 |* Input parameters:                    *|
01158 |*  optargs     -C option arguments           *|
01159 |*  argv      argument list             *|
01160 |*                        *|
01161 |* Output parameters:                   *|
01162 |*  NONE                      *|
01163 |*                        *|
01164 |* Returns:                     *|
01165 |*  NOTHING                     *|
01166 |*                        *|
01167 |* Algorithm notes:                   *|
01168 |*   CIF file output is requested via the -C option.              *|
01169 |*                            *|
01170 |*   Qualifier    Constant         Meaning                  *|
01171 |*   ---------    --------         --------             *|
01172 |*      a         ALL_RECS         All available CIF record types       *|
01173 |*      c         COMPILER_RECS    Only CIF records that contain compiler     *|
01174 |*                                   information, plus f-level records        *|
01175 |*      f         BASIC_RECS       Basic CIF records (file info, unit markers,*|
01176 |*                                   include files, etc.)           *|
01177 |*      i         INFO_RECS        Information records for variables, labels, *|
01178 |*                                   constants, etc., plus f-level records    *|
01179 |*      m         MESSAGE_RECS     Message records plus f-level records       *|
01180 |*      o         MISC_RECS        Miscellaneous other records (stmt types,   *|
01181 |*                                   call sites, etc.) plus f- and i-level    *|
01182 |*                                   records              *|
01183 |*      s         OUTPUT_TO_STDOUT Redirect CIF output to stdout instead of   *|
01184 |*                                   file.T               *|
01185 |*      x         XREF_RECS        Cross-reference information plus f- and    *|
01186 |*                                   i-level records            *|
01187 |*                                  *|
01188 \******************************************************************************/
01189  
01190 static void process_C_option (char *optargs,
01191                   char *argv[])
01192 
01193 {
01194    int    ch;
01195    char   err_str[2];
01196    long   orig_cmd_len;
01197 
01198    extern int optind;         /* defined in getopt  */
01199 
01200 
01201    TRACE (Func_Entry, "process_C_option", NULL);
01202 
01203    while (ch = *optargs++) {
01204 
01205       switch (ch) {
01206 
01207    case 'a':
01208       cif_flags = cif_flags | ALL_RECS      |
01209                                     XREF_RECS     | MISC_RECS |
01210             MESSAGE_RECS  | INFO_RECS |
01211             BASIC_RECS    | COMPILER_RECS;
01212             cif_C_opts = cif_C_opts | ALL_RECS;
01213       break;
01214 
01215    case 'c':
01216       cif_flags  = cif_flags | COMPILER_RECS | BASIC_RECS;
01217             cif_C_opts = cif_C_opts | COMPILER_RECS;
01218       break;
01219 
01220    case 'f':
01221       cif_flags  = cif_flags | BASIC_RECS;
01222             cif_C_opts = cif_C_opts | BASIC_RECS;
01223       break;
01224 
01225    case 'i':
01226       cif_flags  = cif_flags | INFO_RECS | BASIC_RECS;
01227             cif_C_opts = cif_C_opts | INFO_RECS;
01228       break;
01229 
01230    case 'm':
01231       cif_flags  = cif_flags | MESSAGE_RECS | BASIC_RECS;
01232             cif_C_opts = cif_C_opts | MESSAGE_RECS;
01233       break;
01234 
01235    case 'o':
01236       cif_flags  = cif_flags | MISC_RECS | INFO_RECS | BASIC_RECS;
01237             cif_C_opts = cif_C_opts | MISC_RECS;
01238       break;
01239 
01240    case 's':
01241       cif_flags  = cif_flags | OUTPUT_TO_STDOUT;
01242             cif_C_opts = cif_C_opts | OUTPUT_TO_STDOUT;
01243       break;  
01244 
01245    case 'x':
01246       cif_flags  = cif_flags | XREF_RECS | INFO_RECS | BASIC_RECS;
01247             cif_C_opts = cif_C_opts | XREF_RECS;
01248       break;
01249 
01250          case 'Y':
01251 
01252             /* -CY is NOT a user-specifiable option.  It is used by the MPP   */
01253             /* driver to pass the command line as entered by the user and     */
01254             /* added to by the driver for the Original Command Line CIF       */
01255             /* record which cflist requires.  The PVP driver adds this        */
01256             /* record when it consolidates the .T files.                      */
01257 
01258             orig_cmd_len = (long) strlen(argv[optind]);
01259             ++orig_cmd_len;
01260             MEM_ALLOC(orig_cmd_line, char, orig_cmd_len);
01261             strcpy(orig_cmd_line, argv[optind]);
01262             ++optind;
01263             break;
01264 
01265          case 'Z':
01266 
01267             /* -CZ is NOT a user-specifiable option.  It is the option the    */
01268             /* command line processor uses to pass the CIF name to us.  The   */
01269             /* command line processor issues the error if it's specified by a */
01270             /* user.                                                          */
01271 
01272             strcpy(cif_name, optargs);
01273             
01274             /* Since the string following the CZ is a file name, skip past    */
01275             /* the entire string to complete the while loop.  No additional   */
01276             /* -C options are allowed after a -CZ.                            */
01277 
01278             optargs = optargs + strlen(optargs);
01279             break;
01280 
01281    default:
01282       err_str[0] = ch;
01283       err_str[1] = EOS;
01284 
01285       /* The CIF option has an invalid argument */
01286 
01287             ntr_msg_queue(0, 917, Log_Error, 0, err_str, 0, STR_ARG);
01288       break;
01289 
01290    }  /* switch */
01291 
01292    }  /* while */
01293 
01294    if (cif_flags != 0) {
01295       cif_C_opts = cif_C_opts | CMD_PROVIDED_CIF;
01296    }
01297 
01298    /* If the only suboption specified was the "s" (output to stdout)          */
01299    /* suboption, don't attempt to produce any CIF records.          */
01300 
01301    if (cif_flags == OUTPUT_TO_STDOUT) {
01302       cif_flags = 0;
01303       cif_C_opts = 0;
01304    }
01305 
01306    TRACE (Func_Exit, "process_C_option", NULL);
01307 
01308    return;
01309  
01310 }  /* process_C_option */
01311 
01312 
01313 /******************************************************************************\
01314 |*                        *|
01315 |* Description:                     *|
01316 |*  Process_d_option handles command line on/off options passed via argv  *|
01317 |*  (d switch).                   *|
01318 |*                        *|
01319 |* Input parameters:                    *|
01320 |*  optargs     -d option arguments           *|
01321 |*                        *|
01322 |* Output parameters:                   *|
01323 |*  NONE                      *|
01324 |*                        *|
01325 |* Returns:                     *|
01326 |*  NOTHING                     *|
01327 |*                        *|
01328 \******************************************************************************/
01329  
01330 static void process_d_option (char *optargs)
01331 
01332 {
01333    int  ch;
01334    char err_str[2];
01335  
01336 
01337    TRACE (Func_Entry, "process_d_option", NULL);
01338 
01339    while (ch = *optargs++) {
01340       switch (ch) {
01341       case 'a':
01342          on_off_flags.abort_if_any_errors = FALSE;
01343          break;
01344 
01345 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
01346       case 'c':
01347          on_off_flags.pad_char_literals = FALSE;
01348          break;
01349 # endif
01350 
01351 # ifdef _D_LINES_SUPPORTED
01352       case 'd':
01353          on_off_flags.d_lines = FALSE;
01354          break;
01355 # endif
01356 
01357 # if 0
01358 
01359       /* Take this out for now because we want IEEE intrinsics to always      */
01360       /* be recognized.  Leave the option here in case customers scream too   */
01361       /* much about name space encroachment.              */
01362 
01363       case 'e':
01364          on_off_flags.ieee = FALSE;
01365          break;
01366 
01367 # endif
01368 
01369       case 'f':
01370 
01371 #        if defined(_ACCEPT_FLOW)
01372             on_off_flags.flowtrace_option = FALSE;
01373 #        else
01374             ntr_msg_queue(0, 744, Log_Warning, 0, "f", 'd', ARG_STR_ARG);
01375 #        endif
01376          break;
01377 
01378       case 'g':
01379 
01380 #        if defined(_ACCEPT_CMD_ed_g)
01381             on_off_flags.assembly_listing_file = FALSE;
01382 #        else
01383             ntr_msg_queue(0, 744, Log_Warning, 0, "g", 'd', ARG_STR_ARG);
01384 #        endif
01385          break;
01386 
01387       case 'h':
01388 
01389 #        if defined(_ACCEPT_CMD_ed_h)
01390       on_off_flags.integer_1_and_2 = FALSE;
01391 #        else
01392             ntr_msg_queue(0, 744, Log_Warning, 0, "h", 'd', ARG_STR_ARG);
01393 #        endif
01394          break;
01395 
01396       case 'i':
01397 
01398 #        if defined(_ACCEPT_CMD_ed_i)
01399             ntr_msg_queue(0, 744, Log_Warning, 0, "i", 'd', ARG_STR_ARG);
01400 #        else
01401       on_off_flags.indef_init = FALSE;
01402 #        endif
01403    break;
01404 
01405       case 'j':
01406 
01407 #        if defined(_ACCEPT_CMD_ed_j)
01408       on_off_flags.exec_doloops_once = FALSE;
01409 #        else
01410             ntr_msg_queue(0, 744, Log_Warning, 0, "j", 'd', ARG_STR_ARG);
01411 #        endif
01412          break;
01413 
01414       case 'k': on_off_flags.output_pound_lines = FALSE;
01415    break;
01416 
01417       case 'm':
01418 
01419          /* If turning off -em, need an alternative to write out the module. */
01420 
01421 #        if defined(_MODULE_TO_DOT_o) || defined(_MODULE_TO_DOT_M)
01422             on_off_flags.module_to_mod = FALSE;
01423 #        else
01424             PRINTMSG (0, 744, Log_Warning, 0, 'd', "m");
01425 #        endif
01426          break;
01427 
01428       case 'n':
01429          on_off_flags.issue_ansi_messages = FALSE;
01430          break;
01431 
01432       case 'p':
01433          on_off_flags.enable_double_precision = FALSE;
01434          break;
01435 
01436       case 'q':
01437          on_off_flags.abort_on_100_errors = FALSE;
01438          break;
01439 
01440       case 'r':
01441 
01442 #        if defined(_ACCEPT_CMD_ed_r)
01443 
01444       if (set_trunc_option) {
01445          set_round_option = FALSE;
01446 
01447          /* Rounding(-dr) /truncation (-t) conflict detected. */
01448 
01449                ntr_msg_queue(0, 75, Log_Warning, 0, "-dr", 0, STR_ARG);
01450       }
01451 
01452       cmd_line_flags.truncate_bits  = 0;
01453       on_off_flags.round_mult_operations  = FALSE;
01454       set_round_option      = TRUE;
01455 #        else
01456             ntr_msg_queue(0, 744, Log_Warning, 0, "r", 'd', ARG_STR_ARG);
01457 #        endif
01458          break;
01459 
01460       case 't':
01461          on_off_flags.alloc_autos_on_stack = FALSE;
01462          break;
01463 
01464       case 'u':
01465          set_eu_option   = TRUE;
01466    on_off_flags.eu = FALSE;
01467          break;
01468 
01469       case 'v':
01470          on_off_flags.save_all_vars = FALSE;
01471          break;
01472 
01473       case 'z':
01474 
01475 #        if defined(_ACCEPT_CMD_ed_z)
01476       on_off_flags.recognize_minus_zero = FALSE;
01477 #        else
01478             ntr_msg_queue(0, 744, Log_Warning, 0, "z", 'd', ARG_STR_ARG);
01479 #        endif
01480          break;
01481 
01482       case '0':
01483 #        if defined(_ACCEPT_CMD_ed_0)
01484             on_off_flags.zero_init = FALSE;
01485 #        else
01486             ntr_msg_queue(0, 744, Log_Warning, 0, "0", 'd', ARG_STR_ARG);
01487 #        endif
01488          break;
01489 
01490       case 'A':
01491 
01492 #        if defined(_ACCEPT_CMD_ed_A)
01493             on_off_flags.MPP_apprentice = FALSE;
01494 #        else
01495             ntr_msg_queue(0, 744, Log_Warning, 0, "A", 'd', ARG_STR_ARG);
01496 #        endif
01497          break;
01498     
01499       case 'B':
01500          cmd_line_flags.binary_output = FALSE;
01501          break;
01502 
01503       case 'C':
01504 
01505 #        if defined(_ACCEPT_CMD_ed_C)
01506             on_off_flags.shared_to_private_coer = FALSE;
01507 #        else
01508             ntr_msg_queue(0, 744, Log_Warning, 0, "C", 'd', ARG_STR_ARG);
01509 #        endif
01510          break;
01511 
01512       case 'D':
01513 #        if defined(_ACCEPT_CMD_ed_i)
01514             on_off_flags.all_debug = FALSE;
01515 #        else
01516             ntr_msg_queue(0, 744, Log_Warning, 0, "D", 'd', ARG_STR_ARG);
01517 #        endif
01518          break;
01519 
01520       case 'I':
01521          on_off_flags.implicit_none = FALSE;
01522          break;
01523 
01524       case 'L':
01525          on_off_flags.top_test_shortloops = FALSE;
01526          break;
01527 
01528       case 'N':
01529          on_off_flags.second_underscore = FALSE;
01530          break;
01531 
01532       case 'O':
01533          on_off_flags.underscoring = FALSE;
01534          break;
01535 
01536       case 'Q':   /* Q is undocumented */
01537          on_off_flags.allow_leading_uscore = FALSE;
01538          break;
01539     
01540       case 'R':
01541          on_off_flags.recursive = FALSE;
01542          break;
01543 
01544       case 'S':
01545          cmd_line_flags.assembly_output = FALSE;
01546          break;
01547 
01548       case 'T':
01549 # ifdef _FRONTEND_CONDITIONAL_COMP
01550          no_preprocessing = TRUE;
01551          on_off_flags.preprocess = FALSE;
01552          on_off_flags.preprocess_only = FALSE;
01553          on_off_flags.save_dot_i = FALSE;
01554 # endif
01555          break;
01556 
01557       case 'U':   /* U is undocumented */
01558 #        if defined(_ACCEPT_CMD_ed_U)
01559             on_off_flags.upper_case_names = FALSE;
01560 #        else
01561             ntr_msg_queue(0, 744, Log_Warning, 0, "U", 'd', ARG_STR_ARG);
01562 #        endif
01563          break;
01564 
01565       case 'X':
01566 
01567 #        if defined(_ACCEPT_CMD_ed_X)
01568             on_off_flags.atexpert = FALSE;
01569 #        else
01570             ntr_msg_queue(0, 744, Log_Warning, 0, "X", 'd', ARG_STR_ARG);
01571 #        endif
01572          break;
01573 
01574       default:
01575          err_str[0] = ch;
01576          err_str[1] = EOS;
01577 
01578          /* option has an invalid argument */
01579 
01580          ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'd', ARG_STR_ARG);
01581          break;
01582 
01583       }  /* switch */
01584    }  /* while */
01585 
01586    TRACE (Func_Exit, "process_d_option", NULL);
01587 
01588    return;
01589  
01590 }  /* process_d_option */
01591 
01592 /******************************************************************************\
01593 |*                        *|
01594 |* Description:                     *|
01595 |*  Process_e_option handles command line on/off options passed via argv  *|
01596 |*  (e switch).                   *|
01597 |*                        *|
01598 |* Input parameters:                    *|
01599 |*  optargs     -e option arguments           *|
01600 |*                        *|
01601 |* Output parameters:                   *|
01602 |*  NONE                      *|
01603 |*                        *|
01604 |* Returns:                     *|
01605 |*  NOTHING                     *|
01606 |*                        *|
01607 \******************************************************************************/
01608 
01609 static void process_e_option (char *optargs)
01610 
01611 {
01612    int     ch;
01613    char    err_str[2];
01614 
01615 
01616    TRACE (Func_Entry, "process_e_option", NULL);
01617 
01618    while (ch = *optargs++) {
01619       switch (ch) {
01620       case 'a':
01621          on_off_flags.abort_if_any_errors = TRUE; 
01622          break;
01623 
01624 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
01625       case 'c':
01626          on_off_flags.pad_char_literals = TRUE;
01627          break;
01628 # endif
01629 
01630 # ifdef _D_LINES_SUPPORTED
01631       case 'd':
01632          on_off_flags.d_lines = TRUE;
01633          break;
01634 # endif
01635 
01636 
01637 # if 0
01638       /* Take this out for now because we want IEEE intrinsics to always      */
01639       /* be recognized.  Leave the option here in case customers scream too   */
01640       /* much about name space encroachment.              */
01641 
01642       case 'e':
01643          on_off_flags.ieee = TRUE;
01644          break;
01645 
01646 # endif
01647 
01648       case 'f':
01649 
01650 #        if defined(_ACCEPT_FLOW)
01651       on_off_flags.flowtrace_option = TRUE;
01652 #        else
01653             ntr_msg_queue(0, 744, Log_Warning, 0, "f", 'e', ARG_STR_ARG);
01654 #        endif
01655          break;
01656 
01657       case 'g':
01658 
01659 #        if defined(_ACCEPT_CMD_ed_g)
01660       on_off_flags.assembly_listing_file = TRUE;
01661 
01662             /* issue warning if cal file output is being overridden */  
01663 
01664             if (cmd_line_flags.assembly_output) {  
01665                ntr_msg_queue(0, 388, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
01666                cmd_line_flags.assembly_output = FALSE;  
01667                cmd_line_flags.binary_output = TRUE;  
01668             }
01669 #        else /* doc'd as -rg */
01670             ntr_msg_queue(0, 744, Log_Warning, 0, "g", 'r', ARG_STR_ARG);
01671 #        endif
01672          break;
01673 
01674 
01675       case 'h':
01676 
01677 #        if defined(_ACCEPT_CMD_ed_h)
01678       on_off_flags.integer_1_and_2 = TRUE;
01679 #        else
01680             ntr_msg_queue(0, 744, Log_Warning, 0, "h", 'e', ARG_STR_ARG);
01681 #        endif
01682          break;
01683 
01684 
01685       case 'i':
01686 
01687 #        if defined(_ACCEPT_CMD_ed_i)
01688             on_off_flags.indef_init = TRUE;
01689 
01690             if (on_off_flags.zero_init) {  /* Conflict - issue warning */
01691                on_off_flags.zero_init = FALSE;
01692                ntr_msg_queue(0, 1313, Log_Warning, 0, "ei\ne0", 0,MULT_STR_ARG);
01693             }
01694 #        else
01695             ntr_msg_queue(0, 744, Log_Warning, 0, "i", 'e', ARG_STR_ARG);
01696 #        endif
01697          break;
01698 
01699       case 'j':
01700 
01701 #        if defined(_ACCEPT_CMD_ed_j)
01702             on_off_flags.exec_doloops_once = TRUE;
01703 #        else
01704             ntr_msg_queue(0, 744, Log_Warning, 0, "j", 'e', ARG_STR_ARG);
01705 #        endif
01706          break;
01707 
01708       case 'k':
01709          on_off_flags.save_dot_i = TRUE;
01710          break;
01711 
01712       case 'm':
01713          on_off_flags.module_to_mod = TRUE;
01714          break;
01715 
01716       case 'n':
01717          on_off_flags.issue_ansi_messages = TRUE;
01718          break;
01719 
01720       case 'p':
01721          on_off_flags.enable_double_precision = TRUE;
01722          break;
01723 
01724       case 'q':
01725          on_off_flags.abort_on_100_errors = TRUE;
01726          break;
01727 
01728       case 'r':
01729 
01730 #        if defined(_ACCEPT_CMD_ed_r)
01731 
01732             if (set_trunc_option) {
01733 
01734                /* Rounding(-er) /truncation (-t) conflict detected. */
01735 
01736                ntr_msg_queue(0, 75, Log_Warning, 0, "-er", 0, STR_ARG);
01737                set_trunc_option     = FALSE;
01738             }
01739 
01740             on_off_flags.round_mult_operations  = TRUE;
01741             cmd_line_flags.truncate_bits  = 0;
01742             set_round_option      = TRUE;
01743 #        else
01744             ntr_msg_queue(0, 744, Log_Warning, 0, "r", 'e', ARG_STR_ARG);
01745 #        endif
01746          break;
01747 
01748       case 't':
01749          on_off_flags.alloc_autos_on_stack = TRUE;
01750          break;
01751 
01752       case 'u':
01753          on_off_flags.eu  = TRUE;
01754          set_eu_option    = TRUE;
01755          break;
01756     
01757       case 'v':
01758          on_off_flags.save_all_vars = TRUE;
01759          break;
01760 
01761       case 'z':
01762 
01763 #        if defined(_ACCEPT_CMD_ed_z) || defined(KEY) /* Bug 3405 */
01764       on_off_flags.recognize_minus_zero = TRUE;
01765 #        else
01766             ntr_msg_queue(0, 744, Log_Warning, 0, "z", 'e', ARG_STR_ARG);
01767 #        endif
01768          break;
01769 
01770       case '0':
01771 #        if defined(_ACCEPT_CMD_ed_0)
01772             on_off_flags.zero_init = TRUE;
01773 
01774             if (on_off_flags.indef_init) {  /* Conflict - issue warning */
01775                on_off_flags.indef_init = FALSE;
01776                ntr_msg_queue(0, 1313, Log_Warning, 0, "e0\nei", 0,MULT_STR_ARG);
01777             }
01778 
01779 #        else
01780             ntr_msg_queue(0, 744, Log_Warning, 0, "0", 'e', ARG_STR_ARG);
01781 #        endif
01782          break;
01783 
01784       case 'A':
01785 
01786 #        if defined(_ACCEPT_CMD_ed_A)
01787             on_off_flags.MPP_apprentice = TRUE;
01788 #        else
01789             ntr_msg_queue(0, 744, Log_Warning, 0, "A", 'e', ARG_STR_ARG);
01790 #        endif
01791          break;
01792     
01793       case 'B':
01794 
01795          /* issue warning if cal output is being overridden */ 
01796 
01797          if (cmd_line_flags.assembly_output) { 
01798             ntr_msg_queue(0, 715, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
01799             cmd_line_flags.assembly_output = FALSE; 
01800          }
01801 
01802          cmd_line_flags.binary_output = TRUE;
01803          break;
01804 
01805       case 'C':
01806 
01807 #        if defined(_ACCEPT_CMD_ed_C)
01808             on_off_flags.shared_to_private_coer = TRUE;
01809 #        else
01810             ntr_msg_queue(0, 744, Log_Warning, 0, "C", 'e', ARG_STR_ARG);
01811 #        endif
01812          break;
01813 
01814       case 'D':
01815 #        if defined(_ACCEPT_CMD_ed_D)
01816             on_off_flags.all_debug = TRUE;
01817 #        else
01818             ntr_msg_queue(0, 744, Log_Warning, 0, "D", 'e', ARG_STR_ARG);
01819 #        endif
01820          break;
01821 
01822       case 'I':
01823          on_off_flags.implicit_none = TRUE;
01824          break;
01825 
01826       case 'L':
01827          on_off_flags.top_test_shortloops = TRUE;
01828          break;
01829 
01830       case 'N':
01831          on_off_flags.second_underscore = TRUE;
01832          break;
01833 
01834       case 'O':
01835          on_off_flags.underscoring = TRUE;
01836          break;
01837 
01838       case 'Q':
01839          on_off_flags.allow_leading_uscore = TRUE;
01840          break;
01841 
01842       case 'R':
01843          on_off_flags.recursive = TRUE;
01844          break;
01845 
01846       case 'S':
01847 
01848          /* issue warning if binary output is being overridden */  
01849 
01850          if (cmd_line_flags.binary_output) {   
01851 /*          PRINTMSG (0, 74, Log_Warning, 0);       LRR: driver now does this */
01852             cmd_line_flags.binary_output = FALSE;  
01853          }
01854 
01855          /* issue warning if cal file listing is being overridden */  
01856 
01857          if (on_off_flags.assembly_listing_file) {   
01858             ntr_msg_queue(0, 911, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
01859             on_off_flags.assembly_listing_file = FALSE;  
01860          }
01861      
01862          cmd_line_flags.assembly_output = TRUE;
01863          break;
01864 
01865       case 'T':
01866 # ifdef _FRONTEND_CONDITIONAL_COMP
01867          no_preprocessing = FALSE;
01868          on_off_flags.preprocess = TRUE;
01869 # endif
01870          break;
01871 
01872       case 'U':
01873 #        if defined(_ACCEPT_CMD_ed_U)
01874             on_off_flags.upper_case_names = TRUE;
01875 #        else
01876             ntr_msg_queue(0, 744, Log_Warning, 0, "U", 'e', ARG_STR_ARG);
01877 #        endif
01878          break;
01879 
01880       case 'X':
01881         
01882 #        if defined(_ACCEPT_CMD_ed_X)
01883             on_off_flags.atexpert = TRUE;
01884 #        else
01885             ntr_msg_queue(0, 744, Log_Warning, 0, "X", 'e', ARG_STR_ARG);
01886 #        endif
01887          break;
01888 
01889       case 'Z':
01890 # ifdef _FRONTEND_CONDITIONAL_COMP
01891          no_preprocessing = FALSE;
01892          on_off_flags.preprocess_only = TRUE;
01893          on_off_flags.preprocess = TRUE;
01894 # endif
01895          break;
01896     
01897       default:
01898          err_str[0] = ch;
01899          err_str[1] = EOS;
01900 
01901          /* option has an invalid argument */
01902 
01903          ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'e', ARG_STR_ARG);
01904          break;
01905       }  /* switch */
01906    }  /* while */
01907  
01908    TRACE (Func_Exit, "process_e_option", NULL);
01909 
01910    return;
01911 
01912 }  /* process_e_option */
01913 
01914 /******************************************************************************\
01915 |*                        *|
01916 |* Description:                     *|
01917 |*  Process_O_option handles command line optimization options passed via *|
01918 |*  argv (O switch).                  *|
01919 |*                        *|
01920 |* Input parameters:                    *|
01921 |*  optargs     -O option arguments           *|
01922 |*                        *|
01923 |* Output parameters:                   *|
01924 |*  NONE                      *|
01925 |*                        *|
01926 |* Returns:                     *|
01927 |*  NOTHING                     *|
01928 |*                        *|
01929 \******************************************************************************/
01930 
01931 static void process_O_option (char  *optargs,
01932             int  argc)
01933 
01934 {
01935       char    *cp;
01936       boolean    err;
01937     boolean    first;
01938    extern int    optind;  /* defined in getopt  */
01939 
01940 
01941    TRACE (Func_Entry, "process_O_option", NULL);
01942 
01943    if (*optargs == '-') {
01944 
01945       /* Just a -O, issue warning, backup getopt and continue.  If      */
01946       /* optarg is a "-", the next item following -O is another option. */
01947 
01948       ntr_msg_queue(0, 1221, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
01949       --optind;
01950       return;
01951    }
01952 
01953    first  = TRUE;
01954 
01955    while (*optargs != EOS) {
01956 
01957       for (cp = optargs;
01958           *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
01959           ++optargs);
01960 
01961       if (*optargs != EOS) {
01962    *optargs = EOS;
01963    *optargs++;
01964       }
01965 
01966       err = FALSE;
01967 
01968       switch (*cp) {
01969 
01970          case '0':
01971             if (EQUAL_STRS(cp, "0")) {
01972                opt_flags.support_lvl  = 0;
01973                set_support_lvl_option = TRUE;
01974 
01975                if (! set_scalar_option) {
01976                   opt_flags.scalar_lvl = Scalar_Lvl_0;
01977                }
01978 
01979 #              if defined(_ACCEPT_VECTOR)
01980 
01981                if (! set_vector_option) {
01982                   opt_flags.vector_lvl = Vector_Lvl_0;
01983                }
01984 
01985 #              endif
01986 
01987 #              if defined(_ACCEPT_STREAM)
01988 
01989                if (! set_stream_option) {
01990                   opt_flags.stream_lvl = Stream_Lvl_0;
01991                }
01992 
01993 #              endif
01994 
01995 
01996 #              if defined(_ACCEPT_TASK)
01997 
01998                if (! set_task_option) {
01999                   opt_flags.task_lvl = Task_Lvl_0;
02000                }
02001 
02002 #              endif
02003 
02004             }
02005             else {
02006                err = TRUE;
02007             }
02008 
02009             break;
02010 
02011 
02012          case '1':
02013             if (EQUAL_STRS(cp, "1")) {
02014                opt_flags.support_lvl  = 1;
02015                set_support_lvl_option = TRUE;
02016 
02017                if (! set_scalar_option) {
02018                   opt_flags.scalar_lvl = Scalar_Lvl_1;
02019                }
02020 
02021 #              if defined(_ACCEPT_VECTOR)
02022 
02023                if (! set_vector_option) {
02024                   opt_flags.vector_lvl = Vector_Lvl_1;
02025                }
02026 
02027 #              endif
02028 
02029 #              if defined(_ACCEPT_STREAM)
02030 
02031                if (! set_stream_option) {
02032 
02033 # if defined(_TARGET_SV2)
02034                   opt_flags.stream_lvl = Stream_Lvl_1;
02035 # else
02036                   opt_flags.stream_lvl = Stream_Lvl_0;
02037 # endif
02038                }
02039 
02040 #              endif
02041 
02042 #              if defined(_ACCEPT_TASK)
02043 
02044                if (! set_task_option) {
02045                   opt_flags.task_lvl = Task_Lvl_1;
02046                }
02047 
02048 #              endif
02049 
02050             }
02051             else {
02052                err = TRUE;
02053             }
02054 
02055             break;
02056 
02057 
02058          case '2':
02059             if (EQUAL_STRS(cp, "2")) {
02060                opt_flags.support_lvl  = 2;
02061                set_support_lvl_option = TRUE;
02062 
02063                if (! set_scalar_option) {
02064                   opt_flags.scalar_lvl = Scalar_Lvl_2;
02065                }
02066 
02067 #              if defined(_ACCEPT_STREAM)
02068 
02069                if (! set_stream_option) {
02070 
02071 # if defined(_TARGET_SV2)
02072                   opt_flags.stream_lvl = Stream_Lvl_2;
02073 # else
02074                   opt_flags.stream_lvl = Stream_Lvl_0;
02075 # endif
02076                }
02077 
02078 #              endif
02079 
02080 #              if defined(_ACCEPT_VECTOR)
02081 
02082                if (! set_vector_option) {
02083                   opt_flags.vector_lvl = Vector_Lvl_2;
02084                }
02085 
02086 #              endif
02087 
02088 #              if defined(_ACCEPT_TASK)
02089 
02090                if (! set_task_option) {
02091                   opt_flags.task_lvl = Task_Lvl_1;
02092                }
02093 
02094 #              endif
02095 
02096             }
02097             else {
02098                err = TRUE;
02099             }
02100 
02101             break;
02102 
02103 
02104          case '3':
02105             if (EQUAL_STRS(cp, "3")) {
02106                opt_flags.support_lvl  = 3;
02107                set_support_lvl_option = TRUE;
02108            
02109                if (! set_scalar_option) {
02110                   opt_flags.scalar_lvl = Scalar_Lvl_2;
02111                }
02112 
02113 #              if defined(_ACCEPT_VECTOR)
02114 
02115                if (! set_vector_option) {
02116                   opt_flags.vector_lvl = Vector_Lvl_3;
02117                }
02118 
02119 #              endif
02120 
02121 #              if defined(_ACCEPT_STREAM)
02122 
02123                if (! set_stream_option) {
02124 
02125 # if defined(_TARGET_SV2)
02126                   opt_flags.stream_lvl = Stream_Lvl_3;
02127 # else
02128                   opt_flags.stream_lvl = Stream_Lvl_0;
02129 # endif
02130                }
02131 
02132 #              endif
02133 
02134 
02135 #              if defined(_ACCEPT_TASK)
02136 
02137                if (! set_task_option) {
02138                   opt_flags.task_lvl = Task_Lvl_2;
02139                }
02140 
02141 #              endif
02142 
02143             }
02144             else {
02145                err = TRUE;
02146             }
02147 
02148             break;
02149 
02150 
02151          case 'a':
02152             if (EQUAL_STRS(cp, "aggress")) {
02153                opt_flags.aggress = TRUE;
02154                set_aggress_option = TRUE;
02155             }
02156             else if (EQUAL_STRS(cp, "allfastint")) {
02157 
02158 # if defined(_ACCEPT_CMD_O_FASTINT)
02159                opt_flags.set_allfastint_option = TRUE;
02160 
02161                if (set_i_option) {
02162                   ntr_msg_queue(0, 1192, Log_Warning, 0,
02163                                 "-i\n-O allfastint\n-i",
02164                                 0, MULT_STR_ARG);
02165                }
02166 # else
02167                ntr_msg_queue(0, 744, Log_Warning, 0,
02168                              "allfastint", 'O', ARG_STR_ARG);
02169 # endif
02170             }
02171             else {
02172                err = TRUE;
02173             }
02174 
02175       break;
02176 
02177 
02178          case 'b':
02179             if (! EQUAL_STRS(cp, "bl")) {
02180                err = TRUE;
02181             }
02182             else {
02183 
02184 #              if defined(_ACCEPT_BL)
02185 
02186                opt_flags.bottom_load  = TRUE;
02187                set_bottom_load_option = TRUE;
02188 
02189 #              else
02190 
02191                ntr_msg_queue(0, 744, Log_Warning, 0, "bl", 'O', ARG_STR_ARG);
02192 
02193 #              endif
02194 
02195             }
02196 
02197             break;
02198     
02199 
02200          case 'f':
02201 
02202             if (EQUAL_STRS(cp, "fastint")) {
02203 
02204 # if defined(_ACCEPT_CMD_O_FASTINT)
02205                opt_flags.set_fastint_option = TRUE;
02206                if (set_i_option) {
02207                   ntr_msg_queue(0, 1192, Log_Warning, 0,
02208                                 "-i\n-O fastint\n-i",
02209                                 0, MULT_STR_ARG);
02210                }
02211 # else
02212                ntr_msg_queue(0, 744, Log_Warning, 0,
02213                             "fastint", 'O', ARG_STR_ARG);
02214 # endif
02215             }
02216             else if (EQUAL_STRS(cp, "fusion")) {
02217 
02218 # if defined(_ACCEPT_CMD_O_FUSION)
02219                opt_flags.fusion = TRUE;
02220 # else
02221                ntr_msg_queue(0, 744, Log_Warning, 0,
02222                             "fusion", 'O', ARG_STR_ARG);
02223 # endif
02224             }
02225             else {
02226                err = TRUE;
02227             }
02228       break;
02229 
02230 
02231          case 'i': 
02232 
02233             if (EQUAL_STRS(cp, "ieeeconform")) {
02234 
02235                if (target_ieee) {
02236                   opt_flags.ieeeconform   = TRUE;
02237                   set_ieeeconform_option  = TRUE;
02238            } 
02239                else {
02240                   ntr_msg_queue(0, 744, Log_Warning, 0,
02241                                "ieeeconform", 'O', ARG_STR_ARG);
02242            } 
02243         }
02244             else if ((strncmp (cp, "inlinefrom=", 11) == IDENTICAL)) {
02245                cp = cp+11;
02246                add_to_fp_table (cp, &inline_path_idx, 'O');
02247                set_inlinefrom_option = TRUE;
02248       }
02249             else if (EQUAL_STRS(cp, "inline0")) {
02250 
02251 #              if defined(_ACCEPT_INLINE)
02252 
02253                opt_flags.inline_lvl = Inline_Lvl_0;   
02254 
02255 #              else
02256 
02257                ntr_msg_queue(0, 744, Log_Warning, 0,
02258                              "inline0", 'O', ARG_STR_ARG);
02259 
02260 #              endif
02261 
02262         }
02263       else if (EQUAL_STRS(cp, "inline1") ||
02264                EQUAL_STRS(cp, "inlinee1")) {
02265 
02266 #              if defined(_ACCEPT_INLINE)
02267 
02268                if (EQUAL_STRS(cp, "inlinee1")) {
02269                   opt_flags.extent_assert = TRUE;
02270                }
02271 
02272          opt_flags.inline_lvl = Inline_Lvl_1;   
02273 
02274 #              else
02275 
02276                ntr_msg_queue(0, 744, Log_Warning, 0,
02277                              "inline1", 'O', ARG_STR_ARG);
02278 
02279 #              endif
02280 
02281       }
02282       else if (EQUAL_STRS(cp, "inline2") ||
02283                EQUAL_STRS(cp, "inlinee2")) {
02284 
02285 #              if defined(_ACCEPT_INLINE)
02286 
02287                if (EQUAL_STRS(cp, "inlinee2")) {
02288                   opt_flags.extent_assert = TRUE;
02289                }
02290 
02291                opt_flags.inline_lvl = Inline_Lvl_2;
02292 
02293 #              else
02294 
02295                ntr_msg_queue(0, 744, Log_Warning, 0,
02296                              "inline2", 'O', ARG_STR_ARG);
02297 
02298 #              endif
02299 
02300       }
02301       else if (EQUAL_STRS(cp, "inline3") ||
02302                EQUAL_STRS(cp, "inlinee3")) {
02303 
02304 #              if defined(_ACCEPT_INLINE)
02305 
02306                if (EQUAL_STRS(cp, "inlinee3")) {
02307                   opt_flags.extent_assert = TRUE;
02308                }
02309 
02310                opt_flags.inline_lvl = Inline_Lvl_3;
02311                ntr_msg_queue(0, 1548, Log_Warning, 0,
02312                              "-O inline3", 0, STR_ARG);
02313 
02314 #              else
02315 
02316                ntr_msg_queue(0, 744, Log_Warning, 0,
02317                              "inline3", 'O', ARG_STR_ARG);
02318 
02319 #              endif
02320       }
02321       else if (EQUAL_STRS(cp, "inline4") ||
02322                EQUAL_STRS(cp, "inlinee4")) {
02323 
02324 #              if defined(_ACCEPT_INLINE)
02325 
02326                if (EQUAL_STRS(cp, "inlinee4")) {
02327                   opt_flags.extent_assert = TRUE;
02328                }
02329 
02330                opt_flags.inline_lvl = Inline_Lvl_4;
02331 
02332 #              else
02333 
02334                ntr_msg_queue(0, 744, Log_Warning, 0,
02335                              "inline4", 'O', ARG_STR_ARG);
02336 
02337 #              endif
02338             }
02339       else {  
02340          err = TRUE;
02341       }
02342 
02343             if (set_debug_option) {
02344                opt_flags.inline_lvl = Inline_Lvl_0;
02345             }
02346 
02347             break;
02348 
02349 
02350          case 'j':
02351 
02352             if (! EQUAL_STRS(cp, "jump")) {
02353                err = TRUE;
02354             }
02355             else {
02356 
02357 #              if defined(_ACCEPT_CMD_O_JUMP)
02358                opt_flags.jump  = TRUE;
02359 #              else
02360                ntr_msg_queue(0, 744, Log_Warning, 0, "jump", 'O', ARG_STR_ARG);
02361 #              endif
02362 
02363             }
02364 
02365             break;
02366 
02367     
02368          case 'l': 
02369 
02370             if ( !EQUAL_STRS(cp, "loopalign")) {
02371                err = TRUE;
02372             }
02373             else {
02374 
02375 #              if defined(_ACCEPT_CMD_O_LOOPALIGN)
02376 
02377                opt_flags.loopalign   = TRUE;
02378                set_loop_align_option = TRUE;
02379 
02380 #              else
02381 
02382                ntr_msg_queue(0, 744, Log_Warning, 0,
02383                              "loopalign", 'O', ARG_STR_ARG);
02384 
02385 #              endif
02386 
02387             }
02388 
02389             break;
02390 
02391 
02392          case 'm': 
02393 
02394             if (EQUAL_STRS(cp, "modinline")) {
02395 
02396 #              if defined(_ACCEPT_INLINE)
02397                opt_flags.modinline = TRUE;
02398 #              else
02399 
02400                ntr_msg_queue(0, 744, Log_Warning, 0,
02401                              "modinline", 'O', ARG_STR_ARG);
02402 
02403 #              endif
02404 
02405             }
02406             else if (EQUAL_STRS(cp, "msgs")) {
02407                opt_flags.msgs = TRUE;
02408             }
02409             else if (strncmp(cp, "mark", 4) == 0) {
02410                opt_flags.mark = TRUE;
02411                cp       +=4;
02412 
02413                if (*cp != EOS) {
02414 
02415                   if (*cp != EQUAL) {
02416                      err = TRUE;
02417                   }
02418                   else {  /* Check strlen ??  KAY */
02419                      ++cp;
02420                      strcpy(opt_flags.mark_name.string, cp);
02421                   }
02422                }
02423             }
02424             else if (EQUAL_STRS(cp, "matmul_inline")) {
02425 
02426 #              if defined(_ACCEPT_CMD_O_MATMUL_INLINE)
02427                   opt_flags.matmul_inline = TRUE;
02428 #              else
02429                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "matmul_inline");
02430 #              endif
02431 
02432             }
02433             else if (EQUAL_STRS(cp, "mv_matmul_inline")) {
02434 
02435 #              if defined(_ACCEPT_CMD_O_MATMUL_INLINE)
02436                   opt_flags.mv_matmul_inline = TRUE;
02437 #              else
02438                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "mv_matmul_inline");
02439 #              endif
02440 
02441             }
02442             else { 
02443                err = TRUE;
02444             }
02445 
02446             break;
02447 
02448 
02449          case 'n': 
02450 
02451             if (EQUAL_STRS(cp, "negmsgs")) {
02452                opt_flags.neg_msgs = TRUE;
02453             }
02454             else if (EQUAL_STRS(cp, "noaggress")) {
02455                opt_flags.aggress = FALSE;
02456             }
02457             else if (EQUAL_STRS(cp, "nobl")) {
02458 
02459 #              if defined(_ACCEPT_BL)
02460 
02461          opt_flags.bottom_load = FALSE;
02462 
02463 #              else
02464 
02465                ntr_msg_queue(0, 744, Log_Warning, 0, "nobl", 'O', ARG_STR_ARG);
02466 
02467 #              endif
02468 
02469             } 
02470             else if (EQUAL_STRS(cp, "nofastint")) {
02471 
02472 # if defined(_ACCEPT_CMD_O_FASTINT)
02473                opt_flags.set_nofastint_option = TRUE;
02474 
02475                if (set_i_option) {
02476                   ntr_msg_queue(0, 1192, Log_Warning, 0,
02477                                 "-i\n-O nofastint\n-i",
02478                                 0, MULT_STR_ARG);
02479                }
02480 # else
02481                ntr_msg_queue(0, 744, Log_Warning, 0,
02482                              "nofastint", 'O', ARG_STR_ARG);
02483 # endif
02484 
02485             }
02486             else if (EQUAL_STRS(cp, "nofusion")) {
02487 
02488 # if defined(_ACCEPT_CMD_O_FUSION)
02489                opt_flags.fusion = FALSE;
02490 # else
02491                ntr_msg_queue(0, 744, Log_Warning, 0,
02492                              "nofusion", 'O', ARG_STR_ARG);
02493 # endif
02494             }
02495             else if (EQUAL_STRS(cp, "noieeeconform")) {
02496 
02497                if (target_ieee) {
02498                   opt_flags.ieeeconform   = FALSE;
02499                   set_ieeeconform_option  = TRUE;
02500            } 
02501                else {
02502                   ntr_msg_queue(0, 744, Log_Warning, 0,
02503                                 "noieeeconform", 'O', ARG_STR_ARG);
02504            } 
02505         }
02506             else if (EQUAL_STRS(cp, "nointerchange")) {
02507                opt_flags.nointerchange    = TRUE;
02508         }
02509             else if (EQUAL_STRS(cp, "nojump")) {
02510 
02511 #              if defined(_ACCEPT_CMD_O_JUMP)
02512 
02513          opt_flags.jump = FALSE;
02514 
02515 #              else
02516 
02517                ntr_msg_queue(0, 744, Log_Warning, 0,
02518                              "nojump", 'O', ARG_STR_ARG);
02519 
02520 #              endif
02521 
02522             }
02523             else if (EQUAL_STRS(cp, "noloopalign")) {
02524 
02525 #              if defined(_ACCEPT_CMD_O_LOOPALIGN)
02526 
02527          opt_flags.loopalign = FALSE;
02528 
02529 #              else
02530 
02531                ntr_msg_queue(0, 744, Log_Warning, 0,
02532                              "noloopalign", 'O', ARG_STR_ARG);
02533 
02534 #              endif
02535 
02536             }
02537             else if (EQUAL_STRS(cp, "nomodinline")) {
02538 
02539 #              if defined(_ACCEPT_INLINE)
02540                opt_flags.modinline = FALSE;
02541 #              else
02542 
02543                ntr_msg_queue(0, 744, Log_Warning, 0,
02544                              "nomodinline", 'O', ARG_STR_ARG);
02545 
02546 #              endif
02547 
02548             }
02549             else if (EQUAL_STRS(cp, "nomsgs")) {
02550                opt_flags.msgs = FALSE;
02551             }
02552             else if (EQUAL_STRS(cp, "nonegmsgs")) {
02553                opt_flags.neg_msgs = FALSE;
02554             }
02555             else if (EQUAL_STRS(cp, "nopattern")) {
02556          opt_flags.pattern = FALSE;
02557             }
02558             else if (EQUAL_STRS(cp, "nooverindex")) {
02559                opt_flags.over_index = FALSE;
02560             }
02561             else if (EQUAL_STRS(cp, "norecurrence")) {
02562                opt_flags.recurrence = FALSE;
02563             }
02564             else if (EQUAL_STRS(cp, "notaskinner")) {
02565 
02566 #              if defined(_ACCEPT_TASK)
02567 
02568          opt_flags.taskinner = FALSE;
02569 
02570 #              else
02571 
02572                ntr_msg_queue(0, 744, Log_Warning, 0,
02573                              "notaskinner", 'O', ARG_STR_ARG);
02574 
02575 #              endif
02576 
02577             }
02578             else if (EQUAL_STRS(cp, "nothreshold")) {
02579 
02580 #              if defined(_ACCEPT_TASK)
02581 
02582                opt_flags.threshold  = FALSE;
02583 
02584 #              else
02585 
02586                ntr_msg_queue(0, 744, Log_Warning, 0,
02587                              "nothreshold", 'O', ARG_STR_ARG);
02588 
02589 #              endif
02590             }
02591             else if (EQUAL_STRS(cp, "novsearch")) {
02592 
02593 #              if defined(_ACCEPT_VSEARCH)
02594 
02595          opt_flags.vsearch = FALSE;
02596 
02597 #              else
02598 
02599                ntr_msg_queue(0, 744, Log_Warning, 0,
02600                              "novsearch", 'O', ARG_STR_ARG);
02601 
02602 #              endif
02603 
02604             }
02605             else if (EQUAL_STRS(cp, "nozeroinc")) {
02606 
02607 #              if defined(_ACCEPT_CMD_O_ZEROINC)
02608 
02609          opt_flags.zeroinc = FALSE;
02610 
02611 #              else
02612 
02613                ntr_msg_queue(0, 744, Log_Warning, 0,
02614                              "nozeroinc", 'O', ARG_STR_ARG);
02615 
02616 #              endif
02617 
02618             }
02619             else {
02620                err = TRUE;
02621             }
02622 
02623             break;
02624 
02625 
02626          case 'o':
02627 
02628             if (EQUAL_STRS(cp, "overindex")) {
02629                opt_flags.over_index = TRUE;
02630             }
02631             else if (EQUAL_STRS(cp, "opt_info")) {
02632 
02633 #              if defined(_ACCEPT_CMD_O_OPT_INFO)
02634                   opt_flags.opt_info  = TRUE;
02635 #              else
02636                   ntr_msg_queue(0, 744, Log_Warning, 0,
02637                                 "opt_info", 'O', ARG_STR_ARG);
02638 #              endif
02639             }
02640             else {
02641                err = TRUE;
02642             }
02643 
02644             break;
02645 
02646 
02647          case 'p': 
02648 
02649             if (EQUAL_STRS(cp, "pattern")) {
02650                opt_flags.pattern  = TRUE;
02651                set_pattern_option = TRUE;
02652             }
02653             else if (EQUAL_STRS(cp, "pipeline0")) {
02654 
02655 #              if defined(_ACCEPT_CMD_O_PIPELINE)
02656                   opt_flags.pipeline_lvl  = 0;
02657                   set_pipeline_option   = TRUE;
02658 #              else
02659                   ntr_msg_queue(0, 744, Log_Warning, 0,
02660                                 "pipeline0", 'O', ARG_STR_ARG);
02661 #              endif
02662             }
02663             else if (EQUAL_STRS(cp, "pipeline1")) {
02664 
02665 #              if defined(_ACCEPT_CMD_O_PIPELINE)
02666                   opt_flags.pipeline_lvl  = 1;
02667                   set_pipeline_option   = TRUE;
02668 #              else
02669                   ntr_msg_queue(0, 744, Log_Warning, 0,
02670                                 "pipeline1", 'O', ARG_STR_ARG);
02671 #              endif
02672             }
02673             else if (EQUAL_STRS(cp, "pipeline2")) {
02674 
02675 #              if defined(_ACCEPT_CMD_O_PIPELINE)
02676                   opt_flags.pipeline_lvl  = 2;
02677                   set_pipeline_option   = TRUE;
02678 #              else
02679                   ntr_msg_queue(0, 744, Log_Warning, 0,
02680                                 "pipeline2", 'O', ARG_STR_ARG);
02681 #              endif
02682             }
02683             else if (EQUAL_STRS(cp, "pipeline3")) {
02684 
02685 #              if defined(_ACCEPT_CMD_O_PIPELINE)
02686                   opt_flags.pipeline_lvl  = 3;
02687                   set_pipeline_option   = TRUE;
02688 #              else
02689                   ntr_msg_queue(0, 744, Log_Warning, 0,
02690                                 "pipeline3", 'O', ARG_STR_ARG);
02691 #              endif
02692             }
02693             else {
02694                err = TRUE;
02695             }
02696 
02697             break;
02698 
02699     
02700          case 'r': 
02701 
02702             if (EQUAL_STRS(cp, "reshape")) {
02703 
02704 #  if defined(_ACCEPT_CMD_O_RESHAPE)
02705                opt_flags.reshape_all_arrays = TRUE;
02706                opt_flags.reshape    = TRUE;
02707 # else
02708                ntr_msg_queue(0, 744, Log_Warning, 0,
02709                             "reshape", 'O', ARG_STR_ARG);
02710 # endif
02711             }
02712             else if ((strncmp (cp, "reshape=", 8) == IDENTICAL)) {
02713                cp += 8;
02714                process_reshape_array(cp);
02715             }
02716             else if (! EQUAL_STRS(cp, "recurrence")) {
02717                err = TRUE;
02718             }
02719             else {
02720                opt_flags.recurrence  = TRUE;
02721                set_recurrence_option = TRUE;
02722             }
02723 
02724             break;
02725 
02726 
02727          case 's':
02728 
02729             if (EQUAL_STRS(cp, "scalar0")) {
02730                opt_flags.scalar_lvl = Scalar_Lvl_0;
02731                set_scalar_option    = TRUE;
02732             }
02733             else if (EQUAL_STRS(cp, "scalar1")) {
02734                opt_flags.scalar_lvl = Scalar_Lvl_1;
02735                set_scalar_option    = TRUE;
02736             }
02737             else if (EQUAL_STRS(cp, "scalar2")) {
02738                opt_flags.scalar_lvl = Scalar_Lvl_2;
02739                set_scalar_option    = TRUE;
02740             }
02741             else if (EQUAL_STRS(cp, "scalar3")) {
02742                opt_flags.scalar_lvl = Scalar_Lvl_3;
02743                set_scalar_option    = TRUE;
02744             }
02745             else if (EQUAL_STRS(cp, "split0")) {
02746 
02747 #              if defined(_ACCEPT_SPLIT)
02748                   opt_flags.split_lvl = Split_Lvl_0;
02749 #              else
02750                   ntr_msg_queue(0, 744, Log_Warning, 0,
02751                                 "split0", 'O', ARG_STR_ARG);
02752 #              endif
02753             }
02754             else if (EQUAL_STRS(cp, "split1")) {
02755 
02756 #              if defined(_ACCEPT_SPLIT)
02757                   opt_flags.split_lvl = Split_Lvl_1;
02758 
02759 #              else
02760                   ntr_msg_queue(0, 744, Log_Warning, 0,
02761                                 "split1", 'O', ARG_STR_ARG);
02762 #              endif
02763             }
02764             else if (EQUAL_STRS(cp, "split2")) {
02765 
02766 #              if defined(_ACCEPT_SPLIT)
02767                   opt_flags.split_lvl = Split_Lvl_2;
02768 #             else 
02769                   ntr_msg_queue(0, 744, Log_Warning, 0,
02770                                 "split2", 'O', ARG_STR_ARG);
02771 #              endif
02772             }
02773             else if (EQUAL_STRS(cp, "shortcircuit0")) {
02774 
02775 #              if defined(_ACCEPT_SHORTCIRCUIT)
02776                   opt_flags.short_circuit_lvl = Short_Circuit_Off;
02777 #              else
02778                   ntr_msg_queue(0, 744, Log_Warning, 0,
02779                                 "shortcircuit0", 'O', ARG_STR_ARG);
02780 #              endif
02781 
02782             }
02783             else if (EQUAL_STRS(cp, "shortcircuit1")) {
02784 
02785 #              if defined(_ACCEPT_SHORTCIRCUIT)
02786                   opt_flags.short_circuit_lvl = Short_Circuit_Present;
02787 #              else
02788                   ntr_msg_queue(0, 744, Log_Warning, 0,
02789                                 "shortcircuit1", 'O', ARG_STR_ARG);
02790 #              endif
02791 
02792             }
02793             else if (EQUAL_STRS(cp, "shortcircuit2")) {
02794 
02795 #              if defined(_ACCEPT_SHORTCIRCUIT)
02796                   opt_flags.short_circuit_lvl = Short_Circuit_Left_Right;
02797 #              else
02798                   ntr_msg_queue(0, 744, Log_Warning, 0,
02799                                 "shortcircuit2", 'O', ARG_STR_ARG);
02800 #              endif
02801 
02802             }
02803             else if (EQUAL_STRS(cp, "shortcircuit3")) {
02804 
02805 #              if defined(_ACCEPT_SHORTCIRCUIT)
02806                   opt_flags.short_circuit_lvl = Short_Circuit_Functions;
02807 #              else
02808                   ntr_msg_queue(0, 744, Log_Warning, 0,
02809                                 "shortcircuit3", 'O', ARG_STR_ARG);
02810 #              endif
02811 
02812             }
02813             else if (EQUAL_STRS(cp, "stream0")) {
02814 
02815                if (accept_stream) { 
02816                   set_stream_option = TRUE;
02817                   opt_flags.stream_lvl  = Stream_Lvl_0;
02818                }
02819                else {
02820                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "stream0");
02821                }
02822             }
02823             else if (EQUAL_STRS(cp, "stream1")) {
02824 
02825                if (accept_stream) { 
02826                   set_stream_option = TRUE;
02827                   opt_flags.stream_lvl  = Stream_Lvl_1;
02828                }
02829                else {
02830                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "stream1");
02831                }
02832             }
02833             else if (EQUAL_STRS(cp, "stream2")) {
02834 
02835                if (accept_stream) { 
02836                   set_stream_option = TRUE;
02837                   opt_flags.stream_lvl  = Stream_Lvl_2;
02838                }
02839                else {
02840                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "stream2");
02841                }
02842             }
02843             else if (EQUAL_STRS(cp, "stream3")) {
02844 
02845                if (accept_stream) { 
02846                   set_stream_option = TRUE;
02847                   opt_flags.stream_lvl  = Stream_Lvl_3;
02848                }
02849                else {
02850                   PRINTMSG (0, 744, Log_Warning, 0, 'O', "stream3");
02851                }
02852             }
02853             else {
02854                err = TRUE;
02855             }
02856 
02857             break;
02858 
02859 
02860          case 't': 
02861 
02862             if (EQUAL_STRS(cp, "task0")) {
02863 
02864 #              if defined(_ACCEPT_TASK)
02865 
02866                opt_flags.task_lvl = Task_Lvl_0;
02867                set_task_option    = TRUE;
02868 
02869 #              else
02870 
02871                ntr_msg_queue(0, 744, Log_Warning, 0, "task0", 'O', ARG_STR_ARG);
02872 
02873 #              endif
02874 
02875             }
02876             else if (EQUAL_STRS(cp, "task1")) {
02877 
02878 #              if defined(_ACCEPT_TASK)
02879 
02880                opt_flags.task_lvl = Task_Lvl_1;
02881                set_task_option    = TRUE;
02882 
02883 #              else
02884 
02885                ntr_msg_queue(0, 744, Log_Warning, 0, "task1", 'O', ARG_STR_ARG);
02886 
02887 #              endif
02888 
02889             }
02890             else if (EQUAL_STRS(cp, "task2")) {
02891 
02892 #              if defined(_ACCEPT_TASK)
02893 
02894                opt_flags.task_lvl = Task_Lvl_2;
02895                set_task_option    = TRUE;
02896 
02897 #              else
02898 
02899                ntr_msg_queue(0, 744, Log_Warning, 0, "task2", 'O', ARG_STR_ARG);
02900 
02901 #              endif
02902 
02903             }
02904             else if (EQUAL_STRS(cp, "task3")) {
02905 
02906 #              if defined(_ACCEPT_TASK)
02907 
02908                opt_flags.task_lvl = Task_Lvl_3;
02909                set_task_option    = TRUE;
02910 
02911 #              else
02912 
02913                ntr_msg_queue(0, 744, Log_Warning, 0, "task3", 'O', ARG_STR_ARG);
02914 
02915 #              endif
02916 
02917             }
02918             else if (EQUAL_STRS(cp, "taskinner")) {
02919 
02920 #              if defined(_ACCEPT_TASK)
02921 
02922                opt_flags.taskinner  = TRUE;
02923                set_taskinner_option = TRUE;
02924 
02925 #              else
02926 
02927                ntr_msg_queue(0, 744, Log_Warning, 0,
02928                              "taskinner", 'O', ARG_STR_ARG);
02929 
02930 #              endif
02931 
02932             }
02933             else if (EQUAL_STRS(cp, "threshold")) {
02934 
02935 #              if defined(_ACCEPT_TASK)
02936                opt_flags.threshold  = TRUE;
02937 #              else
02938                ntr_msg_queue(0, 744, Log_Warning, 0,
02939                              "threshold", 'O', ARG_STR_ARG);
02940 #              endif
02941             }
02942             else {
02943                err = TRUE;
02944             }
02945 
02946             break;
02947 
02948 
02949          case 'u':
02950 
02951             if (EQUAL_STRS(cp, "unroll0")) {
02952 
02953 #              if defined(_ACCEPT_CMD_O_UNROLL)
02954             opt_flags.unroll_lvl = Unroll_Lvl_0;
02955 #              else
02956                   ntr_msg_queue(0, 744, Log_Warning, 0,
02957                                 "unroll0", 'O', ARG_STR_ARG);
02958 #              endif
02959             }
02960             else if (EQUAL_STRS(cp, "unroll1")) {
02961    
02962 #              if defined(_ACCEPT_CMD_O_UNROLL)
02963             opt_flags.unroll_lvl = Unroll_Lvl_1;
02964 #              else
02965                   ntr_msg_queue(0, 744, Log_Warning, 0,
02966                                 "unroll1", 'O', ARG_STR_ARG);
02967 #              endif
02968             }
02969             else if (EQUAL_STRS(cp, "unroll2")) {
02970 
02971 #              if defined(_ACCEPT_CMD_O_UNROLL)
02972             opt_flags.unroll_lvl = Unroll_Lvl_2;
02973 #              else
02974                   ntr_msg_queue(0, 744, Log_Warning, 0,
02975                                 "unroll2", 'O', ARG_STR_ARG);
02976 #              endif
02977             }
02978             else {
02979                err = TRUE;
02980             }
02981             break;
02982 
02983 
02984          case 'v':
02985 
02986             if (EQUAL_STRS(cp, "vector0")) {
02987 
02988 #              if defined(_ACCEPT_VECTOR)
02989             opt_flags.vector_lvl = Vector_Lvl_0;
02990                   set_vector_option    = TRUE;
02991 #              else
02992                   ntr_msg_queue(0, 744, Log_Warning, 0,
02993                                 "vector0", 'O', ARG_STR_ARG);
02994 #              endif
02995 
02996             }
02997             else if (EQUAL_STRS(cp, "vector1")) {
02998 
02999 #              if defined(_ACCEPT_VECTOR)
03000 
03001                opt_flags.vector_lvl = Vector_Lvl_1;
03002                set_vector_option    = TRUE;
03003 
03004 #              else
03005 
03006                ntr_msg_queue(0, 744, Log_Warning, 0,
03007                              "vector1", 'O', ARG_STR_ARG);
03008 
03009 #              endif
03010 
03011             }
03012             else if (EQUAL_STRS(cp, "vector2")) {
03013 
03014 #              if defined(_ACCEPT_VECTOR)
03015 
03016                opt_flags.vector_lvl = Vector_Lvl_2;
03017                set_vector_option    = TRUE;
03018 
03019 #              else
03020 
03021                ntr_msg_queue(0, 744, Log_Warning, 0,
03022                              "vector2", 'O', ARG_STR_ARG);
03023 
03024 #              endif
03025 
03026             }
03027             else if (EQUAL_STRS(cp, "vector3")) {
03028 
03029 #              if defined(_ACCEPT_VECTOR)
03030 
03031                opt_flags.vector_lvl = Vector_Lvl_3;
03032                set_vector_option    = TRUE;
03033 
03034 #              else
03035 
03036                ntr_msg_queue(0, 744, Log_Warning, 0,
03037                              "vector3", 'O', ARG_STR_ARG);
03038 
03039 #              endif
03040 
03041             }
03042             else if (EQUAL_STRS(cp, "vsearch")) {
03043 
03044 #              if defined(_ACCEPT_VSEARCH)
03045 
03046          opt_flags.vsearch  = TRUE;
03047          set_vsearch_option = TRUE;
03048 
03049 #              else
03050 
03051                ntr_msg_queue(0, 744, Log_Warning, 0,
03052                              "vsearch", 'O', ARG_STR_ARG);
03053 
03054 #              endif
03055 
03056             }
03057             else {
03058                err = TRUE;
03059             }
03060 
03061             break;
03062 
03063 
03064          case 'z':
03065 
03066             if (! EQUAL_STRS(cp, "zeroinc")) {
03067                err = TRUE;
03068             }
03069             else {
03070 
03071 #              if defined(_ACCEPT_CMD_O_ZEROINC)
03072 
03073                opt_flags.zeroinc  = TRUE;
03074                set_zeroinc_option = TRUE;
03075 
03076 #              else
03077 
03078                ntr_msg_queue(0, 744, Log_Warning, 0,
03079                              "zeroinc", 'O', ARG_STR_ARG);
03080 
03081 #              endif
03082 
03083             }
03084 
03085             break;
03086 
03087 
03088          default:
03089             err = TRUE;
03090             break;
03091       }                            /* End -O argument switch.                 */
03092 
03093 
03094       /* Option has an invalid argument?                    */
03095 
03096       if (err) {
03097 
03098          if (first && (argc == optind)) {
03099 
03100             /* We're seeing something similar to -O end.f        */
03101             /* This is the first time through the while loop     */
03102             /* and there is nothing on the commandline following */
03103             /* the -O and its argument.  We will assume this is  */
03104             /* a lone -O and that the argument is really the     */
03105             /* file to be compiled.  We could also be seeing     */
03106             /* -O vctor where the input is expected to be from   */
03107             /* stdin, but we'll go with the first choice because */
03108             /* it could be correct.  If we didn't we might be    */
03109             /* issuing an error for a valid commandline.         */
03110 
03111             ntr_msg_queue(0, 1221, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
03112             --optind;
03113          }
03114          else {
03115             ntr_msg_queue(0, 78, Log_Error, 0, cp, 'O', ARG_STR_ARG);
03116          }
03117       }
03118 
03119       first = FALSE;
03120    }                               /* End -O argument WHILE loop.       */
03121 
03122    TRACE (Func_Exit, "process_O_option", NULL);
03123 
03124    return;
03125 
03126 }  /* process_O_option */
03127 
03128 
03129 /******************************************************************************\
03130 |*                        *|
03131 |* Description:                     *|
03132 |*  Validate_O_option is called to check the precedence of optimization   *|
03133 |*  options selected.                 *|
03134 |*                        *|
03135 |* Input parameters:                    *|
03136 |*  NONE                      *|
03137 |*                        *|
03138 |* Output parameters:                   *|
03139 |*  NONE                      *|
03140 |*                        *|
03141 |* Returns:                     *|
03142 |*  NOTHING                     *|
03143 |*                        *|
03144 \******************************************************************************/
03145 
03146 static void validate_O_option (void)
03147 
03148 {
03149    char    msg_str[30];
03150    boolean   option_conflict  = FALSE;
03151    int     scalar;
03152    char   *str;
03153    int     task;
03154 
03155 #  if defined(_ACCEPT_VECTOR)
03156    int     vector;
03157 #  endif
03158 
03159 
03160    TRACE (Func_Entry, "validate_O_option", NULL);
03161 
03162    /* If a general optimization option (-O<number>) was specified, no         */
03163    /* specific option (such as -Otask1) can be specified, even if the specific*/
03164    /* option is one that would be implied by the general option.        */
03165 
03166    if (set_support_lvl_option) {
03167 
03168       if (set_scalar_option) {
03169          ntr_msg_queue(0, 1535, Log_Error, 0, 
03170                        scalar_lvl_str[opt_flags.scalar_lvl],
03171                        (long) opt_flags.support_lvl, ARG_STR_ARG);
03172          option_conflict = TRUE;
03173       }
03174 
03175       if (set_vector_option) {
03176          ntr_msg_queue(0, 1535, Log_Error, 0, 
03177                        vector_lvl_str[opt_flags.vector_lvl],
03178                        (long) opt_flags.support_lvl, ARG_STR_ARG);
03179          option_conflict = TRUE;
03180       }
03181 
03182       if (set_task_option) {
03183          ntr_msg_queue(0, 1535, Log_Error, 0, 
03184                        task_lvl_str[opt_flags.task_lvl],
03185                        (long) opt_flags.support_lvl, ARG_STR_ARG);
03186          option_conflict = TRUE;
03187       }
03188    }
03189 
03190    if (option_conflict) {
03191       goto EXIT;
03192    }
03193 
03194    /* Need to check for errors and possibly reset defaults.  An error is set  */
03195    /* if the user requests an invalid combination, but if a user requests a   */
03196    /* valid combination any options not set by the user are adjusted and a    */
03197    /* warning message is issued.  The scalar option is always allowed.  This  */
03198    /* code only needs to be executed if another option, task or vector is     */
03199    /* allowed.                        */
03200 
03201 # ifdef _ACCEPT_TASK
03202 
03203    if (set_taskinner_option  &&  opt_flags.taskinner) {
03204 
03205       if (set_task_option  ||  set_support_lvl_option) {
03206 
03207          if (opt_flags.task_lvl < Task_Lvl_2) {
03208             ntr_msg_queue(0, 1182, Log_Error, 0, (char *) NULL, 0, NO_ARG);
03209          }
03210       }
03211       else {
03212          ntr_msg_queue(0, 1182, Log_Error, 0, (char *) NULL, 0, NO_ARG);
03213       }
03214    }
03215 
03216 # endif
03217 
03218 
03219 #  if defined(_ACCEPT_TASK) && defined(_ACCEPT_VECTOR)
03220 
03221    if (! set_vector_option  &&  ! set_scalar_option  &&  ! set_task_option) {
03222       goto CONTINUE;   /* Nothing is set.  No checking needs to be done. */
03223    }
03224 
03225    if (set_vector_option && set_scalar_option && set_task_option) {
03226 
03227       if (opt_flags.scalar_lvl >= opt_flags.vector_lvl &&
03228           opt_flags.vector_lvl >= opt_flags.task_lvl) {
03229 
03230          /* okay - intentionally blank */
03231       }
03232       else if (opt_flags.task_lvl > Task_Lvl_1 &&
03233                opt_flags.task_lvl > opt_flags.vector_lvl) {
03234          msg_str[0] = NULL_CHAR;
03235          strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]);
03236          strcpy(&msg_str[7], "\n");
03237          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]);
03238          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03239       }
03240       else if (opt_flags.scalar_lvl == Scalar_Lvl_2 &&
03241                opt_flags.vector_lvl == Vector_Lvl_3) {
03242 
03243          /* Okay - intentionally blank */
03244          /* Rule exception - scalar2, vector3  */
03245       }
03246       else if (opt_flags.scalar_lvl < opt_flags.vector_lvl) {
03247          msg_str[0] = NULL_CHAR;
03248          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]);
03249          strcpy(&msg_str[7], "\n");
03250          strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]);
03251          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03252       }
03253    }
03254    else if (set_vector_option  &&  set_scalar_option) {
03255 
03256       if (opt_flags.scalar_lvl == Scalar_Lvl_2  &&
03257           opt_flags.vector_lvl == Vector_Lvl_3) {
03258 
03259          /* Okay - intentionally blank */
03260          /* Rule exception - scalar2, vector3  */
03261          /* If vector3, task can be anything */
03262       }
03263       else if (opt_flags.scalar_lvl < opt_flags.vector_lvl) {
03264          msg_str[0] = NULL_CHAR;
03265          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]);
03266          strcpy(&msg_str[7], "\n");
03267          strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]);
03268          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03269       }
03270       else if (opt_flags.task_lvl > opt_flags.vector_lvl  &&
03271                opt_flags.task_lvl > Task_Lvl_1) {
03272          task = (opt_flags.vector_lvl == Vector_Lvl_0) ?
03273                  Task_Lvl_1 : opt_flags.vector_lvl;
03274 
03275          msg_str[0] = NULL_CHAR;
03276          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03277          strcpy(&msg_str[7], "\n");
03278          strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]); 
03279          strcpy(&msg_str[15], "\n");
03280          strcpy(&msg_str[16], task_lvl_str[opt_flags.task_lvl]); 
03281          strcpy(&msg_str[21], "\n");
03282          strcpy(&msg_str[22], task_lvl_str[task]); 
03283 
03284          ntr_msg_queue(0, 1064, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03285          opt_flags.task_lvl = task;
03286       }
03287    }
03288    else if (set_scalar_option  &&  set_task_option) {
03289 
03290       if (opt_flags.task_lvl == Task_Lvl_3  &&
03291           opt_flags.scalar_lvl == Scalar_Lvl_2) {
03292 
03293          /* Rule exception - Scalar2, Task3 is okay. */
03294 
03295          if (opt_flags.vector_lvl != Vector_Lvl_3) {
03296             msg_str[0] = NULL_CHAR;
03297             strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03298             strcpy(&msg_str[7], "\n");
03299             strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03300             strcpy(&msg_str[13], "\n");
03301             strcpy(&msg_str[14], vector_lvl_str[opt_flags.vector_lvl]); 
03302             strcpy(&msg_str[21], "\n");
03303             strcpy(&msg_str[22], vector_lvl_str[Vector_Lvl_3]); 
03304 
03305             ntr_msg_queue(0, 1064, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03306             opt_flags.vector_lvl = Vector_Lvl_3;
03307          }
03308       }
03309       else if (opt_flags.task_lvl <= Task_Lvl_1) {
03310 
03311          /* Just check scalar and vector */
03312 
03313          if (opt_flags.vector_lvl > opt_flags.scalar_lvl) {
03314             vector = opt_flags.scalar_lvl;
03315             msg_str[0] = NULL_CHAR;
03316             strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03317             strcpy(&msg_str[7], "\n");
03318             strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03319             strcpy(&msg_str[13], "\n");
03320             strcpy(&msg_str[14], vector_lvl_str[opt_flags.vector_lvl]); 
03321             strcpy(&msg_str[21], "\n");
03322             strcpy(&msg_str[22], vector_lvl_str[vector]); 
03323 
03324             ntr_msg_queue(0, 1064, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03325             opt_flags.vector_lvl = vector;
03326          }
03327       }
03328       else if (opt_flags.task_lvl > opt_flags.scalar_lvl) {
03329          msg_str[0] = NULL_CHAR;
03330          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]);
03331          strcpy(&msg_str[7], "\n");
03332          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]);
03333          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03334       }
03335       else if (opt_flags.task_lvl > opt_flags.vector_lvl) {
03336          vector = opt_flags.task_lvl;
03337          msg_str[0] = NULL_CHAR;
03338          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03339          strcpy(&msg_str[7], "\n");
03340          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03341          strcpy(&msg_str[13], "\n");
03342          strcpy(&msg_str[14], vector_lvl_str[opt_flags.vector_lvl]); 
03343          strcpy(&msg_str[21], "\n");
03344          strcpy(&msg_str[22], vector_lvl_str[vector]); 
03345          ntr_msg_queue(0, 1064, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03346 
03347          opt_flags.vector_lvl = vector;
03348       }
03349    }
03350    else if (set_vector_option  &&  set_task_option) {
03351 
03352       if (opt_flags.task_lvl > Task_Lvl_1 &&
03353           opt_flags.task_lvl > opt_flags.vector_lvl) {
03354          msg_str[0] = NULL_CHAR;
03355          strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]);
03356          strcpy(&msg_str[7], "\n");
03357          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]);
03358          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03359       }
03360       else if (opt_flags.vector_lvl > opt_flags.scalar_lvl) {
03361 
03362          if (opt_flags.scalar_lvl == Scalar_Lvl_2) {
03363 
03364             /* Rule exception - scalar2, vector3   If vector is         */
03365             /* Vector_Lvl_3 then task can be anything so this is legal. */
03366          }
03367          else {
03368             scalar = (opt_flags.vector_lvl == Vector_Lvl_3) ?
03369                      Scalar_Lvl_2 : opt_flags.vector_lvl;
03370             msg_str[0] = NULL_CHAR;
03371             strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]); 
03372             strcpy(&msg_str[7], "\n");
03373             strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03374             strcpy(&msg_str[13], "\n");
03375             strcpy(&msg_str[14], scalar_lvl_str[opt_flags.scalar_lvl]); 
03376             strcpy(&msg_str[21], "\n");
03377             strcpy(&msg_str[22], scalar_lvl_str[scalar]); 
03378             ntr_msg_queue(0, 1064, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03379 
03380             opt_flags.scalar_lvl = scalar;
03381          }
03382       }
03383    }
03384    else if (set_scalar_option) {
03385 
03386       if (opt_flags.vector_lvl > opt_flags.scalar_lvl) { 
03387          vector = opt_flags.scalar_lvl;
03388          msg_str[0] = NULL_CHAR;
03389          strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03390          strcpy(&msg_str[7], "\n");
03391          strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]); 
03392          strcpy(&msg_str[15], "\n");
03393          strcpy(&msg_str[16], vector_lvl_str[vector]); 
03394 
03395          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03396          opt_flags.vector_lvl = vector;
03397       }
03398 
03399       if (opt_flags.task_lvl > opt_flags.vector_lvl  && 
03400           opt_flags.task_lvl > Task_Lvl_1) {
03401          task = (opt_flags.vector_lvl == Vector_Lvl_0) ?
03402                  Task_Lvl_1 : opt_flags.vector_lvl;
03403          msg_str[0] = NULL_CHAR;
03404          strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]); 
03405          strcpy(&msg_str[7], "\n");
03406          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03407          strcpy(&msg_str[13], "\n");
03408          strcpy(&msg_str[14], task_lvl_str[task]); 
03409 
03410          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03411          opt_flags.task_lvl = task;
03412       }
03413    }
03414    else if (set_vector_option) {
03415 
03416       if (opt_flags.vector_lvl > opt_flags.scalar_lvl  && 
03417           opt_flags.scalar_lvl != Scalar_Lvl_2) {
03418 
03419          /* Raise scalar lvl unless vector is level 3 */
03420 
03421          scalar = (opt_flags.vector_lvl == Vector_Lvl_3) ?
03422                    Scalar_Lvl_2 : opt_flags.vector_lvl;
03423          msg_str[0] = NULL_CHAR;
03424          strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]); 
03425          strcpy(&msg_str[7], "\n");
03426          strcpy(&msg_str[8], scalar_lvl_str[opt_flags.scalar_lvl]); 
03427          strcpy(&msg_str[15], "\n");
03428          strcpy(&msg_str[16], scalar_lvl_str[scalar]); 
03429 
03430          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03431          opt_flags.scalar_lvl = scalar;
03432       }
03433 
03434       if (opt_flags.task_lvl > opt_flags.vector_lvl  && 
03435           opt_flags.task_lvl > Task_Lvl_1) {
03436 
03437          task = (opt_flags.vector_lvl == Vector_Lvl_0) ?
03438                  Task_Lvl_1 : opt_flags.vector_lvl;
03439          msg_str[0] = NULL_CHAR;
03440          strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]); 
03441          strcpy(&msg_str[7], "\n");
03442          strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03443          strcpy(&msg_str[13], "\n");
03444          strcpy(&msg_str[14], task_lvl_str[task]); 
03445 
03446          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03447          opt_flags.task_lvl = task;
03448       }
03449    }
03450    else if (set_task_option && opt_flags.task_lvl > Task_Lvl_1) {
03451 
03452       if (opt_flags.scalar_lvl < opt_flags.task_lvl  && 
03453           opt_flags.scalar_lvl != Scalar_Lvl_2) {
03454          scalar = (opt_flags.task_lvl == Task_Lvl_3) ?
03455                    Scalar_Lvl_2 : opt_flags.task_lvl;
03456          msg_str[0] = NULL_CHAR;
03457          strcpy(msg_str, task_lvl_str[opt_flags.task_lvl]); 
03458          strcpy(&msg_str[5], "\n");
03459          strcpy(&msg_str[6], scalar_lvl_str[opt_flags.scalar_lvl]); 
03460          strcpy(&msg_str[13], "\n");
03461          strcpy(&msg_str[14], scalar_lvl_str[scalar]); 
03462 
03463          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03464          opt_flags.scalar_lvl = scalar;
03465       }
03466 
03467       if (opt_flags.task_lvl > opt_flags.vector_lvl) { 
03468          vector = opt_flags.task_lvl;
03469          msg_str[0] = NULL_CHAR;
03470          strcpy(msg_str, task_lvl_str[opt_flags.task_lvl]); 
03471          strcpy(&msg_str[5], "\n");
03472          strcpy(&msg_str[6], vector_lvl_str[opt_flags.vector_lvl]); 
03473          strcpy(&msg_str[13], "\n");
03474          strcpy(&msg_str[14], vector_lvl_str[vector]); 
03475 
03476          ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03477          opt_flags.vector_lvl = vector;
03478       }
03479    }
03480 
03481 #  elif defined(_ACCEPT_TASK) && !defined(_ACCEPT_VECTOR)
03482 
03483    if (opt_flags.task_lvl > Task_Lvl_1) {
03484 
03485        /* If task level is 0 or 1, scalar can be anything */
03486 
03487       if (set_scalar_option  &&  set_task_option) {
03488 
03489          if (opt_flags.task_lvl > opt_flags.scalar_lvl  &&
03490              opt_flags.scalar_lvl != Scalar_Lvl_2) {
03491 
03492             /* Scalar2, Task3 is an exception and is legal. */
03493 
03494             msg_str[0] = NULL_CHAR;
03495             strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]);
03496             strcpy(&msg_str[7], "\n");
03497             strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]);
03498             ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03499          }
03500       }
03501       else if (set_scalar_option) {
03502 
03503          if (opt_flags.task_lvl > opt_flags.scalar_lvl) { 
03504             task = (opt_flags.scalar_lvl == Scalar_Lvl_0) ?
03505                     Task_Lvl_1 : opt_flags.scalar_lvl;
03506             msg_str[0] = NULL_CHAR;
03507             strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03508             strcpy(&msg_str[7], "\n");
03509             strcpy(&msg_str[8], task_lvl_str[opt_flags.task_lvl]); 
03510             strcpy(&msg_str[13], "\n");
03511             strcpy(&msg_str[14], task_lvl_str[task]); 
03512 
03513             ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03514             opt_flags.task_lvl = task;
03515          }
03516       }
03517       else if (set_task_option) {
03518 
03519          if (opt_flags.task_lvl > opt_flags.scalar_lvl) { 
03520             scalar = (opt_flags.task_lvl == Task_Lvl_3) ?
03521                       Scalar_Lvl_2 : opt_flags.task_lvl;
03522             msg_str[0] = NULL_CHAR;
03523             strcpy(msg_str, task_lvl_str[opt_flags.task_lvl]); 
03524             strcpy(&msg_str[5], "\n");
03525             strcpy(&msg_str[6], scalar_lvl_str[opt_flags.scalar_lvl]); 
03526             strcpy(&msg_str[13], "\n");
03527             strcpy(&msg_str[14], scalar_lvl_str[scalar]); 
03528 
03529             ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03530             opt_flags.scalar_lvl = scalar;
03531          }
03532       }
03533    }
03534 
03535 #  endif
03536 CONTINUE:
03537 
03538 
03539    if (opt_flags.scalar_lvl == Scalar_Lvl_0) {
03540 
03541       if (set_aggress_option  &&  opt_flags.aggress) {
03542          str = (set_scalar_option) ? "scalar0" : "0";
03543          strcat(str, "\n");
03544          strcat(str, "aggress");
03545          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03546       }
03547 
03548       opt_flags.aggress = FALSE;
03549 
03550       if (set_bottom_load_option  &&  opt_flags.bottom_load) { 
03551          str = (set_scalar_option) ? "scalar0" : "0";
03552          strcat(str, "\n");
03553          strcat(str, "bl");
03554          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03555       }
03556 
03557       opt_flags.bottom_load = FALSE;
03558 
03559       if (set_recurrence_option && opt_flags.recurrence) {
03560          str  = (set_scalar_option) ? "scalar0" : "0";
03561          strcat(str, "\n");
03562          strcat(str, "recurrence");
03563          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03564       }
03565 
03566       opt_flags.recurrence = FALSE;
03567 
03568       if (set_zeroinc_option  &&  opt_flags.zeroinc) {
03569          str  = (set_scalar_option) ? "scalar0" : "0";
03570          strcat(str, "\n");
03571          strcat(str, "zeroinc");
03572          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03573       }
03574 
03575       opt_flags.zeroinc = FALSE;
03576    }
03577    else if (opt_flags.scalar_lvl == Scalar_Lvl_3) {
03578 
03579       if (! set_bottom_load_option) {
03580          opt_flags.bottom_load = TRUE;
03581       }
03582    }
03583 
03584 # if defined(_ACCEPT_VECTOR)
03585 
03586    if (opt_flags.vector_lvl == Vector_Lvl_0) {
03587 
03588       if (set_vsearch_option  &&  opt_flags.vsearch) { 
03589          str = (set_vector_option) ? "vector0" : "0";
03590          strcat(str, "\n");
03591          strcat(str, "vsearch");
03592          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03593       }
03594 
03595       opt_flags.vsearch = FALSE;
03596    
03597 # if defined(_TARGET_OS_UNICOS)
03598 
03599       if (set_pattern_option  &&  opt_flags.pattern) {
03600          str = (set_vector_option) ? "vector0" : "0";
03601          strcat(str, "\n");
03602          strcat(str, "pattern");
03603          ntr_msg_queue(0, 99, Log_Error, 0, str, 0, MULT_STR_ARG);
03604       }
03605 
03606       opt_flags.pattern = FALSE;
03607 # endif
03608 
03609    }
03610 
03611 # if defined(_TARGET_OS_UNICOS)
03612    else if (opt_flags.vector_lvl == Vector_Lvl_1) {
03613 
03614       if (set_pattern_option  &&  opt_flags.pattern) {
03615          str = (set_vector_option) ? "vector1" : "1";
03616          strcpy(msg_str, "\n");
03617          strcpy(msg_str, "pattern");
03618          ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03619       }
03620 
03621       opt_flags.pattern = FALSE;
03622    }
03623 # endif
03624 
03625 # endif
03626 
03627 # if defined(_ACCEPT_STREAM)
03628    if (opt_flags.stream_lvl > Stream_Lvl_0 && cmd_line_flags.co_array_fortran) {
03629       PRINTMSG (0, 1570, Log_Error, 0, "-Z");
03630    }
03631 
03632    if (accept_stream && opt_flags.stream_lvl > Stream_Lvl_0) {
03633 
03634       /* Stream_Lvl_1 requires at least scalar1 and vector1                 */
03635       /* Stream_Lvl_2 and Stream_Lvl_3 require at least scalar2 and vector2 */
03636 
03637       if (opt_flags.stream_lvl > opt_flags.scalar_lvl &&
03638           opt_flags.scalar_lvl < Scalar_Lvl_2) {
03639 
03640          if (set_scalar_option && set_stream_option) {
03641 
03642             /* The two are set wrong - issue an error */
03643 
03644             msg_str[0] = NULL_CHAR;
03645             strcpy(msg_str, stream_lvl_str[opt_flags.stream_lvl]);
03646             strcpy(&msg_str[7], "\n");
03647             strcpy(&msg_str[8], scalar_lvl_str[opt_flags.scalar_lvl]);
03648             ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03649             option_conflict = TRUE;
03650          }
03651          else if (!set_scalar_option  && !set_stream_option) {
03652 
03653             /* The defaults are set wrong - change them */
03654             /* Maybe this should be an INTERNAL error?? */
03655 
03656             opt_flags.stream_lvl = opt_flags.scalar_lvl;
03657          }
03658          else if (set_scalar_option) {
03659             msg_str[0] = NULL_CHAR;
03660             strcpy(msg_str, scalar_lvl_str[opt_flags.scalar_lvl]); 
03661             strcpy(&msg_str[7], "\n");
03662             strcpy(&msg_str[8], stream_lvl_str[opt_flags.stream_lvl]); 
03663             strcpy(&msg_str[15], "\n");
03664             strcpy(&msg_str[16], stream_lvl_str[opt_flags.scalar_lvl]); 
03665 
03666             ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03667             opt_flags.stream_lvl = opt_flags.scalar_lvl;
03668          }
03669          else if (set_stream_option) {
03670             msg_str[0] = NULL_CHAR;
03671             strcpy(msg_str, stream_lvl_str[opt_flags.stream_lvl]); 
03672             strcpy(&msg_str[7], "\n");
03673             strcpy(&msg_str[8], scalar_lvl_str[opt_flags.scalar_lvl]); 
03674             strcpy(&msg_str[15], "\n");
03675 
03676             if (opt_flags.stream_lvl == Stream_Lvl_3) {
03677                strcpy(&msg_str[16], scalar_lvl_str[Stream_Lvl_2]); 
03678 
03679                ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03680                opt_flags.scalar_lvl = Stream_Lvl_2;
03681             }
03682             else {
03683                strcpy(&msg_str[16], scalar_lvl_str[opt_flags.stream_lvl]); 
03684 
03685                ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03686                opt_flags.scalar_lvl = opt_flags.stream_lvl;
03687             }
03688          }
03689       }
03690 
03691 
03692       if (option_conflict) {
03693          goto EXIT;
03694       }
03695 
03696       if (opt_flags.stream_lvl > opt_flags.vector_lvl &&
03697           opt_flags.vector_lvl < Vector_Lvl_2) {
03698 
03699          if (set_vector_option && set_stream_option) {
03700 
03701             /* The two are set wrong - issue an error */
03702 
03703             msg_str[0] = NULL_CHAR;
03704             strcpy(msg_str, stream_lvl_str[opt_flags.stream_lvl]);
03705             strcpy(&msg_str[7], "\n");
03706             strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]);
03707             ntr_msg_queue(0, 99, Log_Error, 0, msg_str, 0, MULT_STR_ARG);
03708             option_conflict = TRUE;
03709          }
03710          else if (!set_vector_option  && !set_stream_option) {
03711 
03712             /* The defaults are set wrong - change them */
03713             /* Maybe this should be an INTERNAL error?? */
03714 
03715             opt_flags.stream_lvl = opt_flags.vector_lvl;
03716          }
03717          else if (set_vector_option) {
03718             msg_str[0] = NULL_CHAR;
03719             strcpy(msg_str, vector_lvl_str[opt_flags.vector_lvl]); 
03720             strcpy(&msg_str[7], "\n");
03721             strcpy(&msg_str[8], stream_lvl_str[opt_flags.stream_lvl]); 
03722             strcpy(&msg_str[15], "\n");
03723             strcpy(&msg_str[16], stream_lvl_str[opt_flags.vector_lvl]); 
03724 
03725             ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03726             opt_flags.stream_lvl = opt_flags.vector_lvl;
03727          }
03728          else if (set_stream_option) {
03729             msg_str[0] = NULL_CHAR;
03730             strcpy(msg_str, stream_lvl_str[opt_flags.stream_lvl]); 
03731             strcpy(&msg_str[7], "\n");
03732             strcpy(&msg_str[8], vector_lvl_str[opt_flags.vector_lvl]); 
03733             strcpy(&msg_str[15], "\n");
03734 
03735             if (opt_flags.stream_lvl == Stream_Lvl_3) {
03736                strcpy(&msg_str[16], vector_lvl_str[Stream_Lvl_2]); 
03737 
03738                ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03739                opt_flags.vector_lvl = Stream_Lvl_2;
03740             }
03741             else {
03742                strcpy(&msg_str[16], vector_lvl_str[opt_flags.stream_lvl]); 
03743 
03744                ntr_msg_queue(0, 1068, Log_Warning, 0, msg_str, 0, MULT_STR_ARG);
03745                opt_flags.vector_lvl = opt_flags.stream_lvl;
03746             }
03747          }
03748       }
03749 
03750       if (option_conflict) {
03751          goto EXIT;
03752       }
03753    }
03754 
03755 # endif
03756 
03757 # if defined(_ACCEPT_INLINE)
03758 
03759    if (opt_flags.inline_lvl == Inline_Lvl_0 &&
03760        set_inlinefrom_option) {
03761       opt_flags.inline_lvl = Inline_Lvl_4;
03762    }
03763 
03764    if (set_debug_option) {
03765       opt_flags.inline_lvl = Inline_Lvl_0;
03766    }
03767 
03768 # endif
03769 
03770 # if defined(_TARGET_OS_UNICOS)
03771       /* Task0 disables open mp on pvp */
03772 
03773       if (opt_flags.task_lvl == Task_Lvl_0) {
03774          dump_flags.open_mp = FALSE;
03775       }
03776       else {
03777          dump_flags.open_mp = TRUE;
03778       }
03779 
03780 # endif
03781 
03782 EXIT:
03783 
03784    TRACE (Func_Exit, "validate_O_option", NULL);
03785 
03786    return;
03787  
03788 }  /* validate_O_option */
03789 
03790 
03791 /******************************************************************************\
03792 |*                        *|
03793 |* Description:                     *|
03794 |*  Process_t_option handles the command line truncation option passed via*|
03795 |*  argv (t switch).                  *|
03796 |*                        *|
03797 |* Input parameters:                    *|
03798 |*  optargs     -t option argument            *|
03799 |*                        *|
03800 |* Output parameters:                   *|
03801 |*  NONE                      *|
03802 |*                        *|
03803 |* Returns:                     *|
03804 |*  NOTHING                     *|
03805 |*                        *|
03806 \******************************************************************************/
03807 
03808 static void process_t_option (char *optargs)
03809  
03810 {
03811    char *opt_chk;
03812    int   trunc;
03813 
03814 
03815    TRACE (Func_Entry, "process_t_option", NULL);
03816 
03817    /* issue warning if rounding option is being overridden */
03818 
03819    if (set_round_option) { /* Rounding/truncation conflict detected. */
03820       ntr_msg_queue(0, 75, Log_Warning, 0, "-t", 0, STR_ARG);
03821       set_round_option = FALSE;
03822    }
03823 
03824    /* validate that -t arg contains only digits */
03825 
03826    opt_chk = optargs;
03827 
03828    while (isdigit(*opt_chk)) {
03829       opt_chk++;
03830    }
03831 
03832    trunc = atoi (optargs);
03833 
03834    if (*opt_chk != EOS  ||  trunc > MAX_TRUNCATION_BITS) {
03835       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 't', ARG_STR_ARG);
03836    }
03837    else {
03838 
03839 # if defined(_TARGET_OS_SOLARIS)
03840 
03841       if (trunc > 0) {
03842          ntr_msg_queue(0, 744, Log_Warning, 0, optargs, 't', ARG_STR_ARG);
03843          trunc = 0;
03844       }
03845 # endif
03846 
03847       on_off_flags.round_mult_operations  = FALSE;
03848       cmd_line_flags.truncate_bits    = trunc;
03849    }
03850 
03851    set_trunc_option = TRUE;
03852 
03853    TRACE (Func_Exit, "process_t_option", NULL);
03854 
03855    return;
03856 
03857 }  /* process_t_option */
03858 
03859 /******************************************************************************\
03860 |*                        *|
03861 |* Description:                     *|
03862 |*  Process_u_option handles command line dump options passed via argv    *|
03863 |*  (u switch).                   *|
03864 |*                        *|
03865 |* Input parameters:                    *|
03866 |*  optargs     -u option arguments           *|
03867 |*                        *|
03868 |* Output parameters:                   *|
03869 |*  NONE                      *|
03870 |*                        *|
03871 |* Returns:                     *|
03872 |*  NOTHING                     *|
03873 |*                        *|
03874 \******************************************************************************/
03875 
03876 static void process_u_option (char *optargs)
03877 
03878 {
03879    char   *cp;
03880    boolean   non_debug_ok = FALSE;
03881 
03882    TRACE (Func_Entry, "process_u_option", NULL);
03883 
03884    while (*optargs != EOS) {
03885 #ifdef KEY
03886       // Bug 933
03887       // If user file name has ",", then "," is a legitimate part of the file
03888       // name in the -u option, e.g., "-ufile=b,b.l".  Spaces in file names are
03889       // encoded as '\ '.
03890       if (strncmp (optargs, "file=", 5) == IDENTICAL) {
03891   char *temp = malloc (strlen (optargs) + 1);
03892   char *t = temp;
03893         for (; *optargs != BLANK && *optargs != EOS; ++optargs) {
03894     // Convert '\ ' to ' '.  Convert '\\' to '\'.
03895     if (*optargs == '\\')
03896       optargs++;
03897     *t++ = *optargs;
03898   }
03899         *t = '\0';
03900   cp = temp;
03901       } else
03902 #endif
03903       for (cp = optargs;
03904      *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
03905      ++optargs);
03906 
03907       if (*optargs != EOS) {
03908    *optargs = EOS;
03909    *optargs++;
03910       }
03911 
03912       if (EQUAL_STRS(cp, "help")) {     /* Describe all the   */
03913    dump_flags.help_dbg  = TRUE;     /* options.           */
03914          non_debug_ok   = TRUE;
03915       }
03916       else if (EQUAL_STRS(cp, "abort_ansi")) {          /* Abort on first ANSI*/
03917          dump_flags.abort_on_ansi = TRUE;
03918          non_debug_ok   = TRUE;
03919       }
03920       else if (EQUAL_STRS(cp, "no_dim_pad")) {          /* for F--  */
03921          dump_flags.no_dimension_padding = TRUE;
03922          non_debug_ok   = TRUE;
03923       }
03924       else if (EQUAL_STRS(cp, "show")) {
03925          dump_flags.show_cmd_line = TRUE;
03926          non_debug_ok   = TRUE;
03927       }
03928       else if (EQUAL_STRS(cp, "mp")) {
03929          dump_flags.mp = TRUE;
03930          non_debug_ok   = TRUE;
03931       }
03932       else if (EQUAL_STRS(cp, "mod_version")) {
03933          dump_flags.mod_version = TRUE;
03934          non_debug_ok   = TRUE;
03935       }
03936       else if (EQUAL_STRS(cp, "open_mp")) {
03937          dump_flags.open_mp = TRUE;
03938          non_debug_ok   = TRUE;
03939       }
03940       else if (EQUAL_STRS(cp, "dsm")) {
03941          dump_flags.dsm = TRUE;
03942          non_debug_ok   = TRUE;
03943       }
03944       else if (EQUAL_STRS(cp, "cray_compatible")) {
03945          dump_flags.cray_compatible = TRUE;
03946          non_debug_ok   = TRUE;
03947       }
03948 
03949 # if defined(_TARGET_PACK_HALF_WORD_TYPES)
03950       else if (EQUAL_STRS(cp, "pack_half_word")) {
03951          dump_flags.pack_half_word = TRUE;
03952          non_debug_ok   = TRUE;
03953       }
03954 # endif
03955       else if (EQUAL_STRS(cp, "fe_version")) {
03956          printf("This is frontend %s of release %s\n",
03957                  frontend_version, release_level);
03958          non_debug_ok   = TRUE;
03959       }
03960 # if defined(_F_MINUS_MINUS)
03961       else if (EQUAL_STRS(cp, "fmm1")) {
03962          dump_flags.f_minus_minus = TRUE;
03963          cmd_line_flags.co_array_fortran  = TRUE;
03964          dump_flags.fmm1 = TRUE;
03965          non_debug_ok   = TRUE;
03966       }
03967       else if (EQUAL_STRS(cp, "fmm2")) {
03968          dump_flags.f_minus_minus = TRUE;
03969          cmd_line_flags.co_array_fortran  = TRUE;
03970          dump_flags.fmm2 = TRUE;
03971          non_debug_ok   = TRUE;
03972       }
03973       else if (EQUAL_STRS(cp, "fmm")) {
03974          dump_flags.f_minus_minus = TRUE;
03975          cmd_line_flags.co_array_fortran  = TRUE;
03976          dump_flags.fmm1 = TRUE;
03977          non_debug_ok   = TRUE;
03978       }
03979 # endif
03980       else if (EQUAL_STRS(cp, "no_mod_output")) { /* For inlinefrom     */
03981          dump_flags.no_module_output = TRUE;
03982          non_debug_ok   = TRUE;
03983       }
03984       else if ((strncmp (cp, "preinline=", 10) == IDENTICAL)) {
03985          dump_flags.preinline = TRUE;
03986          cp = cp + 10;
03987          strcpy(preinline_file, cp);
03988          non_debug_ok   = TRUE;
03989       }
03990       else if (EQUAL_STRS(cp, "f")) {                   /* Fortran output     */
03991          dump_flags.fortran_out = TRUE;
03992       }
03993       else if (EQUAL_STRS(cp, "all")) {     /* all tbls       */
03994    dump_flags.blk_stk   = TRUE;
03995    dump_flags.bd_tbl    = TRUE;
03996    dump_flags.cmd_line_tbls = TRUE;
03997    dump_flags.cn_tbl    = TRUE;
03998    dump_flags.fort_out    = TRUE;
03999    dump_flags.fp_tbl    = TRUE;
04000          dump_flags.ftrace_info   = FALSE;
04001    dump_flags.gl_tbl    = TRUE;
04002          dump_flags.intrin_tbl    = FALSE;  /* TOO much output    */
04003    dump_flags.ir1_tbl   = TRUE;
04004    dump_flags.ir2_tbl   = TRUE;
04005    dump_flags.ir3_tbl   = FALSE;
04006    dump_flags.ir4_tbl   = FALSE;
04007    dump_flags.mem_report    = FALSE;
04008          dump_flags.mtrace_info   = TRUE;
04009    dump_flags.name_tbls   = TRUE;
04010          dump_flags.pdgcs   = TRUE;
04011    dump_flags.sb_tbl    = TRUE;
04012    dump_flags.scp_tbl   = TRUE;
04013    dump_flags.std_err   = FALSE;
04014    dump_flags.sytb    = TRUE;
04015    dump_flags.typ_tbl   = TRUE;
04016    dump_flags.defines   = TRUE;
04017          dump_flags.abort_on_ansi       = FALSE;  /* Not needed         */
04018 
04019          /* These next 2 are mutually exclusive.  stmt_dmp is the plain one   */
04020          /* src_dmp is the one to use for testing out src_input.c             */
04021 
04022    dump_flags.src_dmp   = FALSE;
04023    dump_flags.stmt_dmp    = TRUE;
04024 #ifdef KEY /* Bug 8117 */
04025    dump_flags.arg_passing   = TRUE;
04026 #endif /* KEY Bug 8117 */
04027       }
04028 #ifdef KEY /* Bug 8117 */
04029       else if (EQUAL_STRS(cp, "arg_passing")) {
04030    dump_flags.arg_passing   = TRUE;
04031       }
04032 #endif /* KEY Bug 8117 */
04033       else if (EQUAL_STRS(cp, "bd")) {      /* bounds table       */
04034    dump_flags.bd_tbl  = TRUE;
04035       }
04036       else if (EQUAL_STRS(cp, "blk")) {     /* block stack table  */
04037    dump_flags.blk_stk = TRUE;
04038       }
04039       else if (EQUAL_STRS(cp, "cmd")) {     /* command line info  */
04040    dump_flags.cmd_line_tbls = TRUE;
04041       }
04042       else if (EQUAL_STRS(cp, "cn")) {      /* constant table     */
04043    dump_flags.cn_tbl  = TRUE;
04044       }
04045       else if (EQUAL_STRS(cp, "defines")) {             /* defines info       */
04046          dump_flags.defines = TRUE;
04047       }
04048       else if (EQUAL_STRS(cp, "cnout")) {       /* binary dump of constants */
04049          dump_flags.constant_bits = TRUE;
04050       }
04051       else if ((strncmp (cp, "pvp_test=", 9) == IDENTICAL)) {
04052          cp = cp + 9;
04053          dump_flags.pvp_test = atoi (cp);
04054          non_debug_ok   = TRUE;
04055       }
04056       else if (EQUAL_STRS(cp, "pvp_test")) {            /* pvp_test[=nn]     */
04057          dump_flags.pvp_test = 1;
04058          non_debug_ok   = TRUE;
04059       }
04060       else if ((strncmp (cp, "file=", 5) == IDENTICAL)) {
04061          cp = cp + 5;
04062          strcpy(debug_file_name, cp);
04063          non_debug_ok   = TRUE;
04064       }
04065       else if (EQUAL_STRS(cp, "fortran")) {   /* module file tbl    */
04066          dump_flags.fort_out = TRUE;
04067       }
04068       else if (EQUAL_STRS(cp, "fp")) {      /* module file tbl    */
04069          dump_flags.fp_tbl = TRUE;
04070       }
04071       else if (EQUAL_STRS(cp, "ftrace")) {    /* func trace info    */
04072          dump_flags.ftrace_info = TRUE;
04073       }
04074       else if (EQUAL_STRS(cp, "gl")) {      /* global line tbl    */
04075    dump_flags.gl_tbl = TRUE;
04076       }
04077       else if (EQUAL_STRS(cp, "intrin")) {    /* intrinsic tbl      */
04078    dump_flags.intrin_tbl = TRUE;
04079       }
04080       else if (EQUAL_STRS(cp, "ir1")) {     /* intermediate rep   */
04081    dump_flags.ir1_tbl = TRUE;
04082       }
04083       else if (EQUAL_STRS(cp, "ir2")) {     /* intermediate rep   */
04084    dump_flags.ir2_tbl = TRUE;
04085       }
04086       else if (EQUAL_STRS(cp, "ir3")) {     /* inlining rep       */
04087    dump_flags.ir3_tbl = TRUE;
04088       }
04089       else if (EQUAL_STRS(cp, "ir4")) {     /* swap dimension dmp */
04090    dump_flags.ir4_tbl = TRUE;
04091       }
04092       else if (EQUAL_STRS(cp, "mem_report")) {    /* memory usage report*/
04093          dump_flags.mem_report = TRUE;
04094       }
04095       else if (EQUAL_STRS(cp, "msg")) {     /* memory usage report*/
04096          dump_flags.msg_checking = TRUE;
04097       }
04098       else if (EQUAL_STRS(cp, "mtrace")) {    /* memory trace info  */
04099          dump_flags.mtrace_info = TRUE;
04100       }
04101       else if (EQUAL_STRS(cp, "names")) {               /* name tables        */
04102          dump_flags.name_tbls = TRUE;
04103       }
04104       else if (EQUAL_STRS(cp, "pdg")) {     /* interface calls    */
04105    dump_flags.pdgcs = TRUE;
04106       }
04107       else if (EQUAL_STRS(cp, "pdt")) {     /* interface calls    */
04108    dump_flags.pdt_dump = TRUE;
04109       }
04110       else if (EQUAL_STRS(cp, "sb")) {      /* storage blk tbl    */
04111    dump_flags.sb_tbl = TRUE;
04112       }
04113       else if (EQUAL_STRS(cp, "scp")) {     /* scope tbl        */
04114    dump_flags.scp_tbl = TRUE;
04115       }
04116       else if (EQUAL_STRS(cp, "src")) {             /* print stmts and    */
04117    dump_flags.src_dmp = TRUE;     /* expanded src info  */
04118       }
04119       else if (EQUAL_STRS(cp, "stderr")) {            /* msgs to stderr     */
04120    dump_flags.std_err = TRUE;     /* rather than ordered*/
04121       }
04122       else if (EQUAL_STRS(cp, "stmt")) {    /* print stmts        */
04123    dump_flags.stmt_dmp = TRUE;
04124       }
04125       else if (EQUAL_STRS(cp, "sytb")) {    /* symbol tbl       */
04126    dump_flags.sytb = TRUE;
04127       }
04128       else if (EQUAL_STRS(cp, "typ")) {     /* type tbl       */
04129    dump_flags.typ_tbl = TRUE;
04130       }
04131       else { /* option has an invalid argument */
04132          ntr_msg_queue(0, 78, Log_Error, 0, cp, 'u', ARG_STR_ARG);
04133       }
04134    }  /* while */
04135 
04136 #ifndef _DEBUG
04137 
04138    if (!non_debug_ok) { /* -u options ignored */
04139       ntr_msg_queue(0, 877, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
04140    }
04141 #endif
04142 
04143    TRACE (Func_Exit, "process_u_option", NULL);
04144    return;
04145 
04146 }  /* process_u_option */
04147 
04148  
04149 /******************************************************************************\
04150 |*                        *|
04151 |* Description:                     *|
04152 |*  Process_x_option handles the command line directive suppress options  *|
04153 |*      passed via argv (x switch).               *|
04154 |*                        *|
04155 |* Input parameters:                    *|
04156 |*  optargs     -x option arguments           *|
04157 |*                        *|
04158 |* Output parameters:                   *|
04159 |*  NONE                      *|
04160 |*                        *|
04161 |* Returns:                     *|
04162 |*  NOTHING                     *|
04163 |*                        *|
04164 \******************************************************************************/
04165 
04166 static void process_x_option (char *optargs) 
04167  
04168 {
04169    char     *cp;
04170    boolean     issue_warning  = FALSE;
04171    token_values_type   tok_type;
04172 
04173 
04174    TRACE (Func_Entry, "process_x_option", NULL);
04175 
04176    while (*optargs != EOS) {
04177 
04178       for (cp = optargs;
04179            *optargs != COMMA  &&  *optargs != EOS;
04180            ++optargs);
04181 
04182       if (*optargs != EOS) {
04183          *optargs = EOS;
04184          *optargs++;
04185       }
04186 
04187       tok_type  = get_dir_token_from_str(cp);
04188 
04189       if (tok_type == Tok_Id) {
04190 
04191          /* get_dir_token_from_str special cases for ALL, MIC, MPP and DIR */
04192          /* If it finds one of these it returns Tok_Id, otherwise its      */
04193          /* Tok_Unknown if it can't find a directive or cmic name.         */
04194 
04195          switch(*cp) {
04196          case 'a':
04197 
04198             if (EQUAL_STRS(cp, "all")) {
04199                cmd_line_flags.disregard_all_directives  = TRUE;
04200                cmd_line_flags.disregard_all_dirs  = TRUE;
04201                cmd_line_flags.disregard_all_mics  = TRUE;
04202                cmd_line_flags.disregard_all_mips  = TRUE;
04203                cmd_line_flags.disregard_all_omps  = TRUE;
04204                cmd_line_flags.disregard_conditional_omp = TRUE;
04205             }
04206             else {
04207                ntr_msg_queue(0, 78, Log_Error, 0, cp, 'x', ARG_STR_ARG);
04208             }
04209             break;
04210 
04211          case 'c':
04212 
04213             if (EQUAL_STRS(cp, "conditional_omp")) {
04214                cmd_line_flags.disregard_conditional_omp = TRUE;
04215             }
04216             else {
04217                PRINTMSG (0, 78, Log_Error, 0, 'x', cp);
04218             }
04219             break;
04220 
04221 
04222          case 'd':
04223 
04224             if (EQUAL_STRS(cp, "dir")) {
04225                cmd_line_flags.disregard_all_dirs  = TRUE;
04226             }
04227             else {
04228                ntr_msg_queue(0, 78, Log_Error, 0, cp, 'x', ARG_STR_ARG);
04229             }
04230             break;
04231 
04232 
04233          case 'm':
04234 
04235             if (EQUAL_STRS(cp, "mic")) {
04236                cmd_line_flags.disregard_all_mics  = TRUE;
04237             }
04238             else if (EQUAL_STRS(cp, "mpp")) {
04239                cmd_line_flags.disregard_all_mpp_cdirs = TRUE;
04240             }
04241             else if (EQUAL_STRS(cp, "mipspro")) {
04242                cmd_line_flags.disregard_all_mips  = TRUE;
04243             }
04244             else {
04245                ntr_msg_queue(0, 78, Log_Error, 0, cp, 'x', ARG_STR_ARG);
04246             }
04247             break;
04248 
04249 
04250          case 'o':
04251 
04252             if (EQUAL_STRS(cp, "omp")) {
04253                cmd_line_flags.disregard_all_omps        = TRUE;
04254                cmd_line_flags.disregard_conditional_omp = TRUE;
04255             }
04256             else {
04257                PRINTMSG (0, 78, Log_Error, 0, 'x', cp);
04258             }
04259             break;
04260 
04261 
04262          default:
04263             ntr_msg_queue(0, 78, Log_Error, 0, cp, 'x', ARG_STR_ARG);
04264             break;
04265          }
04266       }
04267       else if (tok_type == Tok_Unknown) {
04268          ntr_msg_queue(0, 78, Log_Error, 0, cp, 'x', ARG_STR_ARG);
04269       }
04270       else {
04271 
04272          if (tok_type > Tok_Dir_Start && tok_type < Tok_Dir_End) {
04273             disregard_directive[tok_type - Tok_Dir_Start] = TRUE;
04274          }
04275          if (tok_type > Tok_Mic_Start && tok_type < Tok_Mic_End) {
04276             disregard_mics[tok_type - Tok_Mic_Start]    = TRUE;
04277          }
04278          if (tok_type > Tok_SGI_Dir_Start && tok_type < Tok_SGI_Dir_End) {
04279             disregard_mips[tok_type - Tok_SGI_Dir_Start]  = TRUE;
04280          }
04281          if (tok_type > Tok_Open_Mp_Dir_Start && 
04282              tok_type < Tok_Open_Mp_Dir_End) {
04283             disregard_open_mp[tok_type - Tok_Open_Mp_Dir_Start] = TRUE;
04284          }
04285 
04286          /* We need to handle the legal directives, vs the tokens that */
04287          /* are actually parameters to the directives.   We also need  */
04288          /* to handle the situation of having the same directive  with */
04289          /* different prefixes.  The following list is all valid dirs  */
04290          /* that can be specified on the -x commandline.  We will      */
04291          /* issue an error if the specified token is not one of the    */
04292          /* listed tokens.  We also look for duplicate names and set   */
04293          /* the token for all possible prefixes.                       */
04294 
04295          switch(tok_type) {
04296 
04297          /* Handle duplicate directive names, by setting the bit for them all */
04298 
04299          case Tok_Dir_Barrier :          /* CRAFT dir - obsolete */
04300          case Tok_SGI_Dir_Barrier :
04301          case Tok_Open_Mp_Dir_Barrier :
04302             disregard_directive[Tok_Dir_Barrier - Tok_Dir_Start]  = TRUE;
04303             disregard_mips[Tok_SGI_Dir_Barrier - Tok_SGI_Dir_Start] = TRUE;
04304             disregard_open_mp[Tok_Open_Mp_Dir_Barrier - 
04305                               Tok_Open_Mp_Dir_Start]      = TRUE;
04306             break;
04307 
04308          case Tok_Dir_Blockable :
04309          case Tok_SGI_Dir_Blockable :
04310             disregard_directive[Tok_Dir_Blockable - Tok_Dir_Start]  = TRUE;
04311             disregard_mips[Tok_SGI_Dir_Blockable - Tok_SGI_Dir_Start] = TRUE;
04312             break;
04313 
04314          case Tok_Dir_Blockingsize :
04315          case Tok_SGI_Dir_Blockingsize :
04316             disregard_directive[Tok_Dir_Blockingsize - Tok_Dir_Start] = TRUE;
04317             disregard_mips[Tok_SGI_Dir_Blockingsize - Tok_SGI_Dir_Start]= TRUE;
04318             break;
04319 
04320          case Tok_Dir_Concurrent :
04321          case Tok_SGI_Dir_Concurrent :
04322             disregard_directive[Tok_Dir_Concurrent - Tok_Dir_Start] = TRUE;
04323             disregard_mips[Tok_SGI_Dir_Concurrent - Tok_SGI_Dir_Start]  = TRUE;
04324             break;
04325 
04326 
04327          case Tok_Open_Mp_Dir_Copyin :   /* Keyword */
04328          case Tok_SGI_Dir_Copyin :
04329             disregard_mips[Tok_SGI_Dir_Copyin - Tok_SGI_Dir_Start]  = TRUE;
04330             break;
04331 
04332          case Tok_Dir_Critical :      /* CRAFT dir - obsolete */
04333          case Tok_Open_Mp_Dir_Critical :
04334             disregard_directive[Tok_Dir_Critical - Tok_Dir_Start] = TRUE;
04335             disregard_open_mp[Tok_Open_Mp_Dir_Critical - 
04336                               Tok_Open_Mp_Dir_Start]      = TRUE;
04337             break;
04338 
04339          case Tok_Open_Mp_Dir_Distribute :
04340          case Tok_SGI_Dir_Distribute :
04341             disregard_mips[Tok_SGI_Dir_Distribute - Tok_SGI_Dir_Start]  = TRUE;
04342             disregard_open_mp[Tok_Open_Mp_Dir_Distribute - 
04343                               Tok_Open_Mp_Dir_Start]      = TRUE;
04344             break;
04345 
04346          case Tok_Open_Mp_Dir_Distribute_Reshape :
04347          case Tok_SGI_Dir_Distribute_Reshape :
04348             disregard_mips[Tok_SGI_Dir_Distribute_Reshape - 
04349                            Tok_SGI_Dir_Start]       = TRUE;
04350             disregard_open_mp[Tok_Open_Mp_Dir_Distribute_Reshape - 
04351                               Tok_Open_Mp_Dir_Start]      = TRUE;
04352             break;
04353 
04354          case Tok_Open_Mp_Dir_Do :
04355          case Tok_SGI_Dir_Do :              /* Keyword */
04356             disregard_open_mp[Tok_Open_Mp_Dir_Do - 
04357                               Tok_Open_Mp_Dir_Start]      = TRUE;
04358             break;
04359 
04360          case Tok_Dir_Dynamic :             /* Obsolete */
04361          case Tok_Open_Mp_Dir_Dynamic :
04362          case Tok_SGI_Dir_Dynamic :
04363             disregard_directive[Tok_Dir_Dynamic - Tok_Dir_Start]  = TRUE;
04364             disregard_mips[Tok_Open_Mp_Dir_Dynamic - Tok_SGI_Dir_Start] = TRUE;
04365             disregard_open_mp[Tok_SGI_Dir_Dynamic - 
04366                               Tok_Open_Mp_Dir_Start]      = TRUE;
04367             break;
04368 
04369          case Tok_Dir_Endcritical :        /* CRAFT directive */
04370          case Tok_Open_Mp_Dir_Endcritical :
04371             disregard_directive[Tok_Dir_Endcritical - Tok_Dir_Start]  = TRUE;
04372             disregard_open_mp[Tok_Open_Mp_Dir_Endcritical - 
04373                               Tok_Open_Mp_Dir_Start]      = TRUE;
04374             break;
04375 
04376          case Tok_Dir_Endmaster :          /* CRAFT directive */
04377          case Tok_Open_Mp_Dir_Endmaster :
04378             disregard_directive[Tok_Dir_Endmaster - Tok_Dir_Start]  = TRUE;
04379             disregard_open_mp[Tok_Open_Mp_Dir_Endmaster - 
04380                               Tok_Open_Mp_Dir_Start]      = TRUE;
04381             break;
04382 
04383          case Tok_Open_Mp_Dir_Endparallel :
04384          case Tok_SGI_Dir_Endparallel :
04385          case Tok_Mic_End_Parallel :
04386             disregard_mics[Tok_Mic_End_Parallel - Tok_Mic_Start]  = TRUE;
04387             disregard_mips[Tok_SGI_Dir_Endparallel - Tok_SGI_Dir_Start] = TRUE;
04388             disregard_open_mp[Tok_Open_Mp_Dir_Endparallel - 
04389                               Tok_Open_Mp_Dir_Start]      = TRUE;
04390             break;
04391 
04392          case Tok_Open_Mp_Dir_Flush :
04393          case Tok_SGI_Dir_Flush :
04394             disregard_mips[Tok_SGI_Dir_Flush - Tok_SGI_Dir_Start] = TRUE;
04395             disregard_open_mp[Tok_Open_Mp_Dir_Flush - 
04396                               Tok_Open_Mp_Dir_Start]      = TRUE;
04397             break;
04398 
04399          case Tok_Dir_Inline :
04400          case Tok_SGI_Dir_Inline :
04401             disregard_directive[Tok_Dir_Inline - Tok_Dir_Start]   = TRUE;
04402             disregard_mips[Tok_SGI_Dir_Inline - Tok_SGI_Dir_Start]  = TRUE;
04403             break;
04404 
04405          case Tok_Dir_Interchange :
04406          case Tok_SGI_Dir_Interchange :
04407             disregard_directive[Tok_Dir_Interchange - Tok_Dir_Start]  = TRUE;
04408             disregard_mips[Tok_SGI_Dir_Interchange - Tok_SGI_Dir_Start] = TRUE;
04409             break;
04410 
04411          case Tok_Dir_Master :                 /* CRAFT directive */
04412          case Tok_Open_Mp_Dir_Master :
04413             disregard_directive[tok_type - Tok_Dir_Start]   = TRUE;
04414             disregard_open_mp[tok_type - Tok_Open_Mp_Dir_Start]   = TRUE;
04415             break;
04416 
04417          case Tok_Dir_Maxcpus :
04418          case Tok_Mic_Maxcpus :        /* Keyword */
04419             disregard_directive[Tok_Dir_Maxcpus - Tok_Dir_Start]  = TRUE;
04420             break;
04421 
04422          case Tok_Dir_Noblocking :
04423          case Tok_SGI_Dir_Noblocking :
04424             disregard_directive[Tok_Dir_Noblocking - Tok_Dir_Start] = TRUE;
04425             disregard_mips[Tok_SGI_Dir_Noblocking - Tok_SGI_Dir_Start]  = TRUE;
04426             break;
04427 
04428          case Tok_Dir_Noinline :
04429          case Tok_SGI_Dir_Noinline :
04430             disregard_directive[Tok_Dir_Noinline - Tok_Dir_Start] = TRUE;
04431             disregard_mips[Tok_SGI_Dir_Noinline - Tok_SGI_Dir_Start]  = TRUE;
04432             break;
04433 
04434          case Tok_Dir_Nointerchange :
04435          case Tok_SGI_Dir_Nointerchange :
04436             disregard_directive[Tok_Dir_Nointerchange - Tok_Dir_Start]  = TRUE;
04437             disregard_mips[Tok_SGI_Dir_Nointerchange - 
04438                            Tok_SGI_Dir_Start]       = TRUE;
04439             break;
04440 
04441          case Tok_Dir_Norecurrence :
04442          case Tok_SGI_Dir_Norecurrence :  /* Keyword */
04443             disregard_directive[Tok_SGI_Dir_Norecurrence - Tok_Dir_Start]= TRUE;
04444             break;
04445 
04446 
04447          case Tok_SGI_Dir_Ordered :   /* Keyword */
04448          case Tok_Open_Mp_Dir_Ordered :
04449             disregard_mips[Tok_SGI_Dir_Ordered - Tok_SGI_Dir_Start] = TRUE;
04450             disregard_open_mp[Tok_Open_Mp_Dir_Ordered - 
04451                               Tok_Open_Mp_Dir_Start]      = TRUE;
04452             break;
04453 
04454          case Tok_SGI_Dir_Page_Place :
04455          case Tok_Open_Mp_Dir_Page_Place :
04456             disregard_mips[Tok_SGI_Dir_Page_Place - Tok_SGI_Dir_Start]  = TRUE;
04457             disregard_open_mp[Tok_Open_Mp_Dir_Page_Place - 
04458                               Tok_Open_Mp_Dir_Start]      = TRUE;
04459             break;
04460 
04461          case Tok_Mic_Parallel :
04462          case Tok_SGI_Dir_Parallel :
04463          case Tok_Open_Mp_Dir_Parallel :
04464             disregard_mics[Tok_Mic_Parallel - Tok_Mic_Start]    = TRUE;
04465             disregard_mips[Tok_SGI_Dir_Parallel - Tok_SGI_Dir_Start]  = TRUE;
04466             disregard_open_mp[Tok_Open_Mp_Dir_Parallel - 
04467                               Tok_Open_Mp_Dir_Start]      = TRUE;
04468             break;
04469 
04470          case Tok_SGI_Dir_Paralleldo :
04471          case Tok_Open_Mp_Dir_Paralleldo :
04472             disregard_mips[Tok_SGI_Dir_Paralleldo - Tok_SGI_Dir_Start]  = TRUE;
04473             disregard_open_mp[Tok_Open_Mp_Dir_Paralleldo - 
04474                               Tok_Open_Mp_Dir_Start]      = TRUE;
04475             break;
04476 
04477          case Tok_Open_Mp_Dir_Parallelworkshare :
04478             disregard_open_mp[tok_type - Tok_Open_Mp_Dir_Start]   = TRUE;
04479             break;
04480 
04481          case Tok_Mic_Permutation :
04482          case Tok_SGI_Dir_Permutation :   /* Keyword */
04483             disregard_mics[Tok_Mic_Permutation - Tok_Mic_Start] = TRUE;
04484             break;
04485 
04486          case Tok_SGI_Dir_Redistribute :
04487          case Tok_Open_Mp_Dir_Redistribute :
04488             disregard_mips[Tok_SGI_Dir_Redistribute - Tok_SGI_Dir_Start]= TRUE;
04489             disregard_open_mp[Tok_Open_Mp_Dir_Redistribute - 
04490                               Tok_Open_Mp_Dir_Start]      = TRUE;
04491             break;
04492 
04493          case Tok_SGI_Dir_Section :
04494          case Tok_Open_Mp_Dir_Section :
04495             disregard_mips[Tok_SGI_Dir_Section - Tok_SGI_Dir_Start] = TRUE;
04496             disregard_open_mp[Tok_Open_Mp_Dir_Section - 
04497                               Tok_Open_Mp_Dir_Start]      = TRUE;
04498             break;
04499 
04500          case Tok_Dir_Shared :          /* CRAFT directive */
04501          case Tok_Open_Mp_Dir_Shared :  /* Keyword */
04502          case Tok_SGI_Dir_Shared :      /* Keyword */
04503             disregard_directive[Tok_Dir_Shared - Tok_Dir_Start]   = TRUE;
04504             break;
04505 
04506          case Tok_Dir_Single :           /* Keyword */
04507          case Tok_Open_Mp_Dir_Single :
04508             disregard_open_mp[Tok_Open_Mp_Dir_Single - 
04509                               Tok_Open_Mp_Dir_Start]      = TRUE;
04510             break;
04511 
04512          case Tok_Open_Mp_Dir_Workshare :
04513             disregard_open_mp[Tok_Open_Mp_Dir_Workshare - 
04514                               Tok_Open_Mp_Dir_Start]      = TRUE;
04515             break;
04516 
04517          case Tok_Dir_Taskcommon :
04518          case Tok_Mic_Taskcommon :  /* Unsupported */
04519             disregard_directive[Tok_Dir_Taskcommon - Tok_Dir_Start] = TRUE;
04520             disregard_mics[Tok_Mic_Taskcommon - Tok_Mic_Start]    = TRUE;
04521             break;
04522 
04523          case Tok_Dir_Unroll :
04524          case Tok_SGI_Dir_Unroll :
04525             disregard_directive[Tok_Dir_Unroll - Tok_Dir_Start]   = TRUE;
04526             disregard_mips[Tok_SGI_Dir_Unroll - Tok_SGI_Dir_Start]  = TRUE;
04527             break;
04528 
04529          case Tok_Dir_Vector :
04530          case Tok_SGI_Dir_Vector :  /* Keyword */
04531             disregard_directive[Tok_Dir_Vector - Tok_Dir_Start]   = TRUE;
04532             break;
04533 
04534 
04535 
04536          case Tok_Dir_Align :
04537          case Tok_Dir_Auxiliary :
04538          case Tok_Dir_Bl :
04539          case Tok_Dir_Bounds :
04540          case Tok_Dir_Cache_Align :
04541          case Tok_Dir_Cache_Bypass :
04542          case Tok_Dir_Cache_Noalloc :
04543          case Tok_Dir_Common :
04544          case Tok_Dir_Copy_Assumed_Shape :
04545          case Tok_Dir_Eject :
04546          case Tok_Dir_Flow :
04547          case Tok_Dir_Fixed :
04548          case Tok_Dir_Free :
04549          case Tok_Dir_Id :
04550          case Tok_Dir_Ignore_TKR :
04551          case Tok_Dir_Inline_Always :
04552          case Tok_Dir_Inline_Never :
04553          case Tok_Dir_Ivdep :
04554          case Tok_Dir_List :
04555          case Tok_Dir_Mark :
04556          case Tok_Dir_Modinline :
04557          case Tok_Dir_Name :
04558          case Tok_Dir_Nextscalar :
04559          case Tok_Dir_Nobl :
04560          case Tok_Dir_Nobounds :
04561          case Tok_Dir_Noflow :
04562          case Tok_Dir_Nolist :
04563          case Tok_Dir_Nomark :
04564          case Tok_Dir_Nomodinline :
04565          case Tok_Dir_Nopattern :
04566          case Tok_Dir_Nosideeffects :
04567          case Tok_Dir_Nosplit :
04568          case Tok_Dir_Nostream :
04569          case Tok_Dir_Notask :
04570          case Tok_Dir_Nounroll :
04571          case Tok_Dir_Novector :
04572          case Tok_Dir_Novsearch :
04573          case Tok_Dir_Pattern :
04574          case Tok_Dir_Preferstream :
04575          case Tok_Dir_Prefertask :
04576          case Tok_Dir_Prefervector :
04577          case Tok_Dir_Recurrence :
04578          case Tok_Dir_Shortloop :
04579          case Tok_Dir_Split :
04580          case Tok_Dir_Stack :
04581          case Tok_Dir_Stream :
04582          case Tok_Dir_Suppress :
04583          case Tok_Dir_Symmetric :
04584          case Tok_Dir_System_Module :
04585          case Tok_Dir_Task :
04586          case Tok_Dir_Uses_Eregs :
04587          case Tok_Dir_Vfunction :
04588          case Tok_Dir_Vsearch :
04589             break;
04590 
04591 
04592          case Tok_Mic_Case :
04593          case Tok_Mic_End_Case :
04594          case Tok_Mic_Cncall :
04595          case Tok_Mic_Do_All :
04596          case Tok_Mic_Do_Parallel :
04597          case Tok_Mic_End_Do :
04598          case Tok_Mic_Guard :
04599          case Tok_Mic_End_Guard :
04600          case Tok_Mic_Numcpus :
04601          case Tok_Mic_Wait :
04602          case Tok_Mic_Send :
04603             break;
04604 
04605 
04606          /* OpenMp directives. */
04607 
04608          case Tok_Open_Mp_Dir_Atomic :
04609          case Tok_Open_Mp_Dir_Enddo :
04610          case Tok_Open_Mp_Dir_Endordered :
04611          case Tok_Open_Mp_Dir_Endparalleldo :
04612          case Tok_Open_Mp_Dir_Endparallelsections :
04613          case Tok_Open_Mp_Dir_Endparallelworkshare :
04614          case Tok_Open_Mp_Dir_Endsections :
04615          case Tok_Open_Mp_Dir_Endsingle :
04616          case Tok_Open_Mp_Dir_Endworkshare :
04617          case Tok_Open_Mp_Dir_Parallelsections :
04618          case Tok_Open_Mp_Dir_Sections :
04619          case Tok_Open_Mp_Dir_Threadprivate :
04620             break;
04621 
04622          /* Mips directives */
04623 
04624          case Tok_SGI_Dir_Aggressiveinner :
04625          case Tok_SGI_Dir_Align_Symbol :
04626          case Tok_SGI_Dir_Assert :
04627          case Tok_SGI_Dir_Chunk :
04628          case Tok_SGI_Dir_Criticalsection :
04629          case Tok_SGI_Dir_Doacross :
04630          case Tok_SGI_Dir_Endcriticalsection :
04631          case Tok_SGI_Dir_Endpsections :
04632          case Tok_SGI_Dir_Endpsection :
04633          case Tok_SGI_Dir_Endpdo :
04634          case Tok_SGI_Dir_Endsingleprocess :
04635          case Tok_SGI_Dir_Fill_Symbol :
04636          case Tok_SGI_Dir_Fission :
04637          case Tok_SGI_Dir_Fissionable :
04638          case Tok_SGI_Dir_Fusable :
04639          case Tok_SGI_Dir_Fuse :
04640          case Tok_SGI_Dir_Ipa :
04641          case Tok_SGI_Dir_Limit :
04642          case Tok_SGI_Dir_Minconcurrent :
04643          case Tok_SGI_Dir_Mp_Schedtype :
04644          case Tok_SGI_Dir_Noconcurrentize :
04645          case Tok_SGI_Dir_Nofission :
04646          case Tok_SGI_Dir_Nofusion :
04647          case Tok_SGI_Dir_Noipa :
04648          case Tok_SGI_Dir_Opaque :
04649          case Tok_SGI_Dir_Optional :
04650 #ifdef KEY /* Bug 2660 */
04651          case Tok_SGI_Dir_Options :
04652 #endif /* KEY Bug 2660 */
04653          case Tok_SGI_Dir_Pdo :
04654          case Tok_SGI_Dir_Prefetch_Manual :
04655          case Tok_SGI_Dir_Prefetch_Ref :
04656          case Tok_SGI_Dir_Prefetch :
04657          case Tok_SGI_Dir_Prefetch_Ref_Disable :
04658          case Tok_SGI_Dir_Psection :
04659          case Tok_SGI_Dir_Psections :
04660          case Tok_SGI_Dir_Purpleconditional :
04661          case Tok_SGI_Dir_Purpleunconditional :
04662          case Tok_SGI_Dir_Regionbegin :
04663          case Tok_SGI_Dir_Regionend :
04664          case Tok_SGI_Dir_Section_Gp :
04665          case Tok_SGI_Dir_Section_Non_Gp :
04666          case Tok_SGI_Dir_Singleprocess :
04667             break;
04668 
04669          /* These are obsolete directives. */
04670 
04671          case Tok_Dir_Block :
04672          case Tok_Dir_Regfile :
04673          case Tok_Dir_Semextern :
04674          case Tok_Dir_Shortsequence :
04675          case Tok_Dir_Static :
04676          case Tok_Dir_Taskhead :
04677             issue_warning = TRUE;
04678             break;
04679 
04680          /* Unsupported cmics */
04681 
04682          case Tok_Mic_Continue :
04683             issue_warning = TRUE;
04684 
04685          /* CRAFT directives */
04686 
04687          case Tok_Dir_Atomicupdate :
04688          case Tok_Dir_Nobarrier :
04689             issue_warning = TRUE;
04690             break;
04691 
04692          }  /* end switch */
04693 
04694          if (issue_warning) {
04695             PRINTMSG (0, 604, Log_Warning, 0, 'x', cp);
04696             issue_warning = FALSE;
04697          }
04698       }
04699    }
04700 
04701    TRACE (Func_Exit, "process_x_option", NULL);
04702 
04703    return; 
04704  
04705 }  /* process_x_option */
04706  
04707 /******************************************************************************\
04708 |*                        *|
04709 |* Description:                     *|
04710 |*  Process_M_option handles the command line message suppress option     *|
04711 |*  passed via argv (M switch).               *|
04712 |*                        *|
04713 |* Input parameters:                    *|
04714 |*  optargs     -M option arguments           *|
04715 |*                        *|
04716 |* Output parameters:                   *|
04717 |*  NONE                      *|
04718 |*                        *|
04719 |* Returns:                     *|
04720 |*  NOTHING                     *|
04721 |*                        *|
04722 \******************************************************************************/
04723 
04724 static void process_M_option (char *optargs) 
04725  
04726 { 
04727    char   *cp;
04728    long    msg_num;
04729    boolean   suppress;
04730    long   *table_ptr;
04731 
04732 
04733    TRACE (Func_Entry, "process_M_option", NULL);
04734 
04735    while (*optargs != EOS) {
04736 
04737       for (cp = optargs;
04738            *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
04739            ++optargs);
04740 
04741       if (*optargs != EOS) {
04742          *optargs = EOS;
04743          *optargs++;
04744       }
04745 
04746       table_ptr = (long *) message_suppress_tbl;
04747       suppress  = TRUE;
04748 
04749       if (*cp == 'E') {
04750          *cp++;
04751          suppress = FALSE;
04752          table_ptr  = (long *) message_error_tbl;
04753       }
04754       else if (*cp == 'W') {
04755          *cp++;
04756          suppress = FALSE;
04757          table_ptr  = (long *) message_warning_tbl;
04758       }
04759       else if (*cp < '0' || *cp > '9') {    /* Not alphabetic */
04760          ntr_msg_queue(0, 78, Log_Error, 0, cp, 'M', ARG_STR_ARG);
04761       }
04762 
04763       msg_num = atoi(cp);
04764 
04765       if (msg_num < 0  || msg_num > (MAX_MSG_SIZE*HOST_BITS_PER_WORD) - 1) {
04766          ntr_msg_queue(0, 78, Log_Error, 0, cp, 'M', ARG_STR_ARG);
04767       }
04768       else {
04769 
04770          if (suppress && !GET_MESSAGE_TBL(message_suppress_tbl, msg_num)) {
04771             cmd_line_flags.num_msgs_suppressed++;
04772          }
04773 
04774          SET_MESSAGE_TBL(table_ptr, msg_num);
04775       }
04776    }
04777 
04778    TRACE (Func_Exit, "process_M_option", NULL);
04779 
04780    return; 
04781  
04782 }  /* process_M_option */
04783 
04784 
04785 /******************************************************************************\
04786 |*                        *|
04787 |* Description:                     *|
04788 |*  Process_Y_option handles ccg dump options.                            *|
04789 |*                        *|
04790 |* Input parameters:                    *|
04791 |*  optargs     -Y option arguments           *|
04792 |*                        *|
04793 |* Output parameters:                   *|
04794 |*  NONE                      *|
04795 |*                        *|
04796 |* Returns:                     *|
04797 |*  NOTHING                     *|
04798 |*                        *|
04799 \******************************************************************************/
04800  
04801 static void process_Y_option (char *optargs)
04802 
04803 {
04804    int  ch;
04805 
04806 
04807    TRACE (Func_Entry, "process_Y_option", NULL);
04808 
04809 
04810    while (ch = *optargs++) {
04811 #ifdef _TARGET32
04812       ccg_dump_flags = ccg_dump_flags | (1 << ((ch - 'A') & 0x1F));
04813 #else
04814       ccg_dump_flags = ccg_dump_flags | (1 << (ch - 'A'));
04815 #endif
04816    }  /* while */
04817 
04818 
04819    TRACE (Func_Exit, "process_Y_option", NULL);
04820 
04821    return;
04822  
04823 }  /* process_Y_option */
04824 
04825 
04826 /******************************************************************************\
04827 |*                        *|
04828 |* Description:                     *|
04829 |*  Set_prog_file_names processes the source file name on command line,   *|
04830 |*  if it exists, otherwise the default source file is 'stdin'.       *|
04831 |*                        *|
04832 |* Input parameters:                    *|
04833 |*  argv      last argument on cmd line is input file       *|
04834 |*                        *|
04835 |* Output parameters:                   *|
04836 |*  NONE                      *|
04837 |*                        *|
04838 |* Returns:                     *|
04839 |*  NOTHING                     *|
04840 |*                        *|
04841 \******************************************************************************/
04842 
04843 static void set_prog_file_names (char *argv[])
04844 
04845 {
04846    extern char  *optarg;    /* defined in getopt */
04847    extern int optind;     /* defined in getopt */
04848 
04849       int fp_idx;
04850       int idx;
04851       int length;
04852     char  *stp;
04853 
04854 
04855    TRACE (Func_Entry, "set_prog_file_names", NULL);
04856 
04857    /* optind points to the last argument;  if it exists, it is the file  */
04858    /* to be compiled;  if nothing is there, input is obtained from stdin */
04859 
04860    optarg = argv[optind];
04861 
04862    if (optarg == NULL) {      /* 'stdin' is default input   */
04863       src_file[0] = EOS;
04864 
04865       /* make sure -b specified when binary file requested and input is stdin */
04866 
04867       if (binary_output  &&  bin_file[0] == EOS) {
04868 
04869    /* Name must be specified for file when input is from stdin. */
04870 
04871          ntr_msg_queue(0, 80, Log_Error, 0, "binary", 0, STR_ARG);
04872    binary_output = FALSE;
04873       }
04874 
04875       /* make sure -S specified when cal file requested and input is stdin */
04876 
04877       if (assembly_output  &&  assembly_file[0] == EOS) {
04878 
04879    /* Name must be specified for file when input is from stdin. */
04880 
04881          ntr_msg_queue(0, 80, Log_Error, 0, "assembly", 0, STR_ARG);
04882    assembly_output = FALSE;
04883       }
04884 
04885       if (on_off_flags.assembly_listing_file) {
04886          strcpy(assembly_listing_file, "stdout");
04887       }
04888 
04889       strcpy(debug_file_name, "stderr");
04890    }
04891    else {         /* named file[.f] is input    */
04892 #ifdef KEY /* Bug 4469 */
04893       if (strlen(optarg) >= MAX_FILE_NAME_SIZE) {
04894   PRINTMSG(0, 57, Limit, 0, (MAX_FILE_NAME_SIZE - 1));
04895         }
04896 #endif /* KEY bug 4469 */
04897       strncpy (src_file, optarg, MAX_FILE_NAME_SIZE);
04898       src_file[MAX_FILE_NAME_SIZE-1] = EOS;
04899 
04900       /* generate default file name for binary file from input file[.f]  */
04901 
04902       if (binary_output && bin_file[0] == EOS) {
04903          MAKE_DEFAULT_NAME (bin_file, src_file, "o");
04904       }
04905 
04906       /* generate default file name for cal file from input file[.f]  */
04907 
04908       if (assembly_output  &&  assembly_file[0] == EOS) {
04909    MAKE_DEFAULT_NAME (assembly_file, src_file, "s");
04910       }
04911 
04912       if (on_off_flags.assembly_listing_file) {
04913    MAKE_DEFAULT_NAME (assembly_listing_file, src_file, "L");
04914       }
04915 
04916       /* Generate default file name for debug file from input file[.f]     */
04917       /* In some obscure cases, the debug file will have been written to   */
04918       /* before the commandline is processed or it may have been specified */
04919       /* on the command line via -ufile=<name>.  DO NOT change the name.   */
04920       /* Leave it as cft90_dump or as specified.  Otherwise name it    */
04921       /* src_file.l                      */
04922       if (debug_file_name[0] == NULL_CHAR) {
04923          MAKE_DEFAULT_NAME (debug_file_name, src_file, "l");
04924       }
04925 
04926       if (! set_source_form_option) {   /* Set fixed/free from src file name  */
04927          stp = strrchr (src_file, DOT);
04928 
04929          if (stp != NULL) {
04930 
04931             if (EQUAL_STRS(stp, ".f") ||
04932                 EQUAL_STRS(stp, ".F")) {
04933                cmd_line_flags.src_form  = Fixed_Form;
04934                source_form    = Fixed_Form;
04935             }
04936             else if (EQUAL_STRS(stp, ".f90") ||
04937 #ifdef KEY /* Bug 5064 */
04938                      EQUAL_STRS(stp, ".f95") ||
04939                      EQUAL_STRS(stp, ".F95") ||
04940 #endif /* KEY Bug 5064 */
04941                      EQUAL_STRS(stp, ".F90")) {
04942                cmd_line_flags.src_form  = Free_Form;
04943                source_form    = Free_Form;
04944             }
04945          }
04946       }
04947 
04948 # if defined(_FRONTEND_CONDITIONAL_COMP)
04949       if (! no_preprocessing) {
04950          /* see if this is a .F or .F90 file */
04951          stp = strrchr (src_file, DOT);
04952 
04953          if (stp != NULL) {
04954 
04955             if (EQUAL_STRS(stp, ".F") ||
04956 #ifdef KEY /* Bug 5064 */
04957     EQUAL_STRS(stp, ".F95") ||
04958 #endif /* KEY Bug 5064 */
04959                 EQUAL_STRS(stp, ".F90")) {
04960 
04961                on_off_flags.preprocess = TRUE;
04962             }
04963          }
04964       }
04965 # endif
04966    }
04967 
04968    /* Check that any inlinefrom files will not be */ 
04969    /* overwritten by the main file compilation.   */
04970 
04971    fp_idx = inline_path_idx;
04972 
04973    while (fp_idx != NULL_IDX) {
04974 
04975       if (strcmp(bin_file, FP_NAME_PTR(fp_idx)) == 0) {
04976 
04977          /* This should use ntr_msg_queue but to do it would be messy. */
04978          /* So technically we cannot stop 1252 from issuing if it is   */
04979          /* used with the -M option.   kay                             */
04980 
04981          PRINTMSG(0, 1252, Log_Error, 0, bin_file, FP_NAME_PTR(fp_idx));
04982       }
04983       fp_idx = FP_NEXT_FILE_IDX(fp_idx);
04984    }
04985 
04986    if (cif_flags != 0  &&  cif_name[0] == '\0') {
04987       MAKE_DEFAULT_NAME (cif_name, src_file, "T");
04988    }
04989 
04990    if (on_off_flags.preprocess_only || on_off_flags.save_dot_i) {
04991       MAKE_DEFAULT_NAME (dot_i_file, src_file, "i");
04992    }
04993 
04994    /* Put the current directory into the module search path.  By putting */
04995    /* it here, it will be searched after all user specified files/dirs.  */
04996 
04997    TBL_REALLOC_CK(file_path_tbl, 1);
04998    CLEAR_TBL_NTRY(file_path_tbl, file_path_tbl_idx);
04999    FP_NAME_LEN(file_path_tbl_idx) = 2;
05000    FP_NAME_IDX(file_path_tbl_idx) = str_pool_idx + 1;
05001    FP_SRCH_THE_FILE(file_path_tbl_idx)  = TRUE;
05002    length       = WORD_LEN(2);
05003 
05004    TBL_REALLOC_CK(str_pool, length);
05005 
05006    for (idx = FP_NAME_IDX(file_path_tbl_idx); idx <= str_pool_idx; idx++) {
05007       str_pool[idx].name_long   = 0;
05008    }
05009 
05010    strcpy(FP_NAME_PTR(file_path_tbl_idx), "./");
05011 
05012    if (module_path_idx != NULL_IDX) {
05013       idx = module_path_idx;
05014 
05015       while (FP_NEXT_FILE_IDX(idx) != NULL_IDX) {
05016          idx = FP_NEXT_FILE_IDX(idx);
05017       }
05018       FP_NEXT_FILE_IDX(idx)   = file_path_tbl_idx;
05019    }
05020    else {
05021       module_path_idx = file_path_tbl_idx;
05022    }
05023 
05024    set_system_module_path();
05025 
05026    TRACE (Func_Exit, "set_prog_file_names", NULL);
05027 
05028    return;
05029 
05030 }  /* set_prog_file_names */
05031 
05032 
05033 # ifdef _DEBUG
05034 /******************************************************************************\
05035 |*                        *|
05036 |* Description:                     *|
05037 |*  Prints a description of the debug items available to stderr.          *|
05038 |*                        *|
05039 |* Input parameters:                    *|
05040 |*  NONE                      *|
05041 |*                        *|
05042 |* Output parameters:                   *|
05043 |*  NONE                      *|
05044 |*                        *|
05045 |* Returns:                     *|
05046 |*  NOTHING                     *|
05047 |*                        *|
05048 \******************************************************************************/
05049 
05050 static  void  dump_help_screen(void)
05051 {
05052    int   i;
05053    char *info_str[] = {
05054              "The following options are available in a compiler with -u: ",
05055              " ",
05056              "abort_ansi       Abort compilation after first ANSI msg.",
05057              "cray_compatible  Sgi  turns s_default64 on, int1,2 off.",
05058              "f                Unimplemented - controls fortran output.",
05059              "dsm              Set by mongoose driver - not a user option.",
05060              "fmm              Controls f-- prototype.",
05061              "fmm1             Controls f-- prototype.",
05062              "fmm2             Controls f-- prototype.",
05063              "mod_version      Prints each module version number being read in",
05064              "mp               Allow recognition of the SGI directives.",
05065              "no_dim_pad       Do not pad out missing dimensions.",
05066              "no_mod_output    Do not do module output.",
05067              "open_mp          Allow recognition of the open mp directives.",
05068              "pack_half_word   Turn on component packing for sdefault32",
05069              "preinline=       Create an inline template for this file.",
05070              "pvp_test         Used for meta development.",
05071              "show             Show input command line to frontend.",
05072              " ",
05073              "The following options are available in a debug compiler with -u:",
05074              " ",
05075              "all              Dump all tables.  Do not do any tracing.",
05076              "bd               Dump the bounds table.",
05077              "blk              Dump the Block Stack.",
05078              "cmd              Dump the commandline table.",
05079              "cn               Dump the Constant table.",
05080              "defines          Dump the build definitions.",
05081              "file=            Specify the name of the debug output file.",
05082              "fortran          Dump the output IR in a Fortran format.",
05083              "fp               Dump the File Path table.",
05084              "ftrace           Activate the function trace.",
05085              "gl               Dump the Global Line table.",
05086              "intrin           Dump the Intrinsic table.",
05087              "ir1              Dump the IR after Pass 1.",
05088              "ir2              Dump the IR after Pass 2.",
05089              "ir3              Dump the IR after inlining.",
05090              "ir4              Dump the IR after swapping dimensions.",
05091              "mem_report       Provide a report of front-end memory usage.",
05092              "msg              Issue an abort for all zero line numbers.",
05093              "mtrace           Trace front-end memory usage.",
05094              "names            Dump the local, global and hidden name tables.",
05095              "pdg              Dump all calls to the PGDCS interface.",
05096              "pdt              Dump PDT info while searching for modules.",
05097              "sb               Dump the Storage Block table.",
05098              "scp              Dump the scope table.",
05099              "src              Dump whole source program.",
05100              "stderr           Output msgs to stderr rather than ordering.",
05101              "stmt             Dump each statement.",
05102              "sytb             Dump the symbol table.",
05103              "typ              Dump the Type table.",
05104              "cnout            Dump constants as binary to stdout.",
05105              "DONE" };
05106 
05107    TRACE (Func_Entry, "dump_help_screen", NULL);
05108 
05109    i = 0;
05110 
05111    while (strcmp(info_str[i],"DONE")) fprintf(stderr, "%s\n", info_str[i++]);
05112 
05113    TRACE (Func_Exit, "dump_help_screen", NULL);
05114 
05115    return;
05116 
05117 }  /* dump_help_screen */
05118 
05119 # endif
05120 
05121 
05122 /******************************************************************************\
05123 |*                        *|
05124 |* Description:                     *|
05125 |*  Add path names to the file path table.  Used by both -p and -I.       *|
05126 |*ifdef KEY Bug 4210
05127 |*       Also used by -J to prepend the module-creation directory to the      *|
05128 |*  list                                                                  *|
05129 |*endif  KEY Bug 4210
05130 |*                        *|
05131 |* Input parameters:                    *|
05132 |*  NONE                      *|
05133 |*                        *|
05134 |* Output parameters:                   *|
05135 |*  NONE                      *|
05136 |*                        *|
05137 |* Returns:                     *|
05138 |*  NOTHING                     *|
05139 |*                        *|
05140 \******************************************************************************/
05141 
05142 static  void  add_to_fp_table(char  *optargs,
05143         int *start_idx,
05144         int  option)
05145 
05146 {
05147    int     fp_idx;
05148    int     length;
05149    char    path_name[MAX_FILE_NAME_SIZE];
05150 
05151 
05152    TRACE (Func_Entry, "add_to_fp_table", NULL);
05153 
05154    TBL_REALLOC_CK(file_path_tbl, 1);
05155    CLEAR_TBL_NTRY(file_path_tbl, file_path_tbl_idx);
05156 
05157    if (*start_idx == NULL_IDX) {
05158       *start_idx  = file_path_tbl_idx;
05159    }
05160 #ifdef KEY /* Bug 4210 */
05161    /* Prepend the -J directory to the module-search list */
05162    else if ('J' == option) {
05163       FP_NEXT_FILE_IDX(file_path_tbl_idx) = *start_idx;
05164       *start_idx = file_path_tbl_idx;
05165       /* We want 'J' to work like 'p' (the module-search-path option)
05166          henceforth */
05167       option = 'p';
05168    }
05169 #endif /* KEY Bug 4210 */
05170    else {
05171       fp_idx = *start_idx;
05172 
05173       /* Find the end of the list of files/paths.  These must be ordered. */
05174 
05175       while (FP_NEXT_FILE_IDX(fp_idx) != NULL_IDX) {
05176          fp_idx = FP_NEXT_FILE_IDX(fp_idx);
05177       }
05178       FP_NEXT_FILE_IDX(fp_idx)    = file_path_tbl_idx;
05179    }
05180       
05181    FP_NAME_IDX(file_path_tbl_idx) = str_pool_idx + 1;
05182    length       = strlen(optargs);
05183 
05184    if (option == 'p' || option == 'O') {   /* module path option */
05185       FP_SRCH_THE_FILE(file_path_tbl_idx) = TRUE;
05186    }
05187    else {
05188 
05189       FP_CLASS(file_path_tbl_idx) = Include_Fp;
05190 
05191       if (optargs[0] != SLASH)
05192 
05193       {
05194          /* make relative path prefix absolute */
05195 
05196          getcwd (path_name, MAX_FILE_NAME_SIZE);
05197          length += strlen(path_name) + 1;
05198       }
05199    }
05200 
05201    FP_NAME_LEN(file_path_tbl_idx) = length;
05202 
05203    TBL_REALLOC_CK(str_pool, WORD_LEN(length));
05204 
05205    str_pool[str_pool_idx].name_long = 0; /* Zero out last word */
05206 
05207    if (option == 'p' || option == 'O' || optargs[0] == SLASH)
05208      {
05209       strcpy(FP_NAME_PTR(file_path_tbl_idx), optargs);
05210    }
05211    else {  /* Hardcoding a path name here for inlining only */
05212       strcpy(FP_NAME_PTR(file_path_tbl_idx), path_name);
05213       strcat(FP_NAME_PTR(file_path_tbl_idx), "/");
05214       strcat(FP_NAME_PTR(file_path_tbl_idx), optargs);
05215    }
05216 
05217    TRACE (Func_Exit, "add_to_fp_table", NULL);
05218 
05219    return;
05220 
05221 }  /* add_to_fp_table */
05222 
05223 /******************************************************************************\
05224 |*                        *|
05225 |* Description:                     *|
05226 |*  process_P_option handles position independent code model options      *|
05227 |*                        *|
05228 |* Input parameters:                    *|
05229 |*  optargs     -P option arguments           *|
05230 |*                        *|
05231 |* Output parameters:                   *|
05232 |*  NONE                      *|
05233 |*                        *|
05234 |* Returns:                     *|
05235 |*  NOTHING                     *|
05236 |*                        *|
05237 \******************************************************************************/
05238 
05239 static void process_P_option (char *optargs)
05240 
05241 {
05242 #  if defined(_ACCEPT_CMD_P)
05243    int     ch;
05244    char    err_str[2];
05245 #  endif
05246 
05247 
05248    TRACE (Func_Entry, "process_P_option", NULL);
05249 
05250 #  if defined(_ACCEPT_CMD_P)
05251       while (ch = *optargs++) {
05252 
05253          switch (ch) {
05254          case 'l':
05255             cmd_line_flags.large_pic_model  = TRUE;
05256             break;
05257 
05258          case 's':
05259             cmd_line_flags.small_pic_model  = TRUE;
05260             break;
05261 
05262          default:
05263             err_str[0] = ch;
05264             err_str[1] = EOS;
05265 
05266             /* option has an invalid argument */
05267 
05268             ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'P', ARG_STR_ARG);
05269             break;
05270          }   /* switch */
05271       }  /* while */
05272 #  else  /* Unsupported */
05273       ntr_msg_queue(0, 797, Log_Warning, 0, (char *) NULL, 'P' ,ARG_ARG);
05274 #  endif
05275  
05276    TRACE (Func_Exit, "process_P_option", NULL);
05277 
05278    return;
05279 
05280 }  /* process_P_option */
05281 
05282 /******************************************************************************\
05283 |*                        *|
05284 |* Description:                     *|
05285 |*  Process memory option.                                                *|
05286 |*                        *|
05287 |* Input parameters:                    *|
05288 |*  NONE                      *|
05289 |*                        *|
05290 |* Output parameters:                   *|
05291 |*  NONE                      *|
05292 |*                        *|
05293 |* Returns:                     *|
05294 |*  NOTHING                     *|
05295 |*                        *|
05296 \******************************************************************************/
05297 
05298 static  void  process_a_option(char *optargs)
05299 
05300 {
05301    char   *cp;
05302 
05303 #  if defined(_ACCEPT_CMD_a_pad)
05304     int    pad_amount;
05305 #  endif
05306 
05307 
05308    TRACE (Func_Entry, "process_a_option", NULL);
05309 
05310    while (*optargs != EOS) {
05311 
05312       for (cp = optargs;
05313         *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
05314               ++optargs) {
05315       }
05316 
05317       if (*optargs != EOS) {
05318           *optargs = EOS;
05319           *optargs++;
05320       }
05321 
05322 # if 0
05323       if (EQUAL_STRS(cp, "lign8")) {
05324 
05325 #        if defined(_ACCEPT_CMD_align)
05326             cmd_line_flags.align8 = TRUE;
05327 #        else
05328             ntr_msg_queue(0, 744, Log_Warning, 0, "align8", 'a', ARG_STR_ARG);
05329 #        endif
05330       }
05331       else if (EQUAL_STRS(cp, "lign16")) {
05332 
05333 #        if defined(_ACCEPT_CMD_align)
05334             cmd_line_flags.align16  = TRUE;
05335 #        else
05336             ntr_msg_queue(0, 744, Log_Warning, 0, "align16", 'a', ARG_STR_ARG);
05337 #        endif
05338       }
05339 # endif
05340       if (EQUAL_STRS(cp, "lign32")) {
05341 
05342 #        if defined(_ACCEPT_CMD_align)
05343             cmd_line_flags.align32  = TRUE;
05344 #        else
05345             ntr_msg_queue(0, 744, Log_Warning, 0, "align32", 'a', ARG_STR_ARG);
05346 #        endif
05347       }
05348       else if (EQUAL_STRS(cp, "lign64")) {
05349 
05350 #        if defined(_ACCEPT_CMD_align)
05351             cmd_line_flags.align64  = TRUE;
05352             cmd_line_flags.dalign = TRUE;  /* Means the same thing. */
05353 #        else
05354             ntr_msg_queue(0, 744, Log_Warning, 0, "align64", 'a', ARG_STR_ARG);
05355 #        endif
05356       }
05357       else if (EQUAL_STRS(cp, "dalign")) {
05358 
05359 #        if defined(_ACCEPT_CMD_a_dalign)
05360             cmd_line_flags.dalign = TRUE;
05361 #        else
05362             ntr_msg_queue(0, 744, Log_Warning, 0, "dalign", 'a', ARG_STR_ARG);
05363 #        endif
05364       }
05365       else if (EQUAL_STRS(cp, "static_threadprivate")) {
05366 
05367 #        if defined(_ACCEPT_CMD_a_static_threadprivate)
05368             cmd_line_flags.static_threadprivate = TRUE;
05369 #        else
05370             ntr_msg_queue(0, 744, Log_Warning, 0, "static_threadprivate",
05371                                                   'a', ARG_STR_ARG);
05372 #        endif
05373       }
05374       else if (EQUAL_STRS(cp, "taskcommon")) {
05375 
05376 #        if !defined(_TASK_COMMON_EXTENSION)
05377             ntr_msg_queue(0, 744, Log_Warning, 0,
05378                           "taskcommon", 'a', ARG_STR_ARG);
05379 #        else
05380             cmd_line_flags.taskcommon = TRUE;
05381 #        endif
05382       }
05383       else if (strncmp(cp, "pad", 3) == 0) {
05384 
05385 #        if defined(_ACCEPT_CMD_a_pad)
05386             cp             +=3 ;
05387 
05388             if (*cp != EOS) {
05389                pad_amount = atoi(cp);
05390 
05391                if (pad_amount <= 0 || pad_amount >= 4096) {
05392                   ntr_msg_queue(0, 1251, Log_Error, 0,
05393                                 (char *) NULL, pad_amount, ARG_ARG);
05394                }
05395             }
05396             else {
05397                pad_amount = 0;
05398             }
05399  
05400             cmd_line_flags.pad    = TRUE;
05401             cmd_line_flags.pad_amount = pad_amount;
05402 #        else
05403             ntr_msg_queue(0, 744, Log_Warning, 0, "pad", 'a', ARG_STR_ARG);
05404 #        endif
05405       }
05406       else { /* option has an invalid argument */
05407          ntr_msg_queue(0, 78, Log_Error, 0, cp, 'a', ARG_STR_ARG);
05408       }
05409 
05410    }  /* while */
05411 
05412             
05413    TRACE (Func_Exit, "process_a_option", NULL);
05414 
05415    return;
05416 
05417 }  /* process_a_option */
05418 
05419 /******************************************************************************\
05420 |*                        *|
05421 |* Description:                     *|
05422 |*  Add use names to the file path table for implicit use.                *|
05423 |*                        *|
05424 |* Input parameters:                    *|
05425 |*  NONE                      *|
05426 |*                        *|
05427 |* Output parameters:                   *|
05428 |*  NONE                      *|
05429 |*                        *|
05430 |* Returns:                     *|
05431 |*  NOTHING                     *|
05432 |*                        *|
05433 \******************************************************************************/
05434 
05435 static  void  process_A_option(char *optargs)
05436 
05437 {
05438    boolean   found_one;
05439    int     fp_idx;
05440    int     idx;
05441    int     length;
05442    char   *module_name;
05443    int     start_idx;
05444    char   *str_ptr;
05445 
05446 
05447    TRACE (Func_Entry, "process_A_option", NULL);
05448 
05449    start_idx  = file_path_tbl_idx + 1;
05450    found_one  = FALSE;
05451       
05452    while (*optargs != EOS) {
05453 
05454       for (module_name = optargs;
05455           *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
05456           ++optargs);
05457 
05458       if (*optargs != EOS) {
05459    *optargs = EOS;
05460    *optargs++;
05461       }
05462 
05463       if (found_one) {  /* Second or subsequent time through */
05464          FP_NEXT_FILE_IDX(file_path_tbl_idx) = file_path_tbl_idx + 1;
05465       }
05466 
05467       TBL_REALLOC_CK(file_path_tbl, 1);
05468       CLEAR_TBL_NTRY(file_path_tbl, file_path_tbl_idx);
05469 
05470       found_one     = TRUE;
05471       FP_NAME_IDX(file_path_tbl_idx)  = str_pool_idx + 1;
05472       length        = strlen(module_name);
05473       FP_CLASS(file_path_tbl_idx) = Unknown_Fp;
05474       FP_NAME_LEN(file_path_tbl_idx)  = length;
05475 
05476       TBL_REALLOC_CK(str_pool, WORD_LEN(length));
05477 
05478       str_pool[str_pool_idx].name_long = 0; /* Zero out last word */
05479 
05480       str_ptr = &str_pool[FP_NAME_IDX(file_path_tbl_idx)].name_char;
05481 
05482       for (idx = 0;  idx < length;  idx++) {
05483          str_ptr[idx] = toupper(module_name[idx]);
05484       }
05485    }
05486 
05487    if (found_one) {
05488 
05489       if (cmd_line_flags.implicit_use_idx == NULL_IDX) {
05490          cmd_line_flags.implicit_use_idx  = start_idx;
05491       }
05492       else {
05493          fp_idx = cmd_line_flags.implicit_use_idx;
05494 
05495          /* Find the end of the list of files/paths.  These must be ordered. */
05496 
05497          while (FP_NEXT_FILE_IDX(fp_idx) != NULL_IDX) {
05498             fp_idx = FP_NEXT_FILE_IDX(fp_idx);
05499          }
05500          FP_NEXT_FILE_IDX(fp_idx)   = start_idx;
05501       }
05502    }
05503 
05504    TRACE (Func_Exit, "process_A_option", NULL);
05505 
05506    return;
05507 
05508 }  /* process_A_option */
05509 
05510 /******************************************************************************\
05511 |*                        *|
05512 |* Description:                     *|
05513 |*  Process binary option.                                                *|
05514 |*                        *|
05515 |* Input parameters:                    *|
05516 |*  NONE                      *|
05517 |*                        *|
05518 |* Output parameters:                   *|
05519 |*  NONE                      *|
05520 |*                        *|
05521 |* Returns:                     *|
05522 |*  NOTHING                     *|
05523 |*                        *|
05524 \******************************************************************************/
05525 
05526 static  void  process_b_option(char *optargs)
05527 
05528 {
05529 
05530    TRACE (Func_Entry, "process_b_option", NULL);
05531 
05532    /* issue warning if cal output is being overridden */
05533 
05534    if (cmd_line_flags.assembly_output) {
05535       ntr_msg_queue(0, 715, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
05536       cmd_line_flags.assembly_output = FALSE;
05537     }
05538  
05539     cmd_line_flags.binary_output = TRUE;
05540     strncpy (bin_file, optargs, MAX_FILE_NAME_SIZE);
05541     bin_file[MAX_FILE_NAME_SIZE-1] = EOS;
05542 
05543    TRACE (Func_Exit, "process_b_option", NULL);
05544 
05545    return;
05546 
05547 }  /* process_b_option */
05548 
05549 /******************************************************************************\
05550 |*                        *|
05551 |* Description:                     *|
05552 |*  Process source form option.                                           *|
05553 |*                        *|
05554 |* Input parameters:                    *|
05555 |*  NONE                      *|
05556 |*                        *|
05557 |* Output parameters:                   *|
05558 |*  NONE                      *|
05559 |*                        *|
05560 |* Returns:                     *|
05561 |*  NOTHING                     *|
05562 |*                        *|
05563 \******************************************************************************/
05564 
05565 static  void  process_f_option(char *optargs)
05566 
05567 {
05568 
05569    TRACE (Func_Entry, "process_f_option", NULL);
05570 
05571    if (EQUAL_STRS(optargs, "fixed")) {
05572       cmd_line_flags.src_form = Fixed_Form;
05573       source_form   = Fixed_Form;
05574       set_source_form_option  = TRUE;
05575    }
05576    else if (EQUAL_STRS(optargs, "free")) {
05577       cmd_line_flags.src_form = Free_Form;
05578       source_form   = Free_Form;
05579       set_source_form_option  = TRUE;
05580    }
05581 #ifdef KEY /* Bug 12482 */
05582    else if (EQUAL_STRS(optargs, "fortran2003")) {
05583       on_off_flags.fortran2003 = TRUE;
05584    }
05585 #endif /* KEY Bug 12482 */
05586    else {
05587       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'f', ARG_STR_ARG);
05588    }
05589 
05590    TRACE (Func_Exit, "process_f_option", NULL);
05591 
05592    return;
05593 
05594 }  /* process_f_option */
05595 
05596 /******************************************************************************\
05597 |*                        *|
05598 |* Description:                     *|
05599 |*  Process integer option.                                               *|
05600 |*                        *|
05601 |* Input parameters:                    *|
05602 |*  NONE                      *|
05603 |*                        *|
05604 |* Output parameters:                   *|
05605 |*  NONE                      *|
05606 |*                        *|
05607 |* Returns:                     *|
05608 |*  NOTHING                     *|
05609 |*                        *|
05610 \******************************************************************************/
05611 
05612 static  void  process_i_option(char *optargs)
05613 {
05614 
05615    TRACE (Func_Entry, "process_i_option", NULL);
05616 
05617 
05618 
05619    set_i_option = TRUE;
05620 
05621 #ifdef KEY /* Bug 5089 */
05622    /* Search-path for .mod files for F2003 intrinsic modules */
05623 #define IMPATH "ntrinsic_module_path="
05624    if (EQUAL_STRS(optargs, "ntrinsic_module_gen")) {
05625       on_off_flags.intrinsic_module_gen = TRUE;
05626    }
05627    else if (optargs == strstr(optargs, IMPATH)) {
05628       /* We want the same behavior inside add_to_fp_table() which it exhibits
05629        * for the 'p' option for nonintrinsic module paths */
05630       add_to_fp_table (optargs + (sizeof IMPATH) - 1,
05631         &intrinsic_module_path_idx, 'p');
05632    }
05633    else
05634 #endif /* KEY Bug 5089 */
05635    if (!EQUAL_STRS(optargs, "32")) {
05636       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'i', ARG_STR_ARG);
05637    }
05638    else if (opt_flags.set_fastint_option) {
05639       ntr_msg_queue(0, 1192, Log_Warning, 0,
05640                     "-i\n-O fastint\n-O fastint",
05641                     0, MULT_STR_ARG);
05642    }
05643    else if (opt_flags.set_allfastint_option) {
05644       ntr_msg_queue(0, 1192, Log_Warning, 0,
05645                     "-i\n-O allfastint\n-O allfastint",
05646                     0, MULT_STR_ARG);
05647    }
05648    else if (opt_flags.set_nofastint_option) {
05649       ntr_msg_queue(0, 1192, Log_Warning, 0,
05650                     "-i\n-O nofastint\n-O nofastint",
05651                     0, MULT_STR_ARG);
05652    }
05653 
05654    cmd_line_flags.integer_32 = TRUE;
05655 
05656    TRACE (Func_Exit, "process_i_option", NULL);
05657 
05658    return;
05659 
05660 }  /* process_i_option */
05661 
05662 
05663 /******************************************************************************\
05664 |*                        *|
05665 |* Description:                     *|
05666 |*  Process solaris profile option.                                       *|
05667 |*                        *|
05668 |* Input parameters:                    *|
05669 |*  NONE                      *|
05670 |*                        *|
05671 |* Output parameters:                   *|
05672 |*  NONE                      *|
05673 |*                        *|
05674 |* Returns:                     *|
05675 |*  NOTHING                     *|
05676 |*                        *|
05677 \******************************************************************************/
05678 
05679 static  void  process_k_option(char *optargs)
05680 
05681 {
05682 
05683    TRACE (Func_Entry, "process_k_option", NULL);
05684 
05685 #  if defined(_ACCEPT_CMD_k)
05686 
05687       if (EQUAL_STRS(optargs, "g") || EQUAL_STRS(optargs, "s")) {
05688          cmd_line_flags.solaris_profile = TRUE;
05689       }
05690       else {
05691          ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'k', ARG_STR_ARG);
05692       }
05693 #  else  /* Unsupported */
05694       ntr_msg_queue(0, 797, Log_Warning, 0, (char *) NULL, 'k' ,ARG_ARG);
05695 #  endif
05696 
05697    TRACE (Func_Exit, "process_k_option", NULL);
05698 
05699    return;
05700 
05701 }  /* process_k_option */
05702 
05703 /******************************************************************************\
05704 |*                        *|
05705 |* Description:                     *|
05706 |*  Process msg level option.                                             *|
05707 |*                        *|
05708 |* Input parameters:                    *|
05709 |*  NONE                      *|
05710 |*                        *|
05711 |* Output parameters:                   *|
05712 |*  NONE                      *|
05713 |*                        *|
05714 |* Returns:                     *|
05715 |*  NOTHING                     *|
05716 |*                        *|
05717 \******************************************************************************/
05718 
05719 static  void  process_m_option(char *optargs)
05720 
05721 {
05722 
05723    TRACE (Func_Entry, "process_m_option", NULL);
05724 
05725    if (EQUAL_STRS(optargs, "0")) {
05726       cmd_line_flags.msg_lvl_suppressed = Comment_Lvl;
05727    }
05728    else if (EQUAL_STRS(optargs, "1")) {
05729       cmd_line_flags.msg_lvl_suppressed = Note_Lvl;
05730    }
05731    else if (EQUAL_STRS(optargs, "2")) { 
05732       cmd_line_flags.msg_lvl_suppressed = Caution_Lvl;
05733    }
05734    else if (EQUAL_STRS(optargs, "3")) { 
05735       cmd_line_flags.msg_lvl_suppressed = Warning_Lvl;
05736    }
05737    else if (EQUAL_STRS(optargs, "4")) { 
05738       cmd_line_flags.msg_lvl_suppressed = Error_Lvl;
05739    }
05740    else {
05741       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'm', ARG_STR_ARG);
05742    }
05743 
05744    TRACE (Func_Exit, "process_m_option", NULL);
05745 
05746    return;
05747 
05748 }  /* process_m_option */
05749 
05750 /******************************************************************************\
05751 |*                        *|
05752 |* Description:                     *|
05753 |*  Process cal file option.                                              *|
05754 |*                        *|
05755 |* Input parameters:                    *|
05756 |*  NONE                      *|
05757 |*                        *|
05758 |* Output parameters:                   *|
05759 |*  NONE                      *|
05760 |*                        *|
05761 |* Returns:                     *|
05762 |*  NOTHING                     *|
05763 |*                        *|
05764 \******************************************************************************/
05765 
05766 static  void  process_S_option(char *optargs)
05767 {
05768    TRACE (Func_Entry, "process_S_option", NULL);
05769 
05770    /* issue warning if binary output is being overridden */
05771 
05772    if (cmd_line_flags.binary_output) {  /* Driver issues this message */
05773       cmd_line_flags.binary_output = FALSE;
05774    }
05775 
05776    /* issue warning if cal file listing is being overridden */  
05777 
05778    if (on_off_flags.assembly_listing_file) {   
05779       ntr_msg_queue(0, 911, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
05780       on_off_flags.assembly_listing_file = FALSE;  
05781    }
05782 
05783    cmd_line_flags.assembly_output = TRUE;
05784    strncpy (assembly_file, optargs, MAX_FILE_NAME_SIZE);
05785    assembly_file[MAX_FILE_NAME_SIZE-1] = EOS;
05786 
05787    TRACE (Func_Exit, "process_S_option", NULL);
05788 
05789    return;
05790 
05791 }  /* process_S_option */
05792 
05793 /******************************************************************************\
05794 |*                        *|
05795 |* Description:                     *|
05796 |*  Process debug option.                                                 *|
05797 |*                        *|
05798 |* Input parameters:                    *|
05799 |*  NONE                      *|
05800 |*                        *|
05801 |* Output parameters:                   *|
05802 |*  NONE                      *|
05803 |*                        *|
05804 |* Returns:                     *|
05805 |*  NOTHING                     *|
05806 |*                        *|
05807 \******************************************************************************/
05808 
05809 static  void  process_G_option(char *optargs)
05810 
05811 {
05812 
05813    TRACE (Func_Entry, "process_G_option", NULL);
05814 
05815    if (EQUAL_STRS(optargs, "0")) {
05816       cmd_line_flags.debug_lvl = Debug_Lvl_0;
05817    }
05818    else if (EQUAL_STRS(optargs, "1")) {
05819       cmd_line_flags.debug_lvl = Debug_Lvl_1;
05820    }
05821    else if (EQUAL_STRS(optargs, "2")) {
05822       cmd_line_flags.debug_lvl = Debug_Lvl_2;
05823    }
05824    else if (EQUAL_STRS(optargs, "3")) {  /* -G deferred */
05825       ntr_msg_queue(0, 886, Log_Warning, 0, (char *) NULL, 3 ,ARG_ARG);
05826       cmd_line_flags.debug_lvl = Debug_Lvl_3;
05827    }
05828 
05829 # if defined(_ACCEPT_CMD_Gd)
05830 
05831    /* This is set by the sgi commandline if debug symbols are to be generated */
05832    /* for Dwarf.  At the moment, this just ensures that parameters are sent   */
05833    /* through so that named constants can be found in the debug symbol table. */
05834 
05835    else if (EQUAL_STRS(optargs, "d")) {
05836       cmd_line_flags.dwarf_debug = TRUE;
05837    }
05838 # endif
05839 
05840    else {
05841       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'G', ARG_STR_ARG);
05842    }
05843 
05844    TRACE (Func_Exit, "process_G_option", NULL);
05845 
05846    return;
05847 
05848 }  /* process_G_option */
05849 
05850 /******************************************************************************\
05851 |*                        *|
05852 |* Description:                     *|
05853 |*  Process pdgcs debug option.                                           *|
05854 |*                        *|
05855 |* Input parameters:                    *|
05856 |*  NONE                      *|
05857 |*                        *|
05858 |* Output parameters:                   *|
05859 |*  NONE                      *|
05860 |*                        *|
05861 |* Returns:                     *|
05862 |*  NOTHING                     *|
05863 |*                        *|
05864 \******************************************************************************/
05865 
05866 static  void  process_v_option(char *optargs)
05867 
05868 {
05869 
05870    TRACE (Func_Entry, "process_v_option", NULL);
05871 
05872 #if defined(_DEBUG) && defined(_ENABLE_FEI)
05873    process_v_dbg_flags (optargs);   /* pdgcs debug calls  */
05874 #else
05875    /* Command line has an invalid option. */
05876    ntr_msg_queue(0, 77, Log_Error, 0, (char *) NULL, 'v' ,ARG_ARG);
05877 #endif
05878 
05879    TRACE (Func_Exit, "process_v_option", NULL);
05880 
05881    return;
05882 
05883 }  /* process_v_option */
05884 
05885 
05886 /******************************************************************************\
05887 |*                        *|
05888 |* Description:                     *|
05889 |*  Process line size option.                                             *|
05890 |*                        *|
05891 |* Input parameters:                    *|
05892 |*  NONE                      *|
05893 |*                        *|
05894 |* Output parameters:                   *|
05895 |*  NONE                      *|
05896 |*                        *|
05897 |* Returns:                     *|
05898 |*  NOTHING                     *|
05899 |*                        *|
05900 \******************************************************************************/
05901 
05902 static  void  process_N_option(char *optargs)
05903 
05904 {
05905 
05906    TRACE (Func_Entry, "process_N_option", NULL);
05907 
05908    if (cmd_line_flags.src_form != Fixed_Form) {
05909 
05910       /* Line size option ignored.  Free source form is in effect. */
05911 
05912       ntr_msg_queue(0, 11, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
05913    }
05914    else if (EQUAL_STRS(optargs, "72")) {
05915       cmd_line_flags.line_size_80 = FALSE;
05916       cmd_line_flags.line_size_132 = FALSE;
05917    }
05918    else if (EQUAL_STRS(optargs, "80")) {
05919       cmd_line_flags.line_size_80 = TRUE;
05920       cmd_line_flags.line_size_132 = FALSE;
05921    }
05922    else if (EQUAL_STRS(optargs, "120")) { /* KAY - support */
05923       ntr_msg_queue(0, 1659, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
05924       cmd_line_flags.line_size_132 = TRUE;
05925       cmd_line_flags.line_size_80 = FALSE;
05926    }
05927    else if (EQUAL_STRS(optargs, "132")) {
05928       cmd_line_flags.line_size_132 = TRUE;
05929       cmd_line_flags.line_size_80 = FALSE;
05930    }
05931    else { /* option has an invalid argument */
05932       ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'N', ARG_STR_ARG);
05933    }
05934 
05935    TRACE (Func_Exit, "process_N_option", NULL);
05936 
05937    return;
05938 
05939 }  /* process_N_option */
05940 
05941 /******************************************************************************\
05942 |*                        *|
05943 |* Description:                     *|
05944 |*  Process MPP number of PEs option.                                     *|
05945 |*                        *|
05946 |* Input parameters:                    *|
05947 |*  NONE                      *|
05948 |*                        *|
05949 |* Output parameters:                   *|
05950 |*  NONE                      *|
05951 |*                        *|
05952 |* Returns:                     *|
05953 |*  NOTHING                     *|
05954 |*                        *|
05955 \******************************************************************************/
05956 
05957 static  void  process_X_option(char *optargs)
05958 
05959 {
05960 #  if defined(_ACCEPT_CMD_X)
05961    char   *opt_chk;
05962    int     n_pes;
05963 # endif
05964 
05965 
05966    TRACE (Func_Entry, "process_X_option", NULL);
05967 
05968 #  if defined(_ACCEPT_CMD_X)
05969 
05970       /* validate that -X arg contains only digits */
05971 
05972       if (*optargs == 'm') {
05973          cmd_line_flags.malleable = TRUE;
05974 
05975          if (set_MPP_num_pes) {
05976             set_MPP_num_pes = FALSE;
05977 
05978             /* -X # overrides -Xm */
05979 
05980             ntr_msg_queue(0, 1231, Log_Warning, 0, "m", 0, STR_ARG);
05981 
05982 # if defined(_TARGET_OS_MAX)
05983             cmd_line_flags.MPP_num_pes = 0;
05984 # else
05985             cmd_line_flags.MPP_num_pes = 1;
05986 # endif
05987          }
05988       }
05989       else {
05990 
05991          opt_chk = optargs;
05992 
05993          while (isdigit(*opt_chk)) {
05994             opt_chk++;
05995          }
05996 
05997          n_pes = atoi (optargs);
05998 
05999          if (*opt_chk != EOS) {
06000             ntr_msg_queue(0, 78, Log_Error, 0, optargs, 'X', ARG_STR_ARG);
06001          }
06002          else if (cmd_line_flags.malleable) {
06003             ntr_msg_queue(0, 1231, Log_Warning, 0, optargs, 0, STR_ARG);
06004             cmd_line_flags.malleable = FALSE;
06005          }
06006          else if (n_pes < 1 || n_pes > 2048) {
06007             ntr_msg_queue(0, 1238, Log_Error, 0, optargs, 0, STR_ARG);
06008          }
06009 
06010          set_MPP_num_pes    = TRUE;
06011          cmd_line_flags.MPP_num_pes = n_pes;
06012       }
06013 
06014 #  else  /* Unsupported */
06015       ntr_msg_queue(0, 797, Log_Warning, 0, (char *) NULL, 'X' ,ARG_ARG);
06016 #  endif
06017 
06018    TRACE (Func_Exit, "process_X_option", NULL);
06019 
06020    return;
06021 
06022 }  /* process_X_option */
06023 
06024 /******************************************************************************\
06025 |*                        *|
06026 |* Description:                     *|
06027 |*  process_q_option handles expression evaluator args passed via argv    *|
06028 |*                        *|
06029 |* Input parameters:                    *|
06030 |*  optargs     -q option arguments           *|
06031 |*                        *|
06032 |* Output parameters:                   *|
06033 |*  NONE                      *|
06034 |*                        *|
06035 |* Returns:                     *|
06036 |*  NOTHING                     *|
06037 |*                        *|
06038 \******************************************************************************/
06039 
06040 static void process_q_option (char *optargs)
06041 
06042 {
06043    int     ch;
06044    char    err_str[2];
06045 
06046 
06047    TRACE (Func_Entry, "process_q_option", NULL);
06048 
06049    while (ch = *optargs++) {
06050 
06051       switch (ch) {
06052       case 'e':
06053          cmd_line_flags.expression_eval_expr = TRUE;
06054          break;
06055 
06056       case 's':
06057          cmd_line_flags.expression_eval_stmt = TRUE;
06058          break;
06059 
06060       default:
06061          err_str[0] = ch;
06062          err_str[1] = EOS;
06063 
06064          /* option has an invalid argument */
06065 
06066          ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'q', ARG_STR_ARG);
06067          break;
06068       }
06069 
06070    }  /* while */
06071  
06072    TRACE (Func_Exit, "process_q_option", NULL);
06073 
06074    return;
06075 
06076 }  /* process_q_option */
06077 
06078 /******************************************************************************\
06079 |*                        *|
06080 |* Description:                     *|
06081 |*  process_r_option handles runtime checking options passed via argv     *|
06082 |*                        *|
06083 |* Input parameters:                    *|
06084 |*  optargs     -r option arguments           *|
06085 |*                        *|
06086 |* Output parameters:                   *|
06087 |*  NONE                      *|
06088 |*                        *|
06089 |* Returns:                     *|
06090 |*  NOTHING                     *|
06091 |*                        *|
06092 \******************************************************************************/
06093 
06094 static void process_r_option (char *optargs)
06095 
06096 {
06097    int     ch;
06098    char    err_str[2];
06099 
06100 
06101    TRACE (Func_Entry, "process_r_option", NULL);
06102 
06103    while (ch = *optargs++) {
06104 
06105       switch (ch) {
06106       case 'g':
06107 
06108 #        if defined(_ACCEPT_CMD_ed_g)
06109       on_off_flags.assembly_listing_file = TRUE;
06110 
06111             /* issue warning if cal file output is being overridden */  
06112 
06113             if (cmd_line_flags.assembly_output) {  
06114                ntr_msg_queue(0, 388, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
06115                cmd_line_flags.assembly_output = FALSE;  
06116                cmd_line_flags.binary_output = TRUE;  
06117             }
06118 #        else  /* doc'd as -rg */
06119             ntr_msg_queue(0, 744, Log_Warning, 0, "g", 'r', ARG_STR_ARG);
06120 #        endif
06121          break;
06122 
06123       default:
06124          err_str[0] = ch;
06125          err_str[1] = EOS;
06126 
06127          /* option has an invalid argument */
06128 
06129          ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'r', ARG_STR_ARG);
06130          break;
06131       }  /* switch */
06132    }  /* while */
06133  
06134    TRACE (Func_Exit, "process_r_option", NULL);
06135 
06136    return;
06137 
06138 }  /* process_r_option */
06139 
06140 /******************************************************************************\
06141 |*                        *|
06142 |* Description:                     *|
06143 |*  process_R_option handles runtime checking options passed via argv     *|
06144 |*                        *|
06145 |* Input parameters:                    *|
06146 |*  optargs     -R option arguments           *|
06147 |*                        *|
06148 |* Output parameters:                   *|
06149 |*  NONE                      *|
06150 |*                        *|
06151 |* Returns:                     *|
06152 |*  NOTHING                     *|
06153 |*                        *|
06154 \******************************************************************************/
06155 
06156 static void process_R_option (char *optargs)
06157 
06158 {
06159    int     ch;
06160    char    err_str[2];
06161    char   *cp;
06162 
06163 
06164    TRACE (Func_Entry, "process_R_option", NULL);
06165 
06166    while (ch = *optargs++) {
06167 
06168       switch (ch) {
06169       case 'a':
06170          cmd_line_flags.runtime_argument  = TRUE;
06171          break;
06172 
06173       case 'b':
06174          cmd_line_flags.runtime_bounds    = TRUE;
06175          break;
06176 
06177       case 'c':
06178          cmd_line_flags.runtime_conformance = TRUE;
06179          break;
06180 
06181       case 'C':
06182          cmd_line_flags.runtime_arg_call  = TRUE;
06183          break;
06184 
06185       case 'E':
06186          cmd_line_flags.runtime_arg_entry = TRUE;
06187          break;
06188 
06189       case 'M':
06190 
06191          while (*optargs != EOS && isdigit(*optargs)) {
06192 
06193             for (cp = optargs;
06194                  *optargs != BLANK  &&  *optargs != COMMA  &&  *optargs != EOS;
06195                  ++optargs);
06196 
06197             if (*optargs != EOS) {
06198                *optargs = EOS;
06199                *optargs++;
06200             }
06201 
06202             num_argchck_suppress_msg++;
06203             argchck_suppress_msg[num_argchck_suppress_msg] = atoi(cp);
06204          }
06205 
06206          argchck_suppress_msg[num_argchck_suppress_msg+1] = 0;
06207          break;
06208 
06209       case 'n':
06210          cmd_line_flags.runtime_arg_count_only  = TRUE;
06211          break;
06212 
06213       case 'p':
06214          cmd_line_flags.runtime_ptr_chk   = TRUE;
06215          break;
06216 
06217       case 's':
06218          cmd_line_flags.runtime_substring = TRUE;
06219          break;
06220 
06221       default:
06222          err_str[0] = ch;
06223          err_str[1] = EOS;
06224 
06225          /* option has an invalid argument */
06226 
06227          ntr_msg_queue(0, 78, Log_Error, 0, err_str, 'R', ARG_STR_ARG);
06228          break;
06229       }  /* switch */
06230    }  /* while */
06231  
06232    TRACE (Func_Exit, "process_R_option", NULL);
06233 
06234    return;
06235 
06236 }  /* process_R_option */
06237 
06238 /******************************************************************************\
06239 |*                        *|
06240 |* Description:                     *|
06241 |*  process_s_option handles size options passed via argv                 *|
06242 |*                        *|
06243 |* Input parameters:                    *|
06244 |*  optargs     -s option arguments           *|
06245 |*                        *|
06246 |* Output parameters:                   *|
06247 |*  NONE                      *|
06248 |*                        *|
06249 |* Returns:                     *|
06250 |*  NOTHING                     *|
06251 |*                        *|
06252 \******************************************************************************/
06253 
06254 static void process_s_option (char *optargs)
06255 {
06256    TRACE (Func_Entry, "process_s_option", NULL);
06257 
06258    if (EQUAL_STRS(optargs, "integer8")) {
06259          cmd_line_flags.s_integer8    = TRUE;
06260    }
06261    else if (EQUAL_STRS(optargs, "logical8")) {
06262          cmd_line_flags.s_logical8    = TRUE;
06263    }
06264    else if (EQUAL_STRS(optargs, "real8")) {
06265          cmd_line_flags.s_real8     = TRUE;
06266    }
06267    else if (EQUAL_STRS(optargs, "complex8")) {
06268          cmd_line_flags.s_complex8    = TRUE;
06269    }
06270    else if (EQUAL_STRS(optargs, "doubleprecision16")) {
06271          cmd_line_flags.s_doubleprecision16 = TRUE;
06272    }
06273    else if (EQUAL_STRS(optargs, "doublecomplex16")) {
06274          cmd_line_flags.s_doublecomplex16 = TRUE;
06275    }
06276    else if (EQUAL_STRS(optargs, "pointer8")) {
06277          cmd_line_flags.s_pointer8    = TRUE;
06278    }
06279    else if (EQUAL_STRS(optargs, "cf77types")) {
06280 
06281 #     if defined(_ACCEPT_CMD_s_cf77types)
06282          cmd_line_flags.s_cf77types = TRUE;
06283          ntr_msg_queue(0, 1172, Log_Warning, 0, (char *) NULL, 0, NO_ARG);
06284 #     else
06285          ntr_msg_queue(0, 744, Log_Warning, 0, "cf77types", 's', ARG_STR_ARG);
06286 #     endif
06287    }
06288    else if (EQUAL_STRS(optargs, "float64")) {
06289 
06290 #     if defined(_ACCEPT_CMD_s_64)
06291          cmd_line_flags.s_float64 = TRUE;
06292 #     else
06293          ntr_msg_queue(0, 744, Log_Warning, 0, "float64", 's', ARG_STR_ARG);
06294 #     endif
06295    }
06296    else if (EQUAL_STRS(optargs, "default64")) {
06297 
06298 #     if defined(_ACCEPT_CMD_s_64)
06299          cmd_line_flags.s_float64 = TRUE;
06300          cmd_line_flags.s_default64 = TRUE;
06301 #     else
06302          ntr_msg_queue(0, 744, Log_Warning, 0, "default64", 's', ARG_STR_ARG);
06303 #     endif
06304    }
06305    else if (EQUAL_STRS(optargs, "default32")) {
06306 
06307 #     if defined(_ACCEPT_CMD_s_32)
06308
osprey/crayf90/fe90/cmd_line.c
