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