00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045 static char USMID[] = "\n@(#)5.0_pl/sources/p_directiv.c 5.12 10/12/99 10:54:10\n";
00046
00047 # include "defines.h"
00048
00049 # include "host.m"
00050 # include "host.h"
00051 # include "target.m"
00052 # include "target.h"
00053
00054 # include "globals.m"
00055 # include "tokens.m"
00056 # include "sytb.m"
00057 # include "p_globals.m"
00058 # include "debug.m"
00059
00060 # include "globals.h"
00061 # include "tokens.h"
00062 # include "sytb.h"
00063 # include "p_globals.h"
00064 # include "s_globals.h"
00065
00066 # include "p_directiv.h"
00067
00068
00069
00070
00071
00072 static void check_do_open_mp_nesting(void);
00073 static void check_ordered_open_mp_nesting(void);
00074 static boolean check_section_open_mp_context(void);
00075 static boolean directive_region_error(directive_stmt_type, int, int);
00076 static boolean parse_assert_directive(void);
00077 static void parse_auxiliary_dir(void);
00078 static void parse_cache_align_name_list(opnd_type *);
00079 static void parse_cache_bypass_dir(opnd_type *);
00080 static void parse_cache_noalloc(void);
00081 static void parse_common_dirs(sb_type_type);
00082 static void parse_copy_assumed_shape_dir(void);
00083 static void parse_dir_directives(void);
00084 static void parse_dir_var_list(void);
00085 static void parse_distribution_dir(boolean);
00086 static void parse_doall_cmic(void);
00087 static void parse_dollar_directives(void);
00088 static void parse_doparallel_cmic(void);
00089 static void parse_fill_align_symbol(void);
00090 static void parse_id_directive(void);
00091 static void parse_ignore_tkr(void);
00092 static void parse_inline_always_never(boolean);
00093 static void parse_int_or_star_list(opnd_type *);
00094 static void parse_mic_directives(void);
00095 static void parse_mp_directive(mp_directive_type);
00096 static void parse_name_dir(void);
00097 static void parse_nosideeffects_dir(void);
00098 static void parse_par_directives(void);
00099 static void parse_parallel_cmic(void);
00100 static void parse_permutation_mic(void);
00101 static void parse_prefetch_ref(void);
00102 static void parse_redistribute_dir(void);
00103 static void parse_reference_list(opnd_type *);
00104 static void parse_sgi_dir_inline(boolean);
00105 static void parse_slash_common_dirs(void);
00106 static void parse_star_directives(void);
00107 static void parse_star_dir_directives(void);
00108 static void parse_symmetric_dir(void);
00109 static void parse_var_common_list(opnd_type *, boolean);
00110 static boolean parse_var_name_list(opnd_type *);
00111 static void parse_vfunction_dir(void);
00112 static void parse_open_mp_directives(void);
00113 static void parse_open_mp_clauses(open_mp_directive_type);
00114 static int update_fld_type(fld_type, int,int);
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134 void init_directive(int pass)
00135
00136 {
00137 int attr_idx;
00138 int list_idx1;
00139 int list_idx2;
00140 int type_idx;
00141
00142
00143 TRACE (Func_Entry, "init_directive", NULL);
00144
00145
00146
00147
00148
00149
00150 cdir_switches.unroll_count_idx = (opt_flags.unroll_lvl == Unroll_Lvl_2) ?
00151 CN_INTEGER_ZERO_IDX : CN_INTEGER_ONE_IDX;
00152 cdir_switches.vector = (opt_flags.vector_lvl > Vector_Lvl_0);
00153 cdir_switches.task = (opt_flags.task_lvl > Task_Lvl_0);
00154
00155 cdir_switches.notask_region = FALSE;
00156
00157
00158
00159
00160 cdir_switches.do_inline = FALSE;
00161 cdir_switches.noinline = FALSE;
00162
00163
00164
00165
00166 cdir_switches.split = (opt_flags.split_lvl == Split_Lvl_2);
00167
00168 cdir_switches.align = FALSE;
00169 cdir_switches.bl = opt_flags.bottom_load;
00170 cdir_switches.bounds = cmd_line_flags.runtime_bounds;
00171 cdir_switches.concurrent = FALSE;
00172 cdir_switches.ivdep = FALSE;
00173 cdir_switches.mark = opt_flags.mark;
00174 cdir_switches.stream = (opt_flags.stream_lvl >=Stream_Lvl_1);
00175 cdir_switches.nextscalar = FALSE;
00176 cdir_switches.no_internal_calls = FALSE;
00177 cdir_switches.nointerchange = opt_flags.nointerchange;
00178 cdir_switches.pattern = opt_flags.pattern;
00179 cdir_switches.preferstream = FALSE;
00180 cdir_switches.preferstream_nocinv = FALSE;
00181 cdir_switches.prefertask = FALSE;
00182 cdir_switches.prefervector = FALSE;
00183 cdir_switches.recurrence = opt_flags.recurrence;
00184 cdir_switches.shortloop = FALSE;
00185 cdir_switches.shortloop128 = FALSE;
00186 cdir_switches.unroll_dir = FALSE;
00187 cdir_switches.vsearch = opt_flags.vsearch;
00188
00189
00190
00191
00192 cdir_switches.maxcpus = FALSE;
00193 cdir_switches.parallel_region = FALSE;
00194 cdir_switches.doall_region = FALSE;
00195 cdir_switches.casedir = FALSE;
00196 cdir_switches.guard = FALSE;
00197 cdir_switches.guard_has_flag = FALSE;
00198 cdir_switches.guard_in_par_reg = FALSE;
00199 cdir_switches.do_parallel = FALSE;
00200 cdir_switches.autoscope = FALSE;
00201 #ifdef KEY
00202 cdir_switches.single = FALSE;
00203 #endif
00204 cdir_switches.safevl_idx = const_safevl_idx;
00205 cdir_switches.concurrent_idx = NULL_IDX;
00206 cdir_switches.blockable_sh_idx = NULL_IDX;
00207 cdir_switches.cache_bypass_ir_idx = NULL_IDX;
00208 cdir_switches.doall_sh_idx = NULL_IDX;
00209 cdir_switches.dir_nest_check_sh_idx = NULL_IDX;
00210 cdir_switches.doacross_sh_idx = NULL_IDX;
00211 cdir_switches.dopar_sh_idx = NULL_IDX;
00212 cdir_switches.getfirst_list_idx = NULL_IDX;
00213 cdir_switches.interchange_sh_idx = NULL_IDX;
00214 cdir_switches.lastlocal_list_idx = NULL_IDX;
00215 cdir_switches.lastthread_list_idx = NULL_IDX;
00216 cdir_switches.mark_dir_idx = NULL_IDX;
00217 cdir_switches.paralleldo_sh_idx = NULL_IDX;
00218 cdir_switches.pdo_sh_idx = NULL_IDX;
00219 cdir_switches.private_list_idx = NULL_IDX;
00220 cdir_switches.reduction_list_idx = NULL_IDX;
00221 cdir_switches.shared_list_idx = NULL_IDX;
00222
00223 cdir_switches.inline_here_sgi = FALSE;
00224 cdir_switches.noinline_here_sgi = FALSE;
00225 cdir_switches.inline_here_list_idx = NULL_IDX;
00226 cdir_switches.noinline_here_list_idx = NULL_IDX;
00227
00228 cdir_switches.firstprivate_list_idx = NULL_IDX;
00229 cdir_switches.copyin_list_idx = NULL_IDX;
00230 cdir_switches.copyprivate_list_idx = NULL_IDX;
00231 cdir_switches.lastprivate_list_idx = NULL_IDX;
00232 cdir_switches.default_scope_list_idx = NULL_IDX;
00233 cdir_switches.do_omp_sh_idx = NULL_IDX;
00234 cdir_switches.paralleldo_omp_sh_idx = NULL_IDX;
00235
00236 cdir_switches.wait_list_idx = NULL_IDX;
00237 cdir_switches.send_list_idx = NULL_IDX;
00238
00239 cdir_switches.blockable_count = 0;
00240 cdir_switches.blockable_group = 0;
00241 cdir_switches.interchange_count = 0;
00242 cdir_switches.interchange_group = 0;
00243 cdir_switches.interchange_level = 0;
00244
00245 if (pass > 1) {
00246 list_idx1 = cdir_switches.bounds_il_list;
00247
00248 while (list_idx1) {
00249 attr_idx = IL_IDX(list_idx1);
00250 ATD_BOUNDS_CHECK(attr_idx) = FALSE;
00251
00252 list_idx2 = list_idx1;
00253 list_idx1 = IL_NEXT_LIST_IDX(list_idx1);
00254 FREE_IR_LIST_NODE(list_idx2);
00255 }
00256
00257 list_idx1 = cdir_switches.nobounds_il_list;
00258
00259 while (list_idx1) {
00260 attr_idx = IL_IDX(list_idx1);
00261 ATD_NOBOUNDS_CHECK(attr_idx) = FALSE;
00262
00263 list_idx2 = list_idx1;
00264 list_idx1 = IL_NEXT_LIST_IDX(list_idx1);
00265 FREE_IR_LIST_NODE(list_idx2);
00266 }
00267 }
00268
00269 cdir_switches.bounds_il_list = NULL_IDX;
00270 cdir_switches.nobounds_il_list = NULL_IDX;
00271
00272 cdir_switches.mp_schedtype_opnd = null_opnd;
00273
00274 if (global_schedtype_value >= 0) {
00275 OPND_LINE_NUM(cdir_switches.mp_schedtype_opnd) = global_schedtype_line;
00276 OPND_COL_NUM(cdir_switches.mp_schedtype_opnd) = global_schedtype_col;
00277 OPND_FLD(cdir_switches.mp_schedtype_opnd) = CN_Tbl_Idx;
00278 OPND_IDX(cdir_switches.mp_schedtype_opnd) = C_INT_TO_CN(
00279 CG_INTEGER_DEFAULT_TYPE,
00280 global_schedtype_value);
00281 }
00282
00283 cdir_switches.chunk_opnd = null_opnd;
00284 cdir_switches.first_sh_blk_stk = null_opnd;
00285
00286 directive_state = 0;
00287
00288 if (pass == 1) {
00289 cdir_switches.implicit_use_idx = cmd_line_flags.implicit_use_idx;
00290 cdir_switches.flow = on_off_flags.flowtrace_option;
00291 cdir_switches.code = FALSE;
00292
00293 if (!opt_flags.set_allfastint_option &&
00294 !opt_flags.set_fastint_option &&
00295 !opt_flags.set_nofastint_option) {
00296 # ifdef _TARGET_HAS_FAST_INTEGER
00297 opt_flags.set_fastint_option = TRUE;
00298 # endif
00299 }
00300
00301 if (opt_flags.mark && opt_flags.mark_name.string != NULL) {
00302 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX);
00303 TYP_CHAR_CLASS(TYP_WORK_IDX) = Const_Len_Char;
00304 TYP_TYPE(TYP_WORK_IDX) = Character;
00305 TYP_LINEAR(TYP_WORK_IDX) = CHARACTER_DEFAULT_TYPE;
00306 TYP_FLD(TYP_WORK_IDX) = CN_Tbl_Idx;
00307 TYP_IDX(TYP_WORK_IDX) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
00308 strlen(opt_flags.mark_name.string));
00309 type_idx = ntr_type_tbl();
00310
00311 cdir_switches.mark_cmdline_idx = ntr_const_tbl(type_idx,
00312 FALSE,
00313 (long_type *) &(opt_flags.mark_name.words));
00314 }
00315 else {
00316 cdir_switches.mark_cmdline_idx = NULL_IDX;
00317 }
00318 }
00319
00320 TRACE (Func_Exit, "init_directive", NULL);
00321
00322 return;
00323
00324 }
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341 void parse_directive_stmt (void)
00342 {
00343
00344 TRACE (Func_Entry, "parse_directive_stmt", NULL);
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 #ifdef KEY
00355 if (cmd_line_flags.disregard_all_directives) {
00356 parse_err_flush(Find_EOS, NULL);
00357 NEXT_LA_CH;
00358 goto EXIT;
00359 }
00360 #endif
00361
00362
00363
00364
00365
00366
00367
00368
00369 need_new_sh = FALSE;
00370
00371 if (cif_need_unit_rec && cif_first_pgm_unit) {
00372 c_i_f = cif_actual_file;
00373 }
00374
00375 if (TOKEN_STR(token)[0] == 'M') {
00376
00377 if (MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd)) {
00378
00379 # if defined(_ACCEPT_TASK)
00380
00381 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
00382 if ((cdir_switches.task == FALSE ||
00383 cmd_line_flags.disregard_all_mics) &&
00384 TOKEN_VALUE(token) != Tok_Mic_Cncall &&
00385 TOKEN_VALUE(token) != Tok_Mic_Permutation) {
00386 # else
00387 if (cdir_switches.task == FALSE ||
00388 cmd_line_flags.disregard_all_mics) {
00389 # endif
00390 parse_err_flush(Find_EOS, NULL);
00391 NEXT_LA_CH;
00392 goto EXIT;
00393 }
00394 parse_mic_directives();
00395
00396 # else
00397 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
00398 parse_err_flush(Find_EOS, NULL);
00399 NEXT_LA_CH;
00400 goto EXIT;
00401 # endif
00402 }
00403 else {
00404 PRINTMSG(TOKEN_LINE(token), 1356, Warning, TOKEN_COLUMN(token));
00405 parse_err_flush(Find_EOS, NULL);
00406 NEXT_LA_CH;
00407 goto EXIT;
00408 }
00409 }
00410 else if (TOKEN_STR(token)[0] == '$' &&
00411 TOKEN_STR(token)[1] == 'O' &&
00412 TOKEN_STR(token)[2] == 'M' &&
00413 TOKEN_STR(token)[3] == 'P') {
00414
00415 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
00416
00417 # if defined(_TARGET_OS_MAX)
00418 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
00419 parse_err_flush(Find_EOS, NULL);
00420 NEXT_LA_CH;
00421 goto EXIT;
00422 # else
00423
00424 if (cmd_line_flags.disregard_all_omps) {
00425
00426
00427
00428 parse_err_flush(Find_EOS, NULL);
00429 NEXT_LA_CH;
00430 goto EXIT;
00431 }
00432
00433 parse_open_mp_directives();
00434 # endif
00435 }
00436 else {
00437
00438 parse_err_flush(Find_EOS, NULL);
00439 NEXT_LA_CH;
00440 goto EXIT;
00441 }
00442 }
00443 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
00444 else if (TOKEN_STR(token)[0] == '$' &&
00445 TOKEN_STR(token)[1] == 'S' &&
00446 TOKEN_STR(token)[2] == 'G' &&
00447 TOKEN_STR(token)[3] == 'I') {
00448
00449 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
00450 parse_open_mp_directives();
00451 }
00452 else {
00453
00454 parse_err_flush(Find_EOS, NULL);
00455 NEXT_LA_CH;
00456 goto EXIT;
00457 }
00458 }
00459 # endif
00460 else if (TOKEN_STR(token)[0] == '$') {
00461
00462 if (TOKEN_LEN(token) > 1 && TOKEN_STR(token)[1] == 'P') {
00463
00464 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
00465 parse_par_directives();
00466 }
00467 else {
00468
00469 parse_err_flush(Find_EOS, NULL);
00470 NEXT_LA_CH;
00471 goto EXIT;
00472 }
00473 }
00474 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
00475 parse_dollar_directives();
00476 }
00477 else {
00478
00479 parse_err_flush(Find_EOS, NULL);
00480 NEXT_LA_CH;
00481 goto EXIT;
00482 }
00483 }
00484 else if (TOKEN_STR(token)[0] == '*') {
00485
00486 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
00487 parse_star_directives();
00488 }
00489 else {
00490
00491 parse_err_flush(Find_EOS, NULL);
00492 NEXT_LA_CH;
00493 goto EXIT;
00494 }
00495 }
00496
00497 # ifdef _DEBUG
00498
00499 else if (TOKEN_STR(token)[1] == 'B') {
00500
00501 if (!MATCHED_TOKEN_CLASS(Tok_Class_Dbg_Kwd)) {
00502 parse_err_flush(Find_EOS, NULL);
00503 NEXT_LA_CH;
00504 goto EXIT;
00505 }
00506 parse_dir_directives();
00507 }
00508
00509 # endif
00510
00511 else if (MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd)) {
00512
00513 if (cmd_line_flags.disregard_all_dirs) {
00514
00515
00516
00517 parse_err_flush(Find_EOS, NULL);
00518 NEXT_LA_CH;
00519 goto EXIT;
00520 }
00521 parse_dir_directives();
00522 }
00523 else {
00524 PRINTMSG(TOKEN_LINE(token), 1356, Warning, TOKEN_COLUMN(token));
00525 parse_err_flush(Find_EOS, NULL);
00526 NEXT_LA_CH;
00527 goto EXIT;
00528 }
00529
00530 EXIT:
00531
00532 if (cif_need_unit_rec && cif_first_pgm_unit) {
00533 c_i_f = cif_tmp_file;
00534 }
00535
00536 TRACE (Func_Exit, "parse_directive_stmt", NULL);
00537
00538 return;
00539
00540 }
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558 int gen_directive_ir(operator_type operator)
00559
00560 {
00561 int ir_idx;
00562
00563 #ifdef KEY
00564 int tmp_ir_idx;
00565 #endif
00566
00567
00568 TRACE (Func_Entry, "gen_directive_ir", NULL);
00569
00570 need_new_sh = TRUE;
00571
00572 if (SH_IR_IDX(curr_stmt_sh_idx)) {
00573 #ifdef KEY
00574 tmp_ir_idx = SH_NEXT_IDX(curr_stmt_sh_idx);
00575 #endif
00576 #ifdef KEY
00577
00578
00579 int new_stmt = ntr_sh_tbl();
00580 SH_NEXT_IDX(curr_stmt_sh_idx) = new_stmt;
00581 #else
00582 SH_NEXT_IDX(curr_stmt_sh_idx) = ntr_sh_tbl();
00583 #endif
00584 SH_PREV_IDX(SH_NEXT_IDX(curr_stmt_sh_idx))= curr_stmt_sh_idx;
00585 curr_stmt_sh_idx = SH_NEXT_IDX(curr_stmt_sh_idx);
00586 SH_STMT_TYPE(curr_stmt_sh_idx) = Directive_Stmt;
00587 #ifdef KEY
00588 SH_NEXT_IDX(curr_stmt_sh_idx) = tmp_ir_idx;
00589 SH_PREV_IDX(tmp_ir_idx) = curr_stmt_sh_idx;
00590 #endif
00591 }
00592
00593 SH_GLB_LINE(curr_stmt_sh_idx)= TOKEN_LINE(token);
00594 SH_COL_NUM(curr_stmt_sh_idx) = TOKEN_COLUMN(token);
00595
00596 NTR_IR_TBL(ir_idx);
00597 IR_OPR(ir_idx) = operator;
00598
00599
00600
00601 IR_TYPE_IDX(ir_idx) = TYPELESS_DEFAULT_TYPE;
00602 IR_LINE_NUM(ir_idx) = TOKEN_LINE(token);
00603 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(token);
00604
00605 SH_IR_IDX(curr_stmt_sh_idx) = ir_idx;
00606
00607 TRACE (Func_Exit, "gen_directive_ir", NULL);
00608
00609 return(ir_idx);
00610
00611 }
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630 static void parse_copy_assumed_shape_dir(void)
00631
00632 {
00633 int attr_idx;
00634 int head_list_idx = NULL_IDX;
00635 int list_idx;
00636 int name_idx;
00637
00638
00639 TRACE (Func_Entry, "parse_copy_assumed_shape_dir", NULL);
00640
00641 do {
00642 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
00643 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
00644 &name_idx);
00645
00646 if (attr_idx == NULL_IDX) {
00647 attr_idx = ntr_sym_tbl(&token, name_idx);
00648 LN_DEF_LOC(name_idx) = TRUE;
00649 AT_OBJ_CLASS(attr_idx) = Data_Obj;
00650 SET_IMPL_TYPE(attr_idx);
00651 }
00652 else if (fnd_semantic_err(Obj_Copy_Assumed_Shape,
00653 TOKEN_LINE(token),
00654 TOKEN_COLUMN(token),
00655 attr_idx,
00656 TRUE)) {
00657 goto NEXT;
00658 }
00659
00660 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
00661 AT_ATTR_LINK(attr_idx) = NULL_IDX;
00662 LN_DEF_LOC(name_idx) = TRUE;
00663 }
00664
00665 ATD_COPY_ASSUMED_SHAPE(attr_idx) = TRUE;
00666
00667 if (head_list_idx == NULL_IDX) {
00668
00669
00670
00671 NTR_IR_LIST_TBL(head_list_idx);
00672
00673 IL_NEXT_LIST_IDX(head_list_idx)=SCP_COPY_ASSUMED_LIST(curr_scp_idx);
00674
00675 if (IL_NEXT_LIST_IDX(head_list_idx) != NULL_IDX) {
00676 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(head_list_idx))=head_list_idx;
00677 }
00678
00679 SCP_COPY_ASSUMED_LIST(curr_scp_idx) = head_list_idx;
00680
00681 IL_FLD(head_list_idx) = IL_Tbl_Idx;
00682 IL_LIST_CNT(head_list_idx) = 0;
00683 }
00684
00685 NTR_IR_LIST_TBL(list_idx);
00686 IL_NEXT_LIST_IDX(list_idx) = IL_IDX(head_list_idx);
00687
00688 if (IL_NEXT_LIST_IDX(list_idx) != NULL_IDX) {
00689 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
00690 }
00691
00692 IL_LIST_CNT(head_list_idx)++;
00693 IL_IDX(head_list_idx) = list_idx;
00694 IL_FLD(list_idx) = AT_Tbl_Idx;
00695 IL_IDX(list_idx) = attr_idx;
00696 IL_LINE_NUM(list_idx) = TOKEN_LINE(token);
00697 IL_COL_NUM(list_idx) = TOKEN_COLUMN(token);
00698 }
00699 else if (!parse_err_flush(Find_Comma, "variable name")) {
00700 break;
00701 }
00702
00703 NEXT:
00704
00705 if (LA_CH_VALUE == COMMA) {
00706 NEXT_LA_CH;
00707 }
00708 else if (LA_CH_VALUE == EOS ||
00709 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
00710 break;
00711 }
00712 else {
00713 NEXT_LA_CH;
00714 }
00715 }
00716 while (TRUE);
00717
00718 NEXT_LA_CH;
00719
00720 TRACE (Func_Exit, "parse_copy_assumed_shape_dir", NULL);
00721
00722 return;
00723
00724 }
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742 static void parse_ignore_tkr(void)
00743
00744 {
00745 int attr_idx;
00746 int name_idx;
00747
00748
00749 TRACE (Func_Entry, "parse_ignore_tkr", NULL);
00750
00751 do {
00752 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
00753 attr_idx = srch_sym_tbl(TOKEN_STR(token),
00754 TOKEN_LEN(token),
00755 &name_idx);
00756
00757 if (attr_idx == NULL_IDX) {
00758 attr_idx = ntr_sym_tbl(&token, name_idx);
00759 LN_DEF_LOC(name_idx) = TRUE;
00760 AT_OBJ_CLASS(attr_idx) = Data_Obj;
00761 ATD_CLASS(attr_idx) = Dummy_Argument;
00762 ATD_IGNORE_TKR(attr_idx) = TRUE;
00763 SET_IMPL_TYPE(attr_idx);
00764 }
00765 else if (!fnd_semantic_err(Obj_Ignore_TKR,
00766 TOKEN_LINE(token),
00767 TOKEN_COLUMN(token),
00768 attr_idx,
00769 TRUE)) {
00770
00771 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
00772 AT_ATTR_LINK(attr_idx) = NULL_IDX;
00773 LN_DEF_LOC(name_idx) = TRUE;
00774 }
00775
00776 #ifdef KEY
00777
00778
00779 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) {
00780 }
00781 else
00782 #endif
00783 ATD_CLASS(attr_idx) = Dummy_Argument;
00784 ATD_IGNORE_TKR(attr_idx) = TRUE;
00785 }
00786 }
00787 else if (!parse_err_flush(Find_Comma, "dummy-argument name")) {
00788 break;
00789 }
00790
00791 if (LA_CH_VALUE == COMMA) {
00792 NEXT_LA_CH;
00793 }
00794 else if (LA_CH_VALUE == EOS ||
00795 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
00796 break;
00797 }
00798 else {
00799 NEXT_LA_CH;
00800 }
00801 }
00802 while (TRUE);
00803
00804 NEXT_LA_CH;
00805
00806 TRACE (Func_Exit, "parse_ignore_tkr", NULL);
00807
00808 return;
00809
00810 }
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828 static void parse_auxiliary_dir(void)
00829
00830 {
00831 int attr_idx;
00832 int name_idx;
00833 int sb_idx;
00834
00835
00836 TRACE (Func_Entry, "parse_auxiliary_dir", NULL);
00837
00838 do {
00839 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
00840 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
00841 &name_idx);
00842
00843 if (attr_idx == NULL_IDX) {
00844 attr_idx = ntr_sym_tbl(&token, name_idx);
00845 LN_DEF_LOC(name_idx) = TRUE;
00846 ATD_AUXILIARY(attr_idx) = TRUE;
00847 SET_IMPL_TYPE(attr_idx);
00848 }
00849 else if (!fnd_semantic_err(Obj_Auxiliary,
00850 TOKEN_LINE(token),
00851 TOKEN_COLUMN(token),
00852 attr_idx,
00853 TRUE)) {
00854
00855 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
00856 AT_ATTR_LINK(attr_idx) = NULL_IDX;
00857 LN_DEF_LOC(name_idx) = TRUE;
00858 }
00859
00860 ATD_AUXILIARY(attr_idx) = TRUE;
00861
00862 if (ATD_IN_COMMON(attr_idx)) {
00863 sb_idx = ATD_STOR_BLK_IDX(attr_idx);
00864
00865 if (SB_BLANK_COMMON(sb_idx)) {
00866 PRINTMSG(TOKEN_LINE(token), 534, Error,
00867 TOKEN_COLUMN(token),
00868 AT_OBJ_NAME_PTR(attr_idx));
00869 }
00870 else if (SB_BLK_TYPE(sb_idx) == Task_Common) {
00871 PRINTMSG(TOKEN_LINE(token), 537, Error,
00872 TOKEN_COLUMN(token),
00873 AT_OBJ_NAME_PTR(attr_idx),
00874 SB_NAME_PTR(sb_idx));
00875 }
00876 else {
00877 SB_AUXILIARY(sb_idx) = TRUE;
00878 }
00879 }
00880 }
00881 }
00882 else if (!parse_err_flush(Find_Comma, "variable name")) {
00883 break;
00884 }
00885
00886 if (LA_CH_VALUE == COMMA) {
00887 NEXT_LA_CH;
00888 }
00889 else if (LA_CH_VALUE == EOS ||
00890 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
00891 break;
00892 }
00893 else {
00894 NEXT_LA_CH;
00895 }
00896 }
00897 while (TRUE);
00898
00899 NEXT_LA_CH;
00900
00901 TRACE (Func_Exit, "parse_auxiliary_dir", NULL);
00902
00903 return;
00904
00905 }
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922 static void parse_cache_bypass_dir(opnd_type *opnd)
00923
00924 {
00925 int column;
00926 int line;
00927 int list_idx = NULL_IDX;
00928 opnd_type opnd2;
00929
00930
00931 TRACE (Func_Entry, "parse_cache_bypass_dir", NULL);
00932
00933 do {
00934 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
00935
00936 if (!parse_deref(&opnd2, NULL_IDX)) {
00937 parse_err_flush(Find_Comma, NULL);
00938 }
00939 else {
00940 find_opnd_line_and_column(&opnd2, &line, &column);
00941
00942 if (OPND_FLD(opnd2) != AT_Tbl_Idx) {
00943 PRINTMSG(line, 1319, Error, column);
00944 }
00945 else {
00946
00947 if (list_idx == NULL_IDX) {
00948 NTR_IR_LIST_TBL(list_idx);
00949 COPY_OPND(IL_OPND(list_idx), opnd2);
00950 OPND_FLD((*opnd)) = IL_Tbl_Idx;
00951 OPND_IDX((*opnd)) = list_idx;
00952 OPND_LIST_CNT((*opnd)) = 1;
00953 }
00954 else {
00955 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
00956 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
00957 (OPND_LIST_CNT((*opnd)))++;
00958 list_idx = IL_NEXT_LIST_IDX(list_idx);
00959 COPY_OPND(IL_OPND(list_idx), opnd2);
00960 }
00961 }
00962 }
00963 }
00964 else if (!parse_err_flush(Find_Comma, "array name")) {
00965 break;
00966 }
00967
00968 if (LA_CH_VALUE == COMMA) {
00969 NEXT_LA_CH;
00970 }
00971 else if (LA_CH_VALUE == EOS ||
00972 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
00973 break;
00974 }
00975 else {
00976 NEXT_LA_CH;
00977 }
00978 }
00979 while (TRUE);
00980
00981 NEXT_LA_CH;
00982
00983 TRACE (Func_Exit, "parse_cache_bypass_dir", NULL);
00984
00985 return;
00986
00987 }
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004 static void parse_nosideeffects_dir(void)
01005
01006 {
01007 int attr_idx;
01008 int name_idx;
01009
01010
01011 TRACE (Func_Entry, "parse_nosideeffects_dir", NULL);
01012
01013 do {
01014 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
01015 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
01016 &name_idx);
01017
01018 if (attr_idx == NULL_IDX) {
01019 attr_idx = ntr_sym_tbl(&token, name_idx);
01020 LN_DEF_LOC(name_idx) = TRUE;
01021 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
01022 ATP_NOSIDE_EFFECTS(attr_idx)= TRUE;
01023 MAKE_EXTERNAL_NAME(attr_idx,
01024 AT_NAME_IDX(attr_idx),
01025 AT_NAME_LEN(attr_idx));
01026 ATP_PROC(attr_idx) = Extern_Proc;
01027 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
01028 }
01029 else if (!fnd_semantic_err(Obj_No_Side_Effects,
01030 TOKEN_LINE(token),
01031 TOKEN_COLUMN(token),
01032 attr_idx,
01033 TRUE)) {
01034
01035 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
01036 AT_ATTR_LINK(attr_idx) = NULL_IDX;
01037 LN_DEF_LOC(name_idx) = TRUE;
01038 }
01039
01040 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
01041
01042 if (ATD_CLASS(attr_idx) == Function_Result) {
01043 attr_idx = ATD_FUNC_IDX(attr_idx);
01044 }
01045 else {
01046 chg_data_obj_to_pgm_unit(attr_idx,
01047 Pgm_Unknown,
01048 Extern_Proc);
01049 }
01050 }
01051 ATP_NOSIDE_EFFECTS(attr_idx)= TRUE;
01052 }
01053 }
01054 else if (!parse_err_flush(Find_Comma, "procedure name")) {
01055 break;
01056 }
01057
01058 if (LA_CH_VALUE == COMMA) {
01059 NEXT_LA_CH;
01060 }
01061 else if (LA_CH_VALUE == EOS ||
01062 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
01063 break;
01064 }
01065 else {
01066 NEXT_LA_CH;
01067 }
01068 }
01069 while (TRUE);
01070
01071 NEXT_LA_CH;
01072
01073 TRACE (Func_Exit, "parse_nosideeffects_dir", NULL);
01074
01075 return;
01076
01077 }
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094 static void parse_vfunction_dir(void)
01095
01096 {
01097 int attr_idx;
01098 int name_idx;
01099 int rslt_idx;
01100
01101
01102 TRACE (Func_Entry, "parse_vfunction_dir", NULL);
01103
01104
01105
01106
01107
01108 do {
01109 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
01110 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
01111 &name_idx);
01112
01113 if (attr_idx == NULL_IDX) {
01114 attr_idx = ntr_sym_tbl(&token, name_idx);
01115 LN_DEF_LOC(name_idx) = TRUE;
01116 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
01117 ATP_NOSIDE_EFFECTS(attr_idx)= TRUE;
01118 MAKE_EXTERNAL_NAME(attr_idx,
01119 AT_NAME_IDX(attr_idx),
01120 AT_NAME_LEN(attr_idx));
01121 ATP_PROC(attr_idx) = Extern_Proc;
01122 ATP_PGM_UNIT(attr_idx) = Function;
01123 ATP_VFUNCTION(attr_idx) = TRUE;
01124 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
01125
01126 CREATE_FUNC_RSLT(attr_idx, rslt_idx);
01127 SET_IMPL_TYPE(rslt_idx);
01128 }
01129 else if (!fnd_semantic_err(Obj_Vfunction,
01130 TOKEN_LINE(token),
01131 TOKEN_COLUMN(token),
01132 attr_idx,
01133 TRUE)) {
01134
01135 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
01136 AT_ATTR_LINK(attr_idx) = NULL_IDX;
01137 LN_DEF_LOC(name_idx) = TRUE;
01138 }
01139
01140 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
01141 chg_data_obj_to_pgm_unit(attr_idx,
01142 Function,
01143 Extern_Proc);
01144 ATP_PGM_UNIT(attr_idx) = Function;
01145 ATP_VFUNCTION(attr_idx) = TRUE;
01146 }
01147 else if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) {
01148
01149 if (ATP_PGM_UNIT(attr_idx) != Function) {
01150 ATP_PGM_UNIT(attr_idx) = Function;
01151 CREATE_FUNC_RSLT(attr_idx, rslt_idx);
01152 SET_IMPL_TYPE(rslt_idx);
01153 }
01154 ATP_PROC(attr_idx) = Extern_Proc;
01155 ATP_VFUNCTION(attr_idx) = TRUE;
01156 }
01157 }
01158 }
01159 else if (!parse_err_flush(Find_Comma, "procedure name")) {
01160 break;
01161 }
01162
01163 if (LA_CH_VALUE == COMMA) {
01164 NEXT_LA_CH;
01165 }
01166 else if (LA_CH_VALUE == EOS ||
01167 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
01168 break;
01169 }
01170 else {
01171 NEXT_LA_CH;
01172 }
01173 }
01174 while (TRUE);
01175
01176 NEXT_LA_CH;
01177
01178 TRACE (Func_Exit, "parse_vfunction_dir", NULL);
01179
01180 return;
01181
01182 }
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201 static void parse_common_dirs(sb_type_type blk_type)
01202
01203 {
01204 int new_sb_idx;
01205 int sb_idx;
01206
01207
01208 TRACE (Func_Entry, "parse_common_dirs", NULL);
01209
01210 do {
01211 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
01212 sb_idx = srch_stor_blk_tbl(TOKEN_STR(token),
01213 TOKEN_LEN(token),
01214 curr_scp_idx);
01215
01216 if (sb_idx == NULL_IDX) {
01217 sb_idx = ntr_stor_blk_tbl(TOKEN_STR(token),
01218 TOKEN_LEN(token),
01219 TOKEN_LINE(token),
01220 TOKEN_COLUMN(token),
01221 blk_type);
01222
01223 SB_COMMON_NEEDS_OFFSET(sb_idx) = TRUE;
01224 }
01225 else if (SB_BLK_TYPE(sb_idx) == Threadprivate) {
01226 PRINTMSG(TOKEN_LINE(token), 1486, Error, TOKEN_COLUMN(token),
01227 SB_NAME_PTR(sb_idx));
01228 }
01229 else if (SB_USE_ASSOCIATED(sb_idx) || SB_HOST_ASSOCIATED(sb_idx)) {
01230
01231
01232
01233
01234
01235 new_sb_idx = ntr_stor_blk_tbl(TOKEN_STR(token),
01236 TOKEN_LEN(token),
01237 TOKEN_LINE(token),
01238 TOKEN_COLUMN(token),
01239 blk_type);
01240
01241 SB_COMMON_NEEDS_OFFSET(new_sb_idx) = TRUE;
01242 SB_MERGED_BLK_IDX(sb_idx) = new_sb_idx;
01243 SB_HIDDEN(sb_idx) = TRUE;
01244 SB_DEF_MULT_SCPS(sb_idx) = TRUE;
01245 sb_idx = new_sb_idx;
01246 }
01247 else {
01248 SB_BLK_TYPE(sb_idx) = blk_type;
01249 SB_RUNTIME_INIT(stor_blk_tbl_idx) = FALSE;
01250 }
01251
01252
01253
01254 SB_IS_COMMON(sb_idx) = TRUE;
01255
01256 if (blk_type == Common) {
01257 SB_DCL_COMMON_DIR(sb_idx) = TRUE;
01258 }
01259 }
01260 else if (LA_CH_VALUE == SLASH) {
01261 NEXT_LA_CH;
01262
01263 if (LA_CH_VALUE == SLASH) {
01264 PRINTMSG(TOKEN_LINE(token), 1481, Error, TOKEN_COLUMN(token),
01265 TOKEN_STR(token), blk_type == Common ? "COMMON" :
01266 "TASK COMMON");
01267 NEXT_LA_CH;
01268 }
01269 else {
01270 parse_err_flush(Find_Comma, "common block name");
01271 }
01272 }
01273 else if (!parse_err_flush(Find_Comma, "common block name")) {
01274 break;
01275 }
01276
01277 if (LA_CH_VALUE == COMMA) {
01278 NEXT_LA_CH;
01279 }
01280 else if (LA_CH_VALUE == EOS ||
01281 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
01282 break;
01283 }
01284 else {
01285 NEXT_LA_CH;
01286 }
01287 }
01288 while (TRUE);
01289
01290 NEXT_LA_CH;
01291
01292 TRACE (Func_Exit, "parse_common_dirs", NULL);
01293
01294 return;
01295
01296 }
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313 static void parse_slash_common_dirs(void)
01314
01315 {
01316 int sb_idx;
01317 int attr_idx;
01318 int name_idx;
01319 token_values_type token_value;
01320
01321
01322 TRACE (Func_Entry, "parse_slash_common_dirs", NULL);
01323
01324 if (LA_CH_VALUE != LPAREN) {
01325 parse_err_flush(Find_EOS, "(/common-block-name/)");
01326 return;
01327 }
01328
01329 NEXT_LA_CH;
01330
01331 do {
01332
01333 if (LA_CH_VALUE == SLASH) {
01334 NEXT_LA_CH;
01335
01336 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
01337 sb_idx = srch_stor_blk_tbl(TOKEN_STR(token),
01338 TOKEN_LEN(token),
01339 curr_scp_idx);
01340
01341 if (sb_idx == NULL_IDX) {
01342 sb_idx = ntr_stor_blk_tbl(TOKEN_STR(token),
01343 TOKEN_LEN(token),
01344 TOKEN_LINE(token),
01345 TOKEN_COLUMN(token),
01346 Threadprivate);
01347
01348 SB_COMMON_NEEDS_OFFSET(sb_idx) = TRUE;
01349 SB_IS_COMMON(sb_idx) = TRUE;
01350 # if 0
01351
01352
01353
01354 SB_DCL_ERR(sb_idx) = TRUE;
01355
01356
01357
01358 PRINTMSG(TOKEN_LINE(token), 1479, Error, TOKEN_COLUMN(token),
01359 TOKEN_STR(token));
01360 # endif
01361 }
01362 else if (SB_USE_ASSOCIATED(sb_idx)) {
01363
01364 if (SB_BLK_TYPE(sb_idx) != Threadprivate) {
01365 PRINTMSG(TOKEN_LINE(token), 1485, Error, TOKEN_COLUMN(token),
01366 SB_NAME_PTR(sb_idx));
01367 }
01368 }
01369 else if (SB_HOST_ASSOCIATED(sb_idx)) {
01370 PRINTMSG(TOKEN_LINE(token), 1485, Error, TOKEN_COLUMN(token),
01371 SB_NAME_PTR(sb_idx));
01372 }
01373
01374 if (SB_BLK_TYPE(sb_idx) != Common &&
01375 SB_BLK_TYPE(sb_idx) != Threadprivate) {
01376
01377
01378
01379 PRINTMSG(TOKEN_LINE(token), 1486, Error, TOKEN_COLUMN(token),
01380 SB_NAME_PTR(sb_idx));
01381 }
01382 else {
01383 SB_BLK_TYPE(sb_idx) = Threadprivate;
01384 SB_RUNTIME_INIT(sb_idx) = FALSE;
01385 SB_IS_COMMON(sb_idx) = TRUE;
01386 }
01387
01388 if (LA_CH_VALUE == SLASH) {
01389 NEXT_LA_CH;
01390 }
01391 else if (!parse_err_flush(Find_Comma_Slash, "/")) {
01392 break;
01393 }
01394 else if (LA_CH_VALUE == SLASH) {
01395 NEXT_LA_CH;
01396 }
01397 }
01398 else if (LA_CH_VALUE == SLASH) {
01399 NEXT_LA_CH;
01400 PRINTMSG(TOKEN_LINE(token), 1481, Error, TOKEN_COLUMN(token),
01401 TOKEN_STR(token), "THREADPRIVATE");
01402 }
01403 else if (!parse_err_flush(Find_Comma_Rparen, "common-block-name")) {
01404 break;
01405 }
01406 }
01407
01408 else if(MATCHED_TOKEN_CLASS(Tok_Class_Id)){
01409 token_value = TOKEN_VALUE(token);
01410 attr_idx = srch_sym_tbl(TOKEN_STR(token),
01411 TOKEN_LEN(token),
01412 &name_idx);
01413 if(attr_idx == NULL_IDX){
01414 attr_idx = ntr_sym_tbl(&token, name_idx);
01415 LN_DEF_LOC(name_idx) = FALSE;
01416 AT_OBJ_CLASS(attr_idx) = Data_Obj;
01417 SET_IMPL_TYPE(attr_idx);
01418 }
01419 #ifdef KEY
01420 if (ATD_STOR_BLK_IDX(attr_idx) == NULL_IDX) {
01421 assign_storage_blk(attr_idx);
01422 }
01423 SB_BLK_TYPE(ATD_STOR_BLK_IDX(attr_idx)) = Threadprivate;
01424 #endif
01425 #ifdef KEY
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440 #else
01441 if(!fnd_semantic_err((token_value == Tok_SGI_Dir_Section_Gp) ?
01442 Obj_Section_Gp : Obj_Section_Non_Gp,
01443 TOKEN_LINE(token),
01444 TOKEN_COLUMN(token),
01445 attr_idx,
01446 TRUE)){
01447 if(AT_OBJ_CLASS(attr_idx) == Pgm_Unit &&
01448 ATP_PGM_UNIT(attr_idx) == Module){
01449 if(token_value == Tok_SGI_Dir_Section_Gp){
01450 if(attr_idx != SCP_ATTR_IDX(curr_scp_idx)){
01451 PRINTMSG(TOKEN_LINE(token), 1491, Error,
01452 TOKEN_COLUMN(token),
01453 "SECTION_GP" );
01454 }
01455 else if(SB_SECTION_NON_GP(SCP_SB_STATIC_IDX(curr_scp_idx))){
01456 PRINTMSG(TOKEN_LINE(token), 1490, Error,
01457 TOKEN_COLUMN(token),
01458 AT_OBJ_NAME_PTR(attr_idx),
01459 "SECTION_GP", "SECTION_NON_GP");
01460 }
01461 }
01462 else if(token_value == Tok_SGI_Dir_Section_Non_Gp){
01463 if(attr_idx != SCP_ATTR_IDX(curr_scp_idx)){
01464 PRINTMSG(TOKEN_LINE(token), 1491, Error,
01465 TOKEN_COLUMN(token),
01466 "SECTION_NON_GP");
01467 }
01468 else if(SB_SECTION_GP(SCP_SB_STATIC_IDX(curr_scp_idx))){
01469 PRINTMSG(TOKEN_LINE(token), 1490, Error,
01470 TOKEN_COLUMN(token),
01471 AT_OBJ_NAME_PTR(attr_idx),
01472 "SECTION_NON_GP", "SECTION_GP");
01473 }
01474 }
01475 }
01476
01477 if(token_value == Tok_SGI_Dir_Section_Gp)
01478 ATD_SECTION_GP(attr_idx) = TRUE;
01479 else if(token_value == Tok_SGI_Dir_Section_Non_Gp)
01480 ATD_SECTION_NON_GP(attr_idx) = TRUE;
01481 }
01482 #endif
01483 }
01484
01485 else if (!parse_err_flush(Find_Comma_Rparen, "/common-block-name/ or identifier")) {
01486 break;
01487 }
01488
01489 if (LA_CH_VALUE == COMMA) {
01490 NEXT_LA_CH;
01491 }
01492 else {
01493 break;
01494 }
01495 }
01496 while (TRUE);
01497
01498 if (LA_CH_VALUE == RPAREN || parse_err_flush(Find_Rparen, ")")) {
01499 NEXT_LA_CH;
01500 }
01501
01502 if (LA_CH_VALUE != EOS) {
01503 parse_err_flush(Find_EOS, EOS_STR);
01504 }
01505
01506 TRACE (Func_Exit, "parse_slash_common_dirs", NULL);
01507
01508 return;
01509
01510 }
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528 static void parse_dir_var_list(void)
01529
01530 {
01531 int ir_idx;
01532 int list_idx = NULL_IDX;
01533 opnd_type opnd;
01534
01535
01536 TRACE (Func_Entry, "parse_dir_var_list", NULL);
01537
01538 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
01539
01540 do {
01541
01542 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
01543
01544 if (! parse_deref(&opnd, NULL_IDX)) {
01545 parse_err_flush(Find_Comma, NULL);
01546 }
01547 else {
01548
01549 if (list_idx) {
01550 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
01551 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
01552 list_idx = IL_NEXT_LIST_IDX(list_idx);
01553 IR_LIST_CNT_L(ir_idx)++;
01554 }
01555 else {
01556 NTR_IR_LIST_TBL(list_idx);
01557 IR_IDX_L(ir_idx) = list_idx;
01558 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
01559 IR_LIST_CNT_L(ir_idx) = 1;
01560 }
01561
01562 COPY_OPND(IL_OPND(list_idx), opnd);
01563 }
01564 }
01565 else if (!parse_err_flush(Find_Comma, "variable name")) {
01566 break;
01567 }
01568
01569 if (LA_CH_VALUE == COMMA) {
01570 NEXT_LA_CH;
01571 }
01572 else if (LA_CH_VALUE == EOS ||
01573 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
01574 break;
01575 }
01576 else {
01577 NEXT_LA_CH;
01578 }
01579 }
01580 while (TRUE);
01581
01582 NEXT_LA_CH;
01583
01584 TRACE (Func_Exit, "parse_dir_var_list", NULL);
01585
01586 return;
01587
01588 }
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618
01619 static void parse_doall_cmic(void)
01620
01621 {
01622 int i;
01623 int ir_idx;
01624 int list_array[10];
01625 int list_idx;
01626 opnd_type opnd;
01627
01628
01629 TRACE (Func_Entry, "parse_doall_cmic", NULL);
01630
01631 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
01632
01633 for (i = 0; i < 10; i++) {
01634 NTR_IR_LIST_TBL(list_array[i]);
01635 if (i >= 1) {
01636 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
01637 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
01638 }
01639 }
01640
01641 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
01642 IR_IDX_L(ir_idx) = list_array[0];
01643 IR_LIST_CNT_L(ir_idx) = 10;
01644
01645 while (LA_CH_VALUE != EOS) {
01646
01647 if (MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd)) {
01648
01649 switch (TOKEN_VALUE(token)) {
01650
01651 case Tok_Dir_If:
01652
01653 if (LA_CH_VALUE == LPAREN) {
01654
01655 if (IL_IDX(list_array[0]) != NULL_IDX) {
01656 PRINTMSG(LA_CH_LINE, 680, Error, LA_CH_COLUMN,
01657 "DOALL");
01658 parse_err_flush(Find_EOS, NULL);
01659 goto EXIT;
01660 }
01661
01662 NEXT_LA_CH;
01663 parse_expr(&opnd);
01664
01665 COPY_OPND(IL_OPND(list_array[0]), opnd);
01666
01667 if (LA_CH_VALUE == RPAREN) {
01668 NEXT_LA_CH;
01669 }
01670 else {
01671 parse_err_flush(Find_EOS, ")");
01672 goto EXIT;
01673 }
01674 }
01675 else {
01676 parse_err_flush(Find_EOS, "(");
01677 goto EXIT;
01678 }
01679 break;
01680
01681 case Tok_Dir_Shared:
01682
01683 if (LA_CH_VALUE == LPAREN) {
01684 NEXT_LA_CH;
01685 parse_var_name_list(&opnd);
01686
01687 if (IL_IDX(list_array[1]) == NULL_IDX) {
01688 COPY_OPND(IL_OPND(list_array[1]), opnd);
01689 }
01690 else {
01691
01692
01693 list_idx = IL_IDX(list_array[1]);
01694 while (IL_NEXT_LIST_IDX(list_idx)) {
01695 list_idx = IL_NEXT_LIST_IDX(list_idx);
01696 }
01697
01698
01699 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
01700 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
01701 IL_LIST_CNT(list_array[1]) += OPND_LIST_CNT(opnd);
01702 }
01703
01704 if (LA_CH_VALUE == RPAREN) {
01705 NEXT_LA_CH;
01706 }
01707 else {
01708 parse_err_flush(Find_EOS, ")");
01709 goto EXIT;
01710 }
01711 }
01712 else {
01713 parse_err_flush(Find_EOS, "(");
01714 goto EXIT;
01715 }
01716
01717 break;
01718
01719 case Tok_Dir_Private:
01720
01721 if (LA_CH_VALUE == LPAREN) {
01722 NEXT_LA_CH;
01723 parse_var_name_list(&opnd);
01724
01725 if (IL_IDX(list_array[2]) == NULL_IDX) {
01726 COPY_OPND(IL_OPND(list_array[2]), opnd);
01727 }
01728 else {
01729
01730
01731 list_idx = IL_IDX(list_array[2]);
01732 while (IL_NEXT_LIST_IDX(list_idx)) {
01733 list_idx = IL_NEXT_LIST_IDX(list_idx);
01734 }
01735
01736
01737 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
01738 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
01739 IL_LIST_CNT(list_array[2]) += OPND_LIST_CNT(opnd);
01740 }
01741
01742 if (LA_CH_VALUE == RPAREN) {
01743 NEXT_LA_CH;
01744 }
01745 else {
01746 parse_err_flush(Find_EOS, ")");
01747 goto EXIT;
01748 }
01749 }
01750 else {
01751 parse_err_flush(Find_EOS, "(");
01752 goto EXIT;
01753 }
01754
01755 break;
01756
01757 case Tok_Dir_Getfirst:
01758
01759 if (LA_CH_VALUE == LPAREN) {
01760 NEXT_LA_CH;
01761 parse_var_name_list(&opnd);
01762
01763 if (IL_IDX(list_array[3]) == NULL_IDX) {
01764 COPY_OPND(IL_OPND(list_array[3]), opnd);
01765 }
01766 else {
01767
01768
01769 list_idx = IL_IDX(list_array[3]);
01770 while (IL_NEXT_LIST_IDX(list_idx)) {
01771 list_idx = IL_NEXT_LIST_IDX(list_idx);
01772 }
01773
01774
01775 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
01776 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
01777 IL_LIST_CNT(list_array[3]) += OPND_LIST_CNT(opnd);
01778 }
01779
01780 if (LA_CH_VALUE == RPAREN) {
01781 NEXT_LA_CH;
01782 }
01783 else {
01784 parse_err_flush(Find_EOS, ")");
01785 goto EXIT;
01786 }
01787 }
01788 else {
01789 parse_err_flush(Find_EOS, "(");
01790 goto EXIT;
01791 }
01792
01793 break;
01794
01795 case Tok_Dir_Autoscope:
01796
01797 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
01798 PRINTMSG(TOKEN_LINE(token), 1415, Error, TOKEN_COLUMN(token));
01799 # else
01800 IL_FLD(list_array[4]) = CN_Tbl_Idx;
01801 IL_IDX(list_array[4]) = CN_INTEGER_ONE_IDX;
01802 IL_LINE_NUM(list_array[4]) = TOKEN_LINE(token);
01803 IL_COL_NUM(list_array[4]) = TOKEN_COLUMN(token);
01804 # endif
01805
01806 break;
01807
01808 case Tok_Dir_Control:
01809
01810 if (LA_CH_VALUE == LPAREN) {
01811 NEXT_LA_CH;
01812 parse_var_name_list(&opnd);
01813
01814 if (IL_IDX(list_array[5]) == NULL_IDX) {
01815 COPY_OPND(IL_OPND(list_array[5]), opnd);
01816 }
01817 else {
01818
01819
01820 list_idx = IL_IDX(list_array[5]);
01821 while (IL_NEXT_LIST_IDX(list_idx)) {
01822 list_idx = IL_NEXT_LIST_IDX(list_idx);
01823 }
01824
01825
01826 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
01827 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
01828 IL_LIST_CNT(list_array[5]) += OPND_LIST_CNT(opnd);
01829 }
01830
01831 if (LA_CH_VALUE == RPAREN) {
01832 NEXT_LA_CH;
01833 }
01834 else {
01835 parse_err_flush(Find_EOS, ")");
01836 goto EXIT;
01837 }
01838 }
01839 else {
01840 parse_err_flush(Find_EOS, "(");
01841 goto EXIT;
01842 }
01843
01844 break;
01845
01846 case Tok_Dir_Savelast:
01847
01848 IL_FLD(list_array[6]) = CN_Tbl_Idx;
01849 IL_IDX(list_array[6]) = CN_INTEGER_ONE_IDX;
01850 IL_LINE_NUM(list_array[6]) = TOKEN_LINE(token);
01851 IL_COL_NUM(list_array[6]) = TOKEN_COLUMN(token);
01852
01853 break;
01854
01855 case Tok_Dir_Maxcpus:
01856
01857 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
01858 PRINTMSG(TOKEN_LINE(token), 1436, Warning,
01859 TOKEN_COLUMN(token), "MAXCPUS");
01860
01861 # endif
01862 if (LA_CH_VALUE == LPAREN) {
01863 NEXT_LA_CH;
01864 parse_expr(&opnd);
01865 COPY_OPND(IL_OPND(list_array[7]), opnd);
01866
01867 if (LA_CH_VALUE == RPAREN) {
01868 NEXT_LA_CH;
01869 }
01870 else {
01871 parse_err_flush(Find_EOS, ")");
01872 goto EXIT;
01873 }
01874 }
01875 else {
01876 parse_err_flush(Find_EOS, "(");
01877 goto EXIT;
01878 }
01879 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
01880 IL_OPND(list_array[7]) = null_opnd;
01881 # endif
01882 break;
01883
01884 case Tok_Dir_Single:
01885
01886 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
01887 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
01888 parse_err_flush(Find_EOS, NULL);
01889 goto EXIT;
01890 }
01891
01892 IL_FLD(list_array[8]) = CN_Tbl_Idx;
01893 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
01894 CMIC_WORK_DIST_SINGLE);
01895 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
01896 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
01897
01898 break;
01899
01900 case Tok_Dir_Chunksize:
01901
01902 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
01903 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
01904 parse_err_flush(Find_EOS, NULL);
01905 goto EXIT;
01906 }
01907
01908 IL_FLD(list_array[8]) = CN_Tbl_Idx;
01909 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
01910 CMIC_WORK_DIST_CHUNKSIZE);
01911 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
01912 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
01913
01914 if (LA_CH_VALUE == LPAREN) {
01915 NEXT_LA_CH;
01916
01917 if (parse_expr(&opnd)) {
01918 COPY_OPND(IL_OPND(list_array[9]), opnd);
01919 }
01920
01921 if (LA_CH_VALUE == RPAREN) {
01922 NEXT_LA_CH;
01923 }
01924 else {
01925 parse_err_flush(Find_EOS, ")");
01926 goto EXIT;
01927 }
01928 }
01929 else {
01930 parse_err_flush(Find_EOS, "(");
01931 goto EXIT;
01932 }
01933
01934
01935 break;
01936
01937 case Tok_Dir_Numchunks:
01938
01939 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
01940 PRINTMSG(TOKEN_LINE(token), 1436, Warning,
01941 TOKEN_COLUMN(token), "NUMCHUNKS");
01942 # endif
01943
01944
01945 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
01946 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
01947 parse_err_flush(Find_EOS, NULL);
01948 goto EXIT;
01949 }
01950
01951 IL_FLD(list_array[8]) = CN_Tbl_Idx;
01952 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
01953 CMIC_WORK_DIST_NUMCHUNKS);
01954 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
01955 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
01956
01957 if (LA_CH_VALUE == LPAREN) {
01958 NEXT_LA_CH;
01959
01960 if (parse_expr(&opnd)) {
01961 COPY_OPND(IL_OPND(list_array[9]), opnd);
01962 }
01963
01964 if (LA_CH_VALUE == RPAREN) {
01965 NEXT_LA_CH;
01966 }
01967 else {
01968 parse_err_flush(Find_EOS, ")");
01969 goto EXIT;
01970 }
01971 }
01972 else {
01973 parse_err_flush(Find_EOS, "(");
01974 goto EXIT;
01975 }
01976
01977 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
01978 IL_OPND(list_array[8]) = null_opnd;
01979 # endif
01980 break;
01981
01982 case Tok_Dir_Guided:
01983
01984 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
01985 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
01986 parse_err_flush(Find_EOS, NULL);
01987 goto EXIT;
01988 }
01989
01990 IL_FLD(list_array[8]) = CN_Tbl_Idx;
01991 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
01992 CMIC_WORK_DIST_GUIDED);
01993 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
01994 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
01995
01996 if (LA_CH_VALUE == '(') {
01997
01998 if (parse_expr(&opnd)) {
01999 COPY_OPND(IL_OPND(list_array[9]), opnd);
02000 }
02001 }
02002 else {
02003 IL_FLD(list_array[9]) = CN_Tbl_Idx;
02004 IL_IDX(list_array[9]) = const_safevl_idx;
02005 IL_LINE_NUM(list_array[9]) = TOKEN_LINE(token);
02006 IL_COL_NUM(list_array[9]) = TOKEN_COLUMN(token);
02007 }
02008
02009 break;
02010
02011 case Tok_Dir_Vector:
02012
02013 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
02014 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
02015 parse_err_flush(Find_EOS, NULL);
02016 goto EXIT;
02017 }
02018
02019 IL_FLD(list_array[8]) = CN_Tbl_Idx;
02020 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02021 CMIC_WORK_DIST_VECTOR);
02022 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
02023 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
02024
02025 break;
02026
02027 case Tok_Dir_Ncpus_Chunks :
02028
02029 # ifdef _TARGET_OS_SOLARIS
02030
02031 if (IL_FLD(list_array[8]) != NO_Tbl_Idx) {
02032 PRINTMSG(TOKEN_LINE(token), 800, Error, TOKEN_COLUMN(token));
02033 parse_err_flush(Find_EOS, NULL);
02034 goto EXIT;
02035 }
02036
02037 IL_FLD(list_array[8]) = CN_Tbl_Idx;
02038 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02039 CMIC_WORK_DIST_NCPUS_CHUNK);
02040 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
02041 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
02042
02043 # else
02044 PRINTMSG(TOKEN_LINE(token), 1140, Warning, TOKEN_COLUMN(token));
02045 # endif
02046 break;
02047
02048 default:
02049 parse_err_flush(Find_EOS, NULL);
02050 PRINTMSG(TOKEN_LINE(token), 798, Error, TOKEN_COLUMN(token));
02051 break;
02052 }
02053 }
02054 else {
02055 parse_err_flush(Find_EOS, "parameter");
02056 }
02057
02058 if (LA_CH_VALUE == COMMA) {
02059 NEXT_LA_CH;
02060 }
02061 }
02062
02063 if (IL_FLD(list_array[8]) == NO_Tbl_Idx) {
02064 IL_FLD(list_array[8]) = CN_Tbl_Idx;
02065
02066 # ifdef _TARGET_OS_SOLARIS
02067 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02068 CMIC_WORK_DIST_NCPUS_CHUNKS);
02069 # elif (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
02070 IL_IDX(list_array[8]) = CN_INTEGER_ZERO_IDX;
02071 # else
02072 IL_IDX(list_array[8]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02073 CMIC_WORK_DIST_SINGLE);
02074 # endif
02075 IL_LINE_NUM(list_array[8]) = TOKEN_LINE(token);
02076 IL_COL_NUM(list_array[8]) = TOKEN_COLUMN(token);
02077 }
02078
02079 EXIT:
02080
02081 TRACE (Func_Exit, "parse_doall_cmic", NULL);
02082
02083 return;
02084
02085 }
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098
02099
02100
02101
02102
02103
02104 static boolean parse_var_name_list(opnd_type *list_opnd)
02105
02106 {
02107 int column;
02108 int line;
02109 int list_idx = NULL_IDX;
02110 opnd_type opnd;
02111 boolean result = TRUE;
02112
02113
02114 TRACE (Func_Entry, "parse_var_name_list", NULL);
02115
02116 while (TRUE) {
02117
02118 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
02119 parse_deref(&opnd, NULL_IDX);
02120
02121 if (OPND_FLD(opnd) != AT_Tbl_Idx) {
02122 result = FALSE;
02123 find_opnd_line_and_column(&opnd, &line, &column);
02124 PRINTMSG(line, 1374, Error, column);
02125 }
02126 else {
02127
02128 if (list_idx == NULL_IDX) {
02129 NTR_IR_LIST_TBL(list_idx);
02130 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
02131 OPND_IDX((*list_opnd)) = list_idx;
02132 OPND_LIST_CNT((*list_opnd)) = 1;
02133 }
02134 else {
02135 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
02136 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
02137 (OPND_LIST_CNT((*list_opnd)))++;
02138 list_idx = IL_NEXT_LIST_IDX(list_idx);
02139 }
02140
02141 COPY_OPND(IL_OPND(list_idx), opnd);
02142 }
02143 }
02144 else {
02145 parse_err_flush(Find_Comma_Rparen, "IDENTIFIER");
02146 result = FALSE;
02147 }
02148
02149 if (LA_CH_VALUE != COMMA) {
02150 break;
02151 }
02152
02153 NEXT_LA_CH;
02154 }
02155
02156 TRACE (Func_Exit, "parse_var_name_list", NULL);
02157
02158 return(result);
02159
02160 }
02161 # if 0
02162
02163
02164
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182 static void parse_expr_list(opnd_type *list_opnd)
02183
02184 {
02185 int list_idx = NULL_IDX;
02186 boolean ok = TRUE;
02187 opnd_type opnd;
02188
02189
02190 TRACE (Func_Entry, "parse_expr_list", NULL);
02191
02192 while(TRUE) {
02193
02194 ok &= parse_expr(&opnd);
02195
02196 if (ok) {
02197
02198 if (list_idx == NULL_IDX) {
02199 NTR_IR_LIST_TBL(list_idx);
02200 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
02201 OPND_IDX((*list_opnd)) = list_idx;
02202 OPND_LIST_CNT((*list_opnd)) = 1;
02203 }
02204 else {
02205 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
02206 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
02207 (OPND_LIST_CNT((*list_opnd)))++;
02208 list_idx = IL_NEXT_LIST_IDX(list_idx);
02209 }
02210 COPY_OPND(IL_OPND(list_idx), opnd);
02211 }
02212 else {
02213 parse_err_flush(Find_Comma_Rparen, NULL);
02214 break;
02215 }
02216
02217 if (LA_CH_VALUE != COMMA) {
02218 break;
02219 }
02220 NEXT_LA_CH;
02221 }
02222
02223 TRACE (Func_Exit, "parse_expr_list", NULL);
02224
02225 return;
02226
02227 }
02228 # endif
02229
02230
02231
02232
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252 static void parse_doparallel_cmic(void)
02253
02254 {
02255 int i;
02256 int ir_idx;
02257 int list_array[2];
02258 opnd_type opnd;
02259
02260
02261 TRACE (Func_Entry, "parse_doparallel_cmic", NULL);
02262
02263 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
02264
02265 for (i = 0; i < 2; i++) {
02266 NTR_IR_LIST_TBL(list_array[i]);
02267 if (i >= 1) {
02268 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
02269 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
02270 }
02271 }
02272
02273 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
02274 IR_IDX_L(ir_idx) = list_array[0];
02275 IR_LIST_CNT_L(ir_idx) = 2;
02276
02277 IL_OPND(list_array[0]) = null_opnd;
02278
02279 if (LA_CH_VALUE == EOS) {
02280 goto EXIT;
02281 }
02282
02283 if (MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd)) {
02284 switch (TOKEN_VALUE(token)) {
02285 case Tok_Dir_Single:
02286
02287 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02288 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02289 parse_err_flush(Find_EOS, NULL);
02290 goto EXIT;
02291 }
02292
02293 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02294 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02295 CMIC_WORK_DIST_SINGLE);
02296 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02297 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02298
02299 break;
02300
02301 case Tok_Dir_Chunksize:
02302
02303 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02304 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02305 parse_err_flush(Find_EOS, NULL);
02306 goto EXIT;
02307 }
02308
02309 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02310 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02311 CMIC_WORK_DIST_CHUNKSIZE);
02312 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02313 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02314
02315 if (LA_CH_VALUE == LPAREN) {
02316 NEXT_LA_CH;
02317
02318 if (parse_expr(&opnd)) {
02319 COPY_OPND(IL_OPND(list_array[1]), opnd);
02320 }
02321
02322 if (LA_CH_VALUE == RPAREN) {
02323 NEXT_LA_CH;
02324 }
02325 else {
02326 parse_err_flush(Find_EOS, ")");
02327 goto EXIT;
02328 }
02329 }
02330 else {
02331 parse_err_flush(Find_EOS, "(");
02332 goto EXIT;
02333 }
02334
02335 break;
02336
02337 case Tok_Dir_Numchunks:
02338
02339 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
02340 PRINTMSG(TOKEN_LINE(token), 1436, Warning,
02341 TOKEN_COLUMN(token), "NUMCHUNKS");
02342 # endif
02343
02344 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02345 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02346 parse_err_flush(Find_EOS, NULL);
02347 goto EXIT;
02348 }
02349
02350 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02351 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02352 CMIC_WORK_DIST_NUMCHUNKS);
02353 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02354 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02355
02356 if (LA_CH_VALUE == LPAREN) {
02357 NEXT_LA_CH;
02358
02359 if (parse_expr(&opnd)) {
02360 COPY_OPND(IL_OPND(list_array[1]), opnd);
02361 }
02362
02363 if (LA_CH_VALUE == RPAREN) {
02364 NEXT_LA_CH;
02365 }
02366 else {
02367 parse_err_flush(Find_EOS, ")");
02368 goto EXIT;
02369 }
02370 }
02371 else {
02372 parse_err_flush(Find_EOS, "(");
02373 goto EXIT;
02374 }
02375
02376 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
02377 IL_OPND(list_array[0]) = null_opnd;
02378 # endif
02379 break;
02380
02381 case Tok_Dir_Guided:
02382
02383 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02384 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02385 parse_err_flush(Find_EOS, NULL);
02386 goto EXIT;
02387 }
02388
02389 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02390 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02391 CMIC_WORK_DIST_GUIDED);
02392 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02393 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02394
02395 if (LA_CH_VALUE == '(') {
02396 if (parse_expr(&opnd)) {
02397 COPY_OPND(IL_OPND(list_array[1]), opnd);
02398 }
02399 }
02400 else {
02401 IL_FLD(list_array[1]) = CN_Tbl_Idx;
02402 IL_IDX(list_array[1]) = const_safevl_idx;
02403 IL_LINE_NUM(list_array[1]) = TOKEN_LINE(token);
02404 IL_COL_NUM(list_array[1]) = TOKEN_COLUMN(token);
02405 }
02406
02407 break;
02408
02409 case Tok_Dir_Vector:
02410
02411 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02412 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02413 parse_err_flush(Find_EOS, NULL);
02414 goto EXIT;
02415 }
02416
02417 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02418 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02419 CMIC_WORK_DIST_VECTOR);
02420 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02421 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02422
02423 break;
02424
02425 case Tok_Dir_Ncpus_Chunks :
02426
02427 # ifdef _TARGET_OS_SOLARIS
02428
02429 if (IL_FLD(list_array[0]) != NO_Tbl_Idx) {
02430 PRINTMSG(TOKEN_LINE(token), 1139, Error, TOKEN_COLUMN(token));
02431 parse_err_flush(Find_EOS, NULL);
02432 goto EXIT;
02433 }
02434
02435 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02436 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02437 CMIC_WORK_DIST_NCPUS_CHUNKS);
02438 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02439 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02440
02441 # else
02442 PRINTMSG(TOKEN_LINE(token), 1140, Warning, TOKEN_COLUMN(token));
02443 # endif
02444 break;
02445
02446
02447 default:
02448 parse_err_flush(Find_EOS, NULL);
02449 PRINTMSG(TOKEN_LINE(token), 808, Error, TOKEN_COLUMN(token));
02450 break;
02451 }
02452 }
02453 else {
02454 parse_err_flush(Find_EOS, "parameter");
02455 }
02456
02457 if (LA_CH_VALUE != EOS) {
02458 parse_err_flush(Find_EOS, EOS_STR);
02459 }
02460
02461 EXIT:
02462
02463 if (IL_FLD(list_array[0]) == NO_Tbl_Idx) {
02464 IL_FLD(list_array[0]) = CN_Tbl_Idx;
02465
02466 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
02467 IL_IDX(list_array[0]) = CN_INTEGER_ZERO_IDX;
02468 # else
02469 IL_IDX(list_array[0]) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02470 CMIC_WORK_DIST_SINGLE);
02471 # endif
02472 IL_LINE_NUM(list_array[0]) = TOKEN_LINE(token);
02473 IL_COL_NUM(list_array[0]) = TOKEN_COLUMN(token);
02474 }
02475
02476 TRACE (Func_Exit, "parse_doparallel_cmic", NULL);
02477
02478 return;
02479
02480 }
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508 static void parse_parallel_cmic(void)
02509
02510 {
02511 int i;
02512 int ir_idx;
02513 int list_array[7];
02514 int list_idx;
02515 opnd_type opnd;
02516
02517
02518 TRACE (Func_Entry, "parse_parallel_cmic", NULL);
02519
02520 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
02521
02522 for (i = 0; i < 7; i++) {
02523 NTR_IR_LIST_TBL(list_array[i]);
02524 if (i >= 1) {
02525 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
02526 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
02527 }
02528 }
02529
02530 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
02531 IR_IDX_L(ir_idx) = list_array[0];
02532 IR_LIST_CNT_L(ir_idx) = 7;
02533
02534 while (LA_CH_VALUE != EOS) {
02535
02536 if (MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd)) {
02537
02538 switch (TOKEN_VALUE(token)) {
02539
02540 case Tok_Dir_If:
02541
02542 if (LA_CH_VALUE == LPAREN) {
02543
02544 if (IL_IDX(list_array[0]) != NULL_IDX) {
02545 PRINTMSG(LA_CH_LINE, 680, Error, LA_CH_COLUMN,
02546 "PARALLEL");
02547 parse_err_flush(Find_EOS, NULL);
02548 goto EXIT;
02549 }
02550
02551 NEXT_LA_CH;
02552 parse_expr(&opnd);
02553 COPY_OPND(IL_OPND(list_array[0]), opnd);
02554
02555 if (LA_CH_VALUE == RPAREN) {
02556 NEXT_LA_CH;
02557 }
02558 else {
02559 parse_err_flush(Find_EOS, ")");
02560 goto EXIT;
02561 }
02562 }
02563 else {
02564 parse_err_flush(Find_EOS, "(");
02565 goto EXIT;
02566 }
02567 break;
02568
02569 case Tok_Dir_Shared:
02570
02571 if (LA_CH_VALUE == LPAREN) {
02572 NEXT_LA_CH;
02573 parse_var_name_list(&opnd);
02574
02575 if (IL_IDX(list_array[1]) == NULL_IDX) {
02576 COPY_OPND(IL_OPND(list_array[1]), opnd);
02577 }
02578 else {
02579
02580
02581 list_idx = IL_IDX(list_array[1]);
02582 while (IL_NEXT_LIST_IDX(list_idx)) {
02583 list_idx = IL_NEXT_LIST_IDX(list_idx);
02584 }
02585
02586
02587 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
02588 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
02589 IL_LIST_CNT(list_array[1]) += OPND_LIST_CNT(opnd);
02590 }
02591
02592 if (LA_CH_VALUE == RPAREN) {
02593 NEXT_LA_CH;
02594 }
02595 else {
02596 parse_err_flush(Find_EOS, ")");
02597 goto EXIT;
02598 }
02599 }
02600 else {
02601 parse_err_flush(Find_EOS, "(");
02602 goto EXIT;
02603 }
02604
02605 break;
02606
02607 case Tok_Dir_Private:
02608
02609 if (LA_CH_VALUE == LPAREN) {
02610 NEXT_LA_CH;
02611 parse_var_name_list(&opnd);
02612
02613 if (IL_IDX(list_array[2]) == NULL_IDX) {
02614 COPY_OPND(IL_OPND(list_array[2]), opnd);
02615 }
02616 else {
02617
02618
02619 list_idx = IL_IDX(list_array[2]);
02620 while (IL_NEXT_LIST_IDX(list_idx)) {
02621 list_idx = IL_NEXT_LIST_IDX(list_idx);
02622 }
02623
02624
02625 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
02626 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
02627 IL_LIST_CNT(list_array[2]) += OPND_LIST_CNT(opnd);
02628 }
02629
02630 if (LA_CH_VALUE == RPAREN) {
02631 NEXT_LA_CH;
02632 }
02633 else {
02634 parse_err_flush(Find_EOS, ")");
02635 goto EXIT;
02636 }
02637 }
02638 else {
02639 parse_err_flush(Find_EOS, "(");
02640 goto EXIT;
02641 }
02642
02643 break;
02644
02645 case Tok_Dir_Getfirst:
02646
02647 if (LA_CH_VALUE == LPAREN) {
02648 NEXT_LA_CH;
02649 parse_var_name_list(&opnd);
02650
02651 if (IL_IDX(list_array[3]) == NULL_IDX) {
02652 COPY_OPND(IL_OPND(list_array[3]), opnd);
02653 }
02654 else {
02655
02656
02657 list_idx = IL_IDX(list_array[3]);
02658 while (IL_NEXT_LIST_IDX(list_idx)) {
02659 list_idx = IL_NEXT_LIST_IDX(list_idx);
02660 }
02661
02662
02663 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
02664 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
02665 IL_LIST_CNT(list_array[3]) += OPND_LIST_CNT(opnd);
02666 }
02667
02668 if (LA_CH_VALUE == RPAREN) {
02669 NEXT_LA_CH;
02670 }
02671 else {
02672 parse_err_flush(Find_EOS, ")");
02673 goto EXIT;
02674 }
02675 }
02676 else {
02677 parse_err_flush(Find_EOS, "(");
02678 goto EXIT;
02679 }
02680
02681 break;
02682
02683 case Tok_Dir_Autoscope:
02684
02685 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
02686 PRINTMSG(TOKEN_LINE(token), 1415, Error, TOKEN_COLUMN(token));
02687 # else
02688
02689 IL_FLD(list_array[4]) = CN_Tbl_Idx;
02690 IL_IDX(list_array[4]) = CN_INTEGER_ONE_IDX;
02691 IL_LINE_NUM(list_array[4]) = TOKEN_LINE(token);
02692 IL_COL_NUM(list_array[4]) = TOKEN_COLUMN(token);
02693
02694 # endif
02695 break;
02696
02697 case Tok_Dir_Control:
02698
02699 if (LA_CH_VALUE == LPAREN) {
02700 NEXT_LA_CH;
02701 parse_var_name_list(&opnd);
02702
02703 if (IL_IDX(list_array[5]) == NULL_IDX) {
02704 COPY_OPND(IL_OPND(list_array[5]), opnd);
02705 }
02706 else {
02707
02708
02709 list_idx = IL_IDX(list_array[5]);
02710 while (IL_NEXT_LIST_IDX(list_idx)) {
02711 list_idx = IL_NEXT_LIST_IDX(list_idx);
02712 }
02713
02714
02715 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
02716 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
02717 IL_LIST_CNT(list_array[5]) += OPND_LIST_CNT(opnd);
02718 }
02719
02720 if (LA_CH_VALUE == RPAREN) {
02721 NEXT_LA_CH;
02722 }
02723 else {
02724 parse_err_flush(Find_EOS, ")");
02725 goto EXIT;
02726 }
02727 }
02728 else {
02729 parse_err_flush(Find_EOS, "(");
02730 goto EXIT;
02731 }
02732
02733 break;
02734
02735 case Tok_Dir_Maxcpus:
02736
02737 if (LA_CH_VALUE == LPAREN) {
02738 NEXT_LA_CH;
02739 parse_expr(&opnd);
02740 COPY_OPND(IL_OPND(list_array[6]), opnd);
02741
02742 if (LA_CH_VALUE == RPAREN) {
02743 NEXT_LA_CH;
02744 }
02745 else {
02746 parse_err_flush(Find_EOS, ")");
02747 goto EXIT;
02748 }
02749 }
02750 else {
02751 parse_err_flush(Find_EOS, "(");
02752 goto EXIT;
02753 }
02754 break;
02755
02756 default:
02757 parse_err_flush(Find_EOS, NULL);
02758 PRINTMSG(TOKEN_LINE(token), 809, Error, TOKEN_COLUMN(token));
02759 break;
02760 }
02761 }
02762 else {
02763 parse_err_flush(Find_EOS, "parameter");
02764 }
02765
02766 if (LA_CH_VALUE == COMMA) {
02767 NEXT_LA_CH;
02768 }
02769 }
02770
02771 EXIT:
02772
02773 TRACE (Func_Exit, "parse_parallel_cmic", NULL);
02774
02775 return;
02776
02777 }
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791
02792
02793
02794
02795 void do_cmic_blk_checks(void)
02796
02797 {
02798
02799
02800 TRACE (Func_Entry, "do_cmic_blk_checks", NULL);
02801
02802 if (cdir_switches.doall_sh_idx != NULL_IDX) {
02803 PRINTMSG(SH_GLB_LINE(cdir_switches.doall_sh_idx), 1219, Error,
02804 SH_COL_NUM(cdir_switches.doall_sh_idx),
02805 "DO ALL");
02806 }
02807
02808
02809
02810 if (cdir_switches.doacross_sh_idx != NULL_IDX) {
02811 PRINTMSG(SH_GLB_LINE(cdir_switches.doacross_sh_idx), 1219, Error,
02812 SH_COL_NUM(cdir_switches.doacross_sh_idx),
02813 "DOACROSS");
02814 }
02815
02816 cdir_switches.no_internal_calls = FALSE;
02817 cdir_switches.parallel_region = FALSE;
02818 cdir_switches.doall_region = FALSE;
02819 cdir_switches.casedir = FALSE;
02820 cdir_switches.guard = FALSE;
02821 cdir_switches.guard_has_flag = FALSE;
02822 cdir_switches.guard_in_par_reg = FALSE;
02823 cdir_switches.do_parallel = FALSE;
02824
02825 cdir_switches.doall_sh_idx = NULL_IDX;
02826 cdir_switches.doacross_sh_idx = NULL_IDX;
02827 cdir_switches.dopar_sh_idx = NULL_IDX;
02828
02829 TRACE (Func_Exit, "do_cmic_blk_checks", NULL);
02830
02831 return;
02832
02833 }
02834
02835
02836
02837
02838
02839
02840
02841
02842
02843
02844
02845
02846
02847
02848
02849
02850
02851
02852 static void parse_cache_align_name_list(opnd_type *list_opnd)
02853
02854 {
02855 int col;
02856 int line;
02857 int list_idx = NULL_IDX;
02858 opnd_type opnd;
02859 int sb_idx;
02860
02861
02862 TRACE (Func_Entry, "parse_cache_align_name_list", NULL);
02863
02864 while(TRUE) {
02865 if (LA_CH_VALUE == SLASH) {
02866
02867 NEXT_LA_CH;
02868
02869 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
02870
02871 if (LA_CH_VALUE == SLASH) {
02872 NEXT_LA_CH;
02873 sb_idx = srch_stor_blk_tbl(TOKEN_STR(token),
02874 TOKEN_LEN(token),
02875 curr_scp_idx);
02876
02877 if (sb_idx == NULL_IDX) {
02878 sb_idx = ntr_stor_blk_tbl(TOKEN_STR(token),
02879 TOKEN_LEN(token),
02880 TOKEN_LINE(token),
02881 TOKEN_COLUMN(token),
02882 Common);
02883 SB_BLANK_COMMON(sb_idx) = FALSE;
02884 SB_COMMON_NEEDS_OFFSET(sb_idx) = TRUE;
02885 SB_IS_COMMON(sb_idx) = TRUE;
02886 }
02887
02888 if (SB_CACHE_ALIGN(sb_idx)) {
02889
02890 PRINTMSG(TOKEN_LINE(token), 1065, Error,
02891 TOKEN_COLUMN(token), SB_NAME_PTR(sb_idx));
02892 }
02893 else {
02894 SB_CACHE_ALIGN(sb_idx) = TRUE;
02895 }
02896 }
02897 else {
02898 parse_err_flush(Find_EOS, "/");
02899 }
02900 }
02901 else {
02902 parse_err_flush(Find_EOS, "common-block-name");
02903 }
02904 }
02905 else if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
02906 parse_deref(&opnd, NULL_IDX);
02907
02908 if (OPND_FLD(opnd) != AT_Tbl_Idx) {
02909 find_opnd_line_and_column(&opnd, &line, &col);
02910 PRINTMSG(line, 1487, Error, col, "CACHE_ALIGN");
02911 }
02912 else {
02913 if (list_idx == NULL_IDX) {
02914 NTR_IR_LIST_TBL(list_idx);
02915 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
02916 OPND_IDX((*list_opnd)) = list_idx;
02917 OPND_LIST_CNT((*list_opnd)) = 1;
02918 }
02919 else {
02920 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
02921 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
02922 (OPND_LIST_CNT((*list_opnd)))++;
02923 list_idx = IL_NEXT_LIST_IDX(list_idx);
02924 }
02925 COPY_OPND(IL_OPND(list_idx), opnd);
02926 }
02927 }
02928 else {
02929 parse_err_flush(Find_EOS, "IDENTIFIER");
02930 }
02931
02932 if (LA_CH_VALUE != COMMA) {
02933 break;
02934 }
02935 NEXT_LA_CH;
02936 }
02937
02938 TRACE (Func_Exit, "parse_cache_align_name_list", NULL);
02939
02940 return;
02941
02942 }
02943
02944
02945
02946
02947
02948
02949
02950
02951
02952
02953
02954
02955
02956
02957
02958
02959 static void parse_name_dir(void)
02960
02961 {
02962 int attr_idx;
02963 int column;
02964 int idx;
02965 long length;
02966 int line;
02967 char *name;
02968 int name_idx;
02969 opnd_type opnd;
02970
02971
02972 TRACE (Func_Entry, "parse_name_dir", NULL);
02973
02974 if (LA_CH_VALUE != LPAREN) {
02975 parse_err_flush(Find_EOS, "(");
02976 NEXT_LA_CH;
02977 return;
02978 }
02979
02980 NEXT_LA_CH;
02981
02982 do {
02983 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
02984 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
02985 &name_idx);
02986
02987 if (attr_idx == NULL_IDX) {
02988 attr_idx = ntr_sym_tbl(&token, name_idx);
02989 LN_DEF_LOC(name_idx) = TRUE;
02990 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
02991 ATP_PROC(attr_idx) = Extern_Proc;
02992 ATP_NAME_IN_STONE(attr_idx) = TRUE;
02993 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
02994 }
02995 else if (!fnd_semantic_err(Obj_Name,
02996 TOKEN_LINE(token),
02997 TOKEN_COLUMN(token),
02998 attr_idx,
02999 TRUE)) {
03000
03001 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
03002 AT_ATTR_LINK(attr_idx) = NULL_IDX;
03003 LN_DEF_LOC(name_idx) = TRUE;
03004 }
03005
03006 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
03007 chg_data_obj_to_pgm_unit(attr_idx,
03008 Pgm_Unknown,
03009 Extern_Proc);
03010 ATP_NAME_IN_STONE(attr_idx) = TRUE;
03011 }
03012 else if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) {
03013 ATP_PROC(attr_idx) = Extern_Proc;
03014 ATP_NAME_IN_STONE(attr_idx) = TRUE;
03015 }
03016 }
03017 else {
03018 CREATE_ERR_ATTR(attr_idx,
03019 TOKEN_LINE(token),
03020 TOKEN_COLUMN(token),
03021 Pgm_Unit);
03022 ATP_PROC(attr_idx) = Extern_Proc;
03023 ATP_NAME_IN_STONE(attr_idx) = TRUE;
03024 }
03025
03026 if (LA_CH_VALUE == EQUAL) {
03027 NEXT_LA_CH;
03028
03029 if (LA_CH_VALUE == QUOTE ||
03030 LA_CH_VALUE == DBL_QUOTE) {
03031
03032 if (parse_operand(&opnd)) {
03033 find_opnd_line_and_column(&opnd, &line, &column);
03034
03035 if (OPND_FLD(opnd)!= CN_Tbl_Idx ||
03036 TYP_TYPE(CN_TYPE_IDX(OPND_IDX(opnd))) != Character) {
03037 PRINTMSG(line, 1111, Error, column);
03038 AT_DCL_ERR(attr_idx) = TRUE;
03039 ATP_EXT_NAME_LEN(attr_idx) = AT_NAME_LEN(attr_idx);
03040 ATP_EXT_NAME_IDX(attr_idx) = AT_NAME_IDX(attr_idx);
03041 }
03042 else {
03043 length = (long) CN_INT_TO_C(TYP_IDX(
03044 CN_TYPE_IDX(OPND_IDX(opnd))));
03045
03046 NTR_NAME_POOL((long *) &(CN_CONST(OPND_IDX(opnd))),
03047 (int) length, name_idx);
03048
03049 ATP_EXT_NAME_IDX(attr_idx) = name_idx;
03050 ATP_EXT_NAME_LEN(attr_idx) = length;
03051 name = ATP_EXT_NAME_PTR(attr_idx);
03052
03053 for (idx = 0;
03054 idx < (WORD_LEN(length)*TARGET_BYTES_PER_WORD)-length;
03055 idx++) {
03056 *(name + length + idx) = '\0';
03057 }
03058 }
03059 }
03060 else {
03061 parse_err_flush(Find_Rparen, NULL);
03062 AT_DCL_ERR(attr_idx) = TRUE;
03063 ATP_EXT_NAME_LEN(attr_idx) = AT_NAME_LEN(attr_idx);
03064 ATP_EXT_NAME_IDX(attr_idx) = AT_NAME_IDX(attr_idx);
03065 }
03066 }
03067 else {
03068 PRINTMSG(LA_CH_LINE, 1111, Error, LA_CH_COLUMN);
03069 parse_err_flush(Find_Rparen, NULL);
03070 AT_DCL_ERR(attr_idx) = TRUE;
03071 ATP_EXT_NAME_LEN(attr_idx) = AT_NAME_LEN(attr_idx);
03072 ATP_EXT_NAME_IDX(attr_idx) = AT_NAME_IDX(attr_idx);
03073 }
03074 }
03075 else {
03076 parse_err_flush(Find_Rparen, "=");
03077 AT_DCL_ERR(attr_idx) = TRUE;
03078 ATP_EXT_NAME_LEN(attr_idx) = AT_NAME_LEN(attr_idx);
03079 ATP_EXT_NAME_IDX(attr_idx) = AT_NAME_IDX(attr_idx);
03080 }
03081 }
03082 else if (!parse_err_flush(Find_Comma, "procedure name")) {
03083 break;
03084 }
03085
03086 if (LA_CH_VALUE == COMMA) {
03087 NEXT_LA_CH;
03088 }
03089 else {
03090 break;
03091 }
03092 }
03093 while (TRUE);
03094
03095 if (LA_CH_VALUE == RPAREN || parse_err_flush(Find_Rparen, ", or )")) {
03096 NEXT_LA_CH;
03097 }
03098
03099 if (LA_CH_VALUE != EOS) {
03100 parse_err_flush(Find_EOS, EOS_STR);
03101 }
03102
03103 NEXT_LA_CH;
03104
03105 TRACE (Func_Exit, "parse_name_dir", NULL);
03106
03107 return;
03108
03109 }
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126 static void parse_permutation_mic(void)
03127
03128 {
03129 int attr_idx;
03130 int name_idx;
03131
03132 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
03133 int ir_idx;
03134 int list_idx = NULL_IDX;
03135 # endif
03136
03137
03138 TRACE (Func_Entry, "parse_permutation_mic", NULL);
03139
03140 if (LA_CH_VALUE != LPAREN) {
03141 parse_err_flush(Find_EOS, "(");
03142 return;
03143 }
03144
03145 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
03146 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
03147 IR_OPR(ir_idx) = Assert_Star_Opr;
03148
03149 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
03150 IR_IDX_L(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
03151 ASSERT_PERMUTATION);
03152 IR_LINE_NUM_L(ir_idx) = IR_LINE_NUM(ir_idx);
03153 IR_COL_NUM_L(ir_idx) = IR_COL_NUM(ir_idx);
03154 # endif
03155
03156 NEXT_LA_CH;
03157
03158 do {
03159
03160 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
03161 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
03162 &name_idx);
03163
03164 if (attr_idx == NULL_IDX) {
03165 attr_idx = ntr_sym_tbl(&token, name_idx);
03166 LN_DEF_LOC(name_idx) = TRUE;
03167 AT_OBJ_CLASS(attr_idx) = Data_Obj;
03168 ATD_PERMUTATION(attr_idx) = TRUE;
03169 }
03170 else if (AT_OBJ_CLASS(attr_idx) != Data_Obj) {
03171 PRINTMSG(AT_DEF_LINE(attr_idx), 1126, Error,
03172 AT_DEF_COLUMN(attr_idx),
03173 AT_OBJ_NAME_PTR(attr_idx));
03174 AT_DCL_ERR(attr_idx) = TRUE;
03175 }
03176 else {
03177 ATD_PERMUTATION(attr_idx) = TRUE;
03178
03179 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
03180 AT_ATTR_LINK(attr_idx) = NULL_IDX;
03181 LN_DEF_LOC(name_idx) = TRUE;
03182 }
03183 }
03184
03185 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
03186 if (list_idx == NULL_IDX) {
03187 NTR_IR_LIST_TBL(list_idx);
03188 IR_FLD_R(ir_idx) = IL_Tbl_Idx;
03189 IR_IDX_R(ir_idx) = list_idx;
03190 IR_LIST_CNT_R(ir_idx) = 1;
03191 }
03192 else {
03193 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
03194 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
03195 list_idx = IL_NEXT_LIST_IDX(list_idx);
03196 (IR_LIST_CNT_R(ir_idx))++;
03197 }
03198
03199 IL_FLD(list_idx) = AT_Tbl_Idx;
03200 IL_IDX(list_idx) = attr_idx;
03201 IL_LINE_NUM(list_idx) = TOKEN_LINE(token);
03202 IL_COL_NUM(list_idx) = TOKEN_COLUMN(token);
03203 # endif
03204 }
03205 else if (!parse_err_flush(Find_Comma, "array name")) {
03206 break;
03207 }
03208
03209 if (LA_CH_VALUE == COMMA) {
03210 NEXT_LA_CH;
03211 }
03212 else {
03213 break;
03214 }
03215 }
03216 while (TRUE);
03217
03218 if (LA_CH_VALUE == RPAREN || parse_err_flush(Find_Rparen, ", or )")) {
03219 NEXT_LA_CH;
03220 }
03221
03222 if (LA_CH_VALUE != EOS) {
03223 parse_err_flush(Find_EOS, EOS_STR);
03224 }
03225
03226 TRACE (Func_Exit, "parse_permutation_mic", NULL);
03227
03228 return;
03229
03230 }
03231
03232
03233
03234
03235
03236
03237
03238
03239
03240
03241
03242
03243
03244
03245
03246
03247 static void parse_inline_always_never(boolean always)
03248
03249 {
03250 boolean amb_ref;
03251 int attr_idx;
03252 int host_attr_idx;
03253 int host_name_idx;
03254 int name_idx;
03255
03256
03257 TRACE (Func_Entry, "parse_inline_always_never", NULL);
03258
03259 do {
03260 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
03261 amb_ref = FALSE;
03262 attr_idx = srch_sym_tbl(TOKEN_STR(token),
03263 TOKEN_LEN(token),
03264 &name_idx);
03265
03266 if (attr_idx != NULL_IDX) {
03267 host_attr_idx = attr_idx;
03268
03269 if (!LN_DEF_LOC(name_idx)) {
03270 amb_ref = TRUE;
03271
03272 while (AT_ATTR_LINK(host_attr_idx) != NULL_IDX) {
03273 host_attr_idx = AT_ATTR_LINK(host_attr_idx);
03274 }
03275 }
03276 }
03277 else {
03278 amb_ref = TRUE;
03279 host_attr_idx = srch_host_sym_tbl(TOKEN_STR(token),
03280 TOKEN_LEN(token),
03281 &host_name_idx,
03282 TRUE);
03283
03284 if (host_attr_idx != NULL_IDX) {
03285
03286 if (AT_IS_INTRIN(host_attr_idx) &&
03287 ATI_FIRST_SPECIFIC_IDX(host_attr_idx) == NULL_IDX) {
03288 complete_intrinsic_definition(host_attr_idx);
03289 attr_idx = srch_sym_tbl(TOKEN_STR(token),
03290 TOKEN_LEN(token),
03291 &name_idx);
03292 }
03293
03294
03295
03296 attr_idx = ntr_host_in_sym_tbl(&token,
03297 name_idx,
03298 host_attr_idx,
03299 host_name_idx,
03300 TRUE);
03301
03302 if (AT_IS_INTRIN(host_attr_idx)) {
03303 COPY_VARIANT_ATTR_INFO(host_attr_idx,
03304 attr_idx,
03305 Interface);
03306
03307 AT_IS_INTRIN(attr_idx) = TRUE;
03308 AT_ATTR_LINK(attr_idx) = NULL_IDX;
03309 AT_ELEMENTAL_INTRIN(attr_idx) =
03310 AT_ELEMENTAL_INTRIN(host_attr_idx);
03311 AT_DEF_LINE(attr_idx) = TOKEN_LINE(token);
03312 AT_DEF_COLUMN(attr_idx) = TOKEN_COLUMN(token);
03313 }
03314 else if (AT_OBJ_CLASS(attr_idx) != Interface) {
03315 AT_ATTR_LINK(attr_idx) = host_attr_idx;
03316
03317 while (AT_ATTR_LINK(host_attr_idx) != NULL_IDX) {
03318 host_attr_idx = AT_ATTR_LINK(host_attr_idx);
03319 }
03320 }
03321 }
03322 }
03323
03324 if (attr_idx == NULL_IDX) {
03325 attr_idx = ntr_sym_tbl(&token, name_idx);
03326 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
03327 ATP_PGM_UNIT(attr_idx) = Pgm_Unknown;
03328 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
03329 ATP_PROC(attr_idx) = Unknown_Proc;
03330 MAKE_EXTERNAL_NAME(attr_idx,
03331 AT_NAME_IDX(attr_idx),
03332 AT_NAME_LEN(attr_idx));
03333 }
03334 else if (!amb_ref) {
03335
03336
03337
03338
03339 if (fnd_semantic_err(Obj_Inline,
03340 TOKEN_LINE(token),
03341 TOKEN_COLUMN(token),
03342 attr_idx,
03343 TRUE)) {
03344
03345 goto NEXT;
03346 }
03347 }
03348
03349 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit &&
03350 (ATP_INLINE_ALWAYS(attr_idx) || ATP_INLINE_NEVER(attr_idx))) {
03351
03352 if ((always && ATP_INLINE_NEVER(attr_idx)) ||
03353 (!always && ATP_INLINE_ALWAYS(attr_idx))) {
03354 PRINTMSG(AT_DEF_LINE(attr_idx), 1147, Error,
03355 AT_DEF_COLUMN(attr_idx),
03356 AT_OBJ_NAME_PTR(attr_idx));
03357 }
03358 }
03359 else {
03360
03361 if (AT_OBJ_CLASS(attr_idx) == Interface) {
03362
03363 if (ATI_INLINE_ALWAYS(attr_idx) || ATI_INLINE_NEVER(attr_idx)) {
03364
03365 if ((always && ATI_INLINE_NEVER(attr_idx)) ||
03366 (!always && ATI_INLINE_ALWAYS(attr_idx))) {
03367 PRINTMSG(AT_DEF_LINE(attr_idx), 1147, Error,
03368 AT_DEF_COLUMN(attr_idx),
03369 AT_OBJ_NAME_PTR(attr_idx));
03370 }
03371 }
03372 else if (always) {
03373 ATI_INLINE_ALWAYS(attr_idx) = TRUE;
03374 }
03375 else {
03376 ATI_INLINE_NEVER(attr_idx) = TRUE;
03377 }
03378 }
03379 else {
03380
03381 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
03382 chg_data_obj_to_pgm_unit(attr_idx, Pgm_Unknown, Unknown_Proc);
03383 }
03384
03385 if (always) {
03386 ATP_INLINE_ALWAYS(attr_idx) = TRUE;
03387 }
03388 else {
03389 ATP_INLINE_NEVER(attr_idx) = TRUE;
03390 }
03391 }
03392 }
03393 }
03394 else if (!parse_err_flush(Find_Comma, "procedure name")) {
03395 break;
03396 }
03397
03398 NEXT:
03399
03400 if (LA_CH_VALUE == COMMA) {
03401 NEXT_LA_CH;
03402 }
03403 else if (LA_CH_VALUE == EOS ||
03404 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
03405 break;
03406 }
03407 else {
03408 NEXT_LA_CH;
03409 }
03410 }
03411 while (TRUE);
03412
03413 NEXT_LA_CH;
03414
03415 TRACE (Func_Exit, "parse_inline_always_never", NULL);
03416
03417 return;
03418
03419 }
03420
03421
03422
03423
03424
03425
03426
03427
03428
03429
03430
03431
03432
03433
03434
03435
03436 static int update_fld_type(fld_type fld,
03437 int idx,
03438 int new_type)
03439
03440 {
03441 int new_idx;
03442 long_type the_constant[MAX_WORDS_FOR_INTEGER];
03443 int type_idx;
03444
03445
03446 TRACE (Func_Entry, "update_fld_type", NULL);
03447
03448 switch (fld) {
03449 case CN_Tbl_Idx:
03450
03451 if (CN_TYPE_IDX(idx) == INTEGER_DEFAULT_TYPE) {
03452 type_idx = new_type;
03453
03454 if (folder_driver((char *)CN_CONST(idx),
03455 INTEGER_DEFAULT_TYPE,
03456 NULL,
03457 NULL_IDX,
03458 the_constant,
03459 &type_idx,
03460 stmt_start_line,
03461 stmt_start_col,
03462 1,
03463 Cvrt_Opr)) {
03464 new_idx = ntr_const_tbl(new_type,
03465 FALSE,
03466 the_constant);
03467 }
03468 }
03469 break;
03470
03471 case AT_Tbl_Idx:
03472
03473 if (AT_OBJ_CLASS(idx) == Data_Obj) {
03474
03475 switch (ATD_CLASS(idx)) {
03476 case Constant:
03477
03478 if (ATD_TYPE_IDX(idx) == INTEGER_DEFAULT_TYPE) {
03479 new_idx = update_fld_type(CN_Tbl_Idx,
03480 ATD_CONST_IDX(idx),
03481 new_type);
03482 ATD_CONST_IDX(idx) = new_idx;
03483 }
03484 break;
03485
03486 case Function_Result:
03487 case Atd_Unknown:
03488 case Dummy_Argument:
03489 case CRI__Pointee:
03490 case Struct_Component:
03491 break;
03492
03493 case Compiler_Tmp:
03494 new_idx = update_fld_type((fld_type) ATD_FLD(idx),
03495 ATD_TMP_IDX(idx),
03496 new_type);
03497
03498 if (ATD_FLD(idx) == CN_Tbl_Idx) {
03499 ATD_TMP_IDX(idx) = new_idx;
03500 }
03501 break;
03502 }
03503
03504 if (ATD_TYPE_IDX(idx) == INTEGER_DEFAULT_TYPE) {
03505 ATD_TYPE_IDX(idx) = new_type;
03506 }
03507 }
03508 else if (AT_OBJ_CLASS(idx) == Pgm_Unit &&
03509 ATP_PGM_UNIT(idx) == Function &&
03510 ATP_RSLT_IDX(idx) != NULL_IDX &&
03511 ATD_TYPE_IDX(ATP_RSLT_IDX(idx)) == INTEGER_DEFAULT_TYPE) {
03512 ATD_TYPE_IDX(ATP_RSLT_IDX(idx)) = new_type;
03513 }
03514 new_idx = NULL_IDX;
03515
03516 break;
03517
03518 case IR_Tbl_Idx:
03519
03520 new_idx = update_fld_type(IR_FLD_L(idx), IR_IDX_L(idx), new_type);
03521
03522 if (IR_FLD_L(idx) == CN_Tbl_Idx) {
03523 IR_IDX_L(idx) = new_idx;
03524 }
03525
03526 new_idx = update_fld_type(IR_FLD_R(idx), IR_IDX_R(idx), new_type);
03527
03528 if (IR_FLD_R(idx) == CN_Tbl_Idx) {
03529 IR_IDX_R(idx) = new_idx;
03530 }
03531
03532 new_idx = NULL_IDX;
03533
03534 if (IR_TYPE_IDX(idx) == INTEGER_DEFAULT_TYPE) {
03535 IR_TYPE_IDX(idx) = new_type;
03536 }
03537
03538 break;
03539
03540 case IL_Tbl_Idx:
03541
03542 while (idx != NULL_IDX) {
03543 new_idx = update_fld_type(IL_FLD(idx), IL_IDX(idx), new_type);
03544
03545 if (IL_FLD(idx) == CN_Tbl_Idx) {
03546 IL_IDX(idx) = new_idx;
03547 }
03548 idx = IL_NEXT_LIST_IDX(idx);
03549 }
03550 new_idx = NULL_IDX;
03551 break;
03552
03553 case NO_Tbl_Idx:
03554 case SH_Tbl_Idx:
03555 new_idx = NULL_IDX;
03556 break;
03557
03558 }
03559
03560 TRACE (Func_Exit, "update_fld_type", NULL);
03561
03562 return(new_idx);
03563
03564 }
03565
03566
03567
03568
03569
03570
03571
03572
03573
03574
03575
03576
03577
03578
03579
03580
03581 static void parse_symmetric_dir(void)
03582
03583 {
03584 int attr_idx;
03585 int name_idx;
03586
03587
03588 TRACE (Func_Entry, "parse_symmetric_dir", NULL);
03589
03590 do {
03591 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
03592 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
03593 &name_idx);
03594
03595 if (attr_idx == NULL_IDX) {
03596 attr_idx = ntr_sym_tbl(&token, name_idx);
03597 LN_DEF_LOC(name_idx) = TRUE;
03598 AT_OBJ_CLASS(attr_idx) = Data_Obj;
03599 ATD_SYMMETRIC(attr_idx) = TRUE;
03600 ATD_CLASS(attr_idx) = Variable;
03601 SET_IMPL_TYPE(attr_idx);
03602 }
03603 else if (!fnd_semantic_err(Obj_Symmetric,
03604 TOKEN_LINE(token),
03605 TOKEN_COLUMN(token),
03606 attr_idx,
03607 TRUE)) {
03608
03609 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
03610 AT_ATTR_LINK(attr_idx) = NULL_IDX;
03611 LN_DEF_LOC(name_idx) = TRUE;
03612 }
03613
03614 ATD_SYMMETRIC(attr_idx) = TRUE;
03615 ATD_CLASS(attr_idx) = Variable;
03616 }
03617 }
03618 else if (!parse_err_flush(Find_Comma, "procedure name")) {
03619 break;
03620 }
03621
03622 if (LA_CH_VALUE == COMMA) {
03623 NEXT_LA_CH;
03624 }
03625 else if (LA_CH_VALUE == EOS ||
03626 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
03627 break;
03628 }
03629 else {
03630 NEXT_LA_CH;
03631 }
03632 }
03633 while (TRUE);
03634
03635 NEXT_LA_CH;
03636
03637 TRACE (Func_Exit, "parse_symmetric_dir", NULL);
03638
03639 return;
03640
03641 }
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651
03652
03653
03654
03655
03656
03657
03658 static void parse_dir_directives(void)
03659 {
03660
03661 int blk_idx;
03662 int buf_idx;
03663 int cdir_info_idx;
03664 int ir_idx;
03665 int label_idx;
03666 int list_idx;
03667 opnd_type opnd;
03668 operator_type opr;
03669 int stmt_num;
03670 int type_idx;
03671
03672 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
03673 int cvrt_idx;
03674 # endif
03675
03676
03677 TRACE (Func_Entry, "parse_dir_directives", NULL);
03678
03679 for (;;) {
03680
03681 if (TOKEN_VALUE(token) > Tok_Dir_Start &&
03682 TOKEN_VALUE(token) < Tok_Dir_End &&
03683 disregard_directive[TOKEN_VALUE(token) - Tok_Dir_Start]) {
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693
03694 switch (TOKEN_VALUE(token)) {
03695
03696 case Tok_Dir_Auxiliary:
03697 case Tok_Dir_Blockable:
03698 case Tok_Dir_Blockingsize:
03699 case Tok_Dir_Bounds:
03700 case Tok_Dir_Cache_Align:
03701 case Tok_Dir_Cache_Noalloc:
03702 case Tok_Dir_Cncall:
03703 case Tok_Dir_Common:
03704 case Tok_Dir_Inline_Always:
03705 case Tok_Dir_Inline_Never:
03706 case Tok_Dir_Maxcpus:
03707 case Tok_Dir_Nobounds:
03708 case Tok_Dir_Numcpus:
03709 case Tok_Dir_Cache_Bypass:
03710 case Tok_Dir_Nosideeffects:
03711 case Tok_Dir_Permutation:
03712 case Tok_Dir_Suppress:
03713 case Tok_Dir_Symmetric:
03714 case Tok_Dir_Taskcommon:
03715 case Tok_Dir_Vfunction:
03716 parse_err_flush(Find_EOS, NULL);
03717 break;
03718
03719 default:
03720 parse_err_flush(Find_Comma, NULL);
03721 }
03722
03723 goto CONTINUE;
03724 }
03725
03726 if (TOKEN_VALUE(token) <= Tok_Dir_Start ||
03727 TOKEN_VALUE(token) >= Tok_Dir_End) {
03728 PRINTMSG(TOKEN_LINE(token), 790, Warning, TOKEN_COLUMN(token));
03729 parse_err_flush(Find_EOS, NULL);
03730 goto CONTINUE;
03731 }
03732
03733 cdir_info_idx = TOKEN_VALUE(token) - Tok_Dir_Start;
03734
03735
03736
03737
03738
03739 if (!cdir_info[cdir_info_idx].on_platform) {
03740 PRINTMSG(TOKEN_LINE(token), cdir_info[cdir_info_idx].msg_num, Warning,
03741 TOKEN_COLUMN(token));
03742 parse_err_flush(Find_EOS, NULL);
03743 goto CONTINUE;
03744 }
03745
03746 if (cdir_info[cdir_info_idx].issue_795 &&
03747 curr_stmt_category < Dir_Integer_Stmt_Cat) {
03748 PRINTMSG(TOKEN_LINE(token), 795, Warning,
03749 TOKEN_COLUMN(token), cdir_info[cdir_info_idx].name);
03750 parse_err_flush(Find_EOS, NULL);
03751 goto CONTINUE;
03752 }
03753
03754 if (cdir_info[cdir_info_idx].issue_531 &&
03755 curr_stmt_category >= Executable_Stmt_Cat) {
03756 PRINTMSG(TOKEN_LINE(token), 531, Error,
03757 TOKEN_COLUMN(token), cdir_info[cdir_info_idx].name);
03758 parse_err_flush(Find_EOS, NULL);
03759 goto CONTINUE;
03760 }
03761
03762 switch (TOKEN_VALUE(token)) {
03763 case Tok_Dir_Align:
03764
03765 if (opt_flags.scalar_lvl == Scalar_Lvl_0) {
03766 parse_err_flush(Find_Comma, NULL);
03767 }
03768 else {
03769 ir_idx = gen_directive_ir(Align_Cdir_Opr);
03770 }
03771 break;
03772
03773
03774 case Tok_Dir_Auxiliary:
03775 parse_auxiliary_dir();
03776 goto EXIT;
03777
03778
03779 case Tok_Dir_Bl:
03780
03781 if (opt_flags.scalar_lvl == Scalar_Lvl_0 || !opt_flags.bottom_load) {
03782 parse_err_flush(Find_Comma, NULL);
03783 }
03784 else {
03785 cdir_switches.bl = TRUE;
03786 ir_idx = gen_directive_ir(Bl_Cdir_Opr);
03787 }
03788 break;
03789
03790 case Tok_Dir_Blockable:
03791 case Tok_Dir_Blockingsize:
03792 case Tok_Dir_Interchange:
03793 parse_star_dir_directives();
03794 goto EXIT;
03795
03796 case Tok_Dir_Bounds:
03797 cdir_switches.bounds = TRUE;
03798 ir_idx = gen_directive_ir(Bounds_Cdir_Opr);
03799
03800 if (LA_CH_VALUE != EOS) {
03801 parse_var_name_list(&opnd);
03802 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03803
03804 if (LA_CH_VALUE != EOS) {
03805 parse_err_flush(Find_EOS, EOS_STR);
03806 }
03807 NEXT_LA_CH;
03808 }
03809 else {
03810 NEXT_LA_CH;
03811 }
03812
03813 goto EXIT;
03814
03815
03816 case Tok_Dir_Cache_Align:
03817
03818 ir_idx = gen_directive_ir(Cachealign_Cdir_Opr);
03819
03820 if (LA_CH_VALUE != EOS) {
03821 parse_cache_align_name_list(&opnd);
03822 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03823 }
03824 else {
03825 parse_err_flush(Find_EOS, "IDENTIFIER");
03826 }
03827 break;
03828
03829
03830 case Tok_Dir_Cache_Bypass:
03831 ir_idx = gen_directive_ir(Cache_Bypass_Cdir_Opr);
03832 parse_cache_bypass_dir(&opnd);
03833 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03834 goto EXIT;
03835
03836 case Tok_Dir_Cache_Noalloc:
03837 parse_cache_noalloc();
03838 goto EXIT;
03839
03840
03841 case Tok_Dir_Cncall:
03842
03843
03844
03845 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
03846 ir_idx = gen_directive_ir(Cncall_Cmic_Opr);
03847
03848 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
03849
03850
03851
03852
03853
03854 PRINTMSG(LA_CH_LINE, 1123, Caution, LA_CH_COLUMN);
03855 parse_err_flush(Find_EOS, NULL);
03856 }
03857
03858 break;
03859
03860 case Tok_Dir_Common:
03861 parse_common_dirs(Common);
03862 goto EXIT;
03863
03864
03865 case Tok_Dir_Concurrent:
03866
03867 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
03868 buf_idx = LA_CH_BUF_IDX;
03869 stmt_num = LA_CH_STMT_NUM;
03870
03871 if (MATCHED_TOKEN_CLASS(Tok_Class_Id) &&
03872 TOKEN_LEN(token) == 13 &&
03873 strncmp("SAFE_DISTANCE", TOKEN_STR(token), 13) == IDENTICAL) {
03874
03875 ir_idx = gen_directive_ir(Concurrent_Cdir_Opr);
03876
03877 if (LA_CH_VALUE == EQUAL) {
03878 NEXT_LA_CH;
03879
03880 if (!parse_expr(&opnd)) {
03881 parse_err_flush(Find_EOS, NULL);
03882 }
03883 else {
03884 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03885 }
03886 }
03887 else {
03888 parse_err_flush(Find_EOS, "=");
03889 }
03890 }
03891 else {
03892 reset_lex(buf_idx, stmt_num);
03893 parse_err_flush(Find_EOS, "SAFE_DISTANCE = ");
03894 }
03895 }
03896 else {
03897 ir_idx = gen_directive_ir(Concurrent_Cdir_Opr);
03898 }
03899 break;
03900
03901
03902 case Tok_Dir_Copy_Assumed_Shape:
03903
03904 if (LA_CH_VALUE != EOS) {
03905 parse_copy_assumed_shape_dir();
03906 }
03907 else {
03908 SCP_COPY_ASSUMED_SHAPE(curr_scp_idx) = TRUE;
03909
03910 if (SCP_COPY_ASSUMED_LIST(curr_scp_idx) == NULL_IDX) {
03911 NTR_IR_LIST_TBL(list_idx);
03912 IL_LINE_NUM(list_idx) = TOKEN_LINE(token);
03913 IL_COL_NUM(list_idx) = TOKEN_COLUMN(token);
03914 SCP_COPY_ASSUMED_LIST(curr_scp_idx) = list_idx;
03915 }
03916
03917 NEXT_LA_CH;
03918 }
03919
03920 goto EXIT;
03921
03922
03923 case Tok_Dir_Eject:
03924
03925 if ((cif_flags & MISC_RECS) != 0) {
03926 cif_directive_rec(CIF_Eject,
03927 TOKEN_LINE(token),
03928 TOKEN_COLUMN(token));
03929 }
03930 break;
03931
03932
03933 case Tok_Dir_Flow:
03934 cdir_switches.flow = TRUE;
03935 break;
03936
03937
03938 case Tok_Dir_Free:
03939 case Tok_Dir_Fixed:
03940
03941
03942
03943
03944 parse_err_flush(Find_EOS, NULL);
03945 break;
03946
03947
03948 case Tok_Dir_Id:
03949 parse_id_directive();
03950 break;
03951
03952
03953 case Tok_Dir_Ignore_TKR:
03954
03955 if (LA_CH_VALUE != EOS) {
03956 parse_ignore_tkr();
03957 }
03958 else {
03959 SCP_IGNORE_TKR(curr_scp_idx) = TRUE;
03960 NEXT_LA_CH;
03961 }
03962
03963 goto EXIT;
03964
03965
03966 case Tok_Dir_Inline:
03967 case Tok_Dir_Inline_Always:
03968 case Tok_Dir_Inline_Never:
03969
03970 if (opt_flags.inline_lvl == Inline_Lvl_0 && !dump_flags.preinline) {
03971 parse_err_flush(Find_EOS, NULL);
03972 break;
03973 }
03974
03975 if (TOKEN_VALUE(token) == Tok_Dir_Inline) {
03976 cdir_switches.do_inline = TRUE;
03977 ir_idx = gen_directive_ir(Inline_Cdir_Opr);
03978 }
03979 else {
03980 parse_inline_always_never(TOKEN_VALUE(token) ==
03981 Tok_Dir_Inline_Always);
03982 goto EXIT;
03983 }
03984 break;
03985
03986
03987 case Tok_Dir_Ivdep:
03988
03989
03990 # if defined(_ACCEPT_VECTOR)
03991
03992
03993
03994 if (!cdir_switches.vector) {
03995 parse_err_flush(Find_Comma, NULL);
03996 break;
03997 }
03998 # endif
03999
04000 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
04001 buf_idx = LA_CH_BUF_IDX;
04002 stmt_num = LA_CH_STMT_NUM;
04003
04004 if (MATCHED_TOKEN_CLASS(Tok_Class_Id) &&
04005 TOKEN_LEN(token) == 6 &&
04006 strncmp("SAFEVL", TOKEN_STR(token), 6) == IDENTICAL) {
04007
04008 # if defined(_TARGET_OS_MAX) || (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
04009
04010
04011
04012 PRINTMSG(TOKEN_LINE(token), 1317,Warning,TOKEN_COLUMN(token));
04013 # else
04014 ir_idx = gen_directive_ir(Ivdep_Cdir_Opr);
04015 # endif
04016
04017 if (LA_CH_VALUE == EQUAL) {
04018 NEXT_LA_CH;
04019
04020 if (!parse_expr(&opnd)) {
04021 parse_err_flush(Find_EOS, NULL);
04022 }
04023 else {
04024
04025 # if !defined(_TARGET_OS_MAX) && !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) || defined(_TARGET_OS_DARWIN)
04026 COPY_OPND(IR_OPND_L(ir_idx), opnd);
04027 # endif
04028 }
04029 }
04030 else {
04031 parse_err_flush(Find_EOS, "=");
04032 }
04033 }
04034 else {
04035 reset_lex(buf_idx,stmt_num);
04036
04037 # if !defined(_TARGET_OS_MAX)
04038 parse_err_flush(Find_EOS, "SAFEVL = ");
04039 # endif
04040 }
04041 }
04042 else {
04043 ir_idx = gen_directive_ir(Ivdep_Cdir_Opr);
04044 }
04045 break;
04046
04047
04048 case Tok_Dir_List:
04049
04050 if ((cif_flags & MISC_RECS) != 0) {
04051 cif_directive_rec(CIF_List,
04052 TOKEN_LINE(token),
04053 TOKEN_COLUMN(token));
04054 }
04055 break;
04056
04057
04058 case Tok_Dir_Mark:
04059
04060 if (!opt_flags.mark) {
04061 parse_err_flush(Find_Comma, NULL);
04062 break;
04063 }
04064
04065 cdir_switches.mark = TRUE;
04066 ir_idx = gen_directive_ir(Mark_Cdir_Opr);
04067
04068 if (LA_CH_VALUE == EQUAL) {
04069 NEXT_LA_CH;
04070
04071 if (!MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
04072 parse_err_flush(Find_EOS, NULL);
04073 NEXT_LA_CH;
04074 }
04075 else {
04076 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX);
04077 TYP_CHAR_CLASS(TYP_WORK_IDX) = Const_Len_Char;
04078 TYP_TYPE(TYP_WORK_IDX) = Character;
04079 TYP_LINEAR(TYP_WORK_IDX) = CHARACTER_DEFAULT_TYPE;
04080 TYP_FLD(TYP_WORK_IDX) = CN_Tbl_Idx;
04081 TYP_IDX(TYP_WORK_IDX) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
04082 TOKEN_LEN(token));
04083 type_idx = ntr_type_tbl();
04084 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
04085 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
04086 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
04087 IR_IDX_L(ir_idx) = ntr_const_tbl(type_idx,
04088 FALSE,
04089 (long_type *) &(TOKEN_ID(token).words));
04090 }
04091 }
04092 else {
04093 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
04094 IR_IDX_L(ir_idx) = cdir_switches.mark_cmdline_idx;
04095 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
04096 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
04097 }
04098 break;
04099
04100 case Tok_Dir_Modinline:
04101 case Tok_Dir_Nomodinline:
04102
04103 if (!opt_flags.modinline) {
04104 parse_err_flush(Find_Comma, NULL);
04105 }
04106 else if (ATP_PGM_UNIT(SCP_ATTR_IDX(MAIN_SCP_IDX)) != Module) {
04107 PRINTMSG(TOKEN_LINE(token), 1169, Warning, TOKEN_COLUMN(token));
04108 }
04109 else {
04110 ATP_MAY_INLINE(SCP_ATTR_IDX(curr_scp_idx)) =
04111 TOKEN_VALUE(token) == Tok_Dir_Modinline;
04112 }
04113 break;
04114
04115
04116 case Tok_Dir_Name:
04117 parse_name_dir();
04118 goto EXIT;
04119
04120
04121 case Tok_Dir_Nextscalar:
04122
04123 if (!cdir_switches.vector) {
04124 parse_err_flush(Find_Comma, NULL);
04125 }
04126 else {
04127 ir_idx = gen_directive_ir(Nextscalar_Cdir_Opr);
04128 }
04129 break;
04130
04131
04132 case Tok_Dir_Nobl:
04133
04134 if (opt_flags.scalar_lvl == Scalar_Lvl_0 || !opt_flags.bottom_load) {
04135 parse_err_flush(Find_Comma, NULL);
04136 }
04137 else {
04138 cdir_switches.bl = FALSE;
04139 ir_idx = gen_directive_ir(Nobl_Cdir_Opr);
04140 }
04141 break;
04142
04143 case Tok_Dir_Noblocking:
04144 ir_idx = gen_directive_ir(Noblocking_Dir_Opr);
04145 break;
04146
04147 case Tok_Dir_Nobounds:
04148
04149 cdir_switches.bounds = FALSE;
04150 ir_idx = gen_directive_ir(Nobounds_Cdir_Opr);
04151
04152 if (LA_CH_VALUE != EOS) {
04153 parse_var_name_list(&opnd);
04154 COPY_OPND(IR_OPND_L(ir_idx), opnd);
04155
04156 if (LA_CH_VALUE != EOS) {
04157 parse_err_flush(Find_EOS, EOS_STR);
04158 }
04159 NEXT_LA_CH;
04160 }
04161 else {
04162 NEXT_LA_CH;
04163 }
04164
04165 goto EXIT;
04166
04167
04168 case Tok_Dir_Noflow:
04169 cdir_switches.flow = FALSE;
04170 break;
04171
04172
04173 case Tok_Dir_Noinline:
04174
04175 if (opt_flags.inline_lvl == Inline_Lvl_0 && !dump_flags.preinline) {
04176 parse_err_flush(Find_Comma, NULL);
04177 }
04178 else {
04179 cdir_switches.do_inline = FALSE;
04180 ir_idx = gen_directive_ir(Noinline_Cdir_Opr);
04181 }
04182 break;
04183
04184
04185 case Tok_Dir_Nointerchange:
04186
04187
04188
04189 ir_idx = gen_directive_ir(Nointerchange_Dir_Opr);
04190 break;
04191
04192
04193 case Tok_Dir_Nolist:
04194
04195 if ((cif_flags & MISC_RECS) != 0) {
04196 cif_directive_rec(CIF_Nolist,
04197 TOKEN_LINE(token),
04198 TOKEN_COLUMN(token));
04199 }
04200 break;
04201
04202
04203 case Tok_Dir_Nomark:
04204
04205 if (opt_flags.mark) {
04206 cdir_switches.mark = FALSE;
04207 ir_idx = gen_directive_ir(Nomark_Cdir_Opr);
04208 }
04209 else {
04210 parse_err_flush(Find_Comma, NULL);
04211 }
04212 break;
04213
04214
04215 case Tok_Dir_Nopattern:
04216
04217 if (!opt_flags.pattern) {
04218 parse_err_flush(Find_Comma, NULL);
04219 }
04220 else {
04221 cdir_switches.pattern = FALSE;
04222 ir_idx = gen_directive_ir(Nopattern_Cdir_Opr);
04223 }
04224 break;
04225
04226
04227 case Tok_Dir_Norecurrence:
04228
04229 if (!opt_flags.recurrence) {
04230 parse_err_flush(Find_Comma, NULL);
04231 }
04232 else {
04233 cdir_switches.recurrence = FALSE;
04234 ir_idx = gen_directive_ir(Norecurrence_Cdir_Opr);
04235 }
04236 break;
04237
04238
04239 case Tok_Dir_Nosideeffects:
04240 parse_nosideeffects_dir();
04241 goto EXIT;
04242
04243
04244 case Tok_Dir_Nosplit:
04245
04246 if (opt_flags.split_lvl == Split_Lvl_0) {
04247 parse_err_flush(Find_Comma, NULL);
04248 }
04249 else {
04250 ir_idx = gen_directive_ir(Nosplit_Cdir_Opr);
04251 }
04252 break;
04253
04254
04255 case Tok_Dir_Nostream:
04256
04257 if (opt_flags.stream_lvl == Stream_Lvl_0) {
04258 parse_err_flush(Find_Comma, NULL);
04259 }
04260 else {
04261 cdir_switches.stream = FALSE;
04262 ir_idx = gen_directive_ir(Nostream_Dir_Opr);
04263 }
04264 break;
04265
04266
04267 case Tok_Dir_Notask:
04268
04269 # if !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04270 if (opt_flags.task_lvl == Task_Lvl_0) {
04271 parse_err_flush(Find_Comma, NULL);
04272 break;
04273 }
04274 # endif
04275
04276 cdir_switches.task = FALSE;
04277 cdir_switches.notask_region = TRUE;
04278
04279
04280
04281 blk_idx = blk_stk_idx;
04282
04283 while (BLK_TYPE(blk_idx) >= Do_Blk && blk_idx > 0) {
04284
04285 if (BLK_TYPE(blk_idx) == Do_Blk) {
04286 ATL_NOTASK(BLK_TOP_LBL_IDX(blk_idx)) = TRUE;
04287 }
04288
04289 blk_idx--;
04290 }
04291
04292 ir_idx = gen_directive_ir(Notask_Cdir_Opr);
04293 break;
04294
04295
04296 case Tok_Dir_Nounroll:
04297
04298 if (opt_flags.unroll_lvl == Unroll_Lvl_0) {
04299 parse_err_flush(Find_Comma, NULL);
04300 }
04301 else {
04302 ir_idx = gen_directive_ir(Nounroll_Cdir_Opr);
04303 }
04304 break;
04305
04306
04307 case Tok_Dir_Novector:
04308
04309 if (opt_flags.vector_lvl == Vector_Lvl_0) {
04310 parse_err_flush(Find_Comma, NULL);
04311 break;
04312 }
04313
04314 cdir_switches.vector = FALSE;
04315
04316
04317
04318 blk_idx = blk_stk_idx;
04319
04320 while (BLK_TYPE(blk_idx) >= Do_Blk && blk_idx > 0) {
04321
04322 if (BLK_TYPE(blk_idx) == Do_Blk) {
04323 ATL_NOVECTOR(BLK_TOP_LBL_IDX(blk_idx)) = TRUE;
04324 }
04325
04326 blk_idx--;
04327 }
04328
04329 ir_idx = gen_directive_ir(Novector_Cdir_Opr);
04330 break;
04331
04332
04333 case Tok_Dir_Novsearch:
04334
04335 if (!opt_flags.vsearch || !cdir_switches.vector) {
04336 parse_err_flush(Find_Comma, NULL);
04337 }
04338 else {
04339 cdir_switches.vsearch = FALSE;
04340 ir_idx = gen_directive_ir(Novsearch_Cdir_Opr);
04341 }
04342 break;
04343
04344
04345 case Tok_Dir_Numcpus:
04346
04347
04348
04349 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04350 ir_idx = gen_directive_ir(Numcpus_Cmic_Opr);
04351
04352 if (LA_CH_VALUE != LPAREN) {
04353 PRINTMSG(LA_CH_LINE, 1124, Error, LA_CH_COLUMN);
04354 parse_err_flush(Find_EOS, NULL);
04355 }
04356 else {
04357 NEXT_LA_CH;
04358 parse_expr(&opnd);
04359 COPY_OPND(IR_OPND_L(ir_idx), opnd);
04360
04361 if (LA_CH_VALUE != RPAREN) {
04362 parse_err_flush(Find_EOS, ")");
04363 }
04364 else {
04365 NEXT_LA_CH;
04366 }
04367
04368 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04369
04370
04371 COPY_OPND(IR_OPND_R(ir_idx), IR_OPND_L(ir_idx));
04372
04373 if (glb_tbl_idx[Set_Numthreads_Attr_Idx] == NULL_IDX) {
04374 glb_tbl_idx[Set_Numthreads_Attr_Idx] = create_lib_entry_attr(
04375 SET_NUMTHREADS_ENTRY,
04376 SET_NUMTHREADS_NAME_LEN,
04377 IR_LINE_NUM(ir_idx),
04378 IR_COL_NUM(ir_idx));
04379 }
04380
04381 ADD_ATTR_TO_LOCAL_LIST(glb_tbl_idx[Set_Numthreads_Attr_Idx]);
04382
04383 IR_FLD_L(ir_idx) = AT_Tbl_Idx;
04384 IR_IDX_L(ir_idx) = glb_tbl_idx[Set_Numthreads_Attr_Idx];
04385 IR_LINE_NUM_L(ir_idx) = IR_LINE_NUM(ir_idx);
04386 IR_COL_NUM_L(ir_idx) = IR_COL_NUM(ir_idx);
04387
04388 NTR_IR_TBL(cvrt_idx);
04389 IR_OPR(cvrt_idx) = Cvrt_Opr;
04390 IR_TYPE_IDX(cvrt_idx) = Integer_4;
04391 IR_LINE_NUM(cvrt_idx) = IR_LINE_NUM(ir_idx);
04392 IR_COL_NUM(cvrt_idx) = IR_COL_NUM(ir_idx);
04393
04394 COPY_OPND(IR_OPND_L(cvrt_idx), IR_OPND_R(ir_idx));
04395
04396 NTR_IR_LIST_TBL(list_idx);
04397 IR_FLD_R(ir_idx) = IL_Tbl_Idx;
04398 IR_IDX_R(ir_idx) = list_idx;
04399 IR_LIST_CNT_R(ir_idx) = 1;
04400 IL_FLD(list_idx) = IR_Tbl_Idx;
04401 IL_IDX(list_idx) = cvrt_idx;
04402
04403 SH_STMT_TYPE(curr_stmt_sh_idx) = Call_Stmt;
04404 IR_OPR(ir_idx) = Call_Opr;
04405 # endif
04406 }
04407
04408 break;
04409
04410
04411 case Tok_Dir_Pattern:
04412
04413 if (!opt_flags.pattern) {
04414 parse_err_flush(Find_Comma, NULL);
04415 }
04416 else {
04417 cdir_switches.pattern = TRUE;
04418 ir_idx = gen_directive_ir(Pattern_Cdir_Opr);
04419 }
04420 break;
04421
04422 case Tok_Dir_Permutation:
04423
04424
04425
04426
04427 ir_idx = gen_directive_ir(Permutation_Cmic_Opr);
04428 parse_permutation_mic();
04429 break;
04430
04431
04432 case Tok_Dir_Preferstream:
04433
04434 if (!cdir_switches.stream) {
04435 parse_err_flush(Find_Comma, NULL);
04436 }
04437 else {
04438 cdir_switches.preferstream = TRUE;
04439 cdir_switches.preferstream_nocinv = FALSE;
04440 opr = Preferstream_Dir_Opr;
04441
04442 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
04443
04444 if (MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd) &&
04445 TOKEN_VALUE(token) == Tok_Dir_Nocinv) {
04446 cdir_switches.preferstream_nocinv = TRUE;
04447 opr = Preferstream_Nocinv_Dir_Opr;
04448 }
04449 else {
04450 parse_err_flush(Find_EOS, "NOCINV");
04451 }
04452 }
04453 ir_idx = gen_directive_ir(opr);
04454 }
04455 break;
04456
04457
04458 case Tok_Dir_Prefertask:
04459
04460 # if !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04461
04462 if (!cdir_switches.task) {
04463 parse_err_flush(Find_Comma, NULL);
04464 break;
04465 }
04466 # endif
04467
04468 cdir_switches.prefertask = TRUE;
04469 ir_idx = gen_directive_ir(Prefertask_Cdir_Opr);
04470
04471 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04472 IR_OPR(ir_idx) = Assert_Star_Opr;
04473 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
04474 IR_IDX_L(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
04475 ASSERT_DOPREFER);
04476 IR_LINE_NUM_L(ir_idx) = IR_LINE_NUM(ir_idx);
04477 IR_COL_NUM_L(ir_idx) = IR_COL_NUM(ir_idx);
04478
04479 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
04480 IR_IDX_R(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
04481 DOPREFER_CONCURRENT);
04482 IR_LINE_NUM_R(ir_idx) = IR_LINE_NUM(ir_idx);
04483 IR_COL_NUM_R(ir_idx) = IR_COL_NUM(ir_idx);
04484 # endif
04485 break;
04486
04487
04488 case Tok_Dir_Prefervector:
04489
04490 if (!cdir_switches.vector) {
04491 parse_err_flush(Find_Comma, NULL);
04492 }
04493 else {
04494 cdir_switches.prefervector = TRUE;
04495 ir_idx = gen_directive_ir(Prefervector_Cdir_Opr);
04496 }
04497 break;
04498
04499
04500 case Tok_Dir_Recurrence:
04501
04502 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
04503 buf_idx = LA_CH_BUF_IDX;
04504 stmt_num = LA_CH_STMT_NUM;
04505
04506 if (LA_CH_VALUE == '1') {
04507 NEXT_LA_CH;
04508
04509 if (LA_CH_VALUE == '2') {
04510 NEXT_LA_CH;
04511
04512 if (LA_CH_VALUE == '8') {
04513 NEXT_LA_CH;
04514
04515 if (LA_CH_VALUE == EOS) {
04516 PRINTMSG(TOKEN_LINE(token), 801, Warning,
04517 TOKEN_COLUMN(token));
04518 parse_err_flush(Find_EOS, NULL);
04519 break;
04520 }
04521 }
04522 }
04523 }
04524 reset_lex(buf_idx,stmt_num);
04525 }
04526
04527 if (!opt_flags.recurrence) {
04528 parse_err_flush(Find_Comma, NULL);
04529 }
04530 else {
04531 cdir_switches.recurrence = TRUE;
04532 ir_idx = gen_directive_ir(Recurrence_Cdir_Opr);
04533 }
04534 break;
04535
04536
04537 case Tok_Dir_Shortloop:
04538
04539 if (!cdir_switches.vector) {
04540 parse_err_flush(Find_Comma, NULL);
04541 break;
04542 }
04543
04544 ir_idx = gen_directive_ir(Shortloop_Cdir_Opr);
04545
04546 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
04547 buf_idx = LA_CH_BUF_IDX;
04548 stmt_num = LA_CH_STMT_NUM;
04549
04550 if (LA_CH_VALUE == '1') {
04551 NEXT_LA_CH;
04552
04553 if (LA_CH_VALUE == '2') {
04554 NEXT_LA_CH;
04555
04556 if (LA_CH_VALUE == '8') {
04557 NEXT_LA_CH;
04558
04559 if (LA_CH_VALUE == EOS) {
04560
04561 # if defined(_ACCEPT_DIR_SHORTLOOP128)
04562 IR_OPR(ir_idx) = Shortloop128_Cdir_Opr;
04563 cdir_switches.shortloop128 = TRUE;
04564 # else
04565 PRINTMSG(TOKEN_LINE(token), 801, Warning,
04566 TOKEN_COLUMN(token));
04567 # endif
04568 break;
04569 }
04570 }
04571 }
04572 }
04573 reset_lex(buf_idx,stmt_num);
04574 parse_err_flush(Find_EOS, "128 or "EOS_STR);
04575 }
04576 else {
04577 cdir_switches.shortloop = TRUE;
04578 }
04579 break;
04580
04581
04582 case Tok_Dir_Split:
04583
04584 if (opt_flags.split_lvl == Split_Lvl_0) {
04585 parse_err_flush(Find_Comma, NULL);
04586 }
04587 else {
04588 ir_idx = gen_directive_ir(Split_Cdir_Opr);
04589 }
04590 break;
04591
04592
04593 case Tok_Dir_Stack:
04594
04595 if (CURR_BLK == Interface_Body_Blk || CURR_BLK == Interface_Blk) {
04596
04597
04598
04599 PRINTMSG(TOKEN_LINE(token), 1404, Warning, TOKEN_COLUMN(token));
04600 parse_err_flush(Find_EOS, NULL);
04601 break;
04602 }
04603
04604 ATP_STACK_DIR(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04605
04606 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) == Module) {
04607
04608
04609
04610 PRINTMSG(TOKEN_LINE(token), 1405, Warning, TOKEN_COLUMN(token));
04611 }
04612
04613 if (ATP_SAVE_ALL(SCP_ATTR_IDX(curr_scp_idx))) {
04614
04615
04616
04617
04618 PRINTMSG(TOKEN_LINE(token), 1144, Warning, TOKEN_COLUMN(token),
04619 "STACK");
04620 ATP_STACK_DIR(SCP_ATTR_IDX(curr_scp_idx)) = FALSE;
04621 }
04622 break;
04623
04624
04625 case Tok_Dir_Stream:
04626
04627 if (opt_flags.stream_lvl > Stream_Lvl_0) {
04628 cdir_switches.stream = TRUE;
04629 ir_idx = gen_directive_ir(Stream_Dir_Opr);
04630 }
04631 break;
04632
04633
04634 case Tok_Dir_Suppress:
04635
04636 ir_idx = gen_directive_ir(Suppress_Opr);
04637 IR_LIST_CNT_L(ir_idx) = 0;
04638
04639 if (LA_CH_VALUE != EOS) {
04640 parse_dir_var_list();
04641 }
04642 else {
04643 NEXT_LA_CH;
04644 }
04645
04646 label_idx = gen_internal_lbl(stmt_start_line);
04647 IR_FLD_R(ir_idx) = AT_Tbl_Idx;
04648 IR_IDX_R(ir_idx) = label_idx;
04649 IR_LINE_NUM_R(ir_idx) = stmt_start_line;
04650 IR_COL_NUM_R(ir_idx) = stmt_start_col;
04651 AT_DEFINED(label_idx) = TRUE;
04652 ATL_DEF_STMT_IDX(label_idx) = curr_stmt_sh_idx;
04653 goto EXIT;
04654
04655
04656 case Tok_Dir_Symmetric:
04657
04658 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) == Module) {
04659
04660
04661
04662 PRINTMSG(TOKEN_LINE(token), 1233, Error, TOKEN_COLUMN(token),
04663 "SYMMETRIC");
04664 parse_err_flush(Find_EOS, NULL);
04665 break;
04666 }
04667
04668 if (LA_CH_VALUE == EOS) {
04669 ATP_SYMMETRIC(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04670 }
04671 else {
04672 parse_symmetric_dir();
04673 goto EXIT;
04674 }
04675 break;
04676
04677
04678 case Tok_Dir_System_Module:
04679
04680 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) != Module) {
04681 PRINTMSG(TOKEN_LINE(token), 1508, Error,
04682 TOKEN_COLUMN(token), "SYSTEM_MODULE");
04683 }
04684 else {
04685 ATP_SYSTEM_MODULE(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04686 SCP_IMPL_NONE(curr_scp_idx) = TRUE;
04687 }
04688 break;
04689
04690
04691 case Tok_Dir_Task:
04692
04693 # if !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04694 if (opt_flags.task_lvl == Task_Lvl_0) {
04695 parse_err_flush(Find_Comma, NULL);
04696 }
04697 else {
04698 cdir_switches.task = TRUE;
04699 ir_idx = gen_directive_ir(Task_Cdir_Opr);
04700 }
04701 # else
04702 cdir_switches.task = TRUE;
04703 cdir_switches.notask_region = FALSE;
04704 ir_idx = gen_directive_ir(Task_Cdir_Opr);
04705 # endif
04706 break;
04707
04708
04709 case Tok_Dir_Taskcommon:
04710 parse_common_dirs(Task_Common);
04711 goto EXIT;
04712
04713
04714 case Tok_Dir_Unroll:
04715
04716 if (opt_flags.unroll_lvl == Unroll_Lvl_0) {
04717 parse_err_flush(Find_Comma, NULL);
04718 break;
04719 }
04720
04721
04722
04723 ir_idx = gen_directive_ir(Unroll_Cdir_Opr);
04724 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
04725 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
04726 IR_FLD_L(ir_idx) = NO_Tbl_Idx;
04727 IR_IDX_L(ir_idx) = NULL_IDX;
04728
04729 if (LA_CH_VALUE != EOS) {
04730
04731 if (!parse_expr(&opnd)) {
04732 parse_err_flush(Find_EOS, NULL);
04733 }
04734 else {
04735 COPY_OPND(IR_OPND_L(ir_idx), opnd);
04736 }
04737 }
04738 break;
04739
04740
04741 case Tok_Dir_Uses_Eregs:
04742
04743 if (CURR_BLK == Interface_Body_Blk || CURR_BLK == Interface_Blk) {
04744
04745
04746
04747 PRINTMSG(TOKEN_LINE(token), 1404, Warning, TOKEN_COLUMN(token));
04748 parse_err_flush(Find_EOS, NULL);
04749 break;
04750 }
04751
04752 ATP_USES_EREGS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04753
04754 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) == Module) {
04755
04756
04757
04758 PRINTMSG(TOKEN_LINE(token), 1405, Warning, TOKEN_COLUMN(token));
04759 }
04760 break;
04761
04762
04763 case Tok_Dir_Vector:
04764
04765 if (opt_flags.vector_lvl == Vector_Lvl_0) {
04766 parse_err_flush(Find_Comma, NULL);
04767 }
04768 else {
04769 cdir_switches.vector = TRUE;
04770 ir_idx = gen_directive_ir(Vector_Cdir_Opr);
04771 }
04772 break;
04773
04774
04775 case Tok_Dir_Vfunction:
04776 parse_vfunction_dir();
04777 goto EXIT;
04778
04779
04780 case Tok_Dir_Vsearch:
04781
04782 if (!opt_flags.vsearch || !cdir_switches.vector) {
04783 parse_err_flush(Find_Comma, NULL);
04784 }
04785 else {
04786 cdir_switches.vsearch = TRUE;
04787 ir_idx = gen_directive_ir(Vsearch_Cdir_Opr);
04788 }
04789 break;
04790
04791
04792
04793 case Tok_Dir_Doshared:
04794 case Tok_Dir_Endmaster:
04795 case Tok_Dir_Geometry:
04796 case Tok_Dir_Parallel_Only:
04797 case Tok_Dir_Pe_Resident:
04798 case Tok_Dir_Pe_Private:
04799 case Tok_Dir_Serial_Only:
04800 case Tok_Dir_Shared:
04801 case Tok_Dir_Unknown:
04802 case Tok_Dir_Unknown_Shared:
04803 parse_err_flush(Find_EOS, NULL);
04804
04805
04806
04807 case Tok_Dir_Atomicupdate:
04808 case Tok_Dir_Barrier:
04809 case Tok_Dir_Critical:
04810 case Tok_Dir_Endcritical:
04811 case Tok_Dir_Master:
04812 case Tok_Dir_Nobarrier:
04813
04814 if (!cmd_line_flags.disregard_all_mpp_cdirs) {
04815 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
04816 parse_err_flush(Find_EOS, NULL);
04817 }
04818
04819 break;
04820
04821 # ifdef _DEBUG
04822
04823 case Tok_Dbg_Sytb:
04824 SCP_DBG_PRINT_SYTB(curr_scp_idx) = TRUE;
04825 break;
04826
04827 case Tok_Dbg_Stmt:
04828 SCP_DBG_PRINT_STMT(curr_scp_idx) = TRUE;
04829 break;
04830 # endif
04831
04832 default:
04833
04834
04835 break;
04836
04837 }
04838
04839 CONTINUE:
04840
04841 if (LA_CH_VALUE == COMMA) {
04842 NEXT_LA_CH;
04843
04844 if (!MATCHED_TOKEN_CLASS(Tok_Class_Dir_Kwd)) {
04845 PRINTMSG(TOKEN_LINE(token), 1356, Warning, TOKEN_COLUMN(token));
04846 parse_err_flush(Find_EOS, NULL);
04847 NEXT_LA_CH;
04848 break;
04849 }
04850 }
04851 else {
04852 break;
04853 }
04854 }
04855
04856
04857
04858 if (LA_CH_VALUE != EOS) {
04859 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
04860 parse_err_flush(Find_EOS, NULL);
04861 }
04862
04863 NEXT_LA_CH;
04864
04865 EXIT:
04866
04867 TRACE (Func_Exit, "parse_dir_directives", NULL);
04868
04869 return;
04870
04871 }
04872
04873
04874
04875
04876
04877
04878
04879
04880
04881
04882
04883
04884
04885
04886
04887
04888 static void parse_mic_directives(void)
04889
04890 {
04891 int ir_idx;
04892 boolean ok = TRUE;
04893 opnd_type opnd;
04894
04895 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
04896 int cvrt_idx;
04897 int list_idx;
04898 # endif
04899
04900 # if (_ACCEPT_MIC_SEND)
04901 int blk_idx;
04902 int column;
04903 int do_blk_idx;
04904 boolean found_do;
04905 int line;
04906 opnd_type point_opnd;
04907 # endif
04908
04909
04910 TRACE (Func_Entry, "parse_mic_directives", NULL);
04911
04912 for (;;) {
04913
04914 if (TOKEN_VALUE(token) > Tok_Mic_Start &&
04915 TOKEN_VALUE(token) < Tok_Mic_End &&
04916 disregard_mics[TOKEN_VALUE(token) - Tok_Mic_Start]) {
04917
04918 switch (TOKEN_VALUE(token)) {
04919
04920 case Tok_Mic_Cncall:
04921 case Tok_Mic_Guard:
04922 case Tok_Mic_End_Guard:
04923 case Tok_Mic_Numcpus:
04924 case Tok_Mic_Permutation:
04925 case Tok_Mic_Send:
04926 case Tok_Mic_Wait:
04927 parse_err_flush(Find_EOS, NULL);
04928 break;
04929
04930 default:
04931 parse_err_flush(Find_Comma, NULL);
04932 }
04933
04934 goto CONTINUE;
04935 }
04936
04937 switch (TOKEN_VALUE(token)) {
04938
04939 case Tok_Mic_Case:
04940
04941 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04942 ir_idx = gen_directive_ir(Case_Cmic_Opr);
04943
04944 if (! cdir_switches.parallel_region) {
04945
04946 PRINTMSG(IR_LINE_NUM(ir_idx), 785, Error, IR_COL_NUM(ir_idx),
04947 "CASE");
04948 }
04949 else {
04950
04951 if (remove_do_parallel_blk(TRUE, "CASE", IR_LINE_NUM(ir_idx),
04952 IR_COL_NUM(ir_idx))) {
04953 }
04954
04955 SH_STMT_TYPE(curr_stmt_sh_idx) = Parallel_Case_Stmt;
04956 stmt_type = Parallel_Case_Stmt;
04957
04958 if (cdir_switches.casedir) {
04959 end_parallel_case_blk(FALSE);
04960 }
04961
04962 SET_DIRECTIVE_STATE(Case_Region);
04963 cdir_switches.casedir = TRUE;
04964
04965 PUSH_BLK_STK (Parallel_Case_Blk);
04966 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
04967
04968 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
04969 LINK_TO_PARENT_BLK;
04970 }
04971
04972 break;
04973
04974
04975 case Tok_Mic_End_Case:
04976
04977 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
04978 ir_idx = gen_directive_ir(Endcase_Cmic_Opr);
04979
04980 if (! cdir_switches.parallel_region) {
04981
04982 PRINTMSG(IR_LINE_NUM(ir_idx), 785, Error, IR_COL_NUM(ir_idx),
04983 "END CASE");
04984 }
04985 else {
04986
04987 cdir_switches.casedir = FALSE;
04988 SH_STMT_TYPE(curr_stmt_sh_idx) = End_Parallel_Case_Stmt;
04989 stmt_type = End_Parallel_Case_Stmt;
04990
04991 end_parallel_case_blk(FALSE);
04992 }
04993
04994 CLEAR_DIRECTIVE_STATE(Case_Region);
04995 break;
04996
04997
04998 case Tok_Mic_Cncall:
04999
05000
05001
05002 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05003 ir_idx = gen_directive_ir(Cncall_Cmic_Opr);
05004
05005 if (LA_CH_VALUE != EOS && LA_CH_VALUE != COMMA) {
05006
05007
05008
05009
05010
05011 PRINTMSG(LA_CH_LINE, 1123, Caution, LA_CH_COLUMN);
05012 parse_err_flush(Find_EOS, NULL);
05013 }
05014
05015 break;
05016
05017
05018 case Tok_Mic_Do_All:
05019
05020 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05021 ir_idx = gen_directive_ir(Doall_Cmic_Opr);
05022
05023 parse_doall_cmic();
05024
05025 if (cdir_switches.parallel_region ||
05026 cdir_switches.guard_in_par_reg) {
05027
05028 PRINTMSG(IR_LINE_NUM(ir_idx), 814, Error, IR_COL_NUM(ir_idx));
05029 }
05030 else {
05031 SET_DIRECTIVE_STATE(Doall_Region);
05032 cdir_switches.doall_sh_idx = curr_stmt_sh_idx;
05033 }
05034
05035 break;
05036
05037
05038 case Tok_Mic_Do_Parallel:
05039
05040 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05041 ir_idx = gen_directive_ir(Doparallel_Cmic_Opr);
05042
05043 parse_doparallel_cmic();
05044
05045 if (! cdir_switches.parallel_region) {
05046
05047 PRINTMSG(IR_LINE_NUM(ir_idx), 785, Error, IR_COL_NUM(ir_idx),
05048 "DO PARALLEL");
05049 }
05050 else if (cdir_switches.casedir) {
05051
05052 PRINTMSG(IR_LINE_NUM(ir_idx), 1312, Error, IR_COL_NUM(ir_idx));
05053 }
05054 else if (remove_do_parallel_blk(TRUE, "DO PARALLEL",
05055 IR_LINE_NUM(ir_idx), IR_COL_NUM(ir_idx))) {
05056
05057 }
05058 else {
05059 SET_DIRECTIVE_STATE(Do_Parallel_Region);
05060 cdir_switches.do_parallel = TRUE;
05061 cdir_switches.dopar_sh_idx = curr_stmt_sh_idx;
05062 }
05063
05064 break;
05065
05066
05067 case Tok_Mic_End_Do:
05068
05069 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05070 ir_idx = gen_directive_ir(Enddo_Cmic_Opr);
05071
05072 if (! cdir_switches.parallel_region) {
05073
05074 PRINTMSG(IR_LINE_NUM(ir_idx), 785, Error, IR_COL_NUM(ir_idx),
05075 "END DO");
05076 }
05077 else {
05078
05079 CLEAR_DIRECTIVE_STATE(Do_Parallel_Region);
05080 cdir_switches.do_parallel = FALSE;
05081 SH_STMT_TYPE(curr_stmt_sh_idx) = End_Do_Parallel_Stmt;
05082 stmt_type = End_Do_Parallel_Stmt;
05083
05084 end_do_parallel_blk(FALSE);
05085 }
05086
05087 break;
05088
05089
05090 case Tok_Mic_Guard:
05091
05092 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05093 ir_idx = gen_directive_ir(Guard_Cmic_Opr);
05094
05095 if (LA_CH_VALUE != EOS) {
05096 ok = parse_expr(&opnd);
05097 COPY_OPND(IR_OPND_L(ir_idx), opnd);
05098 cdir_switches.guard_has_flag = TRUE;
05099
05100 if (LA_CH_VALUE != EOS) {
05101 parse_err_flush(Find_EOS,EOS_STR);
05102 }
05103 }
05104 else {
05105 cdir_switches.guard_has_flag = FALSE;
05106 }
05107
05108 if (cdir_switches.guard) {
05109
05110 PRINTMSG(IR_LINE_NUM(ir_idx), 815, Error, IR_COL_NUM(ir_idx));
05111 }
05112 else {
05113
05114 SET_DIRECTIVE_STATE(Guard_Region);
05115 cdir_switches.guard = TRUE;
05116 cdir_switches.guard_in_par_reg = cdir_switches.parallel_region;
05117 cdir_switches.parallel_region = FALSE;
05118
05119 PUSH_BLK_STK (Guard_Blk);
05120 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05121
05122 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05123 LINK_TO_PARENT_BLK;
05124 }
05125
05126 break;
05127
05128
05129 case Tok_Mic_End_Guard:
05130
05131 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05132 ir_idx = gen_directive_ir(Endguard_Cmic_Opr);
05133
05134 ok = TRUE;
05135
05136 if (LA_CH_VALUE != EOS) {
05137 ok = parse_expr(&opnd);
05138 COPY_OPND(IR_OPND_L(ir_idx), opnd);
05139
05140 if (! cdir_switches.guard_has_flag) {
05141
05142 PRINTMSG(IR_LINE_NUM(ir_idx), 816, Error, IR_COL_NUM(ir_idx));
05143 ok = FALSE;
05144 }
05145
05146 if (LA_CH_VALUE != EOS) {
05147 parse_err_flush(Find_EOS,EOS_STR);
05148 }
05149 }
05150 else if (cdir_switches.guard_has_flag) {
05151
05152 PRINTMSG(IR_LINE_NUM(ir_idx), 816, Error, IR_COL_NUM(ir_idx));
05153 ok = FALSE;
05154 }
05155
05156 CLEAR_DIRECTIVE_STATE(Guard_Region);
05157
05158 if (ok) {
05159
05160 cdir_switches.guard = FALSE;
05161 cdir_switches.parallel_region = cdir_switches.guard_in_par_reg;
05162 cdir_switches.guard_in_par_reg = FALSE;
05163
05164 SH_STMT_TYPE(curr_stmt_sh_idx) = End_Guard_Stmt;
05165 stmt_type = End_Guard_Stmt;
05166
05167 end_guard_blk(FALSE);
05168 }
05169
05170 break;
05171
05172 case Tok_Mic_Numcpus:
05173
05174
05175
05176 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05177 ir_idx = gen_directive_ir(Numcpus_Cmic_Opr);
05178
05179 if (LA_CH_VALUE != LPAREN) {
05180 PRINTMSG(LA_CH_LINE, 1124, Error, LA_CH_COLUMN);
05181 parse_err_flush(Find_EOS, NULL);
05182 }
05183 else {
05184 NEXT_LA_CH;
05185 ok = parse_expr(&opnd);
05186 COPY_OPND(IR_OPND_L(ir_idx), opnd);
05187
05188 if (LA_CH_VALUE != RPAREN) {
05189 parse_err_flush(Find_EOS, ")");
05190 }
05191 else {
05192 NEXT_LA_CH;
05193 }
05194
05195 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
05196
05197
05198 COPY_OPND(IR_OPND_R(ir_idx), IR_OPND_L(ir_idx));
05199
05200 if (glb_tbl_idx[Set_Numthreads_Attr_Idx] == NULL_IDX) {
05201 glb_tbl_idx[Set_Numthreads_Attr_Idx] = create_lib_entry_attr(
05202 SET_NUMTHREADS_ENTRY,
05203 SET_NUMTHREADS_NAME_LEN,
05204 IR_LINE_NUM(ir_idx),
05205 IR_COL_NUM(ir_idx));
05206 }
05207
05208 ADD_ATTR_TO_LOCAL_LIST(glb_tbl_idx[Set_Numthreads_Attr_Idx]);
05209
05210 IR_FLD_L(ir_idx) = AT_Tbl_Idx;
05211 IR_IDX_L(ir_idx) = glb_tbl_idx[Set_Numthreads_Attr_Idx];
05212 IR_LINE_NUM_L(ir_idx) = IR_LINE_NUM(ir_idx);
05213 IR_COL_NUM_L(ir_idx) = IR_COL_NUM(ir_idx);
05214
05215 NTR_IR_TBL(cvrt_idx);
05216 IR_OPR(cvrt_idx) = Cvrt_Opr;
05217 IR_TYPE_IDX(cvrt_idx) = Integer_4;
05218 IR_LINE_NUM(cvrt_idx) = IR_LINE_NUM(ir_idx);
05219 IR_COL_NUM(cvrt_idx) = IR_COL_NUM(ir_idx);
05220
05221 COPY_OPND(IR_OPND_L(cvrt_idx), IR_OPND_R(ir_idx));
05222
05223 NTR_IR_LIST_TBL(list_idx);
05224 IR_FLD_R(ir_idx) = IL_Tbl_Idx;
05225 IR_IDX_R(ir_idx) = list_idx;
05226 IR_LIST_CNT_R(ir_idx) = 1;
05227 IL_FLD(list_idx) = IR_Tbl_Idx;
05228 IL_IDX(list_idx) = cvrt_idx;
05229
05230 SH_STMT_TYPE(curr_stmt_sh_idx) = Call_Stmt;
05231 IR_OPR(ir_idx) = Call_Opr;
05232 # endif
05233 }
05234
05235 break;
05236
05237
05238 case Tok_Mic_Parallel:
05239
05240 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05241 ir_idx = gen_directive_ir(Parallel_Cmic_Opr);
05242
05243 parse_parallel_cmic();
05244
05245 if (cdir_switches.parallel_region ||
05246 cdir_switches.guard_in_par_reg) {
05247
05248 PRINTMSG(IR_LINE_NUM(ir_idx), 818, Error, IR_COL_NUM(ir_idx));
05249 }
05250 else {
05251 SET_DIRECTIVE_STATE(Parallel_Region);
05252 cdir_switches.parallel_region = TRUE;
05253 PUSH_BLK_STK (Parallel_Blk);
05254 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05255 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05256 LINK_TO_PARENT_BLK;
05257 }
05258
05259 break;
05260
05261
05262 case Tok_Mic_End_Parallel:
05263
05264 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05265 ir_idx = gen_directive_ir(Endparallel_Cmic_Opr);
05266
05267 CLEAR_DIRECTIVE_STATE(Parallel_Region);
05268 cdir_switches.parallel_region = FALSE;
05269 cdir_switches.do_parallel = FALSE;
05270 cdir_switches.guard_in_par_reg = FALSE;
05271
05272 SH_STMT_TYPE(curr_stmt_sh_idx) = End_Parallel_Stmt;
05273 stmt_type = End_Parallel_Stmt;
05274 end_parallel_blk(FALSE);
05275
05276 break;
05277
05278
05279 case Tok_Mic_Permutation:
05280
05281
05282
05283 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05284 ir_idx = gen_directive_ir(Permutation_Cmic_Opr);
05285 parse_permutation_mic();
05286 break;
05287
05288 case Tok_Mic_Wait:
05289
05290 # if defined(_ACCEPT_MIC_WAIT)
05291
05292 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05293
05294 line = TOKEN_LINE(token);
05295 column = TOKEN_COLUMN(token);
05296 ir_idx = gen_directive_ir(Wait_Cmic_Opr);
05297 OPND_LINE_NUM(opnd) = LA_CH_LINE;
05298 OPND_COL_NUM(opnd) = LA_CH_COLUMN;
05299 OPND_FLD(opnd) = CN_Tbl_Idx;
05300 OPND_IDX(opnd) = CN_INTEGER_ONE_IDX;
05301 OPND_LINE_NUM(point_opnd) = LA_CH_LINE;
05302 OPND_COL_NUM(point_opnd) = LA_CH_COLUMN;
05303 point_opnd = null_opnd;
05304
05305 if (LA_CH_VALUE == EOS) {
05306
05307
05308 }
05309 else if (MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd)) {
05310
05311 if (TOKEN_VALUE(token) == Tok_Mic_Point) {
05312
05313 if (LA_CH_VALUE == LPAREN) {
05314 NEXT_LA_CH;
05315 ok = parse_expr(&point_opnd);
05316
05317 if (LA_CH_VALUE != RPAREN) {
05318 parse_err_flush(Find_EOS, ")");
05319 }
05320 else {
05321 NEXT_LA_CH;
05322 }
05323
05324 if (LA_CH_VALUE != EOS) {
05325
05326 if (!MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd) ||
05327 TOKEN_VALUE(token) != Tok_Mic_Span) {
05328 parse_err_flush(Find_EOS, "SPAN or EOS");
05329 }
05330 else if (LA_CH_VALUE == LPAREN) {
05331 NEXT_LA_CH;
05332 ok = parse_expr(&opnd);
05333
05334 if (LA_CH_VALUE != RPAREN) {
05335 parse_err_flush(Find_EOS, ")");
05336 }
05337 else {
05338 NEXT_LA_CH;
05339 }
05340
05341 if (LA_CH_VALUE != EOS) {
05342 parse_err_flush(Find_EOS, "EOS");
05343 }
05344 }
05345 else {
05346 parse_err_flush(Find_EOS, "(");
05347 }
05348 }
05349 }
05350 else {
05351 parse_err_flush(Find_EOS, "(");
05352 }
05353 }
05354 else if (TOKEN_VALUE(token) == Tok_Mic_Span) {
05355
05356 if (LA_CH_VALUE == LPAREN) {
05357 NEXT_LA_CH;
05358 ok = parse_expr(&opnd);
05359
05360 if (LA_CH_VALUE != RPAREN) {
05361 parse_err_flush(Find_EOS, ")");
05362 }
05363 else {
05364 NEXT_LA_CH;
05365 }
05366
05367 if (LA_CH_VALUE != EOS) {
05368 parse_err_flush(Find_EOS, "EOS");
05369 }
05370 }
05371 else {
05372 parse_err_flush(Find_EOS, "(");
05373 }
05374 }
05375 else {
05376 parse_err_flush(Find_EOS, "POINT, SPAN or EOS");
05377 }
05378 }
05379 else {
05380 parse_err_flush(Find_EOS, "POINT, SPAN or EOS");
05381 }
05382
05383 COPY_OPND(IR_OPND_L(ir_idx), point_opnd);
05384 COPY_OPND(IR_OPND_R(ir_idx), opnd);
05385
05386
05387
05388
05389 blk_idx = blk_stk_idx;
05390 do_blk_idx = NULL_IDX;
05391 found_do = FALSE;
05392
05393 while (blk_idx > 0) {
05394
05395 if (BLK_TYPE(blk_idx) == Do_Parallel_Blk ||
05396 BLK_TYPE(blk_idx) == Doall_Blk) {
05397 do_blk_idx = blk_idx;
05398 break;
05399 }
05400
05401 if (BLK_TYPE(blk_idx) == Do_Blk) {
05402 found_do = TRUE;
05403 }
05404
05405 if (BLK_TYPE(blk_idx) == Case_Blk ||
05406 BLK_TYPE(blk_idx) == Guard_Blk) {
05407
05408
05409
05410
05411 PRINTMSG(line, 1519, Error, column,
05412 (BLK_TYPE(blk_idx) == Case_Blk) ? "CASE" : "GUARD");
05413 }
05414 blk_idx--;
05415 }
05416
05417 if (do_blk_idx == NULL_IDX) {
05418
05419
05420
05421 PRINTMSG(line, 1520, Error, column, "WAIT");
05422 }
05423
05424 if (!found_do) {
05425 PRINTMSG(line, 1385, Error, column, "WAIT");
05426 }
05427
05428 # else
05429 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
05430 parse_err_flush(Find_EOS, NULL);
05431 # endif
05432
05433 break;
05434
05435 case Tok_Mic_Send:
05436
05437 # if (_ACCEPT_MIC_SEND)
05438
05439 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05440
05441 line = TOKEN_LINE(token);
05442 column = TOKEN_COLUMN(token);
05443
05444 ir_idx = gen_directive_ir(Send_Cmic_Opr);
05445 OPND_LINE_NUM(opnd) = LA_CH_LINE;
05446 OPND_COL_NUM(opnd) = LA_CH_COLUMN;
05447 opnd = null_opnd;
05448 OPND_LINE_NUM(point_opnd) = LA_CH_LINE;
05449 OPND_COL_NUM(point_opnd) = LA_CH_COLUMN;
05450 point_opnd = null_opnd;
05451
05452 if (LA_CH_VALUE == EOS) {
05453
05454
05455 }
05456 else if (MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd)) {
05457
05458 if (TOKEN_VALUE(token) == Tok_Mic_Point) {
05459
05460 if (LA_CH_VALUE == LPAREN) {
05461 NEXT_LA_CH;
05462 ok = parse_expr(&point_opnd);
05463
05464 if (LA_CH_VALUE != RPAREN) {
05465 parse_err_flush(Find_EOS, ")");
05466 }
05467 else {
05468 NEXT_LA_CH;
05469 }
05470
05471 if (LA_CH_VALUE != EOS) {
05472
05473 if (!MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd) ||
05474 TOKEN_VALUE(token) != Tok_Mic_If) {
05475 reset_lex(TOKEN_BUF_IDX(token), TOKEN_STMT_NUM(token));
05476 parse_err_flush(Find_EOS, "IF or EOS");
05477 }
05478 else if (LA_CH_VALUE == LPAREN) {
05479 NEXT_LA_CH;
05480 ok = parse_expr(&opnd);
05481
05482 if (LA_CH_VALUE != RPAREN) {
05483 parse_err_flush(Find_EOS, ")");
05484 }
05485 else {
05486 NEXT_LA_CH;
05487 }
05488
05489 if (LA_CH_VALUE != EOS) {
05490 parse_err_flush(Find_EOS, "EOS");
05491 }
05492 }
05493 else {
05494 parse_err_flush(Find_EOS, "(");
05495 }
05496 }
05497 }
05498 else {
05499 parse_err_flush(Find_EOS, "(");
05500 }
05501 }
05502 else if (TOKEN_VALUE(token) == Tok_Mic_If) {
05503
05504 if (LA_CH_VALUE == LPAREN) {
05505 NEXT_LA_CH;
05506 ok = parse_expr(&opnd);
05507
05508 if (LA_CH_VALUE != RPAREN) {
05509 parse_err_flush(Find_EOS, ")");
05510 }
05511 else {
05512 NEXT_LA_CH;
05513 }
05514
05515 if (LA_CH_VALUE != EOS) {
05516 parse_err_flush(Find_EOS, "EOS");
05517 }
05518 }
05519 else {
05520 parse_err_flush(Find_EOS, "(");
05521 }
05522 }
05523 else {
05524 parse_err_flush(Find_EOS, "POINT, IF or EOS");
05525 }
05526 }
05527 else {
05528 parse_err_flush(Find_EOS, "POINT, IF or EOS");
05529 }
05530
05531 COPY_OPND(IR_OPND_L(ir_idx), point_opnd);
05532 COPY_OPND(IR_OPND_R(ir_idx), opnd);
05533
05534
05535
05536
05537
05538
05539 blk_idx = blk_stk_idx;
05540 do_blk_idx = NULL_IDX;
05541 found_do = FALSE;
05542
05543 while (blk_idx > 0) {
05544
05545 if (BLK_TYPE(blk_idx) == Do_Parallel_Blk ||
05546 BLK_TYPE(blk_idx) == Doall_Blk) {
05547 do_blk_idx = blk_idx;
05548 break;
05549 }
05550
05551 if (BLK_TYPE(blk_idx) == Do_Blk) {
05552 found_do = TRUE;
05553 }
05554 blk_idx--;
05555 }
05556
05557 if (do_blk_idx == NULL_IDX) {
05558
05559
05560
05561 PRINTMSG(line, 1520, Error, column, "SEND");
05562 }
05563
05564 if (!found_do) {
05565 PRINTMSG(line, 1385, Error, column, "SEND");
05566 }
05567
05568
05569 # else
05570 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
05571 parse_err_flush(Find_EOS, NULL);
05572 # endif
05573
05574 break;
05575
05576
05577 case Tok_Mic_Continue:
05578 case Tok_Mic_Taskcommon:
05579
05580 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
05581 parse_err_flush(Find_EOS, NULL);
05582 break;
05583
05584 default:
05585 PRINTMSG(TOKEN_LINE(token), 790, Warning, TOKEN_COLUMN(token));
05586 parse_err_flush(Find_EOS, NULL);
05587
05588 }
05589
05590 CONTINUE:
05591
05592 if (LA_CH_VALUE == COMMA) {
05593 NEXT_LA_CH;
05594
05595 if (!MATCHED_TOKEN_CLASS(Tok_Class_Mic_Kwd)) {
05596 parse_err_flush(Find_EOS, NULL);
05597 NEXT_LA_CH;
05598 break;
05599 }
05600 }
05601 else {
05602 break;
05603 }
05604 }
05605
05606
05607
05608 if (LA_CH_VALUE != EOS) {
05609 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
05610 parse_err_flush(Find_EOS, NULL);
05611 }
05612
05613 NEXT_LA_CH;
05614
05615 TRACE (Func_Exit, "parse_mic_directives", NULL);
05616
05617 return;
05618
05619 }
05620
05621
05622
05623
05624
05625
05626
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636 static void parse_par_directives(void)
05637 {
05638 int ir_idx;
05639 opnd_type opnd;
05640 boolean paren = FALSE;
05641 int sh_idx;
05642
05643 TRACE (Func_Entry, "parse_par_directives", NULL);
05644
05645 if (TOKEN_VALUE(token) > Tok_SGI_Dir_Start &&
05646 TOKEN_VALUE(token) < Tok_SGI_Dir_End &&
05647 disregard_mips[TOKEN_VALUE(token) - Tok_SGI_Dir_Start]) {
05648 goto EXIT;
05649 }
05650
05651 switch (TOKEN_VALUE(token)) {
05652
05653 case Tok_SGI_Dir_Parallel:
05654 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05655 ir_idx = gen_directive_ir(Parallel_Par_Opr);
05656
05657 parse_mp_directive(Parallel);
05658
05659 if (directive_region_error(Sgi_Parallel_Dir,
05660 IR_LINE_NUM(ir_idx),
05661 IR_COL_NUM(ir_idx))) {
05662 }
05663 else {
05664 SET_DIRECTIVE_STATE(Sgi_Parallel_Region);
05665 PUSH_BLK_STK (SGI_Parallel_Blk);
05666 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05667 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05668 LINK_TO_PARENT_BLK;
05669 }
05670
05671 break;
05672
05673 case Tok_SGI_Dir_Paralleldo:
05674 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05675 ir_idx = gen_directive_ir(Parallel_Do_Par_Opr);
05676
05677 parse_mp_directive(Parallel_Do);
05678
05679 if (directive_region_error(Parallel_Do_Dir,
05680 IR_LINE_NUM(ir_idx),
05681 IR_COL_NUM(ir_idx))) {
05682 }
05683 else {
05684 SET_DIRECTIVE_STATE(Parallel_Do_Region);
05685 cdir_switches.paralleldo_sh_idx = curr_stmt_sh_idx;
05686 }
05687
05688 break;
05689
05690 case Tok_SGI_Dir_Pdo:
05691 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05692 ir_idx = gen_directive_ir(Pdo_Par_Opr);
05693
05694 parse_mp_directive(Pdo);
05695
05696 if (directive_region_error(Pdo_Dir,
05697 IR_LINE_NUM(ir_idx),
05698 IR_COL_NUM(ir_idx))) {
05699 }
05700 else {
05701 SET_DIRECTIVE_STATE(Pdo_Region);
05702 cdir_switches.pdo_sh_idx = curr_stmt_sh_idx;
05703 }
05704
05705 break;
05706
05707 case Tok_SGI_Dir_Barrier:
05708
05709 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05710 ir_idx = gen_directive_ir(Barrier_Par_Opr);
05711
05712 if (directive_region_error(Barrier_Dir,
05713 IR_LINE_NUM(ir_idx),
05714 IR_COL_NUM(ir_idx))) {
05715 }
05716
05717 break;
05718
05719
05720 case Tok_SGI_Dir_Criticalsection:
05721 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05722 ir_idx = gen_directive_ir(Critical_Section_Par_Opr);
05723
05724 if (LA_CH_VALUE != EOS) {
05725
05726 if (LA_CH_VALUE == LPAREN) {
05727 paren = TRUE;
05728 NEXT_LA_CH;
05729 }
05730
05731 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
05732
05733 if (! parse_deref(&opnd, NULL_IDX)) {
05734 parse_err_flush(Find_Rparen, NULL);
05735 }
05736 else {
05737 COPY_OPND(IR_OPND_L(ir_idx), opnd);
05738 }
05739 }
05740 else {
05741 parse_err_flush(Find_Rparen, "IDENTIFIER");
05742 }
05743
05744 if (paren) {
05745 if (LA_CH_VALUE == RPAREN) {
05746 NEXT_LA_CH;
05747 }
05748 else {
05749 parse_err_flush(Find_EOS, ")");
05750 }
05751 }
05752 }
05753
05754 if (directive_region_error(Critical_Section_Dir,
05755 IR_LINE_NUM(ir_idx),
05756 IR_COL_NUM(ir_idx))) {
05757 }
05758
05759 SET_DIRECTIVE_STATE(Critical_Section_Region);
05760 PUSH_BLK_STK (SGI_Critical_Section_Blk);
05761 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05762 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05763 LINK_TO_PARENT_BLK;
05764 break;
05765
05766 case Tok_SGI_Dir_Endcriticalsection:
05767 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05768 ir_idx = gen_directive_ir(End_Critical_Section_Par_Opr);
05769
05770 if (directive_region_error(End_Critical_Section_Dir,
05771 IR_LINE_NUM(ir_idx),
05772 IR_COL_NUM(ir_idx))) {
05773 }
05774
05775 CLEAR_DIRECTIVE_STATE(Critical_Section_Region);
05776 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_End_Critical_Section_Stmt;
05777 stmt_type = SGI_End_Critical_Section_Stmt;
05778 end_critical_section_blk(FALSE);
05779 break;
05780
05781 case Tok_SGI_Dir_Singleprocess:
05782 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05783 ir_idx = gen_directive_ir(Singleprocess_Par_Opr);
05784
05785 parse_mp_directive(Singleprocess);
05786
05787 if (directive_region_error(Single_Process_Dir,
05788 IR_LINE_NUM(ir_idx),
05789 IR_COL_NUM(ir_idx))) {
05790 }
05791
05792 SET_DIRECTIVE_STATE(Single_Process_Region);
05793 PUSH_BLK_STK (SGI_Single_Process_Blk);
05794 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05795 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05796 LINK_TO_PARENT_BLK;
05797 break;
05798
05799 case Tok_SGI_Dir_Endsingleprocess:
05800 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05801 ir_idx = gen_directive_ir(End_Singleprocess_Par_Opr);
05802
05803 if (directive_region_error(End_Single_Process_Dir,
05804 IR_LINE_NUM(ir_idx),
05805 IR_COL_NUM(ir_idx))) {
05806 }
05807
05808 CLEAR_DIRECTIVE_STATE(Single_Process_Region);
05809 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
05810 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
05811 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
05812
05813 if (LA_CH_VALUE != EOS) {
05814 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
05815 TOKEN_VALUE(token) == Tok_SGI_Dir_Nowait) {
05816
05817 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
05818 }
05819 else {
05820 parse_err_flush(Find_EOS, EOS_STR);
05821 }
05822 }
05823 else {
05824 IR_IDX_L(ir_idx) = CN_INTEGER_ZERO_IDX;
05825 }
05826
05827 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_End_Single_Process_Stmt;
05828 stmt_type = SGI_End_Single_Process_Stmt;
05829 end_single_process_blk(FALSE);
05830 break;
05831
05832
05833 case Tok_SGI_Dir_Endpsections:
05834 case Tok_SGI_Dir_Endpsection:
05835 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05836 ir_idx = gen_directive_ir(End_Psection_Par_Opr);
05837
05838 if (directive_region_error(End_Psection_Dir,
05839 IR_LINE_NUM(ir_idx),
05840 IR_COL_NUM(ir_idx))) {
05841 }
05842
05843 CLEAR_DIRECTIVE_STATE(Parallel_Section_Region);
05844 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
05845 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
05846 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
05847
05848 if (LA_CH_VALUE != EOS) {
05849 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
05850 TOKEN_VALUE(token) == Tok_SGI_Dir_Nowait) {
05851
05852 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
05853 }
05854 else {
05855 parse_err_flush(Find_EOS, EOS_STR);
05856 }
05857 }
05858 else {
05859 IR_IDX_L(ir_idx) = CN_INTEGER_ZERO_IDX;
05860 }
05861
05862 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_End_Psection_Stmt;
05863 stmt_type = SGI_End_Psection_Stmt;
05864 end_psection_blk(FALSE);
05865
05866 break;
05867
05868 case Tok_SGI_Dir_Endparallel:
05869 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05870 ir_idx = gen_directive_ir(End_Parallel_Par_Opr);
05871
05872 if (directive_region_error(Sgi_End_Parallel_Dir,
05873 IR_LINE_NUM(ir_idx),
05874 IR_COL_NUM(ir_idx))) {
05875 }
05876
05877 CLEAR_DIRECTIVE_STATE(Sgi_Parallel_Region);
05878 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_End_Parallel_Stmt;
05879 stmt_type = SGI_End_Parallel_Stmt;
05880 end_SGI_parallel_blk(FALSE);
05881 break;
05882
05883 case Tok_SGI_Dir_Endpdo:
05884 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05885 ir_idx = gen_directive_ir(End_Pdo_Par_Opr);
05886
05887 if (LA_CH_VALUE != EOS) {
05888 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
05889 TOKEN_VALUE(token) == Tok_SGI_Dir_Nowait) {
05890
05891 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
05892 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
05893 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
05894 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
05895 }
05896 else {
05897 parse_err_flush(Find_EOS, EOS_STR);
05898 }
05899 }
05900
05901 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_End_Pdo_Stmt;
05902
05903 if (SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx)) != NULL_IDX &&
05904 IR_OPR(SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx))) == End_Pdo_Par_Opr &&
05905 SH_COMPILER_GEN(SH_PREV_IDX(curr_stmt_sh_idx))) {
05906
05907
05908 sh_idx = SH_PREV_IDX(curr_stmt_sh_idx);
05909 COPY_OPND(IR_OPND_R(ir_idx), IR_OPND_R(SH_IR_IDX(sh_idx)));
05910
05911 SH_PREV_IDX(SH_NEXT_IDX(sh_idx)) = SH_PREV_IDX(sh_idx);
05912 SH_NEXT_IDX(SH_PREV_IDX(sh_idx)) = SH_NEXT_IDX(sh_idx);
05913
05914 FREE_IR_NODE(SH_IR_IDX(sh_idx));
05915 FREE_SH_NODE(sh_idx);
05916 break;
05917 }
05918
05919 if (directive_region_error(End_Pdo_Dir,
05920 IR_LINE_NUM(ir_idx),
05921 IR_COL_NUM(ir_idx))) {
05922 }
05923
05924 CLEAR_DIRECTIVE_STATE(Pdo_Region);
05925
05926 stmt_type = SGI_End_Pdo_Stmt;
05927 end_pdo_blk(FALSE);
05928
05929 break;
05930
05931
05932 case Tok_SGI_Dir_Psection:
05933 case Tok_SGI_Dir_Psections:
05934 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05935 ir_idx = gen_directive_ir(Psection_Par_Opr);
05936
05937 if (directive_region_error(Psection_Dir,
05938 IR_LINE_NUM(ir_idx),
05939 IR_COL_NUM(ir_idx))) {
05940 }
05941
05942 parse_mp_directive(Psection);
05943 SET_DIRECTIVE_STATE(Parallel_Section_Region);
05944 PUSH_BLK_STK (SGI_Psection_Blk);
05945 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05946 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05947 LINK_TO_PARENT_BLK;
05948 break;
05949
05950 case Tok_SGI_Dir_Section:
05951 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
05952 ir_idx = gen_directive_ir(Section_Par_Opr);
05953
05954 if (directive_region_error(Section_Dir,
05955 IR_LINE_NUM(ir_idx),
05956 IR_COL_NUM(ir_idx))) {
05957 }
05958
05959 if (remove_pdo_blk(TRUE, "SECTION", IR_LINE_NUM(ir_idx),
05960 IR_COL_NUM(ir_idx))) {
05961 }
05962
05963 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_Section_Stmt;
05964 stmt_type = SGI_Section_Stmt;
05965
05966 if (CURR_BLK == SGI_Section_Blk) {
05967 end_psection_blk(FALSE);
05968 }
05969
05970 PUSH_BLK_STK (SGI_Section_Blk);
05971 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
05972 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
05973 LINK_TO_PARENT_BLK;
05974 break;
05975
05976 default:
05977
05978 parse_err_flush(Find_EOS, NULL);
05979
05980 }
05981
05982
05983
05984 if (LA_CH_VALUE != EOS) {
05985 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
05986 parse_err_flush(Find_EOS, NULL);
05987 }
05988
05989 EXIT:
05990
05991 NEXT_LA_CH;
05992
05993 TRACE (Func_Exit, "parse_par_directives", NULL);
05994
05995 return;
05996
05997 }
05998
05999
06000
06001
06002
06003
06004
06005
06006
06007
06008
06009
06010
06011
06012
06013
06014 static void parse_dollar_directives(void)
06015 {
06016 int ir_idx;
06017 int list_idx;
06018 opnd_type opnd;
06019 #ifdef KEY
06020 long the_constant = 0;
06021 #else
06022 long the_constant;
06023 #endif
06024
06025
06026 TRACE (Func_Entry, "parse_dollar_directives", NULL);
06027
06028 if (TOKEN_VALUE(token) > Tok_SGI_Dir_Start &&
06029 TOKEN_VALUE(token) < Tok_SGI_Dir_End &&
06030 disregard_mips[TOKEN_VALUE(token) - Tok_SGI_Dir_Start]) {
06031 goto EXIT;
06032 }
06033
06034 switch (TOKEN_VALUE(token)) {
06035
06036 case Tok_SGI_Dir_Distribute_Reshape:
06037
06038 if (dump_flags.dsm) {
06039 parse_distribution_dir(TRUE);
06040 }
06041 else {
06042 parse_err_flush(Find_EOS, NULL);
06043 }
06044 break;
06045
06046 case Tok_SGI_Dir_Distribute:
06047
06048 if (dump_flags.dsm) {
06049 parse_distribution_dir(FALSE);
06050 }
06051 else {
06052 parse_err_flush(Find_EOS, NULL);
06053 }
06054 break;
06055
06056 case Tok_SGI_Dir_Redistribute:
06057 if (dump_flags.dsm) {
06058 parse_redistribute_dir();
06059 }
06060 else {
06061 parse_err_flush(Find_EOS, NULL);
06062 }
06063 break;
06064
06065 case Tok_SGI_Dir_Dynamic:
06066 if (dump_flags.dsm) {
06067 if (parse_var_name_list(&opnd)) {
06068 ir_idx = gen_directive_ir(Dynamic_Dollar_Opr);
06069 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06070 }
06071 }
06072 else {
06073 parse_err_flush(Find_EOS, NULL);
06074 }
06075 break;
06076
06077 case Tok_SGI_Dir_Page_Place:
06078
06079 if (dump_flags.dsm) {
06080 ir_idx = gen_directive_ir(Page_Place_Dollar_Opr);
06081
06082 NTR_IR_LIST_TBL(list_idx);
06083 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
06084 IR_IDX_L(ir_idx) = list_idx;
06085 IR_LIST_CNT_L(ir_idx) = 3;
06086
06087 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
06088 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
06089 list_idx = IL_NEXT_LIST_IDX(list_idx);
06090
06091 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
06092 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
06093
06094 list_idx = IR_IDX_L(ir_idx);
06095
06096 if (LA_CH_VALUE == LPAREN) {
06097 NEXT_LA_CH;
06098
06099 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
06100 parse_deref(&opnd, NULL_IDX);
06101 COPY_OPND(IL_OPND(list_idx), opnd);
06102 }
06103 else {
06104 parse_err_flush(Find_EOS, "IDENTIFIER");
06105 goto EXIT;
06106 }
06107
06108 if (LA_CH_VALUE == COMMA) {
06109 NEXT_LA_CH;
06110 }
06111 else {
06112 parse_err_flush(Find_EOS, ",");
06113 goto EXIT;
06114 }
06115
06116 list_idx = IL_NEXT_LIST_IDX(list_idx);
06117
06118 parse_expr(&opnd);
06119
06120 COPY_OPND(IL_OPND(list_idx), opnd);
06121
06122 if (LA_CH_VALUE == COMMA) {
06123 NEXT_LA_CH;
06124 }
06125 else {
06126 parse_err_flush(Find_EOS, ",");
06127 goto EXIT;
06128 }
06129
06130 list_idx = IL_NEXT_LIST_IDX(list_idx);
06131
06132 parse_expr(&opnd);
06133
06134 COPY_OPND(IL_OPND(list_idx), opnd);
06135
06136 if (LA_CH_VALUE == RPAREN) {
06137 NEXT_LA_CH;
06138 }
06139 else {
06140 parse_err_flush(Find_EOS, ")");
06141 }
06142 }
06143 else {
06144 parse_err_flush(Find_EOS, "(");
06145 }
06146 }
06147 else {
06148 parse_err_flush(Find_EOS, NULL);
06149 }
06150 break;
06151
06152 case Tok_SGI_Dir_Copyin:
06153
06154 ir_idx = gen_directive_ir(Copyin_Dollar_Opr);
06155
06156 if (directive_region_error(Copyin_Dir,
06157 IR_LINE_NUM(ir_idx),
06158 IR_COL_NUM(ir_idx))) {
06159 }
06160
06161 parse_var_common_list(&opnd, TRUE);
06162 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06163 break;
06164
06165 case Tok_SGI_Dir_Doacross:
06166 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
06167 ir_idx = gen_directive_ir(Doacross_Dollar_Opr);
06168
06169 parse_mp_directive(Doacross);
06170
06171 if (directive_region_error(Doacross_Dir,
06172 IR_LINE_NUM(ir_idx),
06173 IR_COL_NUM(ir_idx))) {
06174 }
06175 else {
06176 SET_DIRECTIVE_STATE(Doacross_Region);
06177 cdir_switches.doacross_sh_idx = curr_stmt_sh_idx;
06178 }
06179
06180 break;
06181
06182
06183 case Tok_SGI_Dir_Chunk:
06184 if (LA_CH_VALUE == EQUAL) {
06185 NEXT_LA_CH;
06186
06187 parse_expr(&opnd);
06188 COPY_OPND(cdir_switches.chunk_opnd, opnd);
06189 }
06190 else {
06191 parse_err_flush(Find_EOS, "=");
06192 goto EXIT;
06193 }
06194 break;
06195
06196 case Tok_SGI_Dir_Mp_Schedtype:
06197
06198 if (LA_CH_VALUE == EQUAL) {
06199
06200 NEXT_LA_CH;
06201
06202 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
06203
06204 switch (TOKEN_VALUE(token)) {
06205 case Tok_SGI_Dir_Simple:
06206 the_constant = MP_SCHEDTYPE_SIMPLE;
06207 break;
06208 case Tok_SGI_Dir_Static:
06209 the_constant = MP_SCHEDTYPE_SIMPLE;
06210 break;
06211 case Tok_SGI_Dir_Dynamic:
06212 the_constant = MP_SCHEDTYPE_DYNAMIC;
06213 break;
06214 case Tok_SGI_Dir_Interleaved:
06215 the_constant = MP_SCHEDTYPE_INTERLEAVED;
06216 break;
06217 case Tok_SGI_Dir_Interleave:
06218 the_constant = MP_SCHEDTYPE_INTERLEAVED;
06219 break;
06220 case Tok_SGI_Dir_Runtime:
06221 the_constant = MP_SCHEDTYPE_RUNTIME;
06222 break;
06223 case Tok_SGI_Dir_Gss:
06224 the_constant = MP_SCHEDTYPE_GUIDED;
06225 break;
06226 case Tok_SGI_Dir_Guided:
06227 the_constant = MP_SCHEDTYPE_GUIDED;
06228 break;
06229 default:
06230 parse_err_flush(Find_EOS, "MP_SCHEDTYPE mode");
06231 break;
06232 }
06233
06234
06235 OPND_LINE_NUM(cdir_switches.mp_schedtype_opnd) = TOKEN_LINE(token);
06236 OPND_COL_NUM(cdir_switches.mp_schedtype_opnd) = TOKEN_COLUMN(token);
06237 OPND_FLD(cdir_switches.mp_schedtype_opnd) = CN_Tbl_Idx;
06238 OPND_IDX(cdir_switches.mp_schedtype_opnd) =
06239 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
06240 the_constant);
06241
06242 if (directives_are_global) {
06243 global_schedtype_value = the_constant;
06244 global_schedtype_line = TOKEN_LINE(token);
06245 global_schedtype_col = TOKEN_COLUMN(token);
06246 }
06247 }
06248 else {
06249 parse_err_flush(Find_EOS, "MP_SCHEDTYPE mode");
06250 }
06251
06252 }
06253 else {
06254 parse_err_flush(Find_EOS, "=");
06255 goto EXIT;
06256 }
06257 break;
06258
06259 default:
06260 parse_err_flush(Find_EOS, NULL);
06261
06262 }
06263
06264
06265
06266 if (LA_CH_VALUE != EOS) {
06267 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
06268 parse_err_flush(Find_EOS, NULL);
06269 }
06270
06271 EXIT:
06272
06273 NEXT_LA_CH;
06274
06275 TRACE (Func_Exit, "parse_dollar_directives", NULL);
06276
06277 return;
06278
06279 }
06280
06281
06282
06283
06284
06285
06286
06287
06288
06289
06290
06291
06292
06293
06294
06295
06296
06297
06298 static void parse_star_directives(void)
06299 {
06300 int attr_idx;
06301 int blk_idx;
06302 int column;
06303 int ir_idx;
06304 int line;
06305 boolean loop_dir = FALSE;
06306 int name_idx;
06307 opnd_type opnd;
06308 #ifdef KEY
06309 operator_type opr = Null_Opr;
06310 #else
06311 operator_type opr;
06312 #endif
06313 int save_column_num;
06314 int save_line_num;
06315
06316
06317 TRACE (Func_Entry, "parse_star_directives", NULL);
06318
06319 if (TOKEN_VALUE(token) > Tok_SGI_Dir_Start &&
06320 TOKEN_VALUE(token) < Tok_SGI_Dir_End &&
06321 disregard_mips[TOKEN_VALUE(token) - Tok_SGI_Dir_Start]) {
06322 goto EXIT;
06323 }
06324
06325 switch (TOKEN_VALUE(token)) {
06326
06327 case Tok_SGI_Dir_Aggressiveinner:
06328 loop_dir = TRUE;
06329 opr = Aggressiveinnerloopfission_Opr;
06330 break;
06331
06332 case Tok_SGI_Dir_Blockingsize:
06333 parse_star_dir_directives();
06334 goto EXIT;
06335
06336 case Tok_SGI_Dir_Assert:
06337
06338 if (! parse_assert_directive()) {
06339 goto EXIT;
06340 }
06341 break;
06342
06343 case Tok_SGI_Dir_Align_Symbol:
06344
06345 if (curr_stmt_category < Dir_Integer_Stmt_Cat) {
06346 PRINTMSG(TOKEN_LINE(token), 795, Warning,
06347 TOKEN_COLUMN(token), "ALIGN_SYMBOL");
06348 parse_err_flush(Find_EOS, NULL);
06349 break;
06350 }
06351
06352 if (curr_stmt_category >= Executable_Stmt_Cat) {
06353 PRINTMSG(TOKEN_LINE(token), 531, Error,
06354 TOKEN_COLUMN(token),
06355 "ALIGN_SYMBOL");
06356 parse_err_flush(Find_EOS, NULL);
06357 break;
06358 }
06359
06360 ir_idx = gen_directive_ir(Align_Symbol_Star_Opr);
06361 parse_fill_align_symbol();
06362 break;
06363
06364 case Tok_SGI_Dir_Fill_Symbol:
06365
06366 if (curr_stmt_category < Dir_Integer_Stmt_Cat) {
06367 PRINTMSG(TOKEN_LINE(token), 795, Warning,
06368 TOKEN_COLUMN(token), "FILL_SYMBOL");
06369 parse_err_flush(Find_EOS, NULL);
06370 break;
06371 }
06372
06373 if (curr_stmt_category >= Executable_Stmt_Cat) {
06374 PRINTMSG(TOKEN_LINE(token), 531, Error,
06375 TOKEN_COLUMN(token),
06376 "FILL_SYMBOL");
06377 parse_err_flush(Find_EOS, NULL);
06378 break;
06379 }
06380
06381 ir_idx = gen_directive_ir(Fill_Symbol_Star_Opr);
06382 parse_fill_align_symbol();
06383 break;
06384
06385 case Tok_SGI_Dir_Blockable:
06386 parse_star_dir_directives();
06387 goto EXIT;
06388
06389 case Tok_SGI_Dir_Concurrentize:
06390 ir_idx = gen_directive_ir(Concurrentize_Star_Opr);
06391
06392 if (directives_are_global) {
06393
06394 gen_gl_sh(After, Directive_Stmt, IR_LINE_NUM(ir_idx),
06395 IR_COL_NUM(ir_idx),
06396 FALSE, FALSE, TRUE);
06397 GL_SH_IR_IDX(curr_gl_stmt_sh_idx) = copy_to_gl_subtree(ir_idx,
06398 IR_Tbl_Idx);
06399 }
06400 break;
06401
06402 case Tok_SGI_Dir_Fissionable:
06403 loop_dir = TRUE;
06404 opr = Fissionable_Star_Opr;
06405 break;
06406
06407 case Tok_SGI_Dir_Flush:
06408 ir_idx = gen_directive_ir(Flush_Star_Opr);
06409
06410 if (LA_CH_VALUE == LPAREN) {
06411 NEXT_LA_CH;
06412
06413 parse_var_name_list(&opnd);
06414 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06415
06416 if (LA_CH_VALUE == RPAREN) {
06417 NEXT_LA_CH;
06418 }
06419 else {
06420 parse_err_flush(Find_EOS, ")");
06421 goto EXIT;
06422 }
06423 }
06424 break;
06425
06426 case Tok_SGI_Dir_Fusable:
06427 loop_dir = TRUE;
06428 opr = Fusable_Star_Opr;
06429 break;
06430
06431 case Tok_SGI_Dir_Fission:
06432 ir_idx = gen_directive_ir(Fission_Star_Opr);
06433
06434 if (LA_CH_VALUE == LPAREN) {
06435 NEXT_LA_CH;
06436
06437 parse_expr(&opnd);
06438 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06439
06440 if (LA_CH_VALUE == RPAREN) {
06441 NEXT_LA_CH;
06442 }
06443 else {
06444 parse_err_flush(Find_EOS, ")");
06445 goto EXIT;
06446 }
06447 }
06448 else {
06449 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
06450 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
06451 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
06452 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
06453 }
06454 break;
06455
06456 case Tok_SGI_Dir_Fuse:
06457 ir_idx = gen_directive_ir(Fuse_Star_Opr);
06458
06459 if (LA_CH_VALUE == LPAREN) {
06460 NEXT_LA_CH;
06461
06462 parse_expr(&opnd);
06463 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06464
06465 if (LA_CH_VALUE == COMMA) {
06466 NEXT_LA_CH;
06467
06468 parse_expr(&opnd);
06469 COPY_OPND(IR_OPND_R(ir_idx), opnd);
06470 }
06471 else {
06472
06473
06474 IR_LINE_NUM_R(ir_idx) = TOKEN_LINE(token);
06475 IR_COL_NUM_R(ir_idx) = TOKEN_COLUMN(token);
06476 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
06477 IR_IDX_R(ir_idx) = CN_INTEGER_ZERO_IDX;
06478 }
06479
06480 if (LA_CH_VALUE == RPAREN) {
06481 NEXT_LA_CH;
06482 }
06483 else {
06484 parse_err_flush(Find_EOS, ")");
06485 goto EXIT;
06486 }
06487 }
06488 else {
06489
06490
06491 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
06492 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
06493 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
06494 IR_IDX_L(ir_idx) = CN_INTEGER_TWO_IDX;
06495
06496 IR_LINE_NUM_R(ir_idx) = TOKEN_LINE(token);
06497 IR_COL_NUM_R(ir_idx) = TOKEN_COLUMN(token);
06498 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
06499 IR_IDX_R(ir_idx) = CN_INTEGER_ZERO_IDX;
06500 }
06501 break;
06502
06503 case Tok_SGI_Dir_Inline:
06504 case Tok_SGI_Dir_Ipa:
06505 parse_sgi_dir_inline(TRUE);
06506 break;
06507
06508 case Tok_SGI_Dir_Noinline:
06509 case Tok_SGI_Dir_Noipa:
06510 parse_sgi_dir_inline(FALSE);
06511 break;
06512
06513 case Tok_SGI_Dir_Interchange:
06514 parse_star_dir_directives();
06515 goto EXIT;
06516
06517 case Tok_SGI_Dir_Noblocking:
06518 loop_dir = TRUE;
06519 opr = Noblocking_Dir_Opr;
06520 break;
06521
06522 case Tok_SGI_Dir_Noconcurrentize:
06523 ir_idx = gen_directive_ir(Noconcurrentize_Star_Opr);
06524
06525 if (directives_are_global) {
06526
06527 gen_gl_sh(After, Directive_Stmt, IR_LINE_NUM(ir_idx),
06528 IR_COL_NUM(ir_idx),
06529 FALSE, FALSE, TRUE);
06530 GL_SH_IR_IDX(curr_gl_stmt_sh_idx) = copy_to_gl_subtree(ir_idx,
06531 IR_Tbl_Idx);
06532 }
06533 break;
06534
06535 case Tok_SGI_Dir_Nointerchange:
06536 loop_dir = TRUE;
06537 opr = Nointerchange_Dir_Opr;
06538 break;
06539
06540 case Tok_SGI_Dir_Nofission:
06541 loop_dir = TRUE;
06542 opr = Nofission_Star_Opr;
06543 break;
06544
06545 case Tok_SGI_Dir_Nofusion:
06546 loop_dir = TRUE;
06547 opr = Nofusion_Star_Opr;
06548 break;
06549
06550 case Tok_SGI_Dir_Opaque:
06551 loop_dir = TRUE;
06552 opr = Opaque_Star_Opr;
06553
06554 if (directive_region_error(Opaque_Dir,
06555 TOKEN_LINE(token),
06556 TOKEN_COLUMN(token))) {
06557 }
06558 break;
06559
06560 case Tok_SGI_Dir_Optional:
06561
06562 if (curr_stmt_category < Dir_Integer_Stmt_Cat) {
06563 PRINTMSG(TOKEN_LINE(token), 795, Warning,
06564 TOKEN_COLUMN(token), "OPTIONAL");
06565 parse_err_flush(Find_EOS, NULL);
06566 break;
06567 }
06568
06569 if (directive_region_error(Optional_Dir,
06570 TOKEN_LINE(token),
06571 TOKEN_COLUMN(token))) {
06572 break;
06573 }
06574
06575 if (LA_CH_VALUE == LPAREN) {
06576 NEXT_LA_CH;
06577
06578 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
06579 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
06580 &name_idx);
06581
06582 if (attr_idx == NULL_IDX) {
06583 attr_idx = ntr_sym_tbl(&token, name_idx);
06584 LN_DEF_LOC(name_idx) = TRUE;
06585 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
06586 MAKE_EXTERNAL_NAME(attr_idx,
06587 AT_NAME_IDX(attr_idx),
06588 AT_NAME_LEN(attr_idx));
06589 ATP_PROC(attr_idx) = Extern_Proc;
06590 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
06591 ATP_OPTIONAL_DIR(attr_idx) = TRUE;
06592 }
06593 else if (!fnd_semantic_err(Obj_Optional_Dir,
06594 TOKEN_LINE(token),
06595 TOKEN_COLUMN(token),
06596 attr_idx,
06597 TRUE)) {
06598
06599 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
06600 AT_ATTR_LINK(attr_idx) = NULL_IDX;
06601 LN_DEF_LOC(name_idx) = TRUE;
06602 }
06603
06604 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
06605 chg_data_obj_to_pgm_unit(attr_idx,
06606 Function,
06607 Extern_Proc);
06608 ATP_OPTIONAL_DIR(attr_idx) = TRUE;
06609 }
06610 else if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) {
06611 ATP_OPTIONAL_DIR(attr_idx) = TRUE;
06612 }
06613 }
06614 }
06615 else {
06616 parse_err_flush(Find_EOS, "procedure name");
06617 goto EXIT;
06618 }
06619
06620 if (LA_CH_VALUE == RPAREN) {
06621 NEXT_LA_CH;
06622 }
06623 else {
06624 parse_err_flush(Find_EOS, ")");
06625 goto EXIT;
06626 }
06627 }
06628 else {
06629 parse_err_flush(Find_EOS, "(");
06630 goto EXIT;
06631 }
06632 break;
06633
06634 #ifdef KEY
06635
06636 case Tok_SGI_Dir_Options:
06637 ir_idx = gen_directive_ir(Options_Dir_Opr);
06638 if (QUOTE == LA_CH_VALUE || DBL_QUOTE == LA_CH_VALUE) {
06639 parse_expr(&opnd);
06640 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06641 }
06642 else {
06643 parse_err_flush(Find_EOS, "\"");
06644 goto EXIT;
06645 }
06646 break;
06647 #endif
06648
06649 case Tok_SGI_Dir_Purpleconditional:
06650 ir_idx = gen_directive_ir(Purpleconditional_Star_Opr);
06651
06652 if (directive_region_error(PurpleConditional_Dir,
06653 IR_LINE_NUM(ir_idx),
06654 IR_COL_NUM(ir_idx))) {
06655 }
06656
06657 if (LA_CH_VALUE == LPAREN) {
06658 NEXT_LA_CH;
06659 parse_expr(&opnd);
06660
06661 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06662
06663 if (LA_CH_VALUE == RPAREN) {
06664 NEXT_LA_CH;
06665 }
06666 else {
06667 parse_err_flush(Find_EOS, ")");
06668 goto EXIT;
06669 }
06670 }
06671 else {
06672 parse_err_flush(Find_EOS, "(");
06673 goto EXIT;
06674 }
06675 break;
06676
06677 case Tok_SGI_Dir_Purpleunconditional:
06678 loop_dir = TRUE;
06679 opr = Purpleunconditional_Star_Opr;
06680
06681 if (directive_region_error(PurpleUnconditional_Dir,
06682 TOKEN_LINE(token),
06683 TOKEN_COLUMN(token))) {
06684 }
06685 break;
06686
06687 case Tok_SGI_Dir_Regionbegin:
06688 ir_idx = gen_directive_ir(Regionbegin_Star_Opr);
06689
06690 if (directive_region_error(Regionbegin_Dir,
06691 IR_LINE_NUM(ir_idx),
06692 IR_COL_NUM(ir_idx))) {
06693 }
06694
06695 SET_DIRECTIVE_STATE(Region_Region);
06696 PUSH_BLK_STK (SGI_Region_Blk);
06697 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
06698 LINK_TO_PARENT_BLK;
06699 break;
06700
06701 case Tok_SGI_Dir_Regionend:
06702 ir_idx = gen_directive_ir(Regionend_Star_Opr);
06703
06704 if (directive_region_error(Regionend_Dir,
06705 IR_LINE_NUM(ir_idx),
06706 IR_COL_NUM(ir_idx))) {
06707 }
06708
06709 CLEAR_DIRECTIVE_STATE(Region_Region);
06710 SH_STMT_TYPE(curr_stmt_sh_idx) = SGI_Region_End_Stmt;
06711 stmt_type = SGI_Region_End_Stmt;
06712 end_region_blk(FALSE);
06713 break;
06714
06715 case Tok_SGI_Dir_Section_Non_Gp:
06716
06717 if (LA_CH_VALUE != LPAREN) {
06718 parse_err_flush(Find_EOS, "(");
06719 }
06720 else {
06721 NEXT_LA_CH;
06722
06723 ir_idx = gen_directive_ir(Section_Nongp_Star_Opr);
06724
06725 parse_var_common_list(&opnd, FALSE);
06726
06727 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06728
06729 if (LA_CH_VALUE != RPAREN) {
06730 parse_err_flush(Find_EOS, ")");
06731 }
06732 else {
06733 NEXT_LA_CH;
06734 }
06735 }
06736 break;
06737
06738 case Tok_SGI_Dir_Section_Gp:
06739
06740 if (LA_CH_VALUE != LPAREN) {
06741 parse_err_flush(Find_EOS, "(");
06742 }
06743 else {
06744 NEXT_LA_CH;
06745
06746 ir_idx = gen_directive_ir(Section_Gp_Star_Opr);
06747
06748 parse_var_common_list(&opnd, FALSE);
06749
06750 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06751
06752 if (LA_CH_VALUE != RPAREN) {
06753 parse_err_flush(Find_EOS, ")");
06754 }
06755 else {
06756 NEXT_LA_CH;
06757 }
06758 }
06759
06760 break;
06761
06762
06763 case Tok_SGI_Dir_Prefetch_Manual:
06764 ir_idx = gen_directive_ir(Prefetch_Manual_Star_Opr);
06765
06766 if (LA_CH_VALUE == LPAREN) {
06767 NEXT_LA_CH;
06768
06769 parse_expr(&opnd);
06770 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06771
06772 if (LA_CH_VALUE == RPAREN) {
06773 NEXT_LA_CH;
06774 }
06775 else {
06776 parse_err_flush(Find_EOS, ")");
06777 goto EXIT;
06778 }
06779 }
06780 else {
06781 parse_err_flush(Find_EOS, "(");
06782 goto EXIT;
06783 }
06784 break;
06785
06786 case Tok_SGI_Dir_Prefetch_Ref:
06787 ir_idx = gen_directive_ir(Prefetch_Ref_Star_Opr);
06788 parse_prefetch_ref();
06789 break;
06790
06791 case Tok_SGI_Dir_Prefetch:
06792 ir_idx = gen_directive_ir(Prefetch_Star_Opr);
06793
06794 if (LA_CH_VALUE == LPAREN) {
06795 NEXT_LA_CH;
06796
06797 parse_expr(&opnd);
06798 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06799
06800 if (LA_CH_VALUE == COMMA) {
06801 NEXT_LA_CH;
06802
06803 parse_expr(&opnd);
06804 COPY_OPND(IR_OPND_R(ir_idx), opnd);
06805 }
06806 else {
06807
06808 }
06809
06810 if (LA_CH_VALUE == RPAREN) {
06811 NEXT_LA_CH;
06812 }
06813 else {
06814 parse_err_flush(Find_EOS, ")");
06815 goto EXIT;
06816 }
06817 }
06818 else {
06819 parse_err_flush(Find_EOS, "(");
06820 goto EXIT;
06821 }
06822 break;
06823
06824 case Tok_SGI_Dir_Prefetch_Ref_Disable:
06825 ir_idx = gen_directive_ir(Prefetch_Ref_Disable_Star_Opr);
06826
06827 if (LA_CH_VALUE == EQUAL) {
06828 NEXT_LA_CH;
06829
06830 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
06831 parse_deref(&opnd, NULL_IDX);
06832
06833 if (OPND_FLD(opnd) != AT_Tbl_Idx) {
06834 find_opnd_line_and_column(&opnd, &line, &column);
06835 PRINTMSG(line, 1374, Error, column);
06836 }
06837 else {
06838 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06839 }
06840 }
06841 else {
06842 parse_err_flush(Find_EOS, "array name");
06843 goto EXIT;
06844 }
06845
06846 if (LA_CH_VALUE == COMMA) {
06847 NEXT_LA_CH;
06848
06849 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
06850 TOKEN_VALUE(token) == Tok_SGI_Dir_Size) {
06851
06852 if (LA_CH_VALUE == EQUAL) {
06853 NEXT_LA_CH;
06854
06855 parse_expr(&opnd);
06856 COPY_OPND(IR_OPND_R(ir_idx), opnd);
06857 }
06858 else {
06859 parse_err_flush(Find_EOS, "=");
06860 goto EXIT;
06861 }
06862 }
06863 else {
06864 parse_err_flush(Find_EOS, "SIZE");
06865 goto EXIT;
06866 }
06867 }
06868 }
06869 else {
06870 parse_err_flush(Find_EOS, "=");
06871 goto EXIT;
06872 }
06873 break;
06874
06875 case Tok_SGI_Dir_Unroll:
06876 ir_idx = gen_directive_ir(Unroll_Star_Opr);
06877
06878 if (LA_CH_VALUE == LPAREN) {
06879 NEXT_LA_CH;
06880
06881 parse_expr(&opnd);
06882 COPY_OPND(IR_OPND_L(ir_idx), opnd);
06883
06884 if (LA_CH_VALUE == COMMA) {
06885 NEXT_LA_CH;
06886
06887
06888 parse_expr(&opnd);
06889 }
06890
06891 if (LA_CH_VALUE == RPAREN) {
06892 NEXT_LA_CH;
06893 }
06894 else {
06895 parse_err_flush(Find_EOS, ")");
06896 goto EXIT;
06897 }
06898 }
06899 else {
06900 parse_err_flush(Find_EOS, "(");
06901 goto EXIT;
06902 }
06903 break;
06904
06905 case Tok_SGI_Dir_Limit:
06906 case Tok_SGI_Dir_Minconcurrent:
06907 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
06908 parse_err_flush(Find_EOS, NULL);
06909 break;
06910
06911 default:
06912
06913 parse_err_flush(Find_EOS, NULL);
06914
06915 }
06916
06917 if (loop_dir) {
06918
06919 if (curr_stmt_category < Dir_Integer_Stmt_Cat) {
06920 PRINTMSG(TOKEN_LINE(token), 795, Warning, TOKEN_COLUMN(token),
06921 TOKEN_STR(token));
06922 parse_err_flush(Find_EOS, NULL);
06923 }
06924 else {
06925 ir_idx = gen_directive_ir(opr);
06926 }
06927 }
06928
06929
06930
06931 if (LA_CH_VALUE != EOS) {
06932 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
06933 parse_err_flush(Find_EOS, NULL);
06934 }
06935
06936 EXIT:
06937
06938 NEXT_LA_CH;
06939
06940 TRACE (Func_Exit, "parse_star_directives", NULL);
06941
06942 return;
06943
06944 }
06945
06946
06947
06948
06949
06950
06951
06952
06953
06954
06955
06956
06957
06958
06959
06960
06961
06962
06963
06964
06965
06966
06967
06968
06969
06970
06971 static void parse_prefetch_ref(void)
06972
06973 {
06974 int buf_idx;
06975 int column;
06976 int i;
06977 int ir_idx;
06978 int line;
06979 int list_array[5];
06980 int list_idx;
06981 opnd_type opnd;
06982 int stmt_num;
06983
06984
06985 TRACE (Func_Entry, "parse_prefetch_ref", NULL);
06986
06987 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
06988
06989 for (i = 0; i < 5; i++) {
06990 NTR_IR_LIST_TBL(list_array[i]);
06991 if (i >= 1) {
06992 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
06993 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
06994 }
06995 }
06996
06997 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
06998 IR_IDX_L(ir_idx) = list_array[0];
06999 IR_LIST_CNT_L(ir_idx) = 5;
07000
07001 if (LA_CH_VALUE == EQUAL) {
07002 NEXT_LA_CH;
07003
07004 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
07005 parse_deref(&opnd, NULL_IDX);
07006 COPY_OPND(IL_OPND(list_array[0]), opnd);
07007 }
07008 else {
07009 parse_err_flush(Find_EOS, "array name");
07010 goto EXIT;
07011 }
07012 }
07013 else {
07014 parse_err_flush(Find_EOS, "=");
07015 goto EXIT;
07016 }
07017
07018 while (LA_CH_VALUE == COMMA) {
07019 NEXT_LA_CH;
07020
07021 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
07022
07023 if (LA_CH_VALUE == EQUAL) {
07024 NEXT_LA_CH;
07025 }
07026 else {
07027 parse_err_flush(Find_EOS, "=");
07028 goto EXIT;
07029 }
07030
07031 switch (TOKEN_VALUE(token)) {
07032 case Tok_SGI_Dir_Stride:
07033 if (IL_IDX(list_array[1]) != NULL_IDX) {
07034 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07035 "STRIDE", "PREFETCH_REF");
07036 parse_err_flush(Find_EOS, NULL);
07037 goto EXIT;
07038 }
07039
07040
07041 parse_expr(&opnd);
07042 NTR_IR_LIST_TBL(list_idx);
07043 IL_FLD(list_array[1]) = IL_Tbl_Idx;
07044 IL_LIST_CNT(list_array[1]) = 1;
07045 IL_IDX(list_array[1]) = list_idx;
07046
07047 COPY_OPND(IL_OPND(list_idx), opnd);
07048
07049 if (LA_CH_VALUE == COMMA) {
07050 buf_idx = LA_CH_BUF_IDX;
07051 stmt_num = LA_CH_STMT_NUM;
07052
07053 NEXT_LA_CH;
07054 if (isdigit(LA_CH_VALUE)) {
07055 parse_expr(&opnd);
07056 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
07057 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
07058 list_idx = IL_NEXT_LIST_IDX(list_idx);
07059 IL_LIST_CNT(list_array[1]) += 1;
07060 COPY_OPND(IL_OPND(list_idx), opnd);
07061 }
07062 else {
07063 reset_lex(buf_idx, stmt_num);
07064 }
07065 }
07066 break;
07067
07068 case Tok_SGI_Dir_Level:
07069 if (IL_IDX(list_array[2]) != NULL_IDX) {
07070 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07071 "LEVEL", "PREFETCH_REF");
07072 parse_err_flush(Find_EOS, NULL);
07073 goto EXIT;
07074 }
07075
07076
07077 parse_expr(&opnd);
07078 NTR_IR_LIST_TBL(list_idx);
07079 IL_FLD(list_array[2]) = IL_Tbl_Idx;
07080 IL_LIST_CNT(list_array[2]) = 1;
07081 IL_IDX(list_array[2]) = list_idx;
07082
07083 COPY_OPND(IL_OPND(list_idx), opnd);
07084
07085 if (LA_CH_VALUE == COMMA) {
07086 buf_idx = LA_CH_BUF_IDX;
07087 stmt_num = LA_CH_STMT_NUM;
07088
07089 NEXT_LA_CH;
07090 if (isdigit(LA_CH_VALUE)) {
07091 parse_expr(&opnd);
07092 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
07093 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
07094 list_idx = IL_NEXT_LIST_IDX(list_idx);
07095 IL_LIST_CNT(list_array[2]) += 1;
07096 COPY_OPND(IL_OPND(list_idx), opnd);
07097 }
07098 else {
07099 reset_lex(buf_idx, stmt_num);
07100 }
07101 }
07102 break;
07103
07104 case Tok_SGI_Dir_Kind:
07105 if (IL_IDX(list_array[3]) != NULL_IDX) {
07106 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07107 "KIND", "PREFETCH_REF");
07108 parse_err_flush(Find_EOS, NULL);
07109 goto EXIT;
07110 }
07111
07112 if (LA_CH_VALUE == 'R') {
07113 line = LA_CH_LINE;
07114 column = LA_CH_COLUMN;
07115 NEXT_LA_CH;
07116 if (LA_CH_VALUE == 'D') {
07117 NEXT_LA_CH;
07118 IL_FLD(list_array[3]) = CN_Tbl_Idx;
07119 IL_IDX(list_array[3]) = CN_INTEGER_ZERO_IDX;
07120 IL_LINE_NUM(list_array[3]) = line;
07121 IL_COL_NUM(list_array[3]) = column;
07122 }
07123 else {
07124 parse_err_flush(Find_EOS, "RD or WR");
07125 goto EXIT;
07126 }
07127 }
07128 else if (LA_CH_VALUE == 'W') {
07129 line = LA_CH_LINE;
07130 column = LA_CH_COLUMN;
07131 NEXT_LA_CH;
07132 if (LA_CH_VALUE == 'R') {
07133 NEXT_LA_CH;
07134 IL_FLD(list_array[3]) = CN_Tbl_Idx;
07135 IL_IDX(list_array[3]) = CN_INTEGER_ONE_IDX;
07136 IL_LINE_NUM(list_array[3]) = line;
07137 IL_COL_NUM(list_array[3]) = column;
07138 }
07139 else {
07140 parse_err_flush(Find_EOS, "RD or WR");
07141 goto EXIT;
07142 }
07143 }
07144 else {
07145 parse_err_flush(Find_EOS, "RD or WR");
07146 goto EXIT;
07147 }
07148 break;
07149
07150 case Tok_SGI_Dir_Size:
07151 if (IL_IDX(list_array[4]) != NULL_IDX) {
07152 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07153 "SIZE", "PREFETCH_REF");
07154 parse_err_flush(Find_EOS, NULL);
07155 goto EXIT;
07156 }
07157
07158 parse_expr(&opnd);
07159 COPY_OPND(IL_OPND(list_array[4]), opnd);
07160 break;
07161
07162 default:
07163 parse_err_flush(Find_EOS, "PREFETCH_REF clause");
07164 goto EXIT;
07165 }
07166 }
07167 else {
07168 parse_err_flush(Find_EOS, "PREFETCH_REF clause");
07169 goto EXIT;
07170 }
07171 }
07172
07173 line = IR_LINE_NUM(ir_idx);
07174 column = IR_COL_NUM(ir_idx);
07175
07176 if (IL_FLD(list_array[1]) == NO_Tbl_Idx) {
07177 NTR_IR_LIST_TBL(list_idx);
07178 IL_FLD(list_array[1]) = IL_Tbl_Idx;
07179 IL_LIST_CNT(list_array[1]) = 1;
07180 IL_IDX(list_array[1]) = list_idx;
07181
07182 IL_FLD(list_idx) = CN_Tbl_Idx;
07183 IL_IDX(list_idx) = CN_INTEGER_ONE_IDX;
07184 IL_LINE_NUM(list_idx) = line;
07185 IL_COL_NUM(list_idx) = column;
07186 }
07187
07188 if (IL_FLD(list_array[2]) == NO_Tbl_Idx) {
07189 NTR_IR_LIST_TBL(list_idx);
07190 IL_FLD(list_array[2]) = IL_Tbl_Idx;
07191 IL_LIST_CNT(list_array[2]) = 1;
07192 IL_IDX(list_array[2]) = list_idx;
07193
07194 IL_FLD(list_idx) = CN_Tbl_Idx;
07195 IL_IDX(list_idx) = CN_INTEGER_TWO_IDX;
07196 IL_LINE_NUM(list_idx) = line;
07197 IL_COL_NUM(list_idx) = column;
07198 }
07199
07200 if (IL_FLD(list_array[3]) == NO_Tbl_Idx) {
07201 IL_FLD(list_array[3]) = CN_Tbl_Idx;
07202 IL_IDX(list_array[3]) = CN_INTEGER_ONE_IDX;
07203 IL_LINE_NUM(list_array[3]) = line;
07204 IL_COL_NUM(list_array[3]) = column;
07205 }
07206 EXIT:
07207
07208 TRACE (Func_Exit, "parse_prefetch_ref", NULL);
07209
07210 return;
07211
07212 }
07213
07214
07215
07216
07217
07218
07219
07220
07221
07222
07223
07224
07225
07226
07227
07228
07229
07230
07231
07232
07233
07234
07235
07236
07237
07238
07239
07240
07241
07242
07243
07244
07245
07246
07247
07248 static void parse_mp_directive(mp_directive_type directive)
07249
07250 {
07251 int column;
07252 int i;
07253 int ir_idx;
07254 int line;
07255 int list_array[MP_DIR_LIST_CNT];
07256 int list_idx;
07257 int list2_idx;
07258 opnd_type opnd;
07259 boolean seen_nest = FALSE;
07260 #ifdef KEY
07261 long the_constant = 0;
07262 #else
07263 long the_constant;
07264 #endif
07265
07266
07267 TRACE (Func_Entry, "parse_mp_directive", NULL);
07268
07269 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
07270
07271 for (i = 0; i < MP_DIR_LIST_CNT; i++) {
07272 NTR_IR_LIST_TBL(list_array[i]);
07273 if (i >= 1) {
07274 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
07275 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
07276 }
07277 }
07278
07279 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
07280 IR_IDX_L(ir_idx) = list_array[0];
07281 IR_LIST_CNT_L(ir_idx) = MP_DIR_LIST_CNT;
07282
07283 while (LA_CH_VALUE != EOS) {
07284
07285 if (LA_CH_VALUE == LPAREN) {
07286
07287 NEXT_LA_CH;
07288
07289 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
07290
07291 if (TOKEN_VALUE(token) == Tok_SGI_Dir_Ordered) {
07292
07293 if (! clause_allowed[directive][Ordered_Clause]) {
07294 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07295 "ORDERED", mp_dir_str[directive]);
07296 parse_err_flush(Find_EOS, NULL);
07297 goto EXIT;
07298 }
07299
07300 if (IL_IDX(list_array[MP_DIR_ORDERED_IDX]) != NULL_IDX) {
07301 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07302 "ORDERED", mp_dir_str[directive]);
07303 parse_err_flush(Find_EOS, NULL);
07304 goto EXIT;
07305 }
07306
07307
07308 IL_FLD(list_array[MP_DIR_ORDERED_IDX]) = CN_Tbl_Idx;
07309 IL_LINE_NUM(list_array[MP_DIR_ORDERED_IDX]) = TOKEN_LINE(token);
07310 IL_COL_NUM(list_array[MP_DIR_ORDERED_IDX]) = TOKEN_COLUMN(token);
07311 IL_IDX(list_array[MP_DIR_ORDERED_IDX]) = CN_INTEGER_ONE_IDX;
07312
07313 if (LA_CH_VALUE == RPAREN) {
07314 NEXT_LA_CH;
07315 }
07316 else {
07317 parse_err_flush(Find_EOS, ")");
07318 }
07319 }
07320 else {
07321 parse_err_flush(Find_EOS, "ORDERED clause");
07322 }
07323 }
07324 else {
07325 parse_err_flush(Find_EOS, "mp clause");
07326 }
07327 }
07328 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
07329
07330 switch (TOKEN_VALUE(token)) {
07331
07332 case Tok_SGI_Dir_If:
07333
07334 if (! clause_allowed[directive][If_Clause]) {
07335 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07336 "IF", mp_dir_str[directive]);
07337 parse_err_flush(Find_EOS, NULL);
07338 goto EXIT;
07339 }
07340
07341 if (IL_IDX(list_array[MP_DIR_IF_IDX]) != NULL_IDX) {
07342 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07343 "IF", mp_dir_str[directive]);
07344 parse_err_flush(Find_EOS, NULL);
07345 goto EXIT;
07346 }
07347
07348 if (LA_CH_VALUE == LPAREN) {
07349 NEXT_LA_CH;
07350 parse_expr(&opnd);
07351
07352 COPY_OPND(IL_OPND(list_array[MP_DIR_IF_IDX]), opnd);
07353
07354 if (LA_CH_VALUE == RPAREN) {
07355 NEXT_LA_CH;
07356 }
07357 else {
07358 parse_err_flush(Find_EOS, ")");
07359 goto EXIT;
07360 }
07361 }
07362 else {
07363 parse_err_flush(Find_EOS, "(");
07364 goto EXIT;
07365 }
07366 break;
07367
07368 case Tok_SGI_Dir_Share:
07369 case Tok_SGI_Dir_Shared:
07370
07371 if (! clause_allowed[directive][Share_Clause]) {
07372 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07373 "SHARE", mp_dir_str[directive]);
07374 parse_err_flush(Find_EOS, NULL);
07375 goto EXIT;
07376 }
07377
07378 if (LA_CH_VALUE == LPAREN) {
07379 NEXT_LA_CH;
07380 parse_var_name_list(&opnd);
07381
07382 if (IL_IDX(list_array[MP_DIR_SHARE_IDX]) == NULL_IDX) {
07383 COPY_OPND(IL_OPND(list_array[MP_DIR_SHARE_IDX]), opnd);
07384 }
07385 else {
07386
07387
07388 list_idx = IL_IDX(list_array[MP_DIR_SHARE_IDX]);
07389 while (IL_NEXT_LIST_IDX(list_idx)) {
07390 list_idx = IL_NEXT_LIST_IDX(list_idx);
07391 }
07392
07393
07394 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
07395 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
07396 IL_LIST_CNT(list_array[MP_DIR_SHARE_IDX]) +=
07397 OPND_LIST_CNT(opnd);
07398 }
07399
07400 if (LA_CH_VALUE == RPAREN) {
07401 NEXT_LA_CH;
07402 }
07403 else {
07404 parse_err_flush(Find_EOS, ")");
07405 goto EXIT;
07406 }
07407 }
07408 else {
07409 parse_err_flush(Find_EOS, "(");
07410 goto EXIT;
07411 }
07412
07413 break;
07414
07415 case Tok_SGI_Dir_Lastlocal:
07416
07417 if (! clause_allowed[directive][Lastlocal_Clause]) {
07418 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07419 "LASTLOCAL", mp_dir_str[directive]);
07420 parse_err_flush(Find_EOS, NULL);
07421 goto EXIT;
07422 }
07423
07424 if (LA_CH_VALUE == LPAREN) {
07425 NEXT_LA_CH;
07426 parse_var_name_list(&opnd);
07427
07428 if (IL_IDX(list_array[MP_DIR_LASTLOCAL_IDX]) == NULL_IDX) {
07429 COPY_OPND(IL_OPND(list_array[MP_DIR_LASTLOCAL_IDX]),
07430 opnd);
07431 }
07432 else {
07433
07434
07435 list_idx = IL_IDX(list_array[MP_DIR_LASTLOCAL_IDX]);
07436 while (IL_NEXT_LIST_IDX(list_idx)) {
07437 list_idx = IL_NEXT_LIST_IDX(list_idx);
07438 }
07439
07440
07441 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
07442 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
07443 IL_LIST_CNT(list_array[MP_DIR_LASTLOCAL_IDX]) +=
07444 OPND_LIST_CNT(opnd);
07445 }
07446
07447 if (LA_CH_VALUE == RPAREN) {
07448 NEXT_LA_CH;
07449 }
07450 else {
07451 parse_err_flush(Find_EOS, ")");
07452 goto EXIT;
07453 }
07454 }
07455 else {
07456 parse_err_flush(Find_EOS, "(");
07457 goto EXIT;
07458 }
07459
07460 break;
07461
07462 case Tok_SGI_Dir_Reduction:
07463
07464 if (! clause_allowed[directive][Reduction_Clause]) {
07465 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07466 "REDUCTION", mp_dir_str[directive]);
07467 parse_err_flush(Find_EOS, NULL);
07468 goto EXIT;
07469 }
07470
07471 if (LA_CH_VALUE == LPAREN) {
07472 NEXT_LA_CH;
07473 parse_reference_list(&opnd);
07474
07475 if (IL_IDX(list_array[MP_DIR_REDUCTION_IDX]) == NULL_IDX) {
07476 COPY_OPND(IL_OPND(list_array[MP_DIR_REDUCTION_IDX]),
07477 opnd);
07478 }
07479 else {
07480
07481
07482 list_idx = IL_IDX(list_array[MP_DIR_REDUCTION_IDX]);
07483 while (IL_NEXT_LIST_IDX(list_idx)) {
07484 list_idx = IL_NEXT_LIST_IDX(list_idx);
07485 }
07486
07487
07488 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
07489 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
07490 IL_LIST_CNT(list_array[MP_DIR_REDUCTION_IDX]) +=
07491 OPND_LIST_CNT(opnd);
07492 }
07493
07494 if (LA_CH_VALUE == RPAREN) {
07495 NEXT_LA_CH;
07496 }
07497 else {
07498 parse_err_flush(Find_EOS, ")");
07499 goto EXIT;
07500 }
07501 }
07502 else {
07503 parse_err_flush(Find_EOS, "(");
07504 goto EXIT;
07505 }
07506
07507 break;
07508
07509 case Tok_SGI_Dir_Mp_Schedtype:
07510
07511 if (! clause_allowed[directive][Mp_Schedtype_Clause]) {
07512 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07513 "MP_SCHEDTYPE", mp_dir_str[directive]);
07514 parse_err_flush(Find_EOS, NULL);
07515 goto EXIT;
07516 }
07517
07518 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
07519 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07520 "MP_SCHEDTYPE", mp_dir_str[directive]);
07521 parse_err_flush(Find_EOS, NULL);
07522 goto EXIT;
07523 }
07524
07525 if (LA_CH_VALUE == EQUAL) {
07526
07527 NEXT_LA_CH;
07528
07529 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
07530
07531 switch (TOKEN_VALUE(token)) {
07532 case Tok_SGI_Dir_Simple:
07533 the_constant = MP_SCHEDTYPE_SIMPLE;
07534 break;
07535 case Tok_SGI_Dir_Static:
07536 the_constant = MP_SCHEDTYPE_SIMPLE;
07537 break;
07538 case Tok_SGI_Dir_Dynamic:
07539 the_constant = MP_SCHEDTYPE_DYNAMIC;
07540 break;
07541 case Tok_SGI_Dir_Interleaved:
07542 the_constant = MP_SCHEDTYPE_INTERLEAVED;
07543 break;
07544 case Tok_SGI_Dir_Interleave:
07545 the_constant = MP_SCHEDTYPE_INTERLEAVED;
07546 break;
07547 case Tok_SGI_Dir_Runtime:
07548 the_constant = MP_SCHEDTYPE_RUNTIME;
07549 break;
07550 case Tok_SGI_Dir_Gss:
07551 the_constant = MP_SCHEDTYPE_GUIDED;
07552 break;
07553 case Tok_SGI_Dir_Guided:
07554 the_constant = MP_SCHEDTYPE_GUIDED;
07555 break;
07556
07557 default:
07558 parse_err_flush(Find_EOS, "MP_SCHEDTYPE mode");
07559 break;
07560 }
07561
07562
07563 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07564 TOKEN_LINE(token);
07565 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07566 TOKEN_COLUMN(token);
07567 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07568 CN_Tbl_Idx;
07569 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07570 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
07571 the_constant);
07572 }
07573 else {
07574 parse_err_flush(Find_EOS, "MP_SCHEDTYPE mode");
07575 }
07576
07577 }
07578 else {
07579 parse_err_flush(Find_EOS, "=");
07580 goto EXIT;
07581 }
07582
07583 break;
07584
07585 case Tok_SGI_Dir_Chunk:
07586
07587 if (! clause_allowed[directive][Chunk_Clause]) {
07588 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07589 "CHUNK", mp_dir_str[directive]);
07590 parse_err_flush(Find_EOS, NULL);
07591 goto EXIT;
07592 }
07593
07594 if (IL_IDX(list_array[MP_DIR_CHUNK_IDX]) != NULL_IDX) {
07595 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07596 "CHUNK or BLOCKED", mp_dir_str[directive]);
07597 parse_err_flush(Find_EOS, NULL);
07598 goto EXIT;
07599 }
07600
07601 if (LA_CH_VALUE == EQUAL) {
07602 NEXT_LA_CH;
07603
07604 parse_expr(&opnd);
07605 COPY_OPND(IL_OPND(list_array[MP_DIR_CHUNK_IDX]),
07606 opnd);
07607 }
07608 else {
07609 parse_err_flush(Find_EOS, "=");
07610 goto EXIT;
07611 }
07612 break;
07613
07614 case Tok_SGI_Dir_Blocked:
07615
07616 if (! clause_allowed[directive][Blocked_Clause]) {
07617 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07618 "BLOCKED", mp_dir_str[directive]);
07619 parse_err_flush(Find_EOS, NULL);
07620 goto EXIT;
07621 }
07622
07623 if (IL_IDX(list_array[MP_DIR_CHUNK_IDX]) != NULL_IDX) {
07624 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07625 "CHUNK or BLOCKED", mp_dir_str[directive]);
07626 parse_err_flush(Find_EOS, NULL);
07627 goto EXIT;
07628 }
07629
07630 if (LA_CH_VALUE == LPAREN) {
07631 NEXT_LA_CH;
07632 parse_expr(&opnd);
07633 COPY_OPND(IL_OPND(list_array[MP_DIR_CHUNK_IDX]),
07634 opnd);
07635
07636 if (LA_CH_VALUE == RPAREN) {
07637 NEXT_LA_CH;
07638 }
07639 else {
07640 parse_err_flush(Find_EOS, ")");
07641 goto EXIT;
07642 }
07643 }
07644 else {
07645 parse_err_flush(Find_EOS, "(");
07646 goto EXIT;
07647 }
07648 break;
07649
07650 case Tok_SGI_Dir_Affinity:
07651
07652 if (! clause_allowed[directive][Affinity_Clause]) {
07653 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07654 "AFFINITY", mp_dir_str[directive]);
07655 parse_err_flush(Find_EOS, NULL);
07656 goto EXIT;
07657 }
07658
07659 if (IL_IDX(list_array[MP_DIR_AFFINITY_IDX]) != NULL_IDX) {
07660 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07661 "AFFINITY", mp_dir_str[directive]);
07662 parse_err_flush(Find_EOS, NULL);
07663 goto EXIT;
07664 }
07665
07666 if (LA_CH_VALUE == LPAREN) {
07667 NEXT_LA_CH;
07668 parse_var_name_list(&opnd);
07669
07670 COPY_OPND(IL_OPND(list_array[MP_DIR_AFFINITY_IDX]), opnd);
07671
07672 if (LA_CH_VALUE == RPAREN) {
07673 NEXT_LA_CH;
07674 }
07675 else {
07676 parse_err_flush(Find_EOS, ")");
07677 goto EXIT;
07678 }
07679 }
07680 else {
07681 parse_err_flush(Find_EOS, "(");
07682 goto EXIT;
07683 }
07684
07685 if (LA_CH_VALUE == EQUAL) {
07686
07687 NEXT_LA_CH;
07688
07689 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
07690
07691 IL_FLD(list_array[MP_DIR_IS_THREAD_IDX]) = CN_Tbl_Idx;
07692 IL_LINE_NUM(list_array[MP_DIR_IS_THREAD_IDX]) =
07693 TOKEN_LINE(token);
07694 IL_COL_NUM(list_array[MP_DIR_IS_THREAD_IDX]) =
07695 TOKEN_COLUMN(token);
07696
07697 switch (TOKEN_VALUE(token)) {
07698 case Tok_SGI_Dir_Data:
07699 IL_IDX(list_array[MP_DIR_IS_THREAD_IDX]) =
07700 CN_INTEGER_ZERO_IDX;
07701 break;
07702 case Tok_SGI_Dir_Thread:
07703 IL_IDX(list_array[MP_DIR_IS_THREAD_IDX]) =
07704 CN_INTEGER_ONE_IDX;
07705
07706 break;
07707
07708 default:
07709 parse_err_flush(Find_EOS, "DATA or THREAD");
07710 break;
07711 }
07712
07713 if (LA_CH_VALUE == LPAREN) {
07714
07715 NEXT_LA_CH;
07716
07717 parse_expr(&opnd);
07718
07719 COPY_OPND(IL_OPND(list_array[
07720 MP_DIR_THREAD_DATA_IDX]), opnd);
07721
07722 if (LA_CH_VALUE == RPAREN) {
07723 NEXT_LA_CH;
07724 }
07725 else {
07726 parse_err_flush(Find_EOS, ")");
07727 goto EXIT;
07728 }
07729 }
07730 else {
07731 parse_err_flush(Find_EOS, "(");
07732 goto EXIT;
07733 }
07734 }
07735 else {
07736 parse_err_flush(Find_EOS, "DATA or THREAD");
07737 }
07738
07739 }
07740 else {
07741 parse_err_flush(Find_EOS, "=");
07742 goto EXIT;
07743 }
07744
07745 if (! dump_flags.dsm) {
07746 opnd = null_opnd;
07747
07748 COPY_OPND(IL_OPND(list_array[MP_DIR_AFFINITY_IDX]),
07749 opnd);
07750 COPY_OPND(IL_OPND(list_array[MP_DIR_THREAD_DATA_IDX]),
07751 opnd);
07752 COPY_OPND(IL_OPND(list_array[MP_DIR_IS_THREAD_IDX]),
07753 opnd);
07754 }
07755 break;
07756
07757 case Tok_SGI_Dir_Local:
07758 case Tok_SGI_Dir_Private:
07759
07760 if (! clause_allowed[directive][Local_Clause]) {
07761 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07762 "LOCAL or PRIVATE", mp_dir_str[directive]);
07763 parse_err_flush(Find_EOS, NULL);
07764 goto EXIT;
07765 }
07766
07767 if (LA_CH_VALUE == LPAREN) {
07768 NEXT_LA_CH;
07769 parse_var_name_list(&opnd);
07770
07771 if (IL_IDX(list_array[MP_DIR_LOCAL_IDX]) == NULL_IDX) {
07772 COPY_OPND(IL_OPND(list_array[MP_DIR_LOCAL_IDX]), opnd);
07773 }
07774 else {
07775
07776
07777 list_idx = IL_IDX(list_array[MP_DIR_LOCAL_IDX]);
07778 while (IL_NEXT_LIST_IDX(list_idx)) {
07779 list_idx = IL_NEXT_LIST_IDX(list_idx);
07780 }
07781
07782
07783 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
07784 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
07785 IL_LIST_CNT(list_array[MP_DIR_LOCAL_IDX]) +=
07786 OPND_LIST_CNT(opnd);
07787 }
07788
07789 if (LA_CH_VALUE == RPAREN) {
07790 NEXT_LA_CH;
07791 }
07792 else {
07793 parse_err_flush(Find_EOS, ")");
07794 goto EXIT;
07795 }
07796 }
07797 else {
07798 parse_err_flush(Find_EOS, "(");
07799 goto EXIT;
07800 }
07801
07802 break;
07803
07804 case Tok_SGI_Dir_Onto:
07805 if (! clause_allowed[directive][Onto_Clause]) {
07806 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07807 "ONTO", mp_dir_str[directive]);
07808 parse_err_flush(Find_EOS, NULL);
07809 goto EXIT;
07810 }
07811
07812 if (seen_nest) {
07813
07814 if (IL_IDX(list_array[MP_DIR_ONTO_IDX]) != NULL_IDX) {
07815 PRINTMSG(TOKEN_LINE(token), 1360, Error,
07816 TOKEN_COLUMN(token),
07817 "ONTO", mp_dir_str[directive]);
07818 parse_err_flush(Find_EOS, NULL);
07819 goto EXIT;
07820 }
07821
07822 if (LA_CH_VALUE == LPAREN) {
07823 NEXT_LA_CH;
07824 parse_int_or_star_list(&opnd);
07825
07826 COPY_OPND(IL_OPND(list_array[MP_DIR_ONTO_IDX]), opnd);
07827
07828 if (LA_CH_VALUE == RPAREN) {
07829 NEXT_LA_CH;
07830 }
07831 else {
07832 parse_err_flush(Find_EOS, ")");
07833 goto EXIT;
07834 }
07835 }
07836 else {
07837 parse_err_flush(Find_EOS, "(");
07838 goto EXIT;
07839 }
07840
07841 list_idx = list_array[MP_DIR_ONTO_IDX];
07842
07843 list2_idx = list_array[MP_DIR_NEST_IDX];
07844
07845 if (IL_FLD(list2_idx) != IL_Tbl_Idx ||
07846 IL_LIST_CNT(list2_idx) != IL_LIST_CNT(list_idx)) {
07847
07848
07849
07850 find_opnd_line_and_column(&IL_OPND(IL_IDX(list_idx)),
07851 &line, &column);
07852
07853 PRINTMSG(line, 1369, Error, column);
07854 }
07855 else if (IL_LIST_CNT(list2_idx) == 1) {
07856
07857
07858 find_opnd_line_and_column(&IL_OPND(IL_IDX(list_idx)),
07859 &line, &column);
07860
07861 PRINTMSG(line, 1377, Error, column);
07862 }
07863 }
07864 else {
07865 PRINTMSG(TOKEN_LINE(token), 1361, Error, TOKEN_COLUMN(token),
07866 mp_dir_str[directive]);
07867 parse_err_flush(Find_EOS, NULL);
07868 goto EXIT;
07869 }
07870 break;
07871
07872 case Tok_SGI_Dir_Nest:
07873
07874 if (! clause_allowed[directive][Nest_Clause]) {
07875 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07876 "NEST", mp_dir_str[directive]);
07877 parse_err_flush(Find_EOS, NULL);
07878 goto EXIT;
07879 }
07880
07881 if (seen_nest) {
07882 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07883 "NEST", mp_dir_str[directive]);
07884 parse_err_flush(Find_EOS, NULL);
07885 goto EXIT;
07886 }
07887
07888 seen_nest = TRUE;
07889
07890 if (LA_CH_VALUE == LPAREN) {
07891 NEXT_LA_CH;
07892 parse_var_name_list(&opnd);
07893
07894 COPY_OPND(IL_OPND(list_array[MP_DIR_NEST_IDX]), opnd);
07895
07896 if (LA_CH_VALUE == RPAREN) {
07897 NEXT_LA_CH;
07898 }
07899 else {
07900 parse_err_flush(Find_EOS, ")");
07901 goto EXIT;
07902 }
07903 }
07904 else {
07905 parse_err_flush(Find_EOS, "(");
07906 goto EXIT;
07907 }
07908
07909 break;
07910
07911 case Tok_SGI_Dir_Lastthread:
07912
07913 if (! clause_allowed[directive][Lastthread_Clause]) {
07914 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07915 "LASTTHREAD", mp_dir_str[directive]);
07916 parse_err_flush(Find_EOS, NULL);
07917 goto EXIT;
07918 }
07919
07920 if (IL_IDX(list_array[MP_DIR_LASTTHREAD_IDX]) != NULL_IDX) {
07921 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07922 "LASTTHREAD", mp_dir_str[directive]);
07923 parse_err_flush(Find_EOS, NULL);
07924 goto EXIT;
07925 }
07926
07927 if (LA_CH_VALUE == LPAREN) {
07928 NEXT_LA_CH;
07929
07930 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
07931
07932 if (! parse_deref(&opnd, NULL_IDX)) {
07933 parse_err_flush(Find_Rparen, NULL);
07934 }
07935 else if (OPND_FLD(opnd) != AT_Tbl_Idx) {
07936 find_opnd_line_and_column(&opnd, &line, &column);
07937 PRINTMSG(line, 1376, Error, column);
07938 }
07939 else {
07940 COPY_OPND(IL_OPND(list_array[MP_DIR_LASTTHREAD_IDX]),
07941 opnd);
07942 }
07943 }
07944 else {
07945 parse_err_flush(Find_Rparen, "IDENTIFIER");
07946 }
07947
07948 if (LA_CH_VALUE == RPAREN) {
07949 NEXT_LA_CH;
07950 }
07951 else {
07952 parse_err_flush(Find_EOS, ")");
07953 goto EXIT;
07954 }
07955 }
07956 else {
07957 parse_err_flush(Find_EOS, "(");
07958 goto EXIT;
07959 }
07960 break;
07961
07962
07963
07964 case Tok_SGI_Dir_Simple:
07965 if (! clause_allowed[directive][Mode_Clause]) {
07966 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07967 "MODE", mp_dir_str[directive]);
07968 parse_err_flush(Find_EOS, NULL);
07969 goto EXIT;
07970 }
07971
07972 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
07973 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
07974 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
07975 parse_err_flush(Find_EOS, NULL);
07976 goto EXIT;
07977 }
07978
07979 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07980 TOKEN_LINE(token);
07981 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07982 TOKEN_COLUMN(token);
07983 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
07984 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
07985 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
07986 MP_SCHEDTYPE_SIMPLE);
07987
07988 break;
07989
07990 case Tok_SGI_Dir_Static:
07991 if (! clause_allowed[directive][Mode_Clause]) {
07992 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
07993 "MODE", mp_dir_str[directive]);
07994 parse_err_flush(Find_EOS, NULL);
07995 goto EXIT;
07996 }
07997
07998 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
07999 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08000 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08001 parse_err_flush(Find_EOS, NULL);
08002 goto EXIT;
08003 }
08004
08005 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08006 TOKEN_LINE(token);
08007 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08008 TOKEN_COLUMN(token);
08009 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08010 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08011 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08012 MP_SCHEDTYPE_SIMPLE);
08013
08014 break;
08015
08016 case Tok_SGI_Dir_Dynamic:
08017 if (! clause_allowed[directive][Mode_Clause]) {
08018 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08019 "MODE", mp_dir_str[directive]);
08020 parse_err_flush(Find_EOS, NULL);
08021 goto EXIT;
08022 }
08023
08024 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08025 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08026 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08027 parse_err_flush(Find_EOS, NULL);
08028 goto EXIT;
08029 }
08030
08031 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08032 TOKEN_LINE(token);
08033 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08034 TOKEN_COLUMN(token);
08035 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08036 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08037 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08038 MP_SCHEDTYPE_DYNAMIC);
08039
08040 break;
08041
08042 case Tok_SGI_Dir_Interleaved:
08043 if (! clause_allowed[directive][Mode_Clause]) {
08044 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08045 "MODE", mp_dir_str[directive]);
08046 parse_err_flush(Find_EOS, NULL);
08047 goto EXIT;
08048 }
08049
08050 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08051 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08052 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08053 parse_err_flush(Find_EOS, NULL);
08054 goto EXIT;
08055 }
08056
08057 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08058 TOKEN_LINE(token);
08059 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08060 TOKEN_COLUMN(token);
08061 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08062 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08063 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08064 MP_SCHEDTYPE_INTERLEAVED);
08065
08066 break;
08067
08068 case Tok_SGI_Dir_Interleave:
08069 if (! clause_allowed[directive][Mode_Clause]) {
08070 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08071 "MODE", mp_dir_str[directive]);
08072 parse_err_flush(Find_EOS, NULL);
08073 goto EXIT;
08074 }
08075
08076 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08077 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08078 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08079 parse_err_flush(Find_EOS, NULL);
08080 goto EXIT;
08081 }
08082
08083 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08084 TOKEN_LINE(token);
08085 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08086 TOKEN_COLUMN(token);
08087 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08088 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08089 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08090 MP_SCHEDTYPE_INTERLEAVED);
08091
08092 break;
08093
08094 case Tok_SGI_Dir_Runtime:
08095 if (! clause_allowed[directive][Mode_Clause]) {
08096 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08097 "MODE", mp_dir_str[directive]);
08098 parse_err_flush(Find_EOS, NULL);
08099 goto EXIT;
08100 }
08101
08102 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08103 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08104 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08105 parse_err_flush(Find_EOS, NULL);
08106 goto EXIT;
08107 }
08108
08109 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08110 TOKEN_LINE(token);
08111 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08112 TOKEN_COLUMN(token);
08113 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08114 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08115 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08116 MP_SCHEDTYPE_RUNTIME);
08117
08118 break;
08119
08120 case Tok_SGI_Dir_Gss:
08121 if (! clause_allowed[directive][Mode_Clause]) {
08122 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08123 "MODE", mp_dir_str[directive]);
08124 parse_err_flush(Find_EOS, NULL);
08125 goto EXIT;
08126 }
08127
08128 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08129 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08130 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08131 parse_err_flush(Find_EOS, NULL);
08132 goto EXIT;
08133 }
08134
08135 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08136 TOKEN_LINE(token);
08137 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08138 TOKEN_COLUMN(token);
08139 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08140 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08141 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08142 MP_SCHEDTYPE_GUIDED);
08143
08144 break;
08145
08146 case Tok_SGI_Dir_Guided:
08147 if (! clause_allowed[directive][Mode_Clause]) {
08148 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
08149 "MODE", mp_dir_str[directive]);
08150 parse_err_flush(Find_EOS, NULL);
08151 goto EXIT;
08152 }
08153
08154 if (IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) != NULL_IDX) {
08155 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
08156 "MODE or MP_SCHEDTYPE", mp_dir_str[directive]);
08157 parse_err_flush(Find_EOS, NULL);
08158 goto EXIT;
08159 }
08160
08161 IL_LINE_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08162 TOKEN_LINE(token);
08163 IL_COL_NUM(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08164 TOKEN_COLUMN(token);
08165 IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) = CN_Tbl_Idx;
08166 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) =
08167 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
08168 MP_SCHEDTYPE_GUIDED);
08169
08170 break;
08171
08172 default:
08173 PRINTMSG(TOKEN_LINE(token), 1517, Error, TOKEN_COLUMN(token),
08174 "mp");
08175 parse_err_flush(Find_EOS, NULL);
08176 break;
08177 }
08178 }
08179 else {
08180 parse_err_flush(Find_EOS, "mp clause");
08181 }
08182
08183 if (LA_CH_VALUE == COMMA) {
08184 NEXT_LA_CH;
08185 }
08186 }
08187
08188
08189 if (clause_allowed[directive][Chunk_Clause] &&
08190 IL_IDX(list_array[MP_DIR_CHUNK_IDX]) == NULL_IDX &&
08191 OPND_FLD(cdir_switches.chunk_opnd) != NO_Tbl_Idx) {
08192
08193 COPY_OPND(IL_OPND(list_array[MP_DIR_CHUNK_IDX]),
08194 cdir_switches.chunk_opnd);
08195 }
08196
08197 if (clause_allowed[directive][Mp_Schedtype_Clause] &&
08198 IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) == NULL_IDX &&
08199 OPND_FLD(cdir_switches.mp_schedtype_opnd) != NO_Tbl_Idx) {
08200
08201 COPY_OPND(IL_OPND(list_array[MP_DIR_MP_SCHEDTYPE_IDX]),
08202 cdir_switches.mp_schedtype_opnd);
08203 }
08204
08205
08206 EXIT:
08207
08208 TRACE (Func_Exit, "parse_mp_directive", NULL);
08209
08210 return;
08211
08212 }
08213
08214
08215
08216
08217
08218
08219
08220
08221
08222
08223
08224
08225
08226
08227
08228
08229
08230 static void parse_int_or_star_list(opnd_type *list_opnd)
08231
08232 {
08233 int list_idx = NULL_IDX;
08234 opnd_type opnd;
08235
08236
08237 TRACE (Func_Entry, "parse_int_or_star_list", NULL);
08238
08239 while(TRUE) {
08240
08241 if (LA_CH_VALUE == STAR) {
08242 OPND_FLD(opnd) = CN_Tbl_Idx;
08243 OPND_IDX(opnd) = CN_INTEGER_ZERO_IDX;
08244 OPND_LINE_NUM(opnd) = LA_CH_LINE;
08245 OPND_COL_NUM(opnd) = LA_CH_COLUMN;
08246 NEXT_LA_CH;
08247 }
08248 else {
08249 parse_expr(&opnd);
08250 }
08251
08252 if (list_idx == NULL_IDX) {
08253 NTR_IR_LIST_TBL(list_idx);
08254 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
08255 OPND_IDX((*list_opnd)) = list_idx;
08256 OPND_LIST_CNT((*list_opnd)) = 1;
08257 }
08258 else {
08259 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
08260 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
08261 (OPND_LIST_CNT((*list_opnd)))++;
08262 list_idx = IL_NEXT_LIST_IDX(list_idx);
08263 }
08264 COPY_OPND(IL_OPND(list_idx), opnd);
08265
08266 if (LA_CH_VALUE != COMMA) {
08267 break;
08268 }
08269 NEXT_LA_CH;
08270 }
08271
08272
08273 TRACE (Func_Exit, "parse_int_or_star_list", NULL);
08274
08275 return;
08276
08277 }
08278
08279
08280
08281
08282
08283
08284
08285
08286
08287
08288
08289
08290
08291
08292
08293
08294
08295
08296 static void parse_reference_list(opnd_type *list_opnd)
08297
08298 {
08299 int list_idx = NULL_IDX;
08300 opnd_type opnd;
08301
08302
08303 TRACE (Func_Entry, "parse_reference_list", NULL);
08304
08305 while(TRUE) {
08306
08307 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
08308 parse_deref(&opnd, NULL_IDX);
08309
08310 if (list_idx == NULL_IDX) {
08311 NTR_IR_LIST_TBL(list_idx);
08312 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
08313 OPND_IDX((*list_opnd)) = list_idx;
08314 OPND_LIST_CNT((*list_opnd)) = 1;
08315 }
08316 else {
08317 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
08318 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
08319 (OPND_LIST_CNT((*list_opnd)))++;
08320 list_idx = IL_NEXT_LIST_IDX(list_idx);
08321 }
08322 COPY_OPND(IL_OPND(list_idx), opnd);
08323 }
08324 else {
08325 parse_err_flush(Find_Comma_Rparen, "IDENTIFIER");
08326 }
08327
08328 if (LA_CH_VALUE != COMMA) {
08329 break;
08330 }
08331 NEXT_LA_CH;
08332 }
08333
08334 TRACE (Func_Exit, "parse_reference_list", NULL);
08335
08336 return;
08337
08338 }
08339
08340
08341
08342
08343
08344
08345
08346
08347
08348
08349
08350
08351
08352
08353
08354
08355
08356 static void parse_var_common_list(opnd_type *list_opnd,
08357 boolean subobjects_allowed)
08358
08359 {
08360 int attr_idx;
08361 int column;
08362 int line;
08363 int list_idx = NULL_IDX;
08364 int name_idx;
08365 opnd_type opnd;
08366 int sb_idx;
08367 token_values_type token_value;
08368
08369
08370 TRACE (Func_Entry, "parse_var_common_list", NULL);
08371
08372 token_value = TOKEN_VALUE(token);
08373
08374 while(TRUE) {
08375
08376 if (LA_CH_VALUE == SLASH) {
08377 NEXT_LA_CH;
08378
08379 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
08380
08381 if (LA_CH_VALUE == SLASH) {
08382 NEXT_LA_CH;
08383
08384 sb_idx = srch_stor_blk_tbl(TOKEN_STR(token),
08385 TOKEN_LEN(token),
08386 curr_scp_idx);
08387
08388 if (sb_idx == NULL_IDX) {
08389 sb_idx = ntr_stor_blk_tbl(TOKEN_STR(token),
08390 TOKEN_LEN(token),
08391 TOKEN_LINE(token),
08392 TOKEN_COLUMN(token),
08393 Common);
08394 SB_COMMON_NEEDS_OFFSET(sb_idx) = TRUE;
08395 SB_IS_COMMON(sb_idx) = TRUE;
08396 }
08397
08398 switch (token_value) {
08399 case Tok_SGI_Dir_Section_Gp:
08400 SB_SECTION_GP(sb_idx) = TRUE;
08401 break;
08402 case Tok_SGI_Dir_Section_Non_Gp:
08403 SB_SECTION_NON_GP(sb_idx) = TRUE;
08404 break;
08405 }
08406
08407 if (list_idx == NULL_IDX) {
08408 NTR_IR_LIST_TBL(list_idx);
08409 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
08410 OPND_IDX((*list_opnd)) = list_idx;
08411 OPND_LIST_CNT((*list_opnd)) = 1;
08412 }
08413 else {
08414 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
08415 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
08416 (OPND_LIST_CNT((*list_opnd)))++;
08417 list_idx = IL_NEXT_LIST_IDX(list_idx);
08418 }
08419
08420 IL_IDX(list_idx) = sb_idx;
08421 IL_FLD(list_idx) = SB_Tbl_Idx;
08422 IL_LINE_NUM(list_idx) = TOKEN_LINE(token);
08423 IL_COL_NUM(list_idx) = TOKEN_COLUMN(token);
08424 }
08425 else {
08426 parse_err_flush(Find_Rparen, "/");
08427 }
08428 }
08429 else {
08430 parse_err_flush(Find_Comma_Rparen, "common-block-name");
08431 }
08432 }
08433 else if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
08434 OPND_LINE_NUM(opnd) = TOKEN_LINE(token);
08435 OPND_COL_NUM(opnd) = TOKEN_COLUMN(token);
08436
08437 if (token_value == Tok_SGI_Dir_Section_Gp) {
08438 attr_idx = srch_sym_tbl(TOKEN_STR(token),
08439 TOKEN_LEN(token),
08440 &name_idx);
08441
08442 if (attr_idx == NULL_IDX) {
08443 attr_idx = ntr_sym_tbl(&token, name_idx);
08444 LN_DEF_LOC(name_idx) = TRUE;
08445 AT_OBJ_CLASS(attr_idx) = Data_Obj;
08446 ATD_SECTION_GP(attr_idx) = TRUE;
08447 SET_IMPL_TYPE(attr_idx);
08448 OPND_IDX(opnd) = attr_idx;
08449 OPND_FLD(opnd) = AT_Tbl_Idx;
08450 }
08451 else if (fnd_semantic_err(Obj_Section_Gp,
08452 OPND_LINE_NUM(opnd),
08453 OPND_COL_NUM(opnd),
08454 attr_idx,
08455 TRUE)) {
08456 goto NEXT;
08457 }
08458
08459 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit &&
08460 ATP_PGM_UNIT(attr_idx) == Module) {
08461
08462
08463
08464
08465 if (attr_idx != SCP_ATTR_IDX(curr_scp_idx)) {
08466
08467
08468
08469 PRINTMSG(TOKEN_LINE(token), 1491, Error,
08470 TOKEN_COLUMN(token),
08471 "SECTION_GP");
08472 }
08473 else if (SB_SECTION_NON_GP(SCP_SB_STATIC_IDX(curr_scp_idx))) {
08474 PRINTMSG(TOKEN_LINE(token), 1490, Error,
08475 TOKEN_COLUMN(token),
08476 AT_OBJ_NAME_PTR(attr_idx),
08477 "SECTION_GP", "SECTION_NON_GP");
08478 }
08479 else {
08480 SB_SECTION_GP(SCP_SB_STATIC_IDX(curr_scp_idx)) = TRUE;
08481 }
08482
08483 OPND_IDX(opnd) = SCP_SB_STATIC_IDX(curr_scp_idx);
08484 OPND_FLD(opnd) = SB_Tbl_Idx;
08485 }
08486 else {
08487 ATD_SECTION_GP(attr_idx) = TRUE;
08488 OPND_IDX(opnd) = attr_idx;
08489 OPND_FLD(opnd) = AT_Tbl_Idx;
08490 }
08491 }
08492 else if (token_value == Tok_SGI_Dir_Section_Non_Gp) {
08493 attr_idx = srch_sym_tbl(TOKEN_STR(token),
08494 TOKEN_LEN(token),
08495 &name_idx);
08496
08497 if (attr_idx == NULL_IDX) {
08498 attr_idx = ntr_sym_tbl(&token, name_idx);
08499 LN_DEF_LOC(name_idx) = TRUE;
08500 AT_OBJ_CLASS(attr_idx) = Data_Obj;
08501 ATD_SECTION_NON_GP(attr_idx) = TRUE;
08502 SET_IMPL_TYPE(attr_idx);
08503 OPND_IDX(opnd) = attr_idx;
08504 OPND_FLD(opnd) = AT_Tbl_Idx;
08505 }
08506 else if (fnd_semantic_err(Obj_Section_Non_Gp,
08507 OPND_LINE_NUM(opnd),
08508 OPND_COL_NUM(opnd),
08509 attr_idx,
08510 TRUE)) {
08511 goto NEXT;
08512 }
08513
08514 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit &&
08515 ATP_PGM_UNIT(attr_idx) == Module) {
08516
08517
08518
08519
08520 if (attr_idx != SCP_ATTR_IDX(curr_scp_idx)) {
08521
08522
08523
08524 PRINTMSG(TOKEN_LINE(token), 1491, Error,
08525 TOKEN_COLUMN(token),
08526 "SECTION_NON_GP");
08527 }
08528 else if (SB_SECTION_GP(SCP_SB_STATIC_IDX(curr_scp_idx))) {
08529 PRINTMSG(TOKEN_LINE(token), 1490, Error,
08530 TOKEN_COLUMN(token),
08531 AT_OBJ_NAME_PTR(attr_idx),
08532 "SECTION_NON_GP", "SECTION_GP");
08533 }
08534 else {
08535 SB_SECTION_NON_GP(SCP_SB_STATIC_IDX(curr_scp_idx)) = TRUE;
08536 }
08537 OPND_IDX(opnd) = SCP_SB_STATIC_IDX(curr_scp_idx);
08538 OPND_FLD(opnd) = SB_Tbl_Idx;
08539 }
08540 else {
08541 ATD_SECTION_NON_GP(attr_idx) = TRUE;
08542 OPND_IDX(opnd) = attr_idx;
08543 OPND_FLD(opnd) = AT_Tbl_Idx;
08544 }
08545 }
08546 else {
08547 parse_deref(&opnd, NULL_IDX);
08548 find_opnd_line_and_column(&opnd, &line, &column);
08549
08550 if (!subobjects_allowed && OPND_FLD(opnd) != AT_Tbl_Idx) {
08551 PRINTMSG(line, 802, Error, column);
08552 goto NEXT;
08553 }
08554 }
08555
08556 if (list_idx == NULL_IDX) {
08557 NTR_IR_LIST_TBL(list_idx);
08558 OPND_FLD((*list_opnd)) = IL_Tbl_Idx;
08559 OPND_IDX((*list_opnd)) = list_idx;
08560 OPND_LIST_CNT((*list_opnd)) = 1;
08561 }
08562 else {
08563 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
08564 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
08565 (OPND_LIST_CNT((*list_opnd)))++;
08566 list_idx = IL_NEXT_LIST_IDX(list_idx);
08567 }
08568
08569 COPY_OPND(IL_OPND(list_idx), opnd);
08570 }
08571 else {
08572 parse_err_flush(Find_Comma_Rparen, "IDENTIFIER");
08573 }
08574
08575 NEXT:
08576
08577 if (LA_CH_VALUE != COMMA) {
08578 break;
08579 }
08580 NEXT_LA_CH;
08581 }
08582
08583 TRACE (Func_Exit, "parse_var_common_list", NULL);
08584
08585 return;
08586
08587 }
08588
08589
08590
08591
08592
08593
08594
08595
08596
08597
08598
08599
08600
08601
08602
08603
08604
08605 static void parse_fill_align_symbol(void)
08606
08607 {
08608 int align_symbol;
08609 int attr_idx;
08610 int ir_idx;
08611 int name_idx;
08612 opnd_type opnd;
08613
08614
08615 TRACE (Func_Entry, "parse_fill_align_symbol", NULL);
08616
08617 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
08618 align_symbol = (TOKEN_VALUE(token) == Tok_SGI_Dir_Align_Symbol);
08619 expr_mode = Specification_Expr;
08620
08621 if (LA_CH_VALUE == LPAREN) {
08622 NEXT_LA_CH;
08623
08624 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
08625 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
08626 &name_idx);
08627
08628 if (attr_idx == NULL_IDX) {
08629 attr_idx = ntr_sym_tbl(&token, name_idx);
08630 LN_DEF_LOC(name_idx) = TRUE;
08631 AT_OBJ_CLASS(attr_idx) = Data_Obj;
08632 SET_IMPL_TYPE(attr_idx);
08633
08634 if (align_symbol) {
08635 ATD_ALIGN_SYMBOL(attr_idx) = TRUE;
08636 }
08637 else {
08638 ATD_FILL_SYMBOL(attr_idx) = TRUE;
08639 }
08640
08641 IR_IDX_L(ir_idx) = attr_idx;
08642 IR_FLD_L(ir_idx) = AT_Tbl_Idx;
08643 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
08644 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
08645 }
08646 else if (!fnd_semantic_err(align_symbol ? Obj_Align_Symbol :
08647 Obj_Fill_Symbol,
08648 TOKEN_LINE(token),
08649 TOKEN_COLUMN(token),
08650 attr_idx,
08651 TRUE)) {
08652
08653 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
08654 AT_ATTR_LINK(attr_idx) = NULL_IDX;
08655 LN_DEF_LOC(name_idx) = TRUE;
08656 }
08657
08658 if (align_symbol) {
08659 ATD_ALIGN_SYMBOL(attr_idx) = TRUE;
08660 }
08661 else {
08662 ATD_FILL_SYMBOL(attr_idx) = TRUE;
08663 }
08664
08665 IR_IDX_L(ir_idx) = attr_idx;
08666 IR_FLD_L(ir_idx) = AT_Tbl_Idx;
08667 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
08668 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
08669 }
08670
08671 if (LA_CH_VALUE == LPAREN) {
08672 PRINTMSG(LA_CH_LINE, 1487, Error, LA_CH_COLUMN,
08673 align_symbol ? "ALIGN_SYMBOL": "FILL_SYMBOL");
08674 parse_err_flush(Find_Rparen, NULL);
08675
08676 if (LA_CH_VALUE == RPAREN) {
08677 NEXT_LA_CH;
08678 }
08679 }
08680 }
08681 else {
08682 parse_err_flush(Find_EOS, "variable-name");
08683 goto EXIT;
08684 }
08685
08686 if (LA_CH_VALUE == COMMA) {
08687 NEXT_LA_CH;
08688
08689 if (isdigit(LA_CH_VALUE)) {
08690 parse_expr(&opnd);
08691 COPY_OPND(IR_OPND_R(ir_idx), opnd);
08692 }
08693 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
08694
08695 switch (TOKEN_VALUE(token)) {
08696 case Tok_SGI_Dir_L1cacheline:
08697 IR_IDX_R(ir_idx) = CN_INTEGER_NEG_ONE_IDX;
08698 break;
08699
08700 case Tok_SGI_Dir_L2cacheline:
08701 IR_IDX_R(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE, -2);
08702 break;
08703
08704 case Tok_SGI_Dir_Page:
08705 IR_IDX_R(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE, -3);
08706 break;
08707
08708 default:
08709 parse_err_flush(Find_EOS, "L1cacheline, L2cacheline, or page");
08710 IR_IDX_R(ir_idx) = CN_INTEGER_ZERO_IDX;
08711 break;
08712 }
08713
08714 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
08715 IR_LINE_NUM_R(ir_idx) = TOKEN_LINE(token);
08716 IR_COL_NUM_R(ir_idx) = TOKEN_COLUMN(token);
08717 }
08718 else {
08719 parse_err_flush(Find_Rparen, "L1cacheline or L2cacheline or page");
08720 }
08721
08722 if (LA_CH_VALUE == RPAREN) {
08723 NEXT_LA_CH;
08724 }
08725 else {
08726 parse_err_flush(Find_EOS, ")");
08727 }
08728 }
08729 else {
08730 parse_err_flush(Find_EOS, ",L1cacheline or L2cacheline or page");
08731 }
08732 }
08733 else {
08734 parse_err_flush(Find_EOS, "(");
08735 }
08736
08737 EXIT:
08738
08739 expr_mode = Regular_Expr;
08740
08741 TRACE (Func_Exit, "parse_fill_align_symbol", NULL);
08742
08743 return;
08744
08745 }
08746
08747
08748
08749
08750
08751
08752
08753
08754
08755
08756
08757
08758
08759
08760
08761
08762
08763 static void parse_sgi_dir_inline(boolean turn_on)
08764
08765 {
08766 enum scope_entry {
08767 Here,
08768 Routine,
08769 Global
08770 };
08771
08772 typedef enum scope_entry scope_type;
08773
08774 boolean amb_ref = FALSE;
08775 #ifdef KEY
08776 int attr_idx = 0;
08777 int column = 0;
08778 #else
08779 int attr_idx;
08780 int column;
08781 #endif
08782 int host_attr_idx;
08783 int host_name_idx;
08784 boolean inline_dir = FALSE;
08785 #ifdef KEY
08786 int ir_idx = 0;
08787 int line = 0;
08788 #else
08789 int ir_idx;
08790 int line;
08791 #endif
08792 int list_idx;
08793 int name_idx;
08794 scope_type scope = Here;
08795
08796
08797 TRACE (Func_Entry, "parse_sgi_dir_inline", NULL);
08798
08799
08800
08801
08802
08803 if (TOKEN_VALUE(token) == Tok_SGI_Dir_Inline ||
08804 TOKEN_VALUE(token) == Tok_SGI_Dir_Noinline) {
08805 inline_dir = TRUE;
08806 }
08807
08808 if (LA_CH_VALUE != LPAREN) {
08809
08810 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
08811
08812 switch (TOKEN_VALUE(token)) {
08813 case Tok_SGI_Dir_Here:
08814 scope = Here;
08815 break;
08816
08817 case Tok_SGI_Dir_Routine:
08818 scope = Routine;
08819 break;
08820
08821 case Tok_SGI_Dir_Global:
08822 scope = Global;
08823 break;
08824
08825 default:
08826 parse_err_flush(Find_EOS, "HERE, ROUTINE, or GLOBAL");
08827 goto EXIT;
08828 }
08829 }
08830 }
08831
08832 if (scope == Here) {
08833 ir_idx = gen_directive_ir(turn_on ? Inline_Here_Star_Opr :
08834 Noinline_Here_Star_Opr);
08835
08836
08837
08838
08839 cdir_switches.inline_here_sgi = TRUE;
08840 }
08841 else if (scope == Routine) {
08842 ir_idx = gen_directive_ir(turn_on ? Inline_Routine_Star_Opr :
08843 Noinline_Routine_Star_Opr);
08844 }
08845 else if (scope == Global) {
08846 ir_idx = gen_directive_ir(turn_on ? Inline_Global_Star_Opr :
08847 Noinline_Global_Star_Opr);
08848 }
08849
08850 if (LA_CH_VALUE == LPAREN) {
08851 NEXT_LA_CH;
08852
08853 while (TRUE) {
08854
08855 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
08856 line = TOKEN_LINE(token);
08857 column = TOKEN_COLUMN(token);
08858
08859 attr_idx = srch_sym_tbl(TOKEN_STR(token),
08860 TOKEN_LEN(token),
08861 &name_idx);
08862
08863 if (attr_idx != NULL_IDX) {
08864 host_attr_idx = attr_idx;
08865
08866 if (! LN_DEF_LOC(name_idx)) {
08867 amb_ref = TRUE;
08868
08869 while (AT_ATTR_LINK(host_attr_idx) != NULL_IDX) {
08870 host_attr_idx = AT_ATTR_LINK(host_attr_idx);
08871 }
08872 }
08873 }
08874 else {
08875 amb_ref = TRUE;
08876 host_attr_idx = srch_host_sym_tbl(TOKEN_STR(token),
08877 TOKEN_LEN(token),
08878 &host_name_idx,
08879 TRUE);
08880
08881 if (host_attr_idx != NULL_IDX) {
08882
08883 if (AT_IS_INTRIN(host_attr_idx) &&
08884 ATI_FIRST_SPECIFIC_IDX(host_attr_idx) == NULL_IDX) {
08885 complete_intrinsic_definition(host_attr_idx);
08886 attr_idx = srch_sym_tbl(TOKEN_STR(token),
08887 TOKEN_LEN(token),
08888 &name_idx);
08889 }
08890
08891 attr_idx = ntr_host_in_sym_tbl(&token,
08892 name_idx,
08893 host_attr_idx,
08894 host_name_idx,
08895 TRUE);
08896
08897 if (AT_IS_INTRIN(host_attr_idx)) {
08898 COPY_VARIANT_ATTR_INFO(host_attr_idx,
08899 attr_idx,
08900 Interface);
08901
08902 AT_IS_INTRIN(attr_idx) = TRUE;
08903 AT_ATTR_LINK(attr_idx) = NULL_IDX;
08904 AT_ELEMENTAL_INTRIN(attr_idx) =
08905 AT_ELEMENTAL_INTRIN(host_attr_idx);
08906 AT_DEF_LINE(attr_idx) = TOKEN_LINE(token);
08907 AT_DEF_COLUMN(attr_idx) = TOKEN_COLUMN(token);
08908 }
08909 else if (AT_OBJ_CLASS(attr_idx) != Interface) {
08910 AT_ATTR_LINK(attr_idx) = host_attr_idx;
08911
08912 while (AT_ATTR_LINK(host_attr_idx) != NULL_IDX) {
08913 host_attr_idx = AT_ATTR_LINK(host_attr_idx);
08914 }
08915 }
08916 }
08917 }
08918
08919 if (attr_idx == NULL_IDX) {
08920 attr_idx = ntr_sym_tbl(&token, name_idx);
08921 AT_OBJ_CLASS(attr_idx) = Pgm_Unit;
08922 ATP_PGM_UNIT(attr_idx) = Pgm_Unknown;
08923 ATP_SCP_IDX(attr_idx) = curr_scp_idx;
08924 MAKE_EXTERNAL_NAME(attr_idx,
08925 AT_NAME_IDX(attr_idx),
08926 AT_NAME_LEN(attr_idx));
08927 ATP_PROC(attr_idx) = Unknown_Proc;
08928 }
08929 else if (!amb_ref) {
08930
08931
08932
08933
08934
08935 if (AT_OBJ_CLASS(attr_idx) == Interface && scope == Global) {
08936
08937
08938
08939
08940 PRINTMSG(line, 1654, Error, column,
08941 AT_OBJ_NAME_PTR(attr_idx),
08942 (inline_dir) ? "INLINE" : "IPA");
08943 parse_err_flush(Find_EOS, NULL);
08944 goto EXIT;
08945 }
08946
08947 if (fnd_semantic_err((inline_dir ? Obj_Inline : Obj_Ipa),
08948 line,
08949 column,
08950 attr_idx,
08951 TRUE)) {
08952 parse_err_flush(Find_EOS, NULL);
08953 goto EXIT;
08954 }
08955 }
08956 }
08957
08958 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) {
08959 chg_data_obj_to_pgm_unit(attr_idx,
08960 Pgm_Unknown,
08961 Unknown_Proc);
08962 }
08963
08964 if (AT_OBJ_CLASS(attr_idx) == Interface) {
08965
08966
08967
08968
08969 if (scope == Routine) {
08970
08971 if (turn_on) {
08972 ATI_SGI_ROUTINE_INLINE(attr_idx) = TRUE;
08973 ATI_SGI_ROUTINE_NOINLINE(attr_idx) = FALSE;
08974 }
08975 else {
08976 ATI_SGI_ROUTINE_NOINLINE(attr_idx) = TRUE;
08977 ATI_SGI_ROUTINE_INLINE(attr_idx) = FALSE;
08978 ATI_IPA_DIR_SPECIFIED(attr_idx) = TRUE;
08979 }
08980 }
08981 }
08982 else if (scope == Routine) {
08983
08984 if (turn_on) {
08985 ATP_SGI_ROUTINE_INLINE(attr_idx) = TRUE;
08986 ATP_SGI_ROUTINE_NOINLINE(attr_idx) = FALSE;
08987 }
08988 else {
08989 ATP_SGI_ROUTINE_NOINLINE(attr_idx) = TRUE;
08990 ATP_SGI_ROUTINE_INLINE(attr_idx) = FALSE;
08991 }
08992 }
08993 else if (scope == Global) {
08994
08995
08996
08997 ATP_SGI_ROUTINE_INLINE(attr_idx) = FALSE;
08998 ATP_SGI_ROUTINE_NOINLINE(attr_idx) = FALSE;
08999
09000 if (turn_on) {
09001 ATP_SGI_GLOBAL_INLINE(attr_idx) = TRUE;
09002 ATP_SGI_GLOBAL_NOINLINE(attr_idx) = FALSE;
09003 }
09004 else {
09005 ATP_SGI_GLOBAL_NOINLINE(attr_idx) = TRUE;
09006 ATP_SGI_GLOBAL_INLINE(attr_idx) = FALSE;
09007 }
09008
09009 host_attr_idx = AT_ATTR_LINK(attr_idx);
09010
09011 while (host_attr_idx) {
09012 ATP_SGI_GLOBAL_INLINE(host_attr_idx) =
09013 ATP_SGI_GLOBAL_INLINE(attr_idx);
09014 ATP_SGI_GLOBAL_NOINLINE(host_attr_idx) =
09015 ATP_SGI_GLOBAL_NOINLINE(attr_idx);
09016
09017 ATP_SGI_ROUTINE_INLINE(host_attr_idx) = FALSE;
09018 ATP_SGI_ROUTINE_NOINLINE(host_attr_idx) = FALSE;
09019
09020 host_attr_idx = AT_ATTR_LINK(host_attr_idx);
09021 }
09022 }
09023
09024
09025
09026 NTR_IR_LIST_TBL(list_idx);
09027
09028 if (IR_FLD_L(ir_idx) == NO_Tbl_Idx) {
09029 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
09030 IR_IDX_L(ir_idx) = list_idx;
09031 IR_LIST_CNT_L(ir_idx) = 1;
09032 }
09033 else {
09034 IL_NEXT_LIST_IDX(list_idx) = IR_IDX_L(ir_idx);
09035 IL_PREV_LIST_IDX(IR_IDX_L(ir_idx)) = list_idx;
09036 IR_IDX_L(ir_idx) = list_idx;
09037 IR_LIST_CNT_L(ir_idx) += 1;
09038 }
09039
09040 IL_FLD(list_idx) = AT_Tbl_Idx;
09041 IL_IDX(list_idx) = attr_idx;
09042 IL_LINE_NUM(list_idx) = line;
09043 IL_COL_NUM(list_idx) = column;
09044
09045 if (LA_CH_VALUE == COMMA) {
09046 NEXT_LA_CH;
09047 }
09048 else {
09049 break;
09050 }
09051 }
09052
09053 if (LA_CH_VALUE == RPAREN) {
09054 NEXT_LA_CH;
09055 }
09056 else {
09057 parse_err_flush(Find_EOS, ")");
09058 goto EXIT;
09059 }
09060 }
09061 else if (scope == Global) {
09062
09063 if (turn_on) {
09064 inline_global_sgi = TRUE;
09065 noinline_global_sgi = FALSE;
09066 }
09067 else {
09068 noinline_global_sgi = TRUE;
09069 inline_global_sgi = FALSE;
09070 }
09071 }
09072 else if (scope == Routine) {
09073
09074 if (turn_on) {
09075 SCP_INLINE_SGI(curr_scp_idx) = TRUE;
09076 SCP_NOINLINE_SGI(curr_scp_idx) = FALSE;
09077 }
09078 else {
09079 SCP_NOINLINE_SGI(curr_scp_idx) = TRUE;
09080 SCP_INLINE_SGI(curr_scp_idx) = FALSE;
09081 }
09082 }
09083
09084 EXIT:
09085
09086 if (LA_CH_VALUE != EOS) {
09087 parse_err_flush(Find_EOS, EOS_STR);
09088 }
09089
09090 TRACE (Func_Exit, "parse_sgi_dir_inline", NULL);
09091
09092 return;
09093
09094 }
09095
09096
09097
09098
09099
09100
09101
09102
09103
09104
09105
09106
09107
09108
09109
09110
09111
09112 static void parse_distribution_dir(boolean reshape)
09113
09114
09115 {
09116 int attr_idx;
09117 #ifdef KEY
09118 int bd_idx = 0;
09119 #else
09120 int bd_idx;
09121 #endif
09122 int name_idx;
09123 int onto_col;
09124 int onto_line;
09125 int onto_rank;
09126 opnd_type opnd;
09127 int rank;
09128
09129
09130 TRACE (Func_Entry, "parse_distribution_dir", NULL);
09131
09132 while (TRUE) {
09133
09134 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
09135 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
09136 &name_idx);
09137
09138 if (attr_idx == NULL_IDX) {
09139 attr_idx = ntr_sym_tbl(&token, name_idx);
09140 LN_DEF_LOC(name_idx) = TRUE;
09141 SET_IMPL_TYPE(attr_idx);
09142 }
09143 else {
09144
09145
09146
09147 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
09148 AT_ATTR_LINK(attr_idx) = NULL_IDX;
09149 LN_DEF_LOC(name_idx) = TRUE;
09150 }
09151 }
09152
09153 if (LA_CH_VALUE == LPAREN) {
09154 rank = 0;
09155 bd_idx = reserve_array_ntry(7);
09156 BD_LINE_NUM(bd_idx) = TOKEN_LINE(token);
09157 BD_COLUMN_NUM(bd_idx) = TOKEN_COLUMN(token);
09158 BD_DIST_NTRY(bd_idx) = TRUE;
09159 BD_DISTRIBUTE_RESHAPE(bd_idx) = reshape;
09160
09161 do {
09162 rank++;
09163 NEXT_LA_CH;
09164
09165 if (LA_CH_VALUE == STAR) {
09166 NEXT_LA_CH;
09167
09168 BD_DISTRIBUTION(bd_idx, rank) = Star_Distribution;
09169 }
09170 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
09171
09172 if (TOKEN_VALUE(token) == Tok_SGI_Dir_Block) {
09173 BD_DISTRIBUTION(bd_idx, rank) = Block_Distribution;
09174 }
09175 else if (TOKEN_VALUE(token) == Tok_SGI_Dir_Cyclic) {
09176 BD_DISTRIBUTION(bd_idx, rank) = Cyclic_Distribution;
09177
09178 if (LA_CH_VALUE == LPAREN) {
09179 NEXT_LA_CH;
09180
09181 if (! parse_expr(&opnd)) {
09182 BD_DCL_ERR(bd_idx) = TRUE;
09183 parse_err_flush(Find_EOS, NULL);
09184 goto EXIT;
09185 }
09186
09187 BD_CYCLIC_FLD(bd_idx, rank) = OPND_FLD(opnd);
09188 BD_CYCLIC_IDX(bd_idx, rank) = OPND_IDX(opnd);
09189
09190 if (LA_CH_VALUE != RPAREN) {
09191 parse_err_flush(Find_EOS, ")");
09192 BD_DCL_ERR(bd_idx) = TRUE;
09193 goto EXIT;
09194 }
09195 else {
09196 NEXT_LA_CH;
09197 }
09198 }
09199 }
09200 else {
09201 parse_err_flush(Find_EOS, "BLOCK, CYCLIC or *");
09202 BD_DCL_ERR(bd_idx) = TRUE;
09203 goto EXIT;
09204 }
09205 }
09206 else {
09207 parse_err_flush(Find_EOS, "BLOCK, CYCLIC or *");
09208 BD_DCL_ERR(bd_idx) = TRUE;
09209 goto EXIT;
09210 }
09211 }
09212 while (LA_CH_VALUE == COMMA);
09213
09214 if (LA_CH_VALUE != RPAREN) {
09215 parse_err_flush(Find_EOS, ")");
09216 BD_DCL_ERR(bd_idx) = TRUE;
09217 goto EXIT;
09218 }
09219 else {
09220 NEXT_LA_CH;
09221 }
09222
09223 if (LA_CH_VALUE == COMMA) {
09224
09225 }
09226 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
09227 TOKEN_VALUE(token) == Tok_SGI_Dir_Onto) {
09228
09229 onto_line = TOKEN_LINE(token);
09230 onto_col = TOKEN_COLUMN(token);
09231
09232 if (LA_CH_VALUE == LPAREN) {
09233 onto_rank = 0;
09234
09235 do {
09236 onto_rank++;
09237 NEXT_LA_CH;
09238
09239 while (onto_rank <= rank &&
09240 BD_DISTRIBUTION(bd_idx, onto_rank) ==
09241 Star_Distribution) {
09242
09243 onto_rank++;
09244 }
09245
09246 if (onto_rank > rank) {
09247
09248 PRINTMSG(LA_CH_LINE, 1398, Error, LA_CH_COLUMN,
09249 "many");
09250 parse_err_flush(Find_EOS, NULL);
09251 BD_DCL_ERR(bd_idx) = TRUE;
09252 goto EXIT;
09253 }
09254
09255 if (LA_CH_VALUE == STAR) {
09256 NEXT_LA_CH;
09257 BD_ONTO_FLD(bd_idx,onto_rank) = CN_Tbl_Idx;
09258 BD_ONTO_IDX(bd_idx,onto_rank) = CN_INTEGER_ZERO_IDX;
09259 }
09260 else {
09261 parse_expr(&opnd);
09262 BD_ONTO_FLD(bd_idx,onto_rank) = OPND_FLD(opnd);
09263 BD_ONTO_IDX(bd_idx,onto_rank) = OPND_IDX(opnd);
09264 }
09265 }
09266 while (LA_CH_VALUE == COMMA);
09267
09268 if (LA_CH_VALUE != RPAREN) {
09269 parse_err_flush(Find_EOS, ")");
09270 BD_DCL_ERR(bd_idx) = TRUE;
09271 goto EXIT;
09272 }
09273 else {
09274 NEXT_LA_CH;
09275 }
09276 }
09277 else {
09278 parse_err_flush(Find_EOS, "(");
09279 BD_DCL_ERR(bd_idx) = TRUE;
09280 goto EXIT;
09281 }
09282
09283 while (onto_rank < rank) {
09284 onto_rank++;
09285
09286 if (BD_DISTRIBUTION(bd_idx, onto_rank) !=
09287 Star_Distribution) {
09288 PRINTMSG(onto_line, 1398, Error, onto_col, "few");
09289 parse_err_flush(Find_EOS, NULL);
09290 BD_DCL_ERR(bd_idx) = TRUE;
09291 goto EXIT;
09292 }
09293 }
09294 }
09295 else if (LA_CH_VALUE != EOS) {
09296 parse_err_flush(Find_EOS, "ONTO or EOS");
09297 BD_DCL_ERR(bd_idx) = TRUE;
09298 goto EXIT;
09299 }
09300
09301 BD_RANK(bd_idx) = rank;
09302 ATD_DISTRIBUTION_IDX(attr_idx) = ntr_array_in_bd_tbl(bd_idx);
09303 }
09304 else {
09305 parse_err_flush(Find_EOS, "(");
09306 BD_DCL_ERR(bd_idx) = TRUE;
09307 goto EXIT;
09308 }
09309 }
09310 else {
09311 parse_err_flush(Find_EOS, "array name");
09312 BD_DCL_ERR(bd_idx) = TRUE;
09313 goto EXIT;
09314 }
09315
09316 if (LA_CH_VALUE == COMMA) {
09317 NEXT_LA_CH;
09318 }
09319 else {
09320 break;
09321 }
09322 }
09323
09324 EXIT:
09325
09326
09327 TRACE (Func_Exit, "parse_distribution_dir", NULL);
09328
09329 return;
09330
09331 }
09332
09333
09334
09335
09336
09337
09338
09339
09340
09341
09342
09343
09344
09345
09346
09347
09348
09349
09350
09351
09352
09353
09354
09355
09356
09357
09358
09359
09360 static void parse_redistribute_dir(void)
09361
09362
09363 {
09364 int attr_idx;
09365 int ir_idx;
09366 int list_idx;
09367 #ifdef KEY
09368 int list_idx2 = 0;
09369 int list_idx3 = 0;
09370 #else
09371 int list_idx2;
09372 int list_idx3;
09373 #endif
09374 int name_idx;
09375 int onto_col;
09376 int onto_line;
09377 int onto_rank;
09378 opnd_type opnd;
09379 int rank;
09380
09381
09382 TRACE (Func_Entry, "parse_redistribute_dir", NULL);
09383
09384 while (TRUE) {
09385
09386 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
09387 ir_idx = gen_directive_ir(Redistribute_Dollar_Opr);
09388
09389 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
09390 &name_idx);
09391
09392 if (attr_idx == NULL_IDX) {
09393 attr_idx = ntr_sym_tbl(&token, name_idx);
09394 LN_DEF_LOC(name_idx) = TRUE;
09395 SET_IMPL_TYPE(attr_idx);
09396 }
09397 else {
09398
09399
09400
09401 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
09402 AT_ATTR_LINK(attr_idx) = NULL_IDX;
09403 LN_DEF_LOC(name_idx) = TRUE;
09404 }
09405 }
09406
09407 IR_FLD_L(ir_idx) = AT_Tbl_Idx;
09408 IR_IDX_L(ir_idx) = attr_idx;
09409 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
09410 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
09411
09412 NTR_IR_LIST_TBL(list_idx);
09413 IR_FLD_R(ir_idx) = IL_Tbl_Idx;
09414 IR_IDX_R(ir_idx) = list_idx;
09415 IR_LIST_CNT_R(ir_idx) = 1;
09416
09417 if (LA_CH_VALUE == LPAREN) {
09418 rank = 0;
09419
09420 do {
09421
09422 if (IL_FLD(list_idx) == NO_Tbl_Idx) {
09423 NTR_IR_LIST_TBL(list_idx2);
09424 IL_FLD(list_idx) = IL_Tbl_Idx;
09425 IL_IDX(list_idx) = list_idx2;
09426 IL_LIST_CNT(list_idx) = 1;
09427 }
09428 else {
09429 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx2));
09430 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx2)) = list_idx2;
09431 list_idx2 = IL_NEXT_LIST_IDX(list_idx2);
09432 IL_LIST_CNT(list_idx) += 1;
09433 }
09434
09435 rank++;
09436 NEXT_LA_CH;
09437
09438 IL_DISTRIBUTION_VARIANT(list_idx2) = TRUE;
09439
09440 if (LA_CH_VALUE == STAR) {
09441 NEXT_LA_CH;
09442
09443 IL_DISTRIBUTION(list_idx2) = Star_Distribution;
09444 }
09445 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
09446
09447 if (TOKEN_VALUE(token) == Tok_SGI_Dir_Block) {
09448 IL_DISTRIBUTION(list_idx2) = Block_Distribution;
09449 }
09450 else if (TOKEN_VALUE(token) == Tok_SGI_Dir_Cyclic) {
09451 IL_DISTRIBUTION(list_idx2) = Cyclic_Distribution;
09452
09453 if (LA_CH_VALUE == LPAREN) {
09454 NEXT_LA_CH;
09455
09456 if (! parse_expr(&opnd)) {
09457 parse_err_flush(Find_EOS, NULL);
09458 goto EXIT;
09459 }
09460
09461 COPY_OPND(IL_OPND(list_idx2), opnd);
09462
09463 if (LA_CH_VALUE != RPAREN) {
09464 parse_err_flush(Find_EOS, ")");
09465 goto EXIT;
09466 }
09467 else {
09468 NEXT_LA_CH;
09469 }
09470 }
09471 }
09472 else {
09473 parse_err_flush(Find_EOS, "BLOCK, CYCLIC or *");
09474 goto EXIT;
09475 }
09476 }
09477 else {
09478 parse_err_flush(Find_EOS, "BLOCK, CYCLIC or *");
09479 goto EXIT;
09480 }
09481 }
09482 while (LA_CH_VALUE == COMMA);
09483
09484 if (LA_CH_VALUE != RPAREN) {
09485 parse_err_flush(Find_EOS, ")");
09486 goto EXIT;
09487 }
09488 else {
09489 NEXT_LA_CH;
09490 }
09491
09492 if (LA_CH_VALUE == COMMA) {
09493
09494 }
09495 else if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd) &&
09496 TOKEN_VALUE(token) == Tok_SGI_Dir_Onto) {
09497
09498 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
09499 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
09500 list_idx2 = IL_IDX(list_idx);
09501 list_idx = IL_NEXT_LIST_IDX(list_idx);
09502 IR_LIST_CNT_R(ir_idx) = 2;
09503
09504 onto_line = TOKEN_LINE(token);
09505 onto_col = TOKEN_COLUMN(token);
09506
09507 if (LA_CH_VALUE == LPAREN) {
09508 onto_rank = 0;
09509
09510 do {
09511
09512 if (IL_FLD(list_idx) == NO_Tbl_Idx) {
09513 NTR_IR_LIST_TBL(list_idx3);
09514 IL_FLD(list_idx) = IL_Tbl_Idx;
09515 IL_IDX(list_idx) = list_idx3;
09516 IL_LIST_CNT(list_idx) = 1;
09517 }
09518 else {
09519 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx3));
09520 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx3)) =
09521 list_idx3;
09522 list_idx3 = IL_NEXT_LIST_IDX(list_idx3);
09523 IL_LIST_CNT(list_idx) += 1;
09524 }
09525
09526 onto_rank++;
09527 NEXT_LA_CH;
09528
09529 while (onto_rank <= rank &&
09530 list_idx2 != NULL_IDX &&
09531 IL_DISTRIBUTION(list_idx2) == Star_Distribution) {
09532
09533 onto_rank++;
09534
09535 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx3));
09536 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx3)) =
09537 list_idx3;
09538 list_idx3 = IL_NEXT_LIST_IDX(list_idx3);
09539 IL_LIST_CNT(list_idx) += 1;
09540
09541 if (list_idx2 != NULL_IDX) {
09542 list_idx2 = IL_NEXT_LIST_IDX(list_idx2);
09543 }
09544 }
09545
09546 if (onto_rank > rank) {
09547
09548 PRINTMSG(LA_CH_LINE, 1398, Error, LA_CH_COLUMN,
09549 "many");
09550 parse_err_flush(Find_EOS, NULL);
09551 goto EXIT;
09552 }
09553
09554 if (LA_CH_VALUE == STAR) {
09555 IL_FLD(list_idx3) = CN_Tbl_Idx;
09556 IL_IDX(list_idx3) = CN_INTEGER_ZERO_IDX;
09557 IL_LINE_NUM(list_idx3) = LA_CH_LINE;
09558 IL_COL_NUM(list_idx3) = LA_CH_COLUMN;
09559 NEXT_LA_CH;
09560 }
09561 else {
09562 parse_expr(&opnd);
09563 COPY_OPND(IL_OPND(list_idx3), opnd);
09564 }
09565
09566 if (list_idx2 != NULL_IDX) {
09567 list_idx2 = IL_NEXT_LIST_IDX(list_idx2);
09568 }
09569 }
09570 while (LA_CH_VALUE == COMMA);
09571
09572 if (LA_CH_VALUE != RPAREN) {
09573 parse_err_flush(Find_EOS, ")");
09574 goto EXIT;
09575 }
09576 else {
09577 NEXT_LA_CH;
09578 }
09579 }
09580 else {
09581 parse_err_flush(Find_EOS, "(");
09582 goto EXIT;
09583 }
09584
09585 while (onto_rank < rank) {
09586 onto_rank++;
09587
09588 if (IL_DISTRIBUTION(list_idx2) != Star_Distribution) {
09589 PRINTMSG(onto_line, 1398, Error, onto_col, "few");
09590 parse_err_flush(Find_EOS, NULL);
09591 goto EXIT;
09592 }
09593
09594 if (list_idx2 != NULL_IDX) {
09595 list_idx2 = IL_NEXT_LIST_IDX(list_idx2);
09596 }
09597 }
09598 }
09599 else if (LA_CH_VALUE != EOS) {
09600 parse_err_flush(Find_EOS, "ONTO or EOS");
09601 goto EXIT;
09602 }
09603 }
09604 else {
09605 parse_err_flush(Find_EOS, "(");
09606 goto EXIT;
09607 }
09608 }
09609 else {
09610 parse_err_flush(Find_EOS, "array name");
09611 goto EXIT;
09612 }
09613
09614 if (LA_CH_VALUE == COMMA) {
09615 NEXT_LA_CH;
09616 }
09617 else {
09618 break;
09619 }
09620 }
09621
09622 EXIT:
09623
09624
09625 TRACE (Func_Exit, "parse_redistribute_dir", NULL);
09626
09627 return;
09628
09629 }
09630
09631
09632
09633
09634
09635
09636
09637
09638
09639
09640
09641
09642
09643
09644
09645
09646
09647 static boolean parse_assert_directive(void)
09648
09649 {
09650 int column;
09651 int ir_idx;
09652 int line;
09653 boolean ok = TRUE;
09654 opnd_type opnd;
09655 long the_constant;
09656 long the_constant2;
09657
09658
09659 TRACE (Func_Entry, "parse_assert_directive", NULL);
09660
09661 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
09662
09663 ir_idx = gen_directive_ir(Assert_Star_Opr);
09664 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
09665 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
09666 line = TOKEN_LINE(token);
09667 column = TOKEN_COLUMN(token);
09668
09669 switch (TOKEN_VALUE(token)) {
09670 case Tok_SGI_Dir_Argumentaliasing:
09671 the_constant = ASSERT_ARGUMENTALIASING;
09672 break;
09673
09674 case Tok_SGI_Dir_Noargumentaliasing:
09675 the_constant = ASSERT_NOARGUMENTALIASING;
09676 break;
09677
09678 case Tok_SGI_Dir_Boundsviolations:
09679 the_constant = ASSERT_BOUNDSVIOLATIONS;
09680 break;
09681
09682 case Tok_SGI_Dir_Noboundsviolations:
09683 the_constant = ASSERT_NOBOUNDSVIOLATIONS;
09684 break;
09685
09686 case Tok_SGI_Dir_Concurrentcall:
09687 the_constant = ASSERT_CONCURRENTCALL;
09688 break;
09689
09690 case Tok_SGI_Dir_Noconcurrentcall:
09691 the_constant = ASSERT_NOCONCURRENTCALL;
09692 break;
09693
09694 case Tok_SGI_Dir_Norecurrence:
09695 the_constant = ASSERT_NORECURRENCE;
09696
09697 if (LA_CH_VALUE == LPAREN) {
09698 NEXT_LA_CH;
09699
09700 parse_var_name_list(&opnd);
09701 COPY_OPND(IR_OPND_R(ir_idx), opnd);
09702
09703 if (LA_CH_VALUE == RPAREN) {
09704 NEXT_LA_CH;
09705 }
09706 else {
09707 parse_err_flush(Find_EOS, ")");
09708 ok = FALSE;
09709 }
09710 }
09711 else {
09712 parse_err_flush(Find_EOS, "(");
09713 ok = FALSE;
09714 }
09715
09716 break;
09717
09718 case Tok_SGI_Dir_Doprefer:
09719 the_constant = ASSERT_DOPREFER;
09720
09721 if (LA_CH_VALUE == LPAREN) {
09722 NEXT_LA_CH;
09723
09724 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
09725 switch (TOKEN_VALUE(token)) {
09726 case Tok_SGI_Dir_Concur:
09727 case Tok_SGI_Dir_Concurrent:
09728 the_constant2 = DOPREFER_CONCURRENT;
09729 break;
09730
09731 case Tok_SGI_Dir_Serial:
09732 the_constant2 = DOPREFER_SERIAL;
09733 break;
09734
09735 case Tok_SGI_Dir_Tile:
09736 case Tok_SGI_Dir_Vector:
09737 the_constant2 = DOPREFER_VECTOR;
09738 break;
09739
09740 default:
09741 the_constant2 = 0;
09742 parse_err_flush(Find_EOS, "PREFERENCE");
09743 ok = FALSE;
09744 break;
09745 }
09746
09747 IR_LINE_NUM_R(ir_idx) = TOKEN_LINE(token);
09748 IR_COL_NUM_R(ir_idx) = TOKEN_COLUMN(token);
09749 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
09750 IR_IDX_R(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
09751 the_constant2);
09752
09753 if (LA_CH_VALUE != RPAREN) {
09754 parse_err_flush(Find_EOS, ")");
09755 }
09756 else {
09757 NEXT_LA_CH;
09758 }
09759
09760 }
09761 else {
09762 parse_err_flush(Find_EOS, "PREFERENCE");
09763 ok = FALSE;
09764 }
09765 }
09766 else {
09767 parse_err_flush(Find_EOS, "(");
09768 ok = FALSE;
09769 }
09770 break;
09771
09772 case Tok_SGI_Dir_Equivalencehazard:
09773 the_constant = ASSERT_EQUIVALENCEHAZARD;
09774 break;
09775
09776 case Tok_SGI_Dir_Noequivalencehazard:
09777 the_constant = ASSERT_NOEQUIVALENCEHAZARD;
09778 break;
09779
09780 case Tok_SGI_Dir_Lastvalueneeded:
09781 the_constant = ASSERT_LASTVALUENEEDED;
09782 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09783 parse_err_flush(Find_EOS, NULL);
09784 break;
09785
09786 case Tok_SGI_Dir_Lastvaluesneeded:
09787 the_constant = ASSERT_LASTVALUESNEEDED;
09788 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09789 parse_err_flush(Find_EOS, NULL);
09790 break;
09791
09792 case Tok_SGI_Dir_Nolastvalueneeded:
09793 the_constant = ASSERT_NOLASTVALUENEEDED;
09794 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09795 parse_err_flush(Find_EOS, NULL);
09796 break;
09797
09798 case Tok_SGI_Dir_Nolastvaluesneeded:
09799 the_constant = ASSERT_NOLASTVALUESNEEDED;
09800 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09801 parse_err_flush(Find_EOS, NULL);
09802 break;
09803
09804 case Tok_SGI_Dir_Permutation:
09805 the_constant = ASSERT_PERMUTATION;
09806
09807 if (LA_CH_VALUE == LPAREN) {
09808 NEXT_LA_CH;
09809
09810 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
09811 ok = parse_deref(&opnd, NULL_IDX);
09812
09813 if (OPND_FLD(opnd) != AT_Tbl_Idx) {
09814 ok = FALSE;
09815 find_opnd_line_and_column(&opnd, &line, &column);
09816 PRINTMSG(line, 1374, Error, column);
09817 }
09818 else {
09819 COPY_OPND(IR_OPND_R(ir_idx), opnd);
09820 }
09821
09822 if (LA_CH_VALUE == RPAREN) {
09823 NEXT_LA_CH;
09824 }
09825 else {
09826 parse_err_flush(Find_EOS, "(");
09827 ok = FALSE;
09828 }
09829 }
09830 else {
09831 parse_err_flush(Find_EOS, "IDENTIFIER");
09832 ok = FALSE;
09833 }
09834 }
09835 else {
09836 parse_err_flush(Find_EOS, "(");
09837 ok = FALSE;
09838 }
09839 break;
09840
09841 case Tok_SGI_Dir_Relation:
09842 the_constant = ASSERT_RELATION;
09843 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09844 parse_err_flush(Find_EOS, NULL);
09845 break;
09846
09847 case Tok_SGI_Dir_Nosync:
09848 the_constant = ASSERT_NOSYNC;
09849 PRINTMSG(TOKEN_LINE(token), 801, Warning, TOKEN_COLUMN(token));
09850 parse_err_flush(Find_EOS, NULL);
09851 break;
09852
09853 case Tok_SGI_Dir_Temporariesforconstantarguments:
09854 the_constant = ASSERT_TEMPORARIESFORCONSTANTARGUMENTS;
09855 break;
09856
09857 case Tok_SGI_Dir_Notemporariesforconstantarguments:
09858 the_constant = ASSERT_NOTEMPORARIESFORCONSTANTARGUMENTS;
09859
09860 parse_err_flush(Find_EOS, NULL);
09861 break;
09862
09863 case Tok_SGI_Dir_Do:
09864 the_constant = ASSERT_DO;
09865
09866 if (LA_CH_VALUE == LPAREN) {
09867 NEXT_LA_CH;
09868
09869 if (MATCHED_TOKEN_CLASS(Tok_Class_SGI_Dir_Kwd)) {
09870 switch (TOKEN_VALUE(token)) {
09871 case Tok_SGI_Dir_Concur:
09872 case Tok_SGI_Dir_Concurrent:
09873 the_constant2 = DOPREFER_CONCURRENT;
09874 break;
09875
09876 case Tok_SGI_Dir_Serial:
09877 the_constant2 = DOPREFER_SERIAL;
09878 break;
09879
09880 case Tok_SGI_Dir_Tile:
09881 case Tok_SGI_Dir_Vector:
09882 the_constant2 = DOPREFER_VECTOR;
09883 break;
09884
09885 default:
09886 the_constant2 = 0;
09887 parse_err_flush(Find_EOS, "PREFERENCE");
09888 ok = FALSE;
09889 break;
09890 }
09891
09892 IR_LINE_NUM_R(ir_idx) = TOKEN_LINE(token);
09893 IR_COL_NUM_R(ir_idx) = TOKEN_COLUMN(token);
09894 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
09895 IR_IDX_R(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
09896 the_constant2);
09897
09898 if (LA_CH_VALUE != RPAREN) {
09899 parse_err_flush(Find_EOS, ")");
09900 }
09901 else {
09902 NEXT_LA_CH;
09903 }
09904
09905 }
09906 else {
09907 parse_err_flush(Find_EOS, "PREFERENCE");
09908 ok = FALSE;
09909 }
09910 }
09911 else {
09912 parse_err_flush(Find_EOS, "(");
09913 ok = FALSE;
09914 }
09915 break;
09916
09917 case Tok_SGI_Dir_Benign:
09918 the_constant = ASSERT_BENIGN;
09919 break;
09920
09921 case Tok_SGI_Dir_Dependence:
09922 the_constant = ASSERT_DEPENDENCE;
09923 break;
09924
09925 case Tok_SGI_Dir_Frequency:
09926 the_constant = ASSERT_FREQUENCY;
09927 break;
09928
09929 case Tok_SGI_Dir_Ignoreanydependences:
09930 the_constant = ASSERT_IGNOREANYDEPENDENCES;
09931 break;
09932
09933 case Tok_SGI_Dir_Ignoreanydependence:
09934 the_constant = ASSERT_IGNOREANYDEPENDENCE;
09935 break;
09936
09937 case Tok_SGI_Dir_Ignoreassumeddependences:
09938 the_constant = ASSERT_IGNOREASSUMEDDEPENDENCES;
09939 break;
09940
09941 case Tok_SGI_Dir_Ignoreassumeddependence:
09942 the_constant = ASSERT_IGNOREASSUMEDDEPENDENCE;
09943 break;
09944
09945 case Tok_SGI_Dir_Nointerchange:
09946 the_constant = ASSERT_NOINTERCHANGE;
09947 break;
09948
09949 case Tok_SGI_Dir_Usecompress:
09950 the_constant = ASSERT_USECOMPRESS;
09951 break;
09952
09953 case Tok_SGI_Dir_Useexpand:
09954 the_constant = ASSERT_USEEXPAND;
09955 break;
09956
09957 case Tok_SGI_Dir_Usecontrolledstore:
09958 the_constant = ASSERT_USECONTROLLEDSTORE;
09959 break;
09960
09961 case Tok_SGI_Dir_Usegather:
09962 the_constant = ASSERT_USEGATHER;
09963 break;
09964
09965 case Tok_SGI_Dir_Usescatter:
09966 the_constant = ASSERT_USESCATTER;
09967 break;
09968
09969 default:
09970 PRINTMSG(TOKEN_LINE(token), 1354, Warning, TOKEN_COLUMN(token),
09971 TOKEN_STR(token));
09972 parse_err_flush(Find_EOS, NULL);
09973 ok = FALSE;
09974 goto EXIT;
09975 }
09976
09977 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
09978 IR_IDX_L(ir_idx) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE, the_constant);
09979
09980 if (directives_are_global) {
09981
09982 gen_gl_sh(After, Directive_Stmt, line, column,
09983 FALSE, FALSE, TRUE);
09984 GL_SH_IR_IDX(curr_gl_stmt_sh_idx) = copy_to_gl_subtree(ir_idx,
09985 IR_Tbl_Idx);
09986 }
09987 }
09988 else {
09989 parse_err_flush(Find_EOS, "ASSERTION");
09990 ok = FALSE;
09991 }
09992
09993 EXIT:
09994
09995 TRACE (Func_Exit, "parse_assert_directive", NULL);
09996
09997 return(ok);
09998
09999 }
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
10014
10015
10016
10017 static boolean directive_region_error(directive_stmt_type dir,
10018 int line,
10019 int col)
10020
10021 {
10022 int count = 0;
10023 boolean error = FALSE;
10024 int region;
10025 long mask;
10026 char str[80];
10027 char str2[80];
10028
10029 TRACE (Func_Entry, "directive_region_error", NULL);
10030
10031 if ((directive_cant_be_in[dir] & directive_state) != 0) {
10032 mask = (directive_cant_be_in[dir] & directive_state);
10033 error = TRUE;
10034
10035 for (region = 0; region < Last_Region; region++) {
10036 if (((mask >> region) & 1) != 0) {
10037 break;
10038 }
10039 }
10040
10041 # ifdef _DEBUG
10042 if (region == Last_Region) {
10043 PRINTMSG(stmt_start_line, 626, Internal, stmt_start_col,
10044 "region error", "directive_region_error");
10045 }
10046 # endif
10047
10048 PRINTMSG(line, 1411, Error, col,
10049 directive_stmt_str[dir],
10050 directive_region_str[region]);
10051 }
10052 else if (directive_must_be_in[dir] != 0 &&
10053 (directive_must_be_in[dir] & directive_state) == 0) {
10054 error = TRUE;
10055 str[0] = '\0';
10056
10057 for (region = 0; region < Last_Region; region++) {
10058 if (((directive_must_be_in[dir] >> region) & 1) != 0) {
10059 count++;
10060 if (count > 1) {
10061 sprintf(str2, ", or %s", directive_region_str[region]);
10062 }
10063 else {
10064 sprintf(str2, "%s", directive_region_str[region]);
10065 }
10066 strcat(str, str2);
10067 }
10068 }
10069
10070 PRINTMSG(line, 1412, Error, col,
10071 directive_stmt_str[dir],
10072 str);
10073 }
10074
10075 TRACE (Func_Exit, "directive_region_error", NULL);
10076
10077 return(error);
10078
10079 }
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097 static void parse_id_directive(void)
10098
10099 {
10100 int column;
10101 int init_idx;
10102 size_offset_type length;
10103 int line;
10104 int list_idx;
10105 id_str_type name;
10106 opnd_type opnd;
10107 opnd_type opnd2;
10108 size_offset_type result;
10109 int sb_idx;
10110 int tmp_idx;
10111
10112
10113 TRACE (Func_Entry, "parse_id_directive", NULL);
10114
10115 if (parse_expr(&opnd)) {
10116 find_opnd_line_and_column(&opnd, &line, &column);
10117
10118 if (OPND_FLD(opnd)!= CN_Tbl_Idx ||
10119 TYP_TYPE(CN_TYPE_IDX(OPND_IDX(opnd))) != Character) {
10120 PRINTMSG(line, 874, Error, column);
10121 }
10122 else {
10123 tmp_idx = gen_compiler_tmp(line, column, Shared, TRUE);
10124 ATD_TYPE_IDX(tmp_idx) = CN_TYPE_IDX(OPND_IDX(opnd));
10125 ATD_TMP_SEMANTICS_DONE(tmp_idx) = TRUE;
10126
10127 CREATE_ID(name, sb_name[What_Blk], sb_len[What_Blk]);
10128
10129 sb_idx = srch_stor_blk_tbl(name.string, sb_len[What_Blk],curr_scp_idx);
10130
10131 if (sb_idx == NULL_IDX) {
10132 sb_idx = ntr_stor_blk_tbl(name.string,
10133 sb_len[What_Blk],
10134 line,
10135 column,
10136 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
10137 Coment);
10138 # else
10139 Static_Named);
10140 # endif
10141 SB_SAVED(sb_idx) = TRUE;
10142 }
10143
10144 ATD_STOR_BLK_IDX(tmp_idx) = sb_idx;
10145
10146 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
10147
10148 ATD_TMP_IDX(tmp_idx) = OPND_IDX(opnd);
10149 ATD_FLD(tmp_idx) = CN_Tbl_Idx;
10150 # endif
10151
10152 # if defined(_DEBUG)
10153 if (SB_LEN_FLD(sb_idx) != CN_Tbl_Idx) {
10154 PRINTMSG(line, 1201, Internal, column, SB_NAME_PTR(sb_idx));
10155 }
10156 # endif
10157 ATD_OFFSET_ASSIGNED(tmp_idx) = TRUE;
10158 ATD_OFFSET_IDX(tmp_idx) = SB_LEN_IDX(sb_idx);
10159 ATD_OFFSET_FLD(tmp_idx) = SB_LEN_FLD(sb_idx);
10160
10161
10162
10163 result.idx = CN_INTEGER_CHAR_BIT_IDX;
10164 result.fld = CN_Tbl_Idx;
10165 length.idx = TYP_IDX(ATD_TYPE_IDX(tmp_idx));
10166 length.fld = TYP_FLD(ATD_TYPE_IDX(tmp_idx));
10167
10168 if (!size_offset_binary_calc(&length, &result, Mult_Opr, &result)) {
10169 AT_DCL_ERR(tmp_idx) = TRUE;
10170 }
10171
10172 length.idx = SB_LEN_IDX(sb_idx);
10173 length.fld = SB_LEN_FLD(sb_idx);
10174
10175 if (!size_offset_binary_calc(&length, &result, Plus_Opr, &result)) {
10176 AT_DCL_ERR(tmp_idx) = TRUE;
10177 }
10178
10179 if (result.fld == NO_Tbl_Idx) {
10180 SB_LEN_FLD(sb_idx) = CN_Tbl_Idx;
10181 SB_LEN_IDX(sb_idx) = ntr_const_tbl(result.type_idx,
10182 FALSE,
10183 result.constant);
10184 }
10185 else {
10186 SB_LEN_IDX(sb_idx) = result.idx;
10187 SB_LEN_FLD(sb_idx) = result.fld;
10188 }
10189
10190 OPND_FLD(opnd2) = AT_Tbl_Idx;
10191 OPND_IDX(opnd2) = tmp_idx;
10192 OPND_LINE_NUM(opnd2) = line;
10193 OPND_COL_NUM(opnd2) = column;
10194
10195 gen_whole_substring(&opnd2, 0);
10196
10197
10198
10199 NTR_IR_TBL(init_idx);
10200 IR_OPR(init_idx) = Init_Opr;
10201 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
10202 IR_OPR(init_idx) = Null_Opr;
10203 # endif
10204
10205
10206
10207 IR_TYPE_IDX(init_idx) = ATD_TYPE_IDX(tmp_idx);
10208 IR_LINE_NUM(init_idx) = line;
10209 IR_COL_NUM(init_idx) = column;
10210 IR_LINE_NUM_R(init_idx) = line;
10211 IR_COL_NUM_R(init_idx) = column;
10212 COPY_OPND(IR_OPND_L(init_idx), opnd2);
10213
10214 NTR_IR_LIST_TBL(list_idx);
10215 IR_FLD_R(init_idx) = IL_Tbl_Idx;
10216 IR_IDX_R(init_idx) = list_idx;
10217 IR_LIST_CNT_R(init_idx) = 3;
10218
10219 COPY_OPND(IL_OPND(list_idx), opnd);
10220
10221 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
10222 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
10223 list_idx = IL_NEXT_LIST_IDX(list_idx);
10224
10225 IL_FLD(list_idx) = CN_Tbl_Idx;
10226 IL_IDX(list_idx) = CN_INTEGER_ONE_IDX;
10227 IL_LINE_NUM(list_idx) = line;
10228 IL_COL_NUM(list_idx) = column;
10229
10230 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
10231 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
10232 list_idx = IL_NEXT_LIST_IDX(list_idx);
10233
10234 IL_FLD(list_idx) = CN_Tbl_Idx;
10235 IL_IDX(list_idx) = CN_INTEGER_ZERO_IDX;
10236 IL_LINE_NUM(list_idx) = line;
10237 IL_COL_NUM(list_idx) = column;
10238
10239 gen_sh(Before, Assignment_Stmt, line, column,
10240 FALSE, FALSE, TRUE);
10241 SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx)) = init_idx;
10242 SH_P2_SKIP_ME(SH_PREV_IDX(curr_stmt_sh_idx)) = TRUE;
10243 }
10244 }
10245 else {
10246 parse_err_flush(Find_EOS, NULL);
10247 }
10248
10249 TRACE (Func_Exit, "parse_id_directive", NULL);
10250
10251 return;
10252
10253 }
10254
10255
10256
10257
10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271 static void parse_open_mp_directives(void)
10272
10273 {
10274 int ir_idx;
10275 int list_idx;
10276 opnd_type opnd;
10277 int sh_idx;
10278 int type_idx;
10279
10280
10281 TRACE (Func_Entry, "parse_open_mp_directives", NULL);
10282
10283 if (TOKEN_VALUE(token) > Tok_Open_Mp_Dir_Start &&
10284 TOKEN_VALUE(token) < Tok_Open_Mp_Dir_End &&
10285 disregard_open_mp[TOKEN_VALUE(token) - Tok_Open_Mp_Dir_Start]) {
10286 parse_err_flush(Find_EOS, NULL);
10287 goto EXIT;
10288 }
10289
10290 switch (TOKEN_VALUE(token)) {
10291 case Tok_Open_Mp_Dir_Critical:
10292 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10293 ir_idx = gen_directive_ir(Critical_Open_Mp_Opr);
10294
10295 if (LA_CH_VALUE == LPAREN) {
10296 NEXT_LA_CH;
10297
10298 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
10299
10300 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX);
10301 TYP_TYPE(TYP_WORK_IDX) = Character;
10302 TYP_LINEAR(TYP_WORK_IDX) = CHARACTER_DEFAULT_TYPE;
10303 TYP_DESC(TYP_WORK_IDX) = Default_Typed;
10304 TYP_CHAR_CLASS(TYP_WORK_IDX)= Const_Len_Char;
10305 TYP_FLD(TYP_WORK_IDX) = CN_Tbl_Idx;
10306 TYP_IDX(TYP_WORK_IDX) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
10307 TOKEN_LEN(token));
10308 type_idx = ntr_type_tbl();
10309
10310 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
10311 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
10312 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
10313 IR_IDX_L(ir_idx) = ntr_const_tbl(type_idx, TRUE, NULL);
10314
10315 strcpy((char *)&CN_CONST(IR_IDX_L(ir_idx)),
10316 TOKEN_STR(token));
10317 }
10318 else {
10319 parse_err_flush(Find_EOS, "IDENTIFIER");
10320 }
10321
10322 if (LA_CH_VALUE == RPAREN) {
10323 NEXT_LA_CH;
10324 }
10325 else {
10326 parse_err_flush(Find_EOS, ")");
10327 goto EXIT;
10328 }
10329 }
10330 else if (LA_CH_VALUE != EOS) {
10331 parse_err_flush(Find_EOS, "( or EOS");
10332 }
10333
10334 if (directive_region_error(Critical_Open_Mp_Dir,
10335 IR_LINE_NUM(ir_idx),
10336 IR_COL_NUM(ir_idx))) {
10337 break;
10338 }
10339
10340 SET_DIRECTIVE_STATE(Open_Mp_Critical_Region);
10341 PUSH_BLK_STK (Open_Mp_Critical_Blk);
10342 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10343 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10344 LINK_TO_PARENT_BLK;
10345 break;
10346
10347
10348 case Tok_Open_Mp_Dir_Endcritical:
10349 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10350 ir_idx = gen_directive_ir(Endcritical_Open_Mp_Opr);
10351
10352 if (LA_CH_VALUE == LPAREN) {
10353 NEXT_LA_CH;
10354
10355 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
10356
10357 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX);
10358 TYP_TYPE(TYP_WORK_IDX) = Character;
10359 TYP_LINEAR(TYP_WORK_IDX) = CHARACTER_DEFAULT_TYPE;
10360 TYP_DESC(TYP_WORK_IDX) = Default_Typed;
10361 TYP_CHAR_CLASS(TYP_WORK_IDX)= Const_Len_Char;
10362 TYP_FLD(TYP_WORK_IDX) = CN_Tbl_Idx;
10363 TYP_IDX(TYP_WORK_IDX) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
10364 TOKEN_LEN(token));
10365 type_idx = ntr_type_tbl();
10366
10367 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
10368 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
10369 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
10370 IR_IDX_L(ir_idx) = ntr_const_tbl(type_idx, TRUE, NULL);
10371
10372 strcpy((char *)&CN_CONST(IR_IDX_L(ir_idx)),
10373 TOKEN_STR(token));
10374 }
10375 else {
10376 parse_err_flush(Find_EOS, "IDENTIFIER");
10377 }
10378
10379 if (LA_CH_VALUE == RPAREN) {
10380 NEXT_LA_CH;
10381 }
10382 else {
10383 parse_err_flush(Find_EOS, ")");
10384 goto EXIT;
10385 }
10386 }
10387 else if (LA_CH_VALUE != EOS) {
10388 parse_err_flush(Find_EOS, "( or EOS");
10389 }
10390
10391 if (directive_region_error(Endcritical_Open_Mp_Dir,
10392 IR_LINE_NUM(ir_idx),
10393 IR_COL_NUM(ir_idx))) {
10394 break;
10395 }
10396
10397 CLEAR_DIRECTIVE_STATE(Open_Mp_Critical_Region);
10398 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Critical_Stmt;
10399 stmt_type = Open_MP_End_Critical_Stmt;
10400
10401 if (CURR_BLK == Open_Mp_Critical_Blk &&
10402 IR_FLD_L(SH_IR_IDX(CURR_BLK_FIRST_SH_IDX)) == CN_Tbl_Idx) {
10403
10404
10405 if (IR_FLD_L(ir_idx) != CN_Tbl_Idx ||
10406 strcmp((char *)&CN_CONST(IR_IDX_L(SH_IR_IDX(
10407 CURR_BLK_FIRST_SH_IDX))),
10408 (char *)&CN_CONST(IR_IDX_L(ir_idx))) != 0) {
10409
10410 PRINTMSG(IR_LINE_NUM(ir_idx), 1472, Error, IR_COL_NUM(ir_idx));
10411 }
10412 }
10413 end_open_mp_critical_blk(FALSE);
10414 break;
10415
10416
10417 case Tok_Open_Mp_Dir_Do:
10418 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10419 ir_idx = gen_directive_ir(Do_Open_Mp_Opr);
10420
10421 parse_open_mp_clauses(Do_Omp);
10422
10423 if (directive_region_error(Do_Open_Mp_Dir,
10424 IR_LINE_NUM(ir_idx),
10425 IR_COL_NUM(ir_idx))) {
10426 break;
10427 }
10428
10429 cdir_switches.do_omp_sh_idx = curr_stmt_sh_idx;
10430
10431 check_do_open_mp_nesting();
10432
10433 SET_DIRECTIVE_STATE(Open_Mp_Do_Region);
10434
10435 break;
10436
10437 case Tok_Open_Mp_Dir_Enddo:
10438 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10439 ir_idx = gen_directive_ir(Enddo_Open_Mp_Opr);
10440
10441 if (LA_CH_VALUE != EOS) {
10442 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
10443 if (TOKEN_VALUE(token) == Tok_Open_Mp_Dir_Nowait) {
10444 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
10445 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
10446 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
10447 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
10448 }
10449 else {
10450 parse_err_flush(Find_EOS, "NOWAIT");
10451 }
10452 }
10453 }
10454
10455 if (SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx)) != NULL_IDX &&
10456 IR_OPR(SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx))) ==
10457 Enddo_Open_Mp_Opr &&
10458 SH_COMPILER_GEN(SH_PREV_IDX(curr_stmt_sh_idx))) {
10459
10460 sh_idx = SH_PREV_IDX(curr_stmt_sh_idx);
10461 COPY_OPND(IR_OPND_R(ir_idx),
10462 IR_OPND_R(SH_IR_IDX(sh_idx)));
10463
10464
10465
10466 SH_PREV_IDX(SH_NEXT_IDX(sh_idx)) = SH_PREV_IDX(sh_idx);
10467 SH_NEXT_IDX(SH_PREV_IDX(sh_idx)) = SH_NEXT_IDX(sh_idx);
10468
10469 FREE_IR_NODE(SH_IR_IDX(sh_idx));
10470 FREE_SH_NODE(sh_idx);
10471 break;
10472 }
10473
10474 if (directive_region_error(Enddo_Open_Mp_Dir,
10475 IR_LINE_NUM(ir_idx),
10476 IR_COL_NUM(ir_idx))) {
10477 break;
10478 }
10479
10480 CLEAR_DIRECTIVE_STATE(Open_Mp_Do_Region);
10481 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Do_Stmt;
10482 stmt_type = Open_MP_End_Do_Stmt;
10483 end_open_mp_do_blk(FALSE);
10484 break;
10485
10486 case Tok_Open_Mp_Dir_Endparallel:
10487 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10488 ir_idx = gen_directive_ir(Endparallel_Open_Mp_Opr);
10489
10490 if (directive_region_error(Endparallel_Open_Mp_Dir,
10491 IR_LINE_NUM(ir_idx),
10492 IR_COL_NUM(ir_idx))) {
10493 break;
10494 }
10495
10496 CLEAR_DIRECTIVE_STATE(Open_Mp_Parallel_Region);
10497 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Parallel_Stmt;
10498 stmt_type = Open_MP_End_Parallel_Stmt;
10499 end_open_mp_parallel_blk(FALSE);
10500 break;
10501
10502 case Tok_Open_Mp_Dir_Endparalleldo:
10503 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10504 ir_idx = gen_directive_ir(Endparalleldo_Open_Mp_Opr);
10505
10506 if (SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx)) != NULL_IDX &&
10507 IR_OPR(SH_IR_IDX(SH_PREV_IDX(curr_stmt_sh_idx))) ==
10508 Endparalleldo_Open_Mp_Opr &&
10509 SH_COMPILER_GEN(SH_PREV_IDX(curr_stmt_sh_idx))) {
10510
10511
10512
10513 sh_idx = SH_PREV_IDX(curr_stmt_sh_idx);
10514 COPY_OPND(IR_OPND_R(ir_idx),
10515 IR_OPND_R(SH_IR_IDX(sh_idx)));
10516
10517 SH_PREV_IDX(SH_NEXT_IDX(sh_idx)) = SH_PREV_IDX(sh_idx);
10518 SH_NEXT_IDX(SH_PREV_IDX(sh_idx)) = SH_NEXT_IDX(sh_idx);
10519
10520 FREE_IR_NODE(SH_IR_IDX(sh_idx));
10521 FREE_SH_NODE(sh_idx);
10522 break;
10523 }
10524
10525 if (directive_region_error(Endparalleldo_Open_Mp_Dir,
10526 IR_LINE_NUM(ir_idx),
10527 IR_COL_NUM(ir_idx))) {
10528 break;
10529 }
10530
10531 CLEAR_DIRECTIVE_STATE(Open_Mp_Parallel_Do_Region);
10532 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Parallel_Do_Stmt;
10533 stmt_type = Open_MP_End_Parallel_Do_Stmt;
10534 end_open_mp_parallel_do_blk(FALSE);
10535 break;
10536
10537 case Tok_Open_Mp_Dir_Endparallelsections:
10538 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10539 ir_idx = gen_directive_ir(Endparallelsections_Open_Mp_Opr);
10540
10541 if (directive_region_error(Endparallelsections_Open_Mp_Dir,
10542 IR_LINE_NUM(ir_idx),
10543 IR_COL_NUM(ir_idx))) {
10544 break;
10545 }
10546
10547 if (CURR_BLK == Open_Mp_Section_Blk) {
10548 end_open_mp_section_blk(FALSE);
10549 CLEAR_DIRECTIVE_STATE(Open_Mp_Section_Region);
10550 }
10551
10552 CLEAR_DIRECTIVE_STATE(Open_Mp_Parallel_Sections_Region);
10553 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Parallel_Sections_Stmt;
10554 stmt_type = Open_MP_End_Parallel_Sections_Stmt;
10555 end_open_mp_parallel_sections_blk(FALSE);
10556 break;
10557
10558 case Tok_Open_Mp_Dir_Endmaster:
10559 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10560 ir_idx = gen_directive_ir(Endmaster_Open_Mp_Opr);
10561
10562 if (directive_region_error(Endmaster_Open_Mp_Dir,
10563 IR_LINE_NUM(ir_idx),
10564 IR_COL_NUM(ir_idx))) {
10565 break;
10566 }
10567
10568 CLEAR_DIRECTIVE_STATE(Open_Mp_Master_Region);
10569 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Master_Stmt;
10570 stmt_type = Open_MP_End_Master_Stmt;
10571 end_open_mp_master_blk(FALSE);
10572 break;
10573
10574 case Tok_Open_Mp_Dir_Endordered:
10575 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10576 ir_idx = gen_directive_ir(Endordered_Open_Mp_Opr);
10577
10578 if (directive_region_error(Endordered_Open_Mp_Dir,
10579 IR_LINE_NUM(ir_idx),
10580 IR_COL_NUM(ir_idx))) {
10581 break;
10582 }
10583
10584 CLEAR_DIRECTIVE_STATE(Open_Mp_Ordered_Region);
10585 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Ordered_Stmt;
10586 stmt_type = Open_MP_End_Ordered_Stmt;
10587 end_open_mp_ordered_blk(FALSE);
10588 break;
10589
10590 case Tok_Open_Mp_Dir_Endsections:
10591 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10592 ir_idx = gen_directive_ir(Endsections_Open_Mp_Opr);
10593
10594 if (LA_CH_VALUE != EOS) {
10595 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
10596 if (TOKEN_VALUE(token) == Tok_Open_Mp_Dir_Nowait) {
10597 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
10598 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
10599 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
10600 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
10601 }
10602 else {
10603 parse_err_flush(Find_EOS, "NOWAIT");
10604 }
10605 }
10606 }
10607
10608 if (directive_region_error(Endsections_Open_Mp_Dir,
10609 IR_LINE_NUM(ir_idx),
10610 IR_COL_NUM(ir_idx))) {
10611 break;
10612 }
10613
10614 if (CURR_BLK == Open_Mp_Section_Blk) {
10615 end_open_mp_section_blk(FALSE);
10616 CLEAR_DIRECTIVE_STATE(Open_Mp_Section_Region);
10617 }
10618
10619 CLEAR_DIRECTIVE_STATE(Open_Mp_Sections_Region);
10620 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Sections_Stmt;
10621 stmt_type = Open_MP_End_Sections_Stmt;
10622 end_open_mp_sections_blk(FALSE);
10623 break;
10624
10625 case Tok_Open_Mp_Dir_Endsingle:
10626 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10627 ir_idx = gen_directive_ir(Endsingle_Open_Mp_Opr);
10628
10629
10630 NTR_IR_LIST_TBL(list_idx);
10631 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
10632 IR_IDX_L(ir_idx) = list_idx;
10633 IR_LIST_CNT_L(ir_idx) = 2;
10634
10635 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
10636 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
10637
10638
10639 while (LA_CH_VALUE != EOS) {
10640
10641 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
10642
10643 switch (TOKEN_VALUE(token)) {
10644 case Tok_Open_Mp_Dir_Nowait:
10645
10646 if (IL_IDX(list_idx) != NULL_IDX) {
10647 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
10648 "NOWAIT", "END SINGLE");
10649 parse_err_flush(Find_EOS, NULL);
10650 goto EXIT;
10651 }
10652
10653 if (IL_IDX(IL_NEXT_LIST_IDX(list_idx)) != NULL_IDX) {
10654 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
10655 "COPYPRIVATE", "END SINGLE");
10656 parse_err_flush(Find_EOS, NULL);
10657 goto EXIT;
10658 }
10659
10660 IL_FLD(list_idx) = CN_Tbl_Idx;
10661 IL_IDX(list_idx) = CN_INTEGER_ONE_IDX;
10662 IL_LINE_NUM(list_idx) = TOKEN_LINE(token);
10663 IL_COL_NUM(list_idx) = TOKEN_COLUMN(token);
10664 break;
10665
10666 case Tok_Open_Mp_Dir_Copyprivate:
10667
10668 if (IL_IDX(list_idx) != NULL_IDX) {
10669 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
10670 "NOWAIT", "END SINGLE");
10671 parse_err_flush(Find_EOS, NULL);
10672 goto EXIT;
10673 }
10674
10675 if (LA_CH_VALUE == LPAREN) {
10676 NEXT_LA_CH;
10677 parse_var_common_list(&opnd, FALSE);
10678
10679 if (IL_IDX(IL_NEXT_LIST_IDX(list_idx)) == NULL_IDX) {
10680 COPY_OPND(IL_OPND(IL_NEXT_LIST_IDX(list_idx)), opnd);
10681 }
10682 else {
10683
10684 int copyprivate_list_idx;
10685
10686 copyprivate_list_idx = IL_IDX(IL_NEXT_LIST_IDX(list_idx));
10687 while (IL_NEXT_LIST_IDX(copyprivate_list_idx)) {
10688 copyprivate_list_idx = IL_NEXT_LIST_IDX(copyprivate_list_idx);
10689 }
10690
10691
10692 IL_NEXT_LIST_IDX(copyprivate_list_idx) = OPND_IDX(opnd);
10693 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = copyprivate_list_idx;
10694 IL_LIST_CNT(IL_NEXT_LIST_IDX(list_idx)) += OPND_LIST_CNT(opnd);
10695 }
10696
10697 if (LA_CH_VALUE == RPAREN) {
10698 NEXT_LA_CH;
10699 }
10700 else {
10701 parse_err_flush(Find_EOS, ")");
10702 goto EXIT;
10703 }
10704 }
10705 else {
10706 parse_err_flush(Find_EOS, "(");
10707 goto EXIT;
10708 }
10709
10710 break;
10711
10712 default:
10713 PRINTMSG(TOKEN_LINE(token), 1517, Error, TOKEN_COLUMN(token),
10714 "OpenMP");
10715 parse_err_flush(Find_EOS, NULL);
10716 break;
10717 }
10718 }
10719 else {
10720 parse_err_flush(Find_EOS, "END SINGLE clause");
10721 }
10722
10723 if (LA_CH_VALUE == COMMA) {
10724 NEXT_LA_CH;
10725 }
10726 }
10727
10728 if (directive_region_error(Endsingle_Open_Mp_Dir,
10729 IR_LINE_NUM(ir_idx),
10730 IR_COL_NUM(ir_idx))) {
10731 break;
10732 }
10733
10734 CLEAR_DIRECTIVE_STATE(Open_Mp_Single_Region);
10735 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Single_Stmt;
10736 stmt_type = Open_MP_End_Single_Stmt;
10737 end_open_mp_single_blk(FALSE);
10738 break;
10739
10740 case Tok_Open_Mp_Dir_Master:
10741 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10742 ir_idx = gen_directive_ir(Master_Open_Mp_Opr);
10743
10744 if (directive_region_error(Master_Open_Mp_Dir,
10745 IR_LINE_NUM(ir_idx),
10746 IR_COL_NUM(ir_idx))) {
10747 break;
10748 }
10749
10750 SET_DIRECTIVE_STATE(Open_Mp_Master_Region);
10751 PUSH_BLK_STK (Open_Mp_Master_Blk);
10752 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10753 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10754 LINK_TO_PARENT_BLK;
10755 break;
10756
10757 case Tok_Open_Mp_Dir_Ordered:
10758 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10759 ir_idx = gen_directive_ir(Ordered_Open_Mp_Opr);
10760
10761 if (directive_region_error(Ordered_Open_Mp_Dir,
10762 IR_LINE_NUM(ir_idx),
10763 IR_COL_NUM(ir_idx))) {
10764 break;
10765 }
10766
10767 check_ordered_open_mp_nesting();
10768
10769 SET_DIRECTIVE_STATE(Open_Mp_Ordered_Region);
10770 PUSH_BLK_STK (Open_Mp_Ordered_Blk);
10771 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10772 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10773 LINK_TO_PARENT_BLK;
10774 break;
10775
10776 case Tok_Open_Mp_Dir_Parallel:
10777 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10778 ir_idx = gen_directive_ir(Parallel_Open_Mp_Opr);
10779
10780 parse_open_mp_clauses(Parallel_Omp);
10781
10782 if (directive_region_error(Parallel_Open_Mp_Dir,
10783 IR_LINE_NUM(ir_idx),
10784 IR_COL_NUM(ir_idx))) {
10785 break;
10786 }
10787
10788 SET_DIRECTIVE_STATE(Open_Mp_Parallel_Region);
10789 PUSH_BLK_STK (Open_Mp_Parallel_Blk);
10790 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10791 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10792 LINK_TO_PARENT_BLK;
10793 break;
10794
10795 case Tok_Open_Mp_Dir_Paralleldo:
10796 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10797 ir_idx = gen_directive_ir(Paralleldo_Open_Mp_Opr);
10798
10799 parse_open_mp_clauses(Parallel_Do_Omp);
10800
10801 if (directive_region_error(Paralleldo_Open_Mp_Dir,
10802 IR_LINE_NUM(ir_idx),
10803 IR_COL_NUM(ir_idx))) {
10804 break;
10805 }
10806
10807 cdir_switches.paralleldo_omp_sh_idx = curr_stmt_sh_idx;
10808
10809 SET_DIRECTIVE_STATE(Open_Mp_Parallel_Do_Region);
10810
10811 break;
10812
10813 case Tok_Open_Mp_Dir_Parallelsections:
10814 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10815 ir_idx = gen_directive_ir(Parallelsections_Open_Mp_Opr);
10816
10817 parse_open_mp_clauses(Parallel_Sections_Omp);
10818
10819 if (directive_region_error(Parallelsections_Open_Mp_Dir,
10820 IR_LINE_NUM(ir_idx),
10821 IR_COL_NUM(ir_idx))) {
10822 break;
10823 }
10824
10825 SET_DIRECTIVE_STATE(Open_Mp_Parallel_Sections_Region);
10826 PUSH_BLK_STK (Open_Mp_Parallel_Sections_Blk);
10827 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10828 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10829 LINK_TO_PARENT_BLK;
10830
10831
10832 SET_DIRECTIVE_STATE(Open_Mp_Section_Region);
10833 PUSH_BLK_STK (Open_Mp_Section_Blk);
10834 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10835 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10836 LINK_TO_PARENT_BLK;
10837 break;
10838
10839
10840 case Tok_Open_Mp_Dir_Section:
10841 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10842 ir_idx = gen_directive_ir(Section_Open_Mp_Opr);
10843
10844 if (directive_region_error(Section_Open_Mp_Dir,
10845 IR_LINE_NUM(ir_idx),
10846 IR_COL_NUM(ir_idx))) {
10847 break;
10848 }
10849
10850 if (! check_section_open_mp_context()) {
10851 break;
10852 }
10853
10854 if (CURR_BLK == Open_Mp_Section_Blk) {
10855 end_open_mp_section_blk(FALSE);
10856 CLEAR_DIRECTIVE_STATE(Open_Mp_Section_Region);
10857 }
10858
10859 SET_DIRECTIVE_STATE(Open_Mp_Section_Region);
10860 PUSH_BLK_STK (Open_Mp_Section_Blk);
10861 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10862 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10863 LINK_TO_PARENT_BLK;
10864 break;
10865
10866 case Tok_Open_Mp_Dir_Sections:
10867 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10868 ir_idx = gen_directive_ir(Sections_Open_Mp_Opr);
10869
10870 parse_open_mp_clauses(Sections_Omp);
10871
10872 if (directive_region_error(Sections_Open_Mp_Dir,
10873 IR_LINE_NUM(ir_idx),
10874 IR_COL_NUM(ir_idx))) {
10875 break;
10876 }
10877
10878 SET_DIRECTIVE_STATE(Open_Mp_Sections_Region);
10879
10880 check_do_open_mp_nesting();
10881
10882 PUSH_BLK_STK (Open_Mp_Sections_Blk);
10883 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10884 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10885 LINK_TO_PARENT_BLK;
10886
10887
10888 SET_DIRECTIVE_STATE(Open_Mp_Section_Region);
10889 PUSH_BLK_STK (Open_Mp_Section_Blk);
10890 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10891 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10892 LINK_TO_PARENT_BLK;
10893 break;
10894
10895 case Tok_Open_Mp_Dir_Single:
10896 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10897 ir_idx = gen_directive_ir(Single_Open_Mp_Opr);
10898
10899 parse_open_mp_clauses(Single_Omp);
10900
10901 if (directive_region_error(Single_Open_Mp_Dir,
10902 IR_LINE_NUM(ir_idx),
10903 IR_COL_NUM(ir_idx))) {
10904 break;
10905 }
10906
10907 SET_DIRECTIVE_STATE(Open_Mp_Single_Region);
10908
10909 check_do_open_mp_nesting();
10910
10911 PUSH_BLK_STK (Open_Mp_Single_Blk);
10912 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10913 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10914 LINK_TO_PARENT_BLK;
10915 break;
10916
10917 case Tok_Open_Mp_Dir_Workshare:
10918 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10919 ir_idx = gen_directive_ir(Workshare_Open_Mp_Opr);
10920
10921 parse_open_mp_clauses(Workshare_Omp);
10922
10923 if (directive_region_error(Workshare_Open_Mp_Dir,
10924 IR_LINE_NUM(ir_idx),
10925 IR_COL_NUM(ir_idx))) {
10926 break;
10927 }
10928
10929 SET_DIRECTIVE_STATE(Open_Mp_Workshare_Region);
10930
10931 check_do_open_mp_nesting();
10932
10933 PUSH_BLK_STK(Open_Mp_Workshare_Blk);
10934 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10935 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10936 LINK_TO_PARENT_BLK;
10937 break;
10938
10939 case Tok_Open_Mp_Dir_Parallelworkshare:
10940 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10941 ir_idx = gen_directive_ir(Parallelworkshare_Open_Mp_Opr);
10942
10943 parse_open_mp_clauses(Parallel_Workshare_Omp);
10944
10945 if (directive_region_error(Parallelworkshare_Open_Mp_Dir,
10946 IR_LINE_NUM(ir_idx),
10947 IR_COL_NUM(ir_idx))){
10948 break;
10949 }
10950
10951 SET_DIRECTIVE_STATE(Open_Mp_Parallel_Workshare_Region);
10952 PUSH_BLK_STK(Open_Mp_Parallel_Workshare_Blk);
10953 BLK_IS_PARALLEL_REGION(blk_stk_idx) = TRUE;
10954 CURR_BLK_FIRST_SH_IDX = curr_stmt_sh_idx;
10955 LINK_TO_PARENT_BLK;
10956 break;
10957
10958 case Tok_Open_Mp_Dir_Endworkshare:
10959 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10960 ir_idx = gen_directive_ir(Endworkshare_Open_Mp_Opr);
10961
10962 if (LA_CH_VALUE != EOS) {
10963 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
10964 if (TOKEN_VALUE(token) == Tok_Open_Mp_Dir_Nowait) {
10965 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
10966 IR_IDX_L(ir_idx) = CN_INTEGER_ONE_IDX;
10967 IR_LINE_NUM_L(ir_idx) = TOKEN_LINE(token);
10968 IR_COL_NUM_L(ir_idx) = TOKEN_COLUMN(token);
10969 }
10970 else{
10971 parse_err_flush(Find_EOS, "NOWAIT");
10972 }
10973 }
10974 }
10975
10976 if (directive_region_error(Endworkshare_Open_Mp_Dir,
10977 IR_LINE_NUM(ir_idx),
10978 IR_COL_NUM(ir_idx))) {
10979 break;
10980 }
10981
10982 CLEAR_DIRECTIVE_STATE(Open_Mp_Workshare_Region);
10983 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Workshare_Stmt;
10984 stmt_type = Open_MP_End_Workshare_Stmt;
10985 end_open_mp_workshare_blk(FALSE);
10986 break;
10987
10988 case Tok_Open_Mp_Dir_Endparallelworkshare:
10989 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
10990 ir_idx = gen_directive_ir(Endparallelworkshare_Open_Mp_Opr);
10991
10992 if(directive_region_error(Endparallelworkshare_Open_Mp_Dir,
10993 IR_LINE_NUM(ir_idx),
10994 IR_COL_NUM(ir_idx))){
10995 break;
10996 }
10997
10998 CLEAR_DIRECTIVE_STATE(Open_Mp_Parallel_Workshare_Region);
10999 SH_STMT_TYPE(curr_stmt_sh_idx) = Open_MP_End_Parallel_Workshare_Stmt;
11000 stmt_type = Open_MP_End_Parallel_Workshare_Stmt;
11001 end_open_mp_parallel_workshare_blk(FALSE);
11002 break;
11003
11004 case Tok_Open_Mp_Dir_Atomic:
11005 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
11006 ir_idx = gen_directive_ir(Atomic_Open_Mp_Opr);
11007
11008 if (directive_region_error(Atomic_Open_Mp_Dir,
11009 IR_LINE_NUM(ir_idx),
11010 IR_COL_NUM(ir_idx))) {
11011 break;
11012 }
11013
11014 break;
11015
11016 case Tok_Open_Mp_Dir_Barrier:
11017 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
11018 ir_idx = gen_directive_ir(Barrier_Open_Mp_Opr);
11019
11020 if (directive_region_error(Barrier_Open_Mp_Dir,
11021 IR_LINE_NUM(ir_idx),
11022 IR_COL_NUM(ir_idx))) {
11023 break;
11024 }
11025
11026 break;
11027
11028 case Tok_Open_Mp_Dir_Flush:
11029 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
11030 ir_idx = gen_directive_ir(Flush_Open_Mp_Opr);
11031
11032 if (LA_CH_VALUE == LPAREN) {
11033 NEXT_LA_CH;
11034
11035 #ifdef KEY
11036 parse_var_common_list(&opnd, FALSE);
11037 #else
11038 parse_var_name_list(&opnd);
11039 #endif
11040 COPY_OPND(IR_OPND_L(ir_idx), opnd);
11041
11042 if (LA_CH_VALUE == RPAREN) {
11043 NEXT_LA_CH;
11044 }
11045 else {
11046 parse_err_flush(Find_EOS, ")");
11047 goto EXIT;
11048 }
11049 }
11050
11051 if (directive_region_error(Flush_Open_Mp_Dir,
11052 IR_LINE_NUM(ir_idx),
11053 IR_COL_NUM(ir_idx))) {
11054 break;
11055 }
11056
11057 break;
11058
11059 case Tok_Open_Mp_Dir_Threadprivate:
11060
11061 ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) = TRUE;
11062
11063 if (curr_stmt_category < Dir_Integer_Stmt_Cat) {
11064 PRINTMSG(TOKEN_LINE(token), 795, Warning,
11065 TOKEN_COLUMN(token), "THREADPRIVATE");
11066 parse_err_flush(Find_EOS, NULL);
11067 break;
11068 }
11069
11070 if (curr_stmt_category >= Executable_Stmt_Cat) {
11071 PRINTMSG(TOKEN_LINE(token), 531, Error,
11072 TOKEN_COLUMN(token),
11073 "THREADPRIVATE");
11074 parse_err_flush(Find_EOS, NULL);
11075 break;
11076 }
11077
11078 parse_slash_common_dirs();
11079 break;
11080
11081 case Tok_Open_Mp_Dir_Distribute:
11082 if (! omp_extension_prefix(TOKEN_LINE(token))) {
11083
11084 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
11085 TOKEN_COLUMN(token),
11086 "DISTRIBUTE directive", "!$SGI");
11087 }
11088
11089 if (dump_flags.dsm) {
11090 parse_distribution_dir(FALSE);
11091 }
11092 else {
11093 parse_err_flush(Find_EOS, NULL);
11094 }
11095 break;
11096
11097 case Tok_Open_Mp_Dir_Distribute_Reshape:
11098 if (! omp_extension_prefix(TOKEN_LINE(token))) {
11099
11100 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
11101 TOKEN_COLUMN(token),
11102 "DISTRIBUTE_RESHAPE directive", "!$SGI");
11103 }
11104
11105 if (dump_flags.dsm) {
11106 parse_distribution_dir(TRUE);
11107 }
11108 else {
11109 parse_err_flush(Find_EOS, NULL);
11110 }
11111 break;
11112
11113 case Tok_Open_Mp_Dir_Dynamic:
11114 if (! omp_extension_prefix(TOKEN_LINE(token))) {
11115
11116 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
11117 TOKEN_COLUMN(token),
11118 "DYNAMIC directive", "!$SGI");
11119 }
11120
11121 if (dump_flags.dsm) {
11122 if (parse_var_name_list(&opnd)) {
11123 ir_idx = gen_directive_ir(Dynamic_Dollar_Opr);
11124 COPY_OPND(IR_OPND_L(ir_idx), opnd);
11125 }
11126 }
11127 else {
11128 parse_err_flush(Find_EOS, NULL);
11129 }
11130 break;
11131
11132 case Tok_Open_Mp_Dir_Page_Place:
11133 if (! omp_extension_prefix(TOKEN_LINE(token))) {
11134
11135 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
11136 TOKEN_COLUMN(token),
11137 "PAGE_PLACE directive", "!$SGI");
11138 }
11139
11140 if (dump_flags.dsm) {
11141 ir_idx = gen_directive_ir(Page_Place_Dollar_Opr);
11142
11143 NTR_IR_LIST_TBL(list_idx);
11144 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
11145 IR_IDX_L(ir_idx) = list_idx;
11146 IR_LIST_CNT_L(ir_idx) = 3;
11147
11148 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
11149 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
11150 list_idx = IL_NEXT_LIST_IDX(list_idx);
11151
11152 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
11153 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
11154
11155 list_idx = IR_IDX_L(ir_idx);
11156
11157 if (LA_CH_VALUE == LPAREN) {
11158 NEXT_LA_CH;
11159
11160 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
11161 parse_deref(&opnd, NULL_IDX);
11162 COPY_OPND(IL_OPND(list_idx), opnd);
11163 }
11164 else {
11165 parse_err_flush(Find_EOS, "IDENTIFIER");
11166 goto EXIT;
11167 }
11168
11169 if (LA_CH_VALUE == COMMA) {
11170 NEXT_LA_CH;
11171 }
11172 else {
11173 parse_err_flush(Find_EOS, ",");
11174 goto EXIT;
11175 }
11176
11177 list_idx = IL_NEXT_LIST_IDX(list_idx);
11178
11179 parse_expr(&opnd);
11180
11181 COPY_OPND(IL_OPND(list_idx), opnd);
11182
11183 if (LA_CH_VALUE == COMMA) {
11184 NEXT_LA_CH;
11185 }
11186 else {
11187 parse_err_flush(Find_EOS, ",");
11188 goto EXIT;
11189 }
11190
11191 list_idx = IL_NEXT_LIST_IDX(list_idx);
11192
11193 parse_expr(&opnd);
11194
11195 COPY_OPND(IL_OPND(list_idx), opnd);
11196
11197 if (LA_CH_VALUE == RPAREN) {
11198 NEXT_LA_CH;
11199 }
11200 else {
11201 parse_err_flush(Find_EOS, ")");
11202 }
11203 }
11204 else {
11205 parse_err_flush(Find_EOS, "(");
11206 }
11207 }
11208 else {
11209 parse_err_flush(Find_EOS, NULL);
11210 }
11211 break;
11212
11213 case Tok_Open_Mp_Dir_Redistribute:
11214 if (! omp_extension_prefix(TOKEN_LINE(token))) {
11215
11216 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
11217 TOKEN_COLUMN(token),
11218 "REDISTRIBUTE directive", "!$SGI");
11219 }
11220
11221 if (dump_flags.dsm) {
11222 parse_redistribute_dir();
11223 }
11224 else {
11225 parse_err_flush(Find_EOS, NULL);
11226 }
11227 break;
11228
11229
11230 default:
11231 PRINTMSG(TOKEN_LINE(token), 790, Warning, TOKEN_COLUMN(token));
11232 parse_err_flush(Find_EOS, NULL);
11233 break;
11234 }
11235
11236 if (LA_CH_VALUE != EOS) {
11237 parse_err_flush(Find_EOS, EOS_STR);
11238 }
11239
11240 EXIT:
11241
11242 NEXT_LA_CH;
11243
11244 TRACE (Func_Exit, "parse_open_mp_directives", NULL);
11245
11246 return;
11247
11248 }
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269
11270
11271
11272
11273
11274
11275
11276
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288 static void parse_open_mp_clauses(open_mp_directive_type directive)
11289
11290 {
11291 int i;
11292 int ir_idx;
11293 int list_array[OPEN_MP_LIST_CNT];
11294 int list_idx;
11295 opnd_type opnd;
11296 int opr_ir_idx;
11297 long the_constant;
11298
11299 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
11300 int column;
11301 int line;
11302 int list2_idx;
11303 boolean seen_nest = FALSE;
11304 # endif
11305
11306
11307 TRACE (Func_Entry, "parse_open_mp_clauses", NULL);
11308
11309 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
11310
11311 for (i = 0; i < OPEN_MP_LIST_CNT; i++) {
11312 NTR_IR_LIST_TBL(list_array[i]);
11313 if (i >= 1) {
11314 IL_NEXT_LIST_IDX(list_array[i - 1]) = list_array[i];
11315 IL_PREV_LIST_IDX(list_array[i]) = list_array[i - 1];
11316 }
11317 }
11318
11319 IR_FLD_L(ir_idx) = IL_Tbl_Idx;
11320 IR_IDX_L(ir_idx) = list_array[0];
11321 IR_LIST_CNT_L(ir_idx) = OPEN_MP_LIST_CNT;
11322
11323 while (LA_CH_VALUE != EOS) {
11324
11325 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
11326
11327 switch (TOKEN_VALUE(token)) {
11328
11329 case Tok_Open_Mp_Dir_If:
11330
11331 if (! open_mp_clause_allowed[directive][If_Omp_Clause]) {
11332 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11333 "IF", open_mp_dir_str[directive]);
11334 parse_err_flush(Find_EOS, NULL);
11335 goto EXIT;
11336 }
11337
11338
11339
11340 if (IL_IDX(list_array[OPEN_MP_IF_IDX]) != NULL_IDX) {
11341 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
11342 "IF", open_mp_dir_str[directive]);
11343 parse_err_flush(Find_EOS, NULL);
11344 goto EXIT;
11345 }
11346
11347 if (LA_CH_VALUE == LPAREN) {
11348 NEXT_LA_CH;
11349 parse_expr(&opnd);
11350
11351 COPY_OPND(IL_OPND(list_array[OPEN_MP_IF_IDX]), opnd);
11352
11353 if (LA_CH_VALUE == RPAREN) {
11354 NEXT_LA_CH;
11355 }
11356 else {
11357 parse_err_flush(Find_EOS, ")");
11358 goto EXIT;
11359 }
11360 }
11361 else {
11362 parse_err_flush(Find_EOS, "(");
11363 goto EXIT;
11364 }
11365 break;
11366
11367 case Tok_Open_Mp_Dir_Num_Threads:
11368 if (! open_mp_clause_allowed[directive][Num_Threads_Omp_Clause]) {
11369 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11370 "NUM_THREADS", open_mp_dir_str[directive]);
11371 parse_err_flush(Find_EOS, NULL);
11372 goto EXIT;
11373 }
11374
11375
11376
11377 if (IL_IDX(list_array[OPEN_MP_NUM_THREADS]) != NULL_IDX) {
11378 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
11379 "NUM_THREADS", open_mp_dir_str[directive]);
11380 parse_err_flush(Find_EOS, NULL);
11381 goto EXIT;
11382 }
11383
11384 if (LA_CH_VALUE == LPAREN) {
11385 NEXT_LA_CH;
11386 parse_expr(&opnd);
11387
11388 COPY_OPND(IL_OPND(list_array[OPEN_MP_NUM_THREADS]), opnd);
11389
11390 if (LA_CH_VALUE == RPAREN) {
11391 NEXT_LA_CH;
11392 }
11393 else {
11394 parse_err_flush(Find_EOS, ")");
11395 goto EXIT;
11396 }
11397 }
11398 else {
11399 parse_err_flush(Find_EOS, "(");
11400 goto EXIT;
11401 }
11402 break;
11403
11404 case Tok_Open_Mp_Dir_Private:
11405
11406 if (! open_mp_clause_allowed[directive][Private_Omp_Clause]) {
11407 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11408 "PRIVATE", open_mp_dir_str[directive]);
11409 parse_err_flush(Find_EOS, NULL);
11410 goto EXIT;
11411 }
11412
11413 if (LA_CH_VALUE == LPAREN) {
11414 NEXT_LA_CH;
11415 parse_var_common_list(&opnd, FALSE);
11416
11417 if (IL_IDX(list_array[OPEN_MP_PRIVATE_IDX]) == NULL_IDX) {
11418 COPY_OPND(IL_OPND(list_array[OPEN_MP_PRIVATE_IDX]), opnd);
11419 }
11420 else {
11421
11422
11423 list_idx = IL_IDX(list_array[OPEN_MP_PRIVATE_IDX]);
11424 while (IL_NEXT_LIST_IDX(list_idx)) {
11425 list_idx = IL_NEXT_LIST_IDX(list_idx);
11426 }
11427
11428
11429 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
11430 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
11431 IL_LIST_CNT(list_array[OPEN_MP_PRIVATE_IDX]) +=
11432 OPND_LIST_CNT(opnd);
11433 }
11434
11435 if (LA_CH_VALUE == RPAREN) {
11436 NEXT_LA_CH;
11437 }
11438 else {
11439 parse_err_flush(Find_EOS, ")");
11440 goto EXIT;
11441 }
11442 }
11443 else {
11444 parse_err_flush(Find_EOS, "(");
11445 goto EXIT;
11446 }
11447
11448 break;
11449
11450 case Tok_Open_Mp_Dir_Shared:
11451
11452 if (! open_mp_clause_allowed[directive][Shared_Omp_Clause]) {
11453 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11454 "SHARED", open_mp_dir_str[directive]);
11455 parse_err_flush(Find_EOS, NULL);
11456 goto EXIT;
11457 }
11458
11459 if (LA_CH_VALUE == LPAREN) {
11460 NEXT_LA_CH;
11461 #ifdef KEY
11462 parse_var_common_list(&opnd, FALSE);
11463 #else
11464 parse_var_name_list(&opnd);
11465 #endif
11466
11467 if (IL_IDX(list_array[OPEN_MP_SHARED_IDX]) == NULL_IDX) {
11468 COPY_OPND(IL_OPND(list_array[OPEN_MP_SHARED_IDX]), opnd);
11469 }
11470 else {
11471
11472
11473 list_idx = IL_IDX(list_array[OPEN_MP_SHARED_IDX]);
11474 while (IL_NEXT_LIST_IDX(list_idx)) {
11475 list_idx = IL_NEXT_LIST_IDX(list_idx);
11476 }
11477
11478
11479 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
11480 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
11481 IL_LIST_CNT(list_array[OPEN_MP_SHARED_IDX]) +=
11482 OPND_LIST_CNT(opnd);
11483 }
11484
11485 if (LA_CH_VALUE == RPAREN) {
11486 NEXT_LA_CH;
11487 }
11488 else {
11489 parse_err_flush(Find_EOS, ")");
11490 goto EXIT;
11491 }
11492 }
11493 else {
11494 parse_err_flush(Find_EOS, "(");
11495 goto EXIT;
11496 }
11497
11498 break;
11499
11500 case Tok_Open_Mp_Dir_Firstprivate:
11501
11502 if (! open_mp_clause_allowed[directive]
11503 [Firstprivate_Omp_Clause]) {
11504 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11505 "FIRSTPRIVATE", open_mp_dir_str[directive]);
11506 parse_err_flush(Find_EOS, NULL);
11507 goto EXIT;
11508 }
11509
11510 if (LA_CH_VALUE == LPAREN) {
11511 NEXT_LA_CH;
11512 parse_var_common_list(&opnd, FALSE);
11513
11514 if (IL_IDX(list_array[OPEN_MP_FIRSTPRIVATE_IDX]) ==
11515 NULL_IDX) {
11516
11517 COPY_OPND(IL_OPND(list_array[OPEN_MP_FIRSTPRIVATE_IDX]),
11518 opnd);
11519 }
11520 else {
11521
11522
11523 list_idx = IL_IDX(list_array[OPEN_MP_FIRSTPRIVATE_IDX]);
11524 while (IL_NEXT_LIST_IDX(list_idx)) {
11525 list_idx = IL_NEXT_LIST_IDX(list_idx);
11526 }
11527
11528
11529 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
11530 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
11531 IL_LIST_CNT(list_array[OPEN_MP_FIRSTPRIVATE_IDX]) +=
11532 OPND_LIST_CNT(opnd);
11533 }
11534
11535 if (LA_CH_VALUE == RPAREN) {
11536 NEXT_LA_CH;
11537 }
11538 else {
11539 parse_err_flush(Find_EOS, ")");
11540 goto EXIT;
11541 }
11542 }
11543 else {
11544 parse_err_flush(Find_EOS, "(");
11545 goto EXIT;
11546 }
11547
11548 break;
11549
11550 case Tok_Open_Mp_Dir_Default:
11551
11552 if (! open_mp_clause_allowed[directive][Default_Omp_Clause]) {
11553 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11554 "DEFAULT", open_mp_dir_str[directive]);
11555 parse_err_flush(Find_EOS, NULL);
11556 goto EXIT;
11557 }
11558
11559
11560
11561 if (IL_IDX(list_array[OPEN_MP_DEFAULT_IDX]) != NULL_IDX) {
11562 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
11563 "DEFAULT", open_mp_dir_str[directive]);
11564 parse_err_flush(Find_EOS, NULL);
11565 goto EXIT;
11566 }
11567
11568 if (LA_CH_VALUE == LPAREN) {
11569 NEXT_LA_CH;
11570
11571 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
11572
11573 switch (TOKEN_VALUE(token)) {
11574 case Tok_Open_Mp_Dir_Private:
11575 the_constant = OPEN_MP_DEFAULT_PRIVATE;
11576 break;
11577
11578 case Tok_Open_Mp_Dir_Shared:
11579 the_constant = OPEN_MP_DEFAULT_SHARED;
11580 break;
11581
11582 case Tok_Open_Mp_Dir_None:
11583 the_constant = OPEN_MP_DEFAULT_NONE;
11584 break;
11585
11586 default:
11587 parse_err_flush(Find_EOS,
11588 "PRIVATE, SHARED, or NONE");
11589 goto EXIT;
11590 }
11591
11592 IL_FLD(list_array[OPEN_MP_DEFAULT_IDX]) = CN_Tbl_Idx;
11593 IL_IDX(list_array[OPEN_MP_DEFAULT_IDX]) =
11594 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
11595 the_constant);
11596
11597 IL_LINE_NUM(list_array[OPEN_MP_DEFAULT_IDX]) =
11598 TOKEN_LINE(token);
11599 IL_COL_NUM(list_array[OPEN_MP_DEFAULT_IDX]) =
11600 TOKEN_COLUMN(token);
11601
11602 if (LA_CH_VALUE == RPAREN) {
11603 NEXT_LA_CH;
11604 }
11605 else {
11606 parse_err_flush(Find_EOS, ")");
11607 goto EXIT;
11608 }
11609 }
11610 else {
11611 parse_err_flush(Find_EOS, "PRIVATE, SHARED, or NONE");
11612 }
11613 }
11614 else {
11615 parse_err_flush(Find_EOS, "(");
11616 goto EXIT;
11617 }
11618
11619 break;
11620
11621 case Tok_Open_Mp_Dir_Copyin:
11622
11623 if (! open_mp_clause_allowed[directive][Copyin_Omp_Clause]) {
11624 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11625 "COPYIN", open_mp_dir_str[directive]);
11626 parse_err_flush(Find_EOS, NULL);
11627 goto EXIT;
11628 }
11629
11630 if (LA_CH_VALUE == LPAREN) {
11631 NEXT_LA_CH;
11632 parse_var_common_list(&opnd, FALSE);
11633
11634 if (IL_IDX(list_array[OPEN_MP_COPYIN_IDX]) == NULL_IDX) {
11635 COPY_OPND(IL_OPND(list_array[OPEN_MP_COPYIN_IDX]),
11636 opnd);
11637 }
11638 else {
11639
11640
11641 list_idx = IL_IDX(list_array[OPEN_MP_COPYIN_IDX]);
11642 while (IL_NEXT_LIST_IDX(list_idx)) {
11643 list_idx = IL_NEXT_LIST_IDX(list_idx);
11644 }
11645
11646
11647 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
11648 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
11649 IL_LIST_CNT(list_array[OPEN_MP_COPYIN_IDX]) +=
11650 OPND_LIST_CNT(opnd);
11651 }
11652
11653 if (LA_CH_VALUE == RPAREN) {
11654 NEXT_LA_CH;
11655 }
11656 else {
11657 parse_err_flush(Find_EOS, ")");
11658 goto EXIT;
11659 }
11660 }
11661 else {
11662 parse_err_flush(Find_EOS, "(");
11663 goto EXIT;
11664 }
11665
11666 break;
11667
11668
11669 case Tok_Open_Mp_Dir_Reduction:
11670
11671 if (! open_mp_clause_allowed[directive][Reduction_Omp_Clause]) {
11672 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11673 "REDUCTION", open_mp_dir_str[directive]);
11674 parse_err_flush(Find_EOS, NULL);
11675 goto EXIT;
11676 }
11677
11678 if (LA_CH_VALUE == LPAREN) {
11679 NEXT_LA_CH;
11680
11681
11682 NTR_IR_TBL(opr_ir_idx);
11683 IR_LINE_NUM(opr_ir_idx) = LA_CH_LINE;
11684 IR_COL_NUM(opr_ir_idx) = LA_CH_COLUMN;
11685 IR_TYPE_IDX(opr_ir_idx) = INTEGER_DEFAULT_TYPE;
11686
11687 if (LA_CH_CLASS == Ch_Class_Letter) {
11688
11689 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
11690
11691 if (TOKEN_STR(token)[0] == 'M') {
11692 if (strcmp(TOKEN_STR(token), "MAX") == 0) {
11693 IR_OPR(opr_ir_idx) = Max_Opr;
11694 }
11695 else if (strcmp(TOKEN_STR(token), "MIN") == 0) {
11696 IR_OPR(opr_ir_idx) = Min_Opr;
11697 }
11698 else {
11699 parse_err_flush(Find_EOS,
11700 "MAX, MIN, IAND, IOR, IEOR");
11701 goto EXIT;
11702 }
11703 }
11704 else if (TOKEN_STR(token)[0] == 'I') {
11705 if (strcmp(TOKEN_STR(token), "IAND") == 0) {
11706 IR_OPR(opr_ir_idx) = Band_Opr;
11707 }
11708 else if (strcmp(TOKEN_STR(token), "IOR") == 0) {
11709 IR_OPR(opr_ir_idx) = Bor_Opr;
11710 }
11711 else if (strcmp(TOKEN_STR(token), "IEOR") == 0) {
11712 IR_OPR(opr_ir_idx) = Bneqv_Opr;
11713 }
11714 else {
11715 parse_err_flush(Find_EOS,
11716 "MAX, MIN, IAND, IOR, IEOR");
11717 goto EXIT;
11718 }
11719 }
11720 else {
11721 parse_err_flush(Find_EOS,
11722 "MAX, MIN, IAND, IOR, IEOR");
11723 goto EXIT;
11724 }
11725 }
11726 else {
11727 parse_err_flush(Find_EOS,
11728 "MAX, MIN, IAND, IOR, IEOR");
11729 goto EXIT;
11730 }
11731 }
11732 else if (MATCHED_TOKEN_CLASS(Tok_Class_Op)) {
11733 switch (TOKEN_VALUE(token)) {
11734 case Tok_Op_Add:
11735 IR_OPR(opr_ir_idx) = Plus_Opr;
11736 break;
11737
11738 case Tok_Op_Sub:
11739 IR_OPR(opr_ir_idx) = Minus_Opr;
11740 break;
11741
11742 case Tok_Op_Mult:
11743 IR_OPR(opr_ir_idx) = Mult_Opr;
11744 break;
11745
11746 case Tok_Op_And:
11747 IR_OPR(opr_ir_idx) = And_Opr;
11748 break;
11749
11750 case Tok_Op_Or:
11751 IR_OPR(opr_ir_idx) = Or_Opr;
11752 break;
11753
11754 case Tok_Op_Eqv:
11755 IR_OPR(opr_ir_idx) = Eqv_Opr;
11756 break;
11757
11758 case Tok_Op_Neqv:
11759 IR_OPR(opr_ir_idx) = Neqv_Opr;
11760 break;
11761
11762 default:
11763 parse_err_flush(Find_EOS,
11764 "+, *, -, .AND., .OR., .EQV., or .NEQV.");
11765 goto EXIT;
11766 }
11767 }
11768 else {
11769 parse_err_flush(Find_EOS, "operator or intrinsic");
11770 goto EXIT;
11771 }
11772
11773 if (IL_IDX(list_array[OPEN_MP_REDUCTION_OPR_IDX]) ==
11774 NULL_IDX) {
11775 NTR_IR_LIST_TBL(list_idx);
11776 IL_FLD(list_array[OPEN_MP_REDUCTION_OPR_IDX]) =
11777 IL_Tbl_Idx;
11778 IL_IDX(list_array[OPEN_MP_REDUCTION_OPR_IDX]) =
11779 list_idx;
11780 IL_LIST_CNT(list_array[OPEN_MP_REDUCTION_OPR_IDX]) = 1;
11781
11782 }
11783 else {
11784
11785
11786 list_idx = IL_IDX(list_array[OPEN_MP_REDUCTION_OPR_IDX]);
11787 while (IL_NEXT_LIST_IDX(list_idx)) {
11788 list_idx = IL_NEXT_LIST_IDX(list_idx);
11789 }
11790
11791 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
11792 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
11793 list_idx = IL_NEXT_LIST_IDX(list_idx);
11794 IL_LIST_CNT(list_array[OPEN_MP_REDUCTION_OPR_IDX]) += 1;
11795 }
11796
11797 IL_FLD(list_idx) = IR_Tbl_Idx;
11798 IL_IDX(list_idx) = opr_ir_idx;
11799
11800 if (LA_CH_VALUE == COLON) {
11801 NEXT_LA_CH;
11802 }
11803 else {
11804 parse_err_flush(Find_EOS, ":");
11805 goto EXIT;
11806 }
11807
11808
11809 parse_var_name_list(&opnd);
11810
11811 if (IL_IDX(list_array[OPEN_MP_REDUCTION_LIST_IDX]) ==
11812 NULL_IDX) {
11813 NTR_IR_LIST_TBL(list_idx);
11814 IL_FLD(list_array[OPEN_MP_REDUCTION_LIST_IDX]) =
11815 IL_Tbl_Idx;
11816 IL_IDX(list_array[OPEN_MP_REDUCTION_LIST_IDX]) =
11817 list_idx;
11818 IL_LIST_CNT(list_array[OPEN_MP_REDUCTION_LIST_IDX]) = 1;
11819
11820 }
11821 else {
11822
11823
11824 list_idx = IL_IDX(list_array[OPEN_MP_REDUCTION_LIST_IDX]);
11825 while (IL_NEXT_LIST_IDX(list_idx)) {
11826 list_idx = IL_NEXT_LIST_IDX(list_idx);
11827 }
11828
11829 NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));
11830 IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;
11831 list_idx = IL_NEXT_LIST_IDX(list_idx);
11832 IL_LIST_CNT(list_array[OPEN_MP_REDUCTION_LIST_IDX]) += 1;
11833 }
11834
11835 COPY_OPND(IL_OPND(list_idx), opnd);
11836
11837 if (LA_CH_VALUE == RPAREN) {
11838 NEXT_LA_CH;
11839 }
11840 else {
11841 parse_err_flush(Find_EOS, ")");
11842 goto EXIT;
11843 }
11844 }
11845 else {
11846 parse_err_flush(Find_EOS, "(");
11847 goto EXIT;
11848 }
11849
11850 break;
11851
11852 case Tok_Open_Mp_Dir_Lastprivate:
11853
11854 if (! open_mp_clause_allowed[directive][Lastprivate_Omp_Clause]){
11855 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11856 "LASTPRIVATE", open_mp_dir_str[directive]);
11857 parse_err_flush(Find_EOS, NULL);
11858 goto EXIT;
11859 }
11860
11861 if (LA_CH_VALUE == LPAREN) {
11862 NEXT_LA_CH;
11863 parse_var_common_list(&opnd, FALSE);
11864
11865 if (IL_IDX(list_array[OPEN_MP_LASTPRIVATE_IDX]) == NULL_IDX) {
11866 COPY_OPND(IL_OPND(list_array[OPEN_MP_LASTPRIVATE_IDX]),
11867 opnd);
11868 }
11869 else {
11870
11871
11872 list_idx = IL_IDX(list_array[OPEN_MP_LASTPRIVATE_IDX]);
11873 while (IL_NEXT_LIST_IDX(list_idx)) {
11874 list_idx = IL_NEXT_LIST_IDX(list_idx);
11875 }
11876
11877
11878 IL_NEXT_LIST_IDX(list_idx) = OPND_IDX(opnd);
11879 IL_PREV_LIST_IDX(OPND_IDX(opnd)) = list_idx;
11880 IL_LIST_CNT(list_array[OPEN_MP_LASTPRIVATE_IDX]) +=
11881 OPND_LIST_CNT(opnd);
11882 }
11883
11884 if (LA_CH_VALUE == RPAREN) {
11885 NEXT_LA_CH;
11886 }
11887 else {
11888 parse_err_flush(Find_EOS, ")");
11889 goto EXIT;
11890 }
11891 }
11892 else {
11893 parse_err_flush(Find_EOS, "(");
11894 goto EXIT;
11895 }
11896
11897 break;
11898
11899 case Tok_Open_Mp_Dir_Ordered:
11900
11901 if (! open_mp_clause_allowed[directive][Ordered_Omp_Clause]) {
11902 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11903 "ORDERED", open_mp_dir_str[directive]);
11904 parse_err_flush(Find_EOS, NULL);
11905 goto EXIT;
11906 }
11907
11908
11909
11910 if (IL_IDX(list_array[OPEN_MP_ORDERED_IDX]) != NULL_IDX) {
11911 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
11912 "ORDERED", open_mp_dir_str[directive]);
11913 parse_err_flush(Find_EOS, NULL);
11914 goto EXIT;
11915 }
11916
11917 IL_LINE_NUM(list_array[OPEN_MP_ORDERED_IDX]) =
11918 TOKEN_LINE(token);
11919 IL_COL_NUM(list_array[OPEN_MP_ORDERED_IDX]) =
11920 TOKEN_COLUMN(token);
11921 IL_FLD(list_array[OPEN_MP_ORDERED_IDX]) = CN_Tbl_Idx;
11922
11923 IL_IDX(list_array[OPEN_MP_ORDERED_IDX]) = CN_INTEGER_ONE_IDX;
11924
11925 break;
11926
11927 case Tok_Open_Mp_Dir_Schedule:
11928
11929 if (! open_mp_clause_allowed[directive][Schedule_Omp_Clause]) {
11930 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
11931 "SCHEDULE", open_mp_dir_str[directive]);
11932 parse_err_flush(Find_EOS, NULL);
11933 goto EXIT;
11934 }
11935
11936
11937
11938 if (IL_IDX(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) != NULL_IDX) {
11939 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
11940 "SCHEDULE", open_mp_dir_str[directive]);
11941 parse_err_flush(Find_EOS, NULL);
11942 goto EXIT;
11943 }
11944
11945 if (LA_CH_VALUE == LPAREN) {
11946 NEXT_LA_CH;
11947
11948 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
11949
11950 switch (TOKEN_VALUE(token)) {
11951 case Tok_Open_Mp_Dir_Static:
11952 the_constant = OPEN_MP_SCHEDULE_STATIC;
11953 break;
11954
11955 case Tok_Open_Mp_Dir_Dynamic:
11956 the_constant = OPEN_MP_SCHEDULE_DYNAMIC;
11957 break;
11958
11959 case Tok_Open_Mp_Dir_Guided:
11960 the_constant = OPEN_MP_SCHEDULE_GUIDED;
11961 break;
11962
11963 case Tok_Open_Mp_Dir_Runtime:
11964 the_constant = OPEN_MP_SCHEDULE_RUNTIME;
11965 break;
11966
11967 default:
11968 parse_err_flush(Find_EOS,"SCHEDULE type");
11969 goto EXIT;
11970 }
11971
11972 IL_FLD(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) =CN_Tbl_Idx;
11973 IL_IDX(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) =
11974 C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
11975 the_constant);
11976
11977 IL_LINE_NUM(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) =
11978 TOKEN_LINE(token);
11979 IL_COL_NUM(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) =
11980 TOKEN_COLUMN(token);
11981
11982 if (LA_CH_VALUE == COMMA) {
11983 NEXT_LA_CH;
11984 parse_expr(&opnd);
11985 COPY_OPND(IL_OPND(list_array[
11986 OPEN_MP_SCHEDULE_CHUNK_IDX]), opnd);
11987 }
11988
11989 if (LA_CH_VALUE == RPAREN) {
11990 NEXT_LA_CH;
11991 }
11992 else {
11993 parse_err_flush(Find_EOS, ")");
11994 goto EXIT;
11995 }
11996 }
11997 else {
11998 parse_err_flush(Find_EOS, "SCHEDULE type");
11999 goto EXIT;
12000 }
12001 }
12002 else {
12003 parse_err_flush(Find_EOS, "(");
12004 goto EXIT;
12005 }
12006 break;
12007
12008 # if (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
12009 case Tok_Open_Mp_Dir_Affinity:
12010
12011 if (! open_mp_clause_allowed[directive][Affinity_Omp_Clause]) {
12012 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
12013 "AFFINITY", open_mp_dir_str[directive]);
12014 parse_err_flush(Find_EOS, NULL);
12015 goto EXIT;
12016 }
12017
12018 if (IL_IDX(list_array[OPEN_MP_AFFINITY_IDX]) != NULL_IDX) {
12019 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
12020 "AFFINITY", open_mp_dir_str[directive]);
12021 parse_err_flush(Find_EOS, NULL);
12022 goto EXIT;
12023 }
12024
12025 if (! omp_extension_prefix(TOKEN_LINE(token))) {
12026
12027 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
12028 TOKEN_COLUMN(token),
12029 "AFFINITY clause", "!$SGI");
12030 }
12031
12032 if (LA_CH_VALUE == LPAREN) {
12033 NEXT_LA_CH;
12034 parse_var_name_list(&opnd);
12035
12036 COPY_OPND(IL_OPND(list_array[OPEN_MP_AFFINITY_IDX]), opnd);
12037
12038 if (LA_CH_VALUE == RPAREN) {
12039 NEXT_LA_CH;
12040 }
12041 else {
12042 parse_err_flush(Find_EOS, ")");
12043 goto EXIT;
12044 }
12045 }
12046 else {
12047 parse_err_flush(Find_EOS, "(");
12048 goto EXIT;
12049 }
12050
12051 if (LA_CH_VALUE == EQUAL) {
12052
12053 NEXT_LA_CH;
12054
12055 if (MATCHED_TOKEN_CLASS(Tok_Class_Open_Mp_Dir_Kwd)) {
12056
12057 IL_FLD(list_array[OPEN_MP_IS_THREAD_IDX]) = CN_Tbl_Idx;
12058 IL_LINE_NUM(list_array[OPEN_MP_IS_THREAD_IDX]) =
12059 TOKEN_LINE(token);
12060 IL_COL_NUM(list_array[OPEN_MP_IS_THREAD_IDX]) =
12061 TOKEN_COLUMN(token);
12062
12063 switch (TOKEN_VALUE(token)) {
12064 case Tok_Open_Mp_Dir_Data:
12065 IL_IDX(list_array[OPEN_MP_IS_THREAD_IDX]) =
12066 CN_INTEGER_ZERO_IDX;
12067 break;
12068 case Tok_Open_Mp_Dir_Thread:
12069 IL_IDX(list_array[OPEN_MP_IS_THREAD_IDX]) =
12070 CN_INTEGER_ONE_IDX;
12071
12072 break;
12073
12074 default:
12075 parse_err_flush(Find_EOS, "DATA or THREAD");
12076 break;
12077 }
12078
12079 if (LA_CH_VALUE == LPAREN) {
12080
12081 NEXT_LA_CH;
12082
12083 parse_expr(&opnd);
12084
12085 COPY_OPND(IL_OPND(list_array[
12086 OPEN_MP_THREAD_DATA_IDX]), opnd);
12087
12088 if (LA_CH_VALUE == RPAREN) {
12089 NEXT_LA_CH;
12090 }
12091 else {
12092 parse_err_flush(Find_EOS, ")");
12093 goto EXIT;
12094 }
12095 }
12096 else {
12097 parse_err_flush(Find_EOS, "(");
12098 goto EXIT;
12099 }
12100 }
12101 else {
12102 parse_err_flush(Find_EOS, "DATA or THREAD");
12103 }
12104
12105 }
12106 else {
12107 parse_err_flush(Find_EOS, "=");
12108 goto EXIT;
12109 }
12110
12111 if (! dump_flags.dsm) {
12112 opnd = null_opnd;
12113
12114 COPY_OPND(IL_OPND(list_array[OPEN_MP_AFFINITY_IDX]),
12115 opnd);
12116 COPY_OPND(IL_OPND(list_array[OPEN_MP_THREAD_DATA_IDX]),
12117 opnd);
12118 COPY_OPND(IL_OPND(list_array[OPEN_MP_IS_THREAD_IDX]),
12119 opnd);
12120 }
12121 break;
12122
12123 case Tok_Open_Mp_Dir_Onto:
12124 if (! open_mp_clause_allowed[directive][Onto_Omp_Clause]) {
12125 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
12126 "ONTO", open_mp_dir_str[directive]);
12127 parse_err_flush(Find_EOS, NULL);
12128 goto EXIT;
12129 }
12130
12131
12132 if (! omp_extension_prefix(TOKEN_LINE(token))) {
12133
12134 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
12135 TOKEN_COLUMN(token),
12136 "ONTO clause", "!$SGI");
12137 }
12138
12139 if (seen_nest) {
12140
12141 if (IL_IDX(list_array[OPEN_MP_ONTO_IDX]) != NULL_IDX) {
12142 PRINTMSG(TOKEN_LINE(token), 1360, Error,
12143 TOKEN_COLUMN(token),
12144 "ONTO", open_mp_dir_str[directive]);
12145 parse_err_flush(Find_EOS, NULL);
12146 goto EXIT;
12147 }
12148
12149 if (LA_CH_VALUE == LPAREN) {
12150 NEXT_LA_CH;
12151 parse_int_or_star_list(&opnd);
12152
12153 COPY_OPND(IL_OPND(list_array[OPEN_MP_ONTO_IDX]), opnd);
12154
12155 if (LA_CH_VALUE == RPAREN) {
12156 NEXT_LA_CH;
12157 }
12158 else {
12159 parse_err_flush(Find_EOS, ")");
12160 goto EXIT;
12161 }
12162 }
12163 else {
12164 parse_err_flush(Find_EOS, "(");
12165 goto EXIT;
12166 }
12167
12168 list_idx = list_array[OPEN_MP_ONTO_IDX];
12169
12170 list2_idx = list_array[OPEN_MP_NEST_IDX];
12171
12172 if (IL_FLD(list2_idx) != IL_Tbl_Idx ||
12173 IL_LIST_CNT(list2_idx) != IL_LIST_CNT(list_idx)) {
12174
12175
12176
12177 find_opnd_line_and_column(&IL_OPND(IL_IDX(list_idx)),
12178 &line, &column);
12179
12180 PRINTMSG(line, 1369, Error, column);
12181 }
12182 else if (IL_LIST_CNT(list2_idx) == 1) {
12183
12184
12185 find_opnd_line_and_column(&IL_OPND(IL_IDX(list_idx)),
12186 &line, &column);
12187
12188 PRINTMSG(line, 1377, Error, column);
12189 }
12190 }
12191 else {
12192 PRINTMSG(TOKEN_LINE(token), 1361, Error, TOKEN_COLUMN(token),
12193 open_mp_dir_str[directive]);
12194 parse_err_flush(Find_EOS, NULL);
12195 goto EXIT;
12196 }
12197 break;
12198
12199 case Tok_Open_Mp_Dir_Nest:
12200
12201 if (! open_mp_clause_allowed[directive][Nest_Omp_Clause]) {
12202 PRINTMSG(TOKEN_LINE(token), 1370, Error, TOKEN_COLUMN(token),
12203 "NEST", open_mp_dir_str[directive]);
12204 parse_err_flush(Find_EOS, NULL);
12205 goto EXIT;
12206 }
12207
12208 if (seen_nest) {
12209 PRINTMSG(TOKEN_LINE(token), 1360, Error, TOKEN_COLUMN(token),
12210 "NEST", open_mp_dir_str[directive]);
12211 parse_err_flush(Find_EOS, NULL);
12212 goto EXIT;
12213 }
12214
12215
12216 if (! omp_extension_prefix(TOKEN_LINE(token))) {
12217
12218 PRINTMSG(TOKEN_LINE(token), 1518, Warning,
12219 TOKEN_COLUMN(token),
12220 "NEST clause", "!$SGI");
12221 }
12222
12223 seen_nest = TRUE;
12224
12225 if (LA_CH_VALUE == LPAREN) {
12226 NEXT_LA_CH;
12227 parse_var_name_list(&opnd);
12228
12229 COPY_OPND(IL_OPND(list_array[OPEN_MP_NEST_IDX]), opnd);
12230
12231 if (LA_CH_VALUE == RPAREN) {
12232 NEXT_LA_CH;
12233 }
12234 else {
12235 parse_err_flush(Find_EOS, ")");
12236 goto EXIT;
12237 }
12238 }
12239 else {
12240 parse_err_flush(Find_EOS, "(");
12241 goto EXIT;
12242 }
12243
12244 break;
12245 # endif
12246
12247 default:
12248 PRINTMSG(TOKEN_LINE(token), 1517, Error, TOKEN_COLUMN(token),
12249 "OpenMP");
12250 parse_err_flush(Find_EOS, NULL);
12251 goto EXIT;
12252 }
12253 }
12254 else {
12255 parse_err_flush(Find_EOS, "OpenMP clause");
12256 }
12257
12258 if (LA_CH_VALUE == COMMA) {
12259 NEXT_LA_CH;
12260 }
12261 }
12262
12263 if (open_mp_clause_allowed[directive][Schedule_Omp_Clause] &&
12264 IL_IDX(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) == NULL_IDX &&
12265 OPND_FLD(cdir_switches.mp_schedtype_opnd) != NO_Tbl_Idx) {
12266
12267 COPY_OPND(IL_OPND(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]),
12268 cdir_switches.mp_schedtype_opnd);
12269 }
12270
12271 EXIT:
12272
12273 TRACE (Func_Exit, "parse_open_mp_clauses", NULL);
12274
12275 return;
12276
12277 }
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295 static void check_do_open_mp_nesting(void)
12296
12297 {
12298 int blk_idx;
12299 int ir_idx;
12300
12301 TRACE (Func_Entry, "check_do_open_mp_nesting", NULL);
12302
12303 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
12304
12305 blk_idx = blk_stk_idx;
12306
12307 while (blk_idx > 0) {
12308 if (BLK_TYPE(blk_idx) == Open_Mp_Parallel_Blk) {
12309 break;
12310 }
12311
12312 if (BLK_TYPE(blk_idx) == Open_Mp_Do_Blk ||
12313 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Do_Blk) {
12314
12315 if (blk_idx < blk_stk_idx &&
12316 BLK_TYPE(blk_idx + 1) == Do_Blk &&
12317 BLK_DEF_LINE(blk_idx) == BLK_DEF_LINE(blk_idx + 1)) {
12318
12319 PRINTMSG(IR_LINE_NUM(ir_idx), 1474, Error,
12320 IR_COL_NUM(ir_idx));
12321 break;
12322 }
12323 else {
12324
12325 if (BLK_TYPE(blk_idx) == Open_Mp_Do_Blk) {
12326 CLEAR_DIRECTIVE_STATE(Open_Mp_Do_Region);
12327 }
12328 else {
12329 CLEAR_DIRECTIVE_STATE(Open_Mp_Parallel_Do_Region);
12330 }
12331 move_blk_to_end(blk_idx);
12332 POP_BLK_STK;
12333 }
12334 }
12335 else if (BLK_TYPE(blk_idx) == Open_Mp_Sections_Blk ||
12336 BLK_TYPE(blk_idx) == Open_Mp_Single_Blk ||
12337 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Sections_Blk ||
12338 BLK_TYPE(blk_idx) == Open_Mp_Workshare_Blk ||
12339 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Workshare_Blk ) {
12340
12341 PRINTMSG(IR_LINE_NUM(ir_idx), 1474, Error,
12342 IR_COL_NUM(ir_idx));
12343 break;
12344 }
12345 blk_idx--;
12346 }
12347
12348 TRACE (Func_Exit, "check_do_open_mp_nesting", NULL);
12349
12350 return;
12351
12352 }
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370 static void check_ordered_open_mp_nesting(void)
12371
12372 {
12373 int blk_idx;
12374 int i;
12375 int ir_idx;
12376 int list_idx;
12377
12378 TRACE (Func_Entry, "check_ordered_open_mp_nesting", NULL);
12379
12380 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
12381
12382 blk_idx = blk_stk_idx;
12383
12384 while (blk_idx > 0) {
12385 if (BLK_TYPE(blk_idx) == Open_Mp_Parallel_Blk ||
12386 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Sections_Blk) {
12387
12388
12389 PRINTMSG(IR_LINE_NUM(ir_idx), 1506, Error,
12390 IR_COL_NUM(ir_idx));
12391 break;
12392 }
12393
12394 if (BLK_TYPE(blk_idx) == Open_Mp_Do_Blk ||
12395 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Do_Blk) {
12396
12397
12398
12399 list_idx = IR_IDX_L(SH_IR_IDX(BLK_FIRST_SH_IDX(blk_idx)));
12400
12401 for (i = 0; i < OPEN_MP_ORDERED_IDX; i++) {
12402 list_idx = IL_NEXT_LIST_IDX(list_idx);
12403 }
12404
12405 if (IL_FLD(list_idx) == NO_Tbl_Idx) {
12406 PRINTMSG(IR_LINE_NUM(ir_idx), 1507, Error,
12407 IR_COL_NUM(ir_idx));
12408 }
12409
12410 break;
12411 }
12412 blk_idx--;
12413 }
12414
12415 TRACE (Func_Exit, "check_ordered_open_mp_nesting", NULL);
12416
12417 return;
12418
12419 }
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437 static boolean check_section_open_mp_context(void)
12438
12439 {
12440 int blk_idx;
12441 int ir_idx;
12442 boolean ok = TRUE;
12443
12444 TRACE (Func_Entry, "check_section_open_mp_context", NULL);
12445
12446 ir_idx = SH_IR_IDX(curr_stmt_sh_idx);
12447
12448 blk_idx = blk_stk_idx;
12449
12450 while (blk_idx > 0) {
12451 if (BLK_TYPE(blk_idx) == Open_Mp_Sections_Blk ||
12452 BLK_TYPE(blk_idx) == Open_Mp_Parallel_Sections_Blk) {
12453
12454 goto FOUND;
12455 }
12456 blk_idx--;
12457 }
12458
12459 PRINTMSG(IR_LINE_NUM(ir_idx), 1412, Error, IR_COL_NUM(ir_idx),
12460 "C$OMP SECTION",
12461 "C$OMP PARALLEL SECTIONS region, or C$OMP SECTIONS region");
12462
12463 ok = FALSE;
12464
12465 FOUND:
12466
12467 TRACE (Func_Exit, "check_section_open_mp_context", NULL);
12468
12469 return(ok);
12470
12471 }
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488 static void parse_cache_noalloc(void)
12489
12490 {
12491 int attr_idx;
12492 int name_idx;
12493
12494
12495 TRACE (Func_Entry, "parse_cache_noalloc", NULL);
12496
12497 do {
12498 if (MATCHED_TOKEN_CLASS(Tok_Class_Id)) {
12499 attr_idx = srch_sym_tbl(TOKEN_STR(token), TOKEN_LEN(token),
12500 &name_idx);
12501
12502 if (attr_idx == NULL_IDX) {
12503 attr_idx = ntr_sym_tbl(&token, name_idx);
12504 LN_DEF_LOC(name_idx) = TRUE;
12505 AT_OBJ_CLASS(attr_idx) = Data_Obj;
12506 ATD_CACHE_NOALLOC(attr_idx) = TRUE;
12507 }
12508 else if (!fnd_semantic_err(Obj_No_Side_Effects,
12509 TOKEN_LINE(token),
12510 TOKEN_COLUMN(token),
12511 attr_idx,
12512 TRUE)) {
12513
12514 if (AT_REFERENCED(attr_idx) == Char_Rslt_Bound_Ref) {
12515 AT_ATTR_LINK(attr_idx) = NULL_IDX;
12516 LN_DEF_LOC(name_idx) = TRUE;
12517 }
12518
12519 }
12520 }
12521 else if (!parse_err_flush(Find_Comma, "procedure name")) {
12522 break;
12523 }
12524
12525 if (LA_CH_VALUE == COMMA) {
12526 NEXT_LA_CH;
12527 }
12528 else if (LA_CH_VALUE == EOS ||
12529 !parse_err_flush(Find_Comma, ", or "EOS_STR)) {
12530 break;
12531 }
12532 else {
12533 NEXT_LA_CH;
12534 }
12535 }
12536 while (TRUE);
12537
12538 NEXT_LA_CH;
12539
12540 TRACE (Func_Exit, "parse_cache_noalloc", NULL);
12541
12542 return;
12543
12544 }
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562 static void parse_star_dir_directives(void)
12563
12564 {
12565 int blk_idx;
12566 int ir_idx;
12567 opnd_type opnd;
12568 int save_line_num;
12569 int save_column_num;
12570
12571
12572 TRACE (Func_Exit, "parse_star_dir_directives", NULL);
12573
12574 switch (TOKEN_VALUE(token)) {
12575 case Tok_SGI_Dir_Blockingsize:
12576 case Tok_Dir_Blockingsize:
12577
12578 ir_idx = gen_directive_ir(Blockingsize_Dir_Opr);
12579
12580 if (LA_CH_VALUE == LPAREN) {
12581 NEXT_LA_CH;
12582
12583 if (LA_CH_VALUE != COMMA) {
12584 parse_expr(&opnd);
12585 COPY_OPND(IR_OPND_L(ir_idx), opnd);
12586 }
12587 else {
12588 IR_FLD_L(ir_idx) = CN_Tbl_Idx;
12589 IR_IDX_L(ir_idx) = CN_INTEGER_NEG_ONE_IDX;
12590 IR_LINE_NUM_L(ir_idx) = LA_CH_LINE;
12591 IR_COL_NUM_L(ir_idx) = LA_CH_COLUMN;
12592 }
12593
12594 if (LA_CH_VALUE == COMMA) {
12595 NEXT_LA_CH;
12596
12597 parse_expr(&opnd);
12598 COPY_OPND(IR_OPND_R(ir_idx), opnd);
12599 }
12600 else {
12601 IR_FLD_R(ir_idx) = CN_Tbl_Idx;
12602 IR_IDX_R(ir_idx) = CN_INTEGER_NEG_ONE_IDX;
12603 IR_LINE_NUM_R(ir_idx) = LA_CH_LINE;
12604 IR_COL_NUM_R(ir_idx) = LA_CH_COLUMN;
12605 }
12606
12607 if (LA_CH_VALUE == RPAREN) {
12608 NEXT_LA_CH;
12609 }
12610 else {
12611 parse_err_flush(Find_EOS, ")");
12612 goto EXIT;
12613 }
12614 }
12615 else {
12616 parse_err_flush(Find_EOS, "(");
12617 goto EXIT;
12618 }
12619 break;
12620
12621
12622 case Tok_SGI_Dir_Blockable:
12623 case Tok_Dir_Blockable:
12624
12625 if (LA_CH_VALUE == LPAREN) {
12626 save_line_num = LA_CH_LINE;
12627 save_column_num = LA_CH_COLUMN;
12628
12629 NEXT_LA_CH;
12630
12631 if (parse_var_name_list(&opnd)) {
12632
12633 if (LA_CH_VALUE == RPAREN) {
12634
12635 if (OPND_LIST_CNT(opnd) > 1) {
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646 if (cdir_switches.blockable_sh_idx == NULL_IDX) {
12647
12648 for (blk_idx = blk_stk_idx; blk_idx > 1; --blk_idx) {
12649
12650 if (BLK_TYPE(blk_idx) == Do_Blk) {
12651 break;
12652 }
12653 }
12654
12655 if (blk_idx > 1 &&
12656 SH_STMT_TYPE(BLK_FIRST_SH_IDX(blk_idx)) ==
12657 Do_Iterative_Stmt &&
12658 BLK_BLOCKABLE_NUM_LCVS(blk_idx) > 1) {
12659
12660 for ( ; blk_idx > 1; --blk_idx) {
12661
12662 if (BLK_BLOCKABLE_DIR_SH_IDX(blk_idx) != NULL_IDX) {
12663 PRINTMSG(stmt_start_line, 1387, Error, 0,
12664 "BLOCKABLE");
12665 SH_ERR_FLG(BLK_BLOCKABLE_DIR_SH_IDX(blk_idx)) =
12666 TRUE;
12667 break;
12668 }
12669 }
12670 }
12671 else {
12672 ir_idx = gen_directive_ir(Blockable_Dir_Opr);
12673 COPY_OPND(IR_OPND_L(ir_idx), opnd);
12674 cdir_switches.blockable_sh_idx = curr_stmt_sh_idx;
12675 cdir_switches.blockable_group++;
12676 }
12677 }
12678 else {
12679 PRINTMSG(stmt_start_line, 1387, Error, 0, "BLOCKABLE");
12680 SH_ERR_FLG(cdir_switches.blockable_sh_idx) = TRUE;
12681 }
12682 }
12683 else {
12684 PRINTMSG(save_line_num, 1375, Error, save_column_num);
12685 }
12686 }
12687 }
12688 else {
12689 parse_err_flush(Find_EOS, NULL);
12690 goto EXIT;
12691 }
12692
12693 if (LA_CH_VALUE == RPAREN) {
12694 NEXT_LA_CH;
12695 }
12696 else {
12697 parse_err_flush(Find_EOS, ", or )");
12698 goto EXIT;
12699 }
12700 }
12701 else {
12702 parse_err_flush(Find_EOS, "(");
12703 goto EXIT;
12704 }
12705 break;
12706
12707 case Tok_SGI_Dir_Interchange:
12708 case Tok_Dir_Interchange:
12709
12710 if (LA_CH_VALUE == LPAREN) {
12711 save_line_num = LA_CH_LINE;
12712 save_column_num = LA_CH_COLUMN;
12713
12714 NEXT_LA_CH;
12715
12716 if (parse_var_name_list(&opnd)) {
12717
12718 if (LA_CH_VALUE == RPAREN) {
12719
12720 if (OPND_LIST_CNT(opnd) > 1) {
12721
12722
12723
12724
12725
12726
12727
12728
12729
12730
12731 if (cdir_switches.interchange_sh_idx == NULL_IDX) {
12732
12733 for (blk_idx = blk_stk_idx; blk_idx > 1; --blk_idx) {
12734
12735 if (BLK_TYPE(blk_idx) == Do_Blk) {
12736 break;
12737 }
12738 }
12739
12740 if (blk_idx > 1 &&
12741 SH_STMT_TYPE(BLK_FIRST_SH_IDX(blk_idx)) ==
12742 Do_Iterative_Stmt &&
12743 BLK_INTERCHANGE_NUM_LCVS(blk_idx) > 1) {
12744
12745 for ( ; blk_idx > 1; --blk_idx) {
12746
12747 if (BLK_INTERCHANGE_DIR_SH_IDX(blk_idx) !=
12748 NULL_IDX) {
12749 PRINTMSG(stmt_start_line, 1387, Error, 0,
12750 "INTERCHANGE");
12751 SH_ERR_FLG(BLK_INTERCHANGE_DIR_SH_IDX(blk_idx)) =
12752 TRUE;
12753 break;
12754 }
12755 }
12756 }
12757 else {
12758 ir_idx = gen_directive_ir(Interchange_Dir_Opr);
12759 COPY_OPND(IR_OPND_L(ir_idx), opnd);
12760 cdir_switches.interchange_sh_idx = curr_stmt_sh_idx;
12761 cdir_switches.interchange_group++;
12762 }
12763 }
12764 else {
12765 PRINTMSG(stmt_start_line, 1387, Error, 0, "INTERCHANGE");
12766 SH_ERR_FLG(cdir_switches.interchange_sh_idx) = TRUE;
12767 }
12768 }
12769 else {
12770 PRINTMSG(save_line_num, 1375, Error, save_column_num);
12771 }
12772 }
12773 }
12774 else {
12775 parse_err_flush(Find_EOS, NULL);
12776 goto EXIT;
12777 }
12778
12779 if (LA_CH_VALUE == RPAREN) {
12780 NEXT_LA_CH;
12781 }
12782 else {
12783 parse_err_flush(Find_EOS, ", or )");
12784 goto EXIT;
12785 }
12786 }
12787 else {
12788 parse_err_flush(Find_EOS, "(");
12789 goto EXIT;
12790 }
12791 }
12792
12793 if (LA_CH_VALUE != EOS) {
12794 PRINTMSG(LA_CH_LINE, 790, Warning, LA_CH_COLUMN);
12795 parse_err_flush(Find_EOS, NULL);
12796 }
12797
12798 NEXT_LA_CH;
12799
12800 EXIT:
12801
12802 TRACE (Func_Exit, "parse_star_dir_directives", NULL);
12803
12804 return;
12805
12806 }
