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 static char USMID[] = "\n@(#)5.0_pl/sources/cond_comp.c 5.8 09/21/99 00:21:13\n";
00038
00039
00040
00041
00042
00043 # include <time.h>
00044
00045 # include <sys/time.h>
00046
00047
00048 # include "defines.h"
00049
00050 # include "host.m"
00051 # include "host.h"
00052 # include "target.m"
00053 # include "target.h"
00054
00055 # include "globals.m"
00056 # include "tokens.m"
00057 # include "sytb.m"
00058 # include "p_globals.m"
00059 # include "src_input.m"
00060 # include "cond_comp.m"
00061 # include "debug.m"
00062
00063 # include "globals.h"
00064 # include "tokens.h"
00065 # include "sytb.h"
00066 # include "p_globals.h"
00067 # include "cond_comp.h"
00068
00069
00070
00071
00072
00073
00074 static void cc_get_token(boolean);
00075 static void cc_get_next_char(void);
00076 static void cc_get_stmt(void);
00077 static boolean parse_cc_add_opnd (opnd_type *);
00078 static boolean parse_cc_level_2 (opnd_type *);
00079 static boolean parse_cc_level_3 (opnd_type *);
00080 static boolean parse_cc_level_4 (opnd_type *);
00081 static boolean parse_cc_level_5 (opnd_type *);
00082 static boolean parse_cc_level_6 (opnd_type *);
00083 static boolean parse_cc_level_7 (opnd_type *);
00084 static boolean parse_cc_level_8 (opnd_type *);
00085 static boolean parse_cc_mult_opnd (opnd_type *);
00086 static boolean parse_cc_or_opnd (opnd_type *);
00087 static boolean parse_cc_equiv_opnd (opnd_type *);
00088 static int srch_cc_sym_tbl (char *,int, int *);
00089 static int ntr_cc_sym_tbl(cc_token_type *, int);
00090 static boolean parse_cc_expr (opnd_type *);
00091 static boolean parse_cc_operand (opnd_type *);
00092 static void flush_cc_line(void);
00093 static int fold_cc_expr(opnd_type *);
00094 static void parse_define_str(int);
00095 static void copy_define_str(int, int);
00096 static void scan_cc_line(void);
00097 static void find_line_and_col(int, int *, int *);
00098 static void shift_cc_stmt_buf(int, int);
00099 static void shift_nxt_line(int, int);
00100 static void scan_cc_macro(int, int);
00101 static boolean scan_fortran_macro(int, int, int);
00102 static int expanded_macro_len(int, cc_arg_type *);
00103 static void insert_macro(int, cc_arg_type *, int, int, int);
00104 static void cc_advance_idx(void);
00105 static void adjust_continued_macro(int, int *);
00106 static char *get_dynamic_predef_str(int, int);
00107 static void free_arg_entry(cc_arg_type *);
00108 static cc_arg_type *alloc_arg_entry(int);
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127 boolean parse_cc_line(void)
00128
00129 {
00130 int attr_idx;
00131 char ch;
00132 int col;
00133 char delim;
00134 boolean include_found = FALSE;
00135 int line;
00136 int name_idx;
00137 opnd_type opnd;
00138 int str_idx;
00139 char str[MAX_SRC_LINE_SIZE];
00140
00141
00142 TRACE (Func_Entry, "parse_cc_line", NULL);
00143
00144 cc_get_stmt();
00145
00146 CC_NEXT_LA_CH;
00147
00148 if (CC_LA_CH_VALUE != pound) {
00149 find_line_and_col(cc_stmt_buf_idx, &line, &col);
00150 PRINTMSG(line, 1164, Internal, col, "parse_cc_line");
00151 flush_cc_line();
00152 }
00153
00154 CC_NEXT_LA_CH;
00155
00156 cc_get_token(TRUE);
00157
00158 switch (TOKEN_VALUE(cc_token)) {
00159
00160 case Cc_Tok_Kwd_Define :
00161
00162 if (! ignore_source_line) {
00163
00164 cc_get_token(FALSE);
00165
00166 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00167
00168 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
00169 TOKEN_LEN(cc_token),
00170 &name_idx);
00171
00172 if (attr_idx != NULL_IDX) {
00173
00174 if (CC_AT_DEFINED(attr_idx)) {
00175
00176
00177 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1670, Warning,
00178 TOKEN_COLUMN(cc_token),
00179 TOKEN_STR(cc_token),
00180 0,
00181 STR_ARG);
00182 }
00183 }
00184 else {
00185 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
00186 }
00187
00188 parse_define_str(attr_idx);
00189 }
00190 else {
00191 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00192 TOKEN_COLUMN(cc_token),
00193 "IDENTIFIER",
00194 0,
00195 STR_ARG);
00196 flush_cc_line();
00197 }
00198 }
00199 else {
00200 flush_cc_line();
00201 }
00202 break;
00203
00204 case Cc_Tok_Kwd_Elif :
00205
00206 if (CC_CURR_BLK_TYPE == Cc_If_Blk ||
00207 CC_CURR_BLK_TYPE == Cc_Ifdef_Blk ||
00208 CC_CURR_BLK_TYPE == Cc_Ifndef_Blk ||
00209 CC_CURR_BLK_TYPE == Cc_Elif_Blk) {
00210
00211
00212
00213
00214 CC_CURR_BLK_TYPE = Cc_Elif_Blk;
00215
00216 if (CC_CURR_BLK_IS_ACTIVE) {
00217
00218 if (! CC_CURR_BLK_DONE) {
00219
00220 scan_cc_line();
00221
00222 # if 0
00223 printf("%s", &(cc_stmt_buf[1]));
00224 # endif
00225
00226 if (CC_LA_CH_VALUE == EOS) {
00227 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error,
00228 CC_LA_CH_COLUMN,
00229 "expression",
00230 0,
00231 STR_ARG);
00232 }
00233 else if (parse_cc_expr(&opnd)) {
00234
00235 if (fold_cc_expr(&opnd)) {
00236
00237 ignore_source_line = FALSE;
00238 }
00239 else {
00240 ignore_source_line = TRUE;
00241 }
00242
00243 CC_CURR_BLK_DONE = (ignore_source_line == FALSE);
00244 }
00245 else {
00246 flush_cc_line();
00247 }
00248 }
00249 else {
00250 ignore_source_line = TRUE;
00251 flush_cc_line();
00252 }
00253 }
00254 else {
00255 flush_cc_line();
00256 }
00257 }
00258 else {
00259
00260 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1166, Error,
00261 TOKEN_COLUMN(cc_token),
00262 "No matching IF, IFDEF, or IFNDEF directive",
00263 0,
00264 STR_ARG);
00265 flush_cc_line();
00266 CC_CURR_BLK_IN_ERROR = TRUE;
00267 }
00268
00269 break;
00270
00271 case Cc_Tok_Kwd_Else :
00272
00273 if (CC_CURR_BLK_TYPE == Cc_If_Blk ||
00274 CC_CURR_BLK_TYPE == Cc_Ifdef_Blk ||
00275 CC_CURR_BLK_TYPE == Cc_Ifndef_Blk ||
00276 CC_CURR_BLK_TYPE == Cc_Elif_Blk) {
00277
00278
00279
00280
00281 CC_CURR_BLK_TYPE = Cc_Else_Blk;
00282
00283 if (CC_CURR_BLK_IS_ACTIVE) {
00284
00285 if (! CC_CURR_BLK_DONE) {
00286 ignore_source_line = FALSE;
00287 CC_CURR_BLK_DONE = TRUE;
00288 }
00289 else {
00290 ignore_source_line = TRUE;
00291 }
00292 }
00293 }
00294 else {
00295
00296 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1166, Error,
00297 TOKEN_COLUMN(cc_token),
00298 "No matching IF, IFDEF, or IFNDEF directive",
00299 0,
00300 STR_ARG);
00301 CC_CURR_BLK_IN_ERROR = TRUE;
00302 }
00303
00304 flush_cc_line();
00305 break;
00306
00307 case Cc_Tok_Kwd_Endif :
00308
00309 if (CC_CURR_BLK_TYPE == Cc_If_Blk ||
00310 CC_CURR_BLK_TYPE == Cc_Ifdef_Blk ||
00311 CC_CURR_BLK_TYPE == Cc_Ifndef_Blk ||
00312 CC_CURR_BLK_TYPE == Cc_Elif_Blk ||
00313 CC_CURR_BLK_TYPE == Cc_Else_Blk) {
00314
00315 if (CC_CURR_BLK_IS_ACTIVE) {
00316 ignore_source_line = FALSE;
00317 }
00318
00319
00320
00321 POP_CC_BLK_STK;
00322
00323 }
00324 else {
00325
00326 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1166, Error,
00327 TOKEN_COLUMN(cc_token),
00328 "No matching IF, IFDEF, or IFNDEF directive",
00329 0,
00330 STR_ARG);
00331 CC_CURR_BLK_IN_ERROR = TRUE;
00332 }
00333
00334 flush_cc_line();
00335 break;
00336
00337 case Cc_Tok_Kwd_If :
00338
00339 PUSH_CC_BLK_STK(Cc_If_Blk);
00340
00341 if (! ignore_source_line) {
00342
00343 CC_CURR_BLK_IS_ACTIVE = TRUE;
00344
00345 scan_cc_line();
00346
00347 # if 0
00348 printf("%s", &(cc_stmt_buf[1]));
00349 # endif
00350 if (CC_LA_CH_VALUE == EOS) {
00351 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error,
00352 CC_LA_CH_COLUMN,
00353 "expression",
00354 0,
00355 STR_ARG);
00356 }
00357 else if (parse_cc_expr(&opnd)) {
00358
00359 if (fold_cc_expr(&opnd)) {
00360
00361 ignore_source_line = FALSE;
00362 }
00363 else {
00364 ignore_source_line = TRUE;
00365 }
00366
00367 CC_CURR_BLK_DONE = (ignore_source_line == FALSE);
00368 }
00369 else {
00370 flush_cc_line();
00371 }
00372 }
00373 else {
00374 flush_cc_line();
00375 }
00376 break;
00377
00378 case Cc_Tok_Kwd_Ifdef :
00379
00380 PUSH_CC_BLK_STK(Cc_Ifdef_Blk);
00381
00382 if (! ignore_source_line) {
00383
00384 CC_CURR_BLK_IS_ACTIVE = TRUE;
00385
00386 cc_get_token(FALSE);
00387
00388 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00389
00390 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
00391 TOKEN_LEN(cc_token),
00392 &name_idx);
00393
00394 if (attr_idx != NULL_IDX) {
00395
00396 if (CC_AT_DEFINED(attr_idx)) {
00397 ignore_source_line = FALSE;
00398 }
00399 else {
00400 ignore_source_line = TRUE;
00401 }
00402 }
00403 else {
00404 ignore_source_line = TRUE;
00405 }
00406
00407 CC_CURR_BLK_DONE = (ignore_source_line == FALSE);
00408 }
00409 else {
00410 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00411 TOKEN_COLUMN(cc_token),
00412 "IDENTIFIER",
00413 0,
00414 STR_ARG);
00415 }
00416
00417 flush_cc_line();
00418 }
00419 else {
00420 flush_cc_line();
00421 }
00422 break;
00423
00424 case Cc_Tok_Kwd_Ifndef :
00425
00426 PUSH_CC_BLK_STK(Cc_Ifndef_Blk);
00427
00428 if (! ignore_source_line) {
00429
00430 CC_CURR_BLK_IS_ACTIVE = TRUE;
00431
00432 cc_get_token(FALSE);
00433
00434 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00435
00436 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
00437 TOKEN_LEN(cc_token),
00438 &name_idx);
00439
00440 if (attr_idx != NULL_IDX) {
00441
00442 if (CC_AT_DEFINED(attr_idx)) {
00443 ignore_source_line = TRUE;
00444 }
00445 else {
00446 ignore_source_line = FALSE;
00447 }
00448 }
00449 else {
00450 ignore_source_line = FALSE;
00451 }
00452
00453 CC_CURR_BLK_DONE = (ignore_source_line == FALSE);
00454 }
00455 else {
00456 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00457 TOKEN_COLUMN(cc_token),
00458 "IDENTIFIER",
00459 0,
00460 STR_ARG);
00461 }
00462
00463 flush_cc_line();
00464 }
00465 else {
00466 flush_cc_line();
00467 }
00468 break;
00469
00470 case Cc_Tok_Kwd_Include :
00471
00472 if (! ignore_source_line) {
00473
00474 if (CC_LA_CH_VALUE == quote ||
00475 CC_LA_CH_VALUE == db_quote ||
00476 CC_LA_CH_VALUE == '<') {
00477
00478 if (CC_LA_CH_VALUE == '<') {
00479 delim = '>';
00480 angle_brkt_include = TRUE;
00481 }
00482 else {
00483 delim = CC_LA_CH_VALUE;
00484 }
00485
00486 str_idx = 0;
00487
00488 while ((ch = cc_stmt_buf[++cc_stmt_buf_idx]) != delim &&
00489 ch != eos) {
00490
00491 if (str_idx < MAX_FILE_NAME_SIZE) {
00492 include_file[str_idx++] = ch;
00493 }
00494 else if (str_idx == MAX_FILE_NAME_SIZE) {
00495
00496
00497
00498 find_line_and_col(cc_stmt_buf_idx, &line, &col);
00499 ntr_next_msg_queue(line, 57, Error,
00500 col,
00501 (char *)NULL,
00502 (MAX_FILE_NAME_SIZE - 1),
00503 ARG_ARG);
00504 flush_cc_line();
00505 break;
00506 }
00507 }
00508
00509 include_file[str_idx] = '\0';
00510
00511 if (str_idx == NULL_IDX) {
00512 find_line_and_col(cc_stmt_buf_idx, &line, &col);
00513 ntr_next_msg_queue(line, 58, Error,
00514 col,
00515 (char *)NULL,
00516 0,
00517 NO_ARG);
00518 }
00519 else if (ch == eos) {
00520 find_line_and_col(cc_stmt_buf_idx, &line, &col);
00521 ntr_next_msg_queue(line, 59, Error,
00522 col,
00523 (char *)NULL,
00524 0,
00525 NO_ARG);
00526 }
00527 else {
00528 include_found = TRUE;
00529 }
00530 }
00531 else {
00532 find_line_and_col(cc_stmt_buf_idx, &line, &col);
00533 ntr_next_msg_queue(line, 1165, Error,
00534 col,
00535 "INCLUDE file name",
00536 0,
00537 STR_ARG);
00538 }
00539 }
00540
00541 flush_cc_line();
00542 break;
00543
00544 case Cc_Tok_Kwd_Undef :
00545
00546 if (! ignore_source_line) {
00547
00548 cc_get_token(FALSE);
00549
00550 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00551
00552 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
00553 TOKEN_LEN(cc_token),
00554 &name_idx);
00555
00556 if (attr_idx != NULL_IDX) {
00557 CC_AT_DEFINED(attr_idx) = FALSE;
00558 }
00559 else {
00560
00561 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
00562 }
00563 }
00564 else {
00565 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00566 TOKEN_COLUMN(cc_token),
00567 "IDENTIFIER",
00568 0,
00569 STR_ARG);
00570 }
00571
00572 flush_cc_line();
00573 }
00574 else {
00575 flush_cc_line();
00576 }
00577 break;
00578
00579 case Cc_Tok_Kwd_Error :
00580
00581 if (! ignore_source_line) {
00582
00583 str_idx = 0;
00584
00585 while (cc_stmt_buf_idx < MAX_SRC_LINE_SIZE &&
00586 (ch = cc_stmt_buf[cc_stmt_buf_idx]) != eos &&
00587 ch != newline) {
00588
00589 str[str_idx] = ch;
00590 str_idx++;
00591 cc_stmt_buf_idx++;
00592 }
00593
00594 str[str_idx] = '\0';
00595
00596 if (cc_line_continued) {
00597
00598 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1178, Error,
00599 TOKEN_COLUMN(cc_token),
00600 (char *)NULL,
00601 0,
00602 NO_ARG);
00603 }
00604
00605 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1177, Error,
00606 TOKEN_COLUMN(cc_token),
00607 str,
00608 0,
00609 STR_ARG);
00610
00611 flush_cc_line();
00612 }
00613 else {
00614 flush_cc_line();
00615 }
00616 break;
00617
00618 case Cc_Tok_EOS :
00619 break;
00620
00621 case Cc_Tok_Constant:
00622
00623
00624 flush_cc_line();
00625 break;
00626
00627 default:
00628 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00629 TOKEN_COLUMN(cc_token),
00630 "conditional compilation directive",
00631 0,
00632 STR_ARG);
00633 flush_cc_line();
00634 break;
00635 }
00636
00637 if (CC_LA_CH_VALUE != EOS) {
00638 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error,
00639 CC_LA_CH_COLUMN,
00640 EOS_STR,
00641 0,
00642 STR_ARG);
00643 flush_cc_line();
00644 }
00645
00646 TRACE (Func_Exit, "parse_cc_line", NULL);
00647
00648 return(include_found);
00649
00650 }
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668 static void parse_define_str(int attr_idx)
00669
00670 {
00671 int arg_num;
00672 int id_start_idx;
00673 int i;
00674 int start_idx;
00675 cc_darg_type *arg_head = NULL;
00676 cc_darg_type *arg_tail = NULL;
00677
00678
00679 TRACE (Func_Entry, "parse_define_str", NULL);
00680
00681 if (CC_LA_CH_VALUE == LPAREN &&
00682 cc_stmt_buf[cc_stmt_buf_idx-1] != blank &&
00683 cc_stmt_buf[cc_stmt_buf_idx-1] != tab &&
00684 cc_stmt_buf[cc_stmt_buf_idx-1] != '/') {
00685
00686
00687 CC_NEXT_LA_CH;
00688 CC_AT_NUM_ARGS(attr_idx) = 0;
00689
00690 while (CC_LA_CH_VALUE != RPAREN) {
00691 cc_get_token(FALSE);
00692
00693 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00694 if (arg_head == NULL) {
00695 arg_head = (cc_darg_type *)malloc(sizeof(cc_darg_type));
00696 arg_head->next = NULL;
00697 arg_tail = arg_head;
00698 }
00699 else {
00700 arg_tail->next = (cc_darg_type *)malloc(sizeof(cc_darg_type));
00701 arg_tail = arg_tail->next;
00702 arg_tail->next = NULL;
00703 }
00704
00705 for (i = 0; i < CC_NUM_ID_WDS; i++) {
00706 arg_tail->name.words[i] = TOKEN_STR_WD(cc_token, i);
00707 }
00708 arg_tail->name_len = TOKEN_LEN(cc_token);
00709 CC_AT_NUM_ARGS(attr_idx) += 1;
00710 # if 0
00711 printf("arg %d = >%s<\n", CC_AT_NUM_ARGS(attr_idx),
00712 arg_tail->name.string);
00713 # endif
00714 }
00715 else {
00716 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00717 TOKEN_COLUMN(cc_token),
00718 "IDENTIFIER",
00719 0,
00720 STR_ARG);
00721 }
00722
00723 if (CC_LA_CH_VALUE == COMMA) {
00724 CC_NEXT_LA_CH;
00725 }
00726 else if (CC_LA_CH_VALUE != RPAREN) {
00727 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error,
00728 TOKEN_COLUMN(cc_token),
00729 ")",
00730 0,
00731 STR_ARG);
00732 flush_cc_line();
00733 goto EXIT;
00734 }
00735 }
00736
00737
00738 CC_NEXT_LA_CH;
00739
00740 start_idx = cc_stmt_buf_idx;
00741
00742 if (CC_LA_CH_VALUE == EOS) {
00743 CC_AT_STR_LEN(attr_idx) = 0;
00744 CC_AT_DEFINED(attr_idx) = TRUE;
00745 goto EXIT;
00746 }
00747
00748 while (CC_LA_CH_VALUE != EOS) {
00749 if (CC_LA_CH_CLASS == Ch_Class_Letter ||
00750 CC_LA_CH_VALUE == underscore) {
00751
00752 id_start_idx = cc_stmt_buf_idx;
00753 cc_get_token(FALSE);
00754
00755 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00756
00757 if (strcmp(TOKEN_STR(cc_token), CC_AT_NAME_PTR(attr_idx))
00758 == 0) {
00759
00760 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1549, Warning,
00761 TOKEN_COLUMN(cc_token),
00762 TOKEN_STR(cc_token),
00763 0,
00764 STR_ARG);
00765 flush_cc_line();
00766 goto EXIT;
00767 }
00768 else {
00769 arg_num = 1;
00770 arg_tail = arg_head;
00771 while (arg_tail != NULL) {
00772
00773 if (strcmp(TOKEN_STR(cc_token), arg_tail->name.string)
00774 == 0) {
00775 # if 0
00776 printf("found match for %s\n", TOKEN_STR(cc_token));
00777 # endif
00778
00779 shift_cc_stmt_buf(id_start_idx+TOKEN_LEN(cc_token),
00780 3 - TOKEN_LEN(cc_token));
00781
00782 cc_stmt_buf[id_start_idx] = '\001';
00783 cc_stmt_buf[id_start_idx+1] = TOKEN_LEN(cc_token);
00784 cc_stmt_buf[id_start_idx+2] = arg_num;
00785
00786 cc_stmt_buf_idx = id_start_idx+2;
00787 CC_NEXT_LA_CH;
00788 break;
00789 }
00790 arg_tail = arg_tail->next;
00791 arg_num++;
00792 }
00793 }
00794 }
00795 }
00796 else {
00797 CC_NEXT_LA_CH;
00798 }
00799 }
00800
00801 copy_define_str(attr_idx, start_idx);
00802
00803 flush_cc_line();
00804
00805 # if 0
00806 printf("len = %d >%s<\n", len, CC_AT_STR_PTR(attr_idx));
00807 # endif
00808 }
00809 else if (CC_LA_CH_VALUE == EOS) {
00810 CC_AT_NUM_ARGS(attr_idx) = 0;
00811 CC_AT_STR_LEN(attr_idx) = 0;
00812
00813 }
00814 else {
00815 start_idx = cc_stmt_buf_idx;
00816
00817 while (CC_LA_CH_VALUE != EOS) {
00818 if (CC_LA_CH_CLASS == Ch_Class_Letter ||
00819 CC_LA_CH_VALUE == underscore) {
00820
00821 id_start_idx = cc_stmt_buf_idx;
00822 cc_get_token(FALSE);
00823
00824 if (TOKEN_VALUE(cc_token) == Cc_Tok_Id) {
00825
00826 if (strcmp(TOKEN_STR(cc_token), CC_AT_NAME_PTR(attr_idx))
00827 == 0) {
00828
00829 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1549, Warning,
00830 TOKEN_COLUMN(cc_token),
00831 TOKEN_STR(cc_token),
00832 0,
00833 STR_ARG);
00834 flush_cc_line();
00835 goto EXIT;
00836 }
00837 }
00838 }
00839 else {
00840 CC_NEXT_LA_CH;
00841 }
00842 }
00843
00844 CC_AT_NUM_ARGS(attr_idx) = 0;
00845
00846 copy_define_str(attr_idx, start_idx);
00847
00848 flush_cc_line();
00849
00850 # if 0
00851 printf(">%s<\n", CC_AT_STR_PTR(attr_idx));
00852 # endif
00853 }
00854
00855 CC_AT_DEFINED(attr_idx) = TRUE;
00856
00857 EXIT:
00858
00859 while (arg_head != NULL) {
00860 arg_tail = arg_head->next;
00861 free(arg_head);
00862 arg_head = arg_tail;
00863 }
00864
00865 TRACE (Func_Exit, "parse_define_str", NULL);
00866
00867 return;
00868
00869 }
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887 static void copy_define_str(int attr_idx,
00888 int start_idx)
00889
00890 {
00891 char *char_ptr;
00892 int col;
00893 int idx;
00894 int len;
00895 int line;
00896 int wd_len;
00897
00898 TRACE (Func_Entry, "copy_define_str", NULL);
00899
00900 idx = start_idx;
00901
00902 len = 0;
00903
00904 while (cc_stmt_buf[idx] != newline) {
00905 if (cc_stmt_buf[idx] == '/' &&
00906 cc_stmt_buf[idx+1] == '*') {
00907
00908 idx += 2;
00909 while (! (cc_stmt_buf[idx] == '*' &&
00910 cc_stmt_buf[idx + 1] == '/') &&
00911 cc_stmt_buf[idx] != newline) {
00912 idx++;
00913 }
00914
00915 if (cc_stmt_buf[idx] != newline) {
00916 idx++;
00917 }
00918 }
00919 else if (cc_stmt_buf[idx] == '\001') {
00920
00921
00922 idx += 2;
00923 len += 3;
00924 }
00925 else {
00926 len++;
00927 }
00928 idx++;
00929 }
00930
00931 idx--;
00932
00933 while (cc_stmt_buf[idx] == blank ||
00934 cc_stmt_buf[idx] == tab ||
00935 (cc_stmt_buf[idx] == '/' &&
00936 cc_stmt_buf[idx-1] == '*')) {
00937
00938 if (cc_stmt_buf[idx] == '/' &&
00939 cc_stmt_buf[idx-1] == '*') {
00940
00941 idx -= 2;
00942 while (! (cc_stmt_buf[idx] == '*' &&
00943 cc_stmt_buf[idx - 1] == '/')) {
00944 idx--;
00945 }
00946 idx--;
00947 }
00948 else {
00949 len--;
00950 }
00951
00952 idx--;
00953 }
00954
00955 find_line_and_col(start_idx, &line, &col);
00956 CC_AT_START_LINE(attr_idx) = line;
00957 CC_AT_START_COL(attr_idx) = col;
00958
00959 if (len > 512) {
00960 ntr_next_msg_queue(line, 1630, Error, col,
00961 CC_AT_NAME_PTR(attr_idx),
00962 512,
00963 STR_ARG_ARG);
00964 }
00965
00966 CC_AT_STR_LEN(attr_idx) = len;
00967
00968 wd_len = WORD_LEN(len);
00969 CC_AT_STR_IDX(attr_idx) = str_pool_idx + 1;
00970 TBL_REALLOC_CK(str_pool,wd_len);
00971
00972 str_pool[CC_AT_STR_IDX(attr_idx) + wd_len - 1].name_long = 0;
00973
00974 char_ptr = CC_AT_STR_PTR(attr_idx);
00975
00976 while (len > 0) {
00977 if (cc_stmt_buf[start_idx] == '/' &&
00978 cc_stmt_buf[start_idx+1] == '*') {
00979
00980
00981 start_idx += 2;
00982 while (! (cc_stmt_buf[start_idx] == '*' &&
00983 cc_stmt_buf[start_idx + 1] == '/') &&
00984 cc_stmt_buf[start_idx] != newline) {
00985 start_idx++;
00986 }
00987
00988 if (cc_stmt_buf[start_idx] != newline) {
00989 start_idx++;
00990 }
00991 }
00992 else {
00993 *char_ptr = cc_stmt_buf[start_idx];
00994 char_ptr++;
00995 len--;
00996 }
00997 start_idx++;
00998 }
00999
01000 TRACE (Func_Exit, "copy_define_str", NULL);
01001
01002 return;
01003
01004 }
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022 static void scan_cc_line(void)
01023
01024 {
01025 int attr_idx;
01026 char *char_ptr;
01027 int col;
01028 int i;
01029 int id_start_idx;
01030 int len;
01031 int line;
01032 int name_idx;
01033 int paren_cnt = 0;
01034 int save_cc_stmt_buf_idx;
01035
01036 TRACE (Func_Entry, "scan_cc_line", NULL);
01037
01038 save_cc_stmt_buf_idx = cc_stmt_buf_idx;
01039
01040 while (CC_LA_CH_VALUE != EOS) {
01041 if (CC_LA_CH_CLASS == Ch_Class_Letter ||
01042 CC_LA_CH_VALUE == underscore) {
01043
01044 id_start_idx = cc_stmt_buf_idx;
01045 cc_get_token(TRUE);
01046
01047 switch (TOKEN_VALUE(cc_token)) {
01048
01049 case Cc_Tok_Id :
01050 case Cc_Tok_Kwd_Define :
01051 case Cc_Tok_Kwd_Elif :
01052 case Cc_Tok_Kwd_Else :
01053 case Cc_Tok_Kwd_Endif :
01054 case Cc_Tok_Kwd_If :
01055 case Cc_Tok_Kwd_Ifdef :
01056 case Cc_Tok_Kwd_Ifndef :
01057 case Cc_Tok_Kwd_Include :
01058 case Cc_Tok_Kwd_Undef :
01059
01060 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
01061 TOKEN_LEN(cc_token),
01062 &name_idx);
01063
01064 if (attr_idx != NULL_IDX &&
01065 CC_AT_DEFINED(attr_idx)) {
01066
01067 if (CC_AT_NUM_ARGS(attr_idx) == 0) {
01068
01069 if (CC_AT_DYNAMIC_PREDEF(attr_idx)) {
01070 find_line_and_col(id_start_idx, &line, &col);
01071 char_ptr = get_dynamic_predef_str(attr_idx, line);
01072 len = strlen(char_ptr);
01073 }
01074 else {
01075 char_ptr = CC_AT_STR_PTR(attr_idx);
01076 len = CC_AT_STR_LEN(attr_idx);
01077 }
01078
01079 shift_cc_stmt_buf(id_start_idx+TOKEN_LEN(cc_token),
01080 len - TOKEN_LEN(cc_token));
01081
01082
01083 for (i = 0; i < len; i++) {
01084 cc_stmt_buf[i+id_start_idx] = char_ptr[i];
01085 }
01086
01087 cc_stmt_buf_idx = id_start_idx - 1;
01088 CC_NEXT_LA_CH;
01089 }
01090 else {
01091
01092 scan_cc_macro(attr_idx, id_start_idx);
01093 }
01094 }
01095 break;
01096
01097 case Cc_Tok_Kwd_Defined :
01098
01099
01100 while (CC_LA_CH_VALUE == '(') {
01101 paren_cnt++;
01102 CC_NEXT_LA_CH;
01103 }
01104
01105 cc_get_token(FALSE);
01106
01107 while (paren_cnt) {
01108 if (CC_LA_CH_VALUE != ')') {
01109 flush_cc_line();
01110 break;
01111 }
01112 else {
01113 CC_NEXT_LA_CH;
01114 paren_cnt--;
01115 }
01116 }
01117 break;
01118 }
01119 }
01120 else {
01121 CC_NEXT_LA_CH;
01122 }
01123 }
01124
01125 cc_stmt_buf_idx = save_cc_stmt_buf_idx - 1;
01126 CC_NEXT_LA_CH;
01127
01128 TRACE (Func_Exit, "scan_cc_line", NULL);
01129
01130 return;
01131
01132 }
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150 static void cc_advance_idx(void)
01151
01152 {
01153 int i;
01154 int save_pp_line_idx;
01155
01156 TRACE (Func_Entry, "cc_advance_idx", NULL);
01157
01158 save_pp_line_idx = pp_line_idx;
01159 prev_idx = cc_stmt_buf_idx;
01160
01161 cc_stmt_buf_idx++;
01162
01163 while (PP_LINE_TYPE == Comment_Line ||
01164 cc_stmt_buf_idx == PP_EOL) {
01165
01166
01167
01168 pp_line_idx++;
01169
01170 if (pp_line_idx > end_stmt_line_idx ||
01171 (PP_LINE_TYPE != Continuation_Line &&
01172 PP_LINE_TYPE != Dir_Continuation_Line)) {
01173
01174 cc_stmt_buf_idx = nxt_line_end_idx[save_pp_line_idx];
01175 break;
01176 }
01177
01178 if (source_form == Fixed_Form &&
01179 PP_LINE_TYPE == Continuation_Line) {
01180 cc_stmt_buf_idx = NULL_IDX;
01181
01182 for (i = NXT_COL(1); i < PP_IDX; i++) {
01183 if (VALID_CC_ID_CHAR(nxt_line[i])) {
01184 cc_stmt_buf_idx = i;
01185 break;
01186 }
01187 }
01188
01189 if (cc_stmt_buf_idx == NULL_IDX) {
01190 cc_stmt_buf_idx = PP_IDX + 1;
01191 }
01192 }
01193 else {
01194 cc_stmt_buf_idx = PP_IDX + 1;
01195 }
01196 }
01197
01198 TRACE (Func_Exit, "cc_advance_idx", NULL);
01199
01200 return;
01201
01202 }
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220 boolean scan_fixed_comment(void)
01221
01222 {
01223 int attr_idx;
01224 char *char_ptr;
01225 int col;
01226 boolean found_macro = FALSE;
01227 int i;
01228 int id_start_idx;
01229 int len;
01230 int macro_len;
01231 int name_idx;
01232 int save_pp_line_idx;
01233
01234 TRACE (Func_Entry, "scan_fixed_comment", NULL);
01235
01236 save_pp_line_idx = pp_line_idx;
01237
01238 end_stmt_line_idx = pp_line_idx;
01239
01240 cc_stmt_buf_idx = NXT_COL(0);
01241
01242
01243
01244 PP_LINE_TYPE = Regular_Line;
01245 cc_advance_idx();
01246
01247 id_start_idx = NXT_COL(1);
01248 col = nxt_line_col[NXT_COL(1)];
01249
01250 CC_GET_ID_TOKEN;
01251
01252 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
01253 TOKEN_LEN(cc_token),
01254 &name_idx);
01255
01256 if (attr_idx != NULL_IDX &&
01257 CC_AT_DEFINED(attr_idx)) {
01258
01259 found_macro = TRUE;
01260
01261 if (CC_AT_NUM_ARGS(attr_idx) == 0) {
01262
01263 if (CC_AT_DYNAMIC_PREDEF(attr_idx)) {
01264 char_ptr = get_dynamic_predef_str(attr_idx,
01265 TOKEN_LINE(cc_token));
01266 len = strlen(char_ptr);
01267 }
01268 else {
01269 char_ptr = CC_AT_STR_PTR(attr_idx);
01270 len = CC_AT_STR_LEN(attr_idx);
01271 }
01272
01273 macro_len = (prev_idx - id_start_idx) + 1;
01274 shift_nxt_line(id_start_idx + macro_len,
01275 len - macro_len);
01276
01277 for (i = 0; i < len; i++) {
01278 nxt_line[i+id_start_idx] = char_ptr[i];
01279 nxt_line_col[i+id_start_idx] = col;
01280 }
01281 }
01282 else {
01283 if (! scan_fortran_macro(attr_idx, id_start_idx, pp_line_idx)) {
01284 found_macro = FALSE;
01285 }
01286 }
01287 }
01288
01289 pp_line_idx = save_pp_line_idx;
01290
01291 if (found_macro) {
01292 for (i = NXT_COL(1); i <= nxt_line_end_idx[end_stmt_line_idx]; i++) {
01293 if (nxt_line[i] < 0) {
01294 nxt_line[i] = nxt_line[i] & 0xFF;
01295 }
01296 }
01297 }
01298
01299 PP_LINE_TYPE = Comment_Line;
01300
01301
01302 TRACE (Func_Exit, "scan_fixed_comment", NULL);
01303
01304 return(found_macro);
01305
01306 }
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324 boolean scan_fortran_stmt(void)
01325
01326 {
01327 int attr_idx;
01328 int col;
01329 char *char_ptr;
01330 int i;
01331 int id_start_idx;
01332 int len;
01333 int macro_len;
01334 int name_idx;
01335 boolean found_macro = FALSE;
01336 int save_pp_line_idx;
01337 int end_idx;
01338
01339 TRACE (Func_Entry, "scan_fortran_stmt", NULL);
01340
01341 end_stmt_line_idx = nxt_line_num_lines;
01342 pp_line_idx = 1;
01343
01344 cc_stmt_buf_idx = NXT_COL(0);
01345 cc_advance_idx();
01346
01347 while (cc_stmt_buf_idx < pp_nxt_line_EOL[end_stmt_line_idx]) {
01348
01349 if (nxt_line[cc_stmt_buf_idx] > 0 &&
01350 (ch_class[nxt_line[cc_stmt_buf_idx]] == Ch_Class_Letter ||
01351 nxt_line[cc_stmt_buf_idx] == underscore)) {
01352
01353 id_start_idx = cc_stmt_buf_idx;
01354 col = nxt_line_col[cc_stmt_buf_idx];
01355 save_pp_line_idx = pp_line_idx;
01356
01357 CC_GET_ID_TOKEN;
01358
01359 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
01360 TOKEN_LEN(cc_token),
01361 &name_idx);
01362
01363 if (attr_idx != NULL_IDX &&
01364 CC_AT_DEFINED(attr_idx)) {
01365
01366 found_macro = TRUE;
01367
01368 if (CC_AT_NUM_ARGS(attr_idx) == 0) {
01369
01370 if (CC_AT_DYNAMIC_PREDEF(attr_idx)) {
01371 char_ptr = get_dynamic_predef_str(attr_idx,
01372 TOKEN_LINE(cc_token));
01373 len = strlen(char_ptr);
01374 }
01375 else {
01376 char_ptr = CC_AT_STR_PTR(attr_idx);
01377 len = CC_AT_STR_LEN(attr_idx);
01378 }
01379
01380 end_idx = prev_idx + 1;
01381
01382 adjust_continued_macro(id_start_idx, &end_idx);
01383
01384 macro_len = end_idx - id_start_idx;
01385
01386 shift_nxt_line(end_idx,
01387 len - macro_len);
01388
01389 for (i = 0; i < len; i++) {
01390 nxt_line[i+id_start_idx] = char_ptr[i];
01391 nxt_line_col[i+id_start_idx] = col;
01392 }
01393
01394 cc_stmt_buf_idx = id_start_idx + len - 1;
01395 pp_line_idx = save_pp_line_idx;
01396 cc_advance_idx();
01397 }
01398 else {
01399 if (! scan_fortran_macro(attr_idx, id_start_idx,
01400 save_pp_line_idx)) {
01401 found_macro = FALSE;
01402 goto EXIT;
01403 }
01404 }
01405 }
01406 }
01407 else {
01408 cc_advance_idx();
01409 }
01410 }
01411
01412 EXIT:
01413
01414 if (found_macro) {
01415 for (i = 1; i <= nxt_line_end_idx[end_stmt_line_idx]; i++) {
01416 if (nxt_line[i] < 0) {
01417 nxt_line[i] = nxt_line[i] & 0xFF;
01418 }
01419 }
01420 }
01421
01422 TRACE (Func_Exit, "scan_fortran_stmt", NULL);
01423
01424 return(found_macro);
01425
01426 }
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444 static cc_arg_type *alloc_arg_entry(int num_chars)
01445
01446 {
01447 cc_arg_type *arg_ptr;
01448 int i;
01449
01450
01451 TRACE (Func_Entry, "alloc_arg_entry", NULL);
01452
01453 arg_ptr = (cc_arg_type *)malloc(sizeof(cc_arg_type));
01454
01455
01456 num_chars = ((num_chars+TARGET_CHARS_PER_WORD)/
01457 TARGET_CHARS_PER_WORD) * TARGET_CHARS_PER_WORD;
01458
01459 arg_ptr->name = (char *)malloc(num_chars);
01460
01461 for (i = 0; i < num_chars; i++) {
01462 arg_ptr->name[i] = '\0';
01463 }
01464
01465 TRACE (Func_Exit, "alloc_arg_entry", NULL);
01466
01467 return(arg_ptr);
01468
01469 }
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487 static void free_arg_entry(cc_arg_type *arg_entry)
01488
01489 {
01490
01491
01492 TRACE (Func_Entry, "free_arg_entry", NULL);
01493
01494 free(arg_entry->name);
01495 free(arg_entry);
01496
01497 TRACE (Func_Exit, "free_arg_entry", NULL);
01498
01499 return;
01500
01501 }
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519 static void scan_cc_macro(int attr_idx,
01520 int id_start_idx)
01521
01522 {
01523 int arg_num;
01524 char *char_ptr;
01525 int col;
01526 int i;
01527 int j;
01528 int k;
01529 int len;
01530 int line;
01531 int paren_cnt = 0;
01532 cc_arg_type *arg_head = NULL;
01533 cc_arg_type *arg_tail = NULL;
01534
01535 TRACE (Func_Entry, "scan_cc_macro", NULL);
01536
01537 if (CC_LA_CH_VALUE == LPAREN) {
01538
01539
01540 cc_stmt_buf_idx++;
01541
01542 arg_num = 1;
01543 while (arg_num <= CC_AT_NUM_ARGS(attr_idx)) {
01544
01545 i = 0;
01546 k = cc_stmt_buf_idx;
01547 paren_cnt = 0;
01548
01549 while ((cc_stmt_buf[k] != RPAREN ||
01550 paren_cnt > 0) &&
01551 (cc_stmt_buf[k] != COMMA ||
01552 paren_cnt > 0) &&
01553 cc_stmt_buf[k] != EOS) {
01554
01555 if (cc_stmt_buf[k] == LPAREN ||
01556 cc_stmt_buf[k] == '[') {
01557 paren_cnt++;
01558 }
01559 else if (cc_stmt_buf[k] == RPAREN ||
01560 cc_stmt_buf[k] == ']') {
01561 paren_cnt--;
01562 }
01563
01564 k++;
01565 i++;
01566 }
01567
01568 if (arg_head == NULL) {
01569 arg_head = alloc_arg_entry(i);
01570 arg_head->next = NULL;
01571 arg_tail = arg_head;
01572 }
01573 else {
01574 arg_tail->next = alloc_arg_entry(i);
01575 arg_tail = arg_tail->next;
01576 arg_tail->next = NULL;
01577 }
01578
01579 i = 0;
01580 paren_cnt = 0;
01581
01582 while ((cc_stmt_buf[cc_stmt_buf_idx] != RPAREN ||
01583 paren_cnt > 0) &&
01584 (cc_stmt_buf[cc_stmt_buf_idx] != COMMA ||
01585 paren_cnt > 0) &&
01586 cc_stmt_buf[cc_stmt_buf_idx] != EOS) {
01587
01588 if (cc_stmt_buf[cc_stmt_buf_idx] == LPAREN ||
01589 cc_stmt_buf[cc_stmt_buf_idx] == '[') {
01590 paren_cnt++;
01591 }
01592 else if (cc_stmt_buf[cc_stmt_buf_idx] == RPAREN ||
01593 cc_stmt_buf[cc_stmt_buf_idx] == ']') {
01594 paren_cnt--;
01595 }
01596
01597 arg_tail->name[i] = cc_stmt_buf[cc_stmt_buf_idx];
01598 cc_stmt_buf_idx++;
01599 i++;
01600 }
01601
01602 arg_tail->name_len = i;
01603
01604 if (cc_stmt_buf[cc_stmt_buf_idx] == COMMA &&
01605 arg_num < CC_AT_NUM_ARGS(attr_idx)) {
01606 CC_NEXT_LA_CH;
01607 }
01608 else if (cc_stmt_buf[cc_stmt_buf_idx] == RPAREN &&
01609 arg_num < CC_AT_NUM_ARGS(attr_idx)) {
01610
01611 find_line_and_col(cc_stmt_buf_idx, &line, &col);
01612 ntr_next_msg_queue(line, 1550, Warning, col,
01613 CC_AT_NAME_PTR(attr_idx),
01614 0,
01615 STR_ARG);
01616 flush_cc_line();
01617 goto EXIT;
01618 }
01619
01620 arg_num++;
01621 }
01622
01623 if (cc_stmt_buf[cc_stmt_buf_idx] != RPAREN) {
01624
01625 find_line_and_col(cc_stmt_buf_idx, &line, &col);
01626 ntr_next_msg_queue(line, 1551, Warning, col,
01627 CC_AT_NAME_PTR(attr_idx),
01628 0,
01629 STR_ARG);
01630 flush_cc_line();
01631 goto EXIT;
01632 }
01633
01634
01635
01636 len = CC_AT_STR_LEN(attr_idx);
01637
01638 for (i = 0; i < CC_AT_STR_LEN(attr_idx); i++) {
01639 if ((CC_AT_STR_PTR(attr_idx))[i] == '\001') {
01640 i += 2;
01641 arg_num = 1;
01642 arg_tail = arg_head;
01643 while (arg_num != (CC_AT_STR_PTR(attr_idx))[i]) {
01644 arg_tail = arg_tail->next;
01645 arg_num++;
01646 }
01647
01648 len += (arg_tail->name_len - 3);
01649 }
01650 }
01651
01652
01653
01654
01655 shift_cc_stmt_buf(cc_stmt_buf_idx,
01656 len-((cc_stmt_buf_idx - id_start_idx) + 1));
01657
01658 char_ptr = CC_AT_STR_PTR(attr_idx);
01659
01660 j = 0;
01661 i = 0;
01662 while (i < len) {
01663 if (char_ptr[j] == '\001') {
01664 j += 2;
01665 arg_num = 1;
01666 arg_tail = arg_head;
01667 while (arg_num != char_ptr[j]) {
01668 arg_tail = arg_tail->next;
01669 arg_num++;
01670 }
01671
01672 for (k = 0; k < arg_tail->name_len; k++) {
01673 cc_stmt_buf[i+id_start_idx] = arg_tail->name[k];
01674 i++;
01675 }
01676 }
01677 else {
01678 cc_stmt_buf[i+id_start_idx] = char_ptr[j];
01679 i++;
01680 }
01681
01682 j++;
01683 }
01684
01685 cc_stmt_buf_idx = id_start_idx - 1;
01686 CC_NEXT_LA_CH;
01687 }
01688
01689 EXIT:
01690
01691 while (arg_head != NULL) {
01692 arg_tail = arg_head->next;
01693 free_arg_entry(arg_head);
01694 arg_head = arg_tail;
01695 }
01696
01697 TRACE (Func_Exit, "scan_cc_macro", NULL);
01698
01699 return;
01700
01701 }
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719 static boolean scan_fortran_macro(int attr_idx,
01720 int id_start_idx,
01721 int save_pp_line_idx)
01722
01723 {
01724 int arg_num;
01725 int col;
01726 int i;
01727 int j;
01728 boolean ok = TRUE;
01729 int paren_cnt = 0;
01730 cc_arg_type *arg_head = NULL;
01731 cc_arg_type *arg_tail = NULL;
01732 int save_line_idx;
01733 int save_cc_stmt_buf_idx;
01734
01735
01736 TRACE (Func_Entry, "scan_fortran_macro", NULL);
01737
01738 if (nxt_line[cc_stmt_buf_idx] == lparen) {
01739
01740
01741 col = nxt_line_col[id_start_idx];
01742
01743 cc_advance_idx();
01744
01745 arg_num = 1;
01746 while (arg_num <= CC_AT_NUM_ARGS(attr_idx)) {
01747
01748 while (nxt_line[cc_stmt_buf_idx] == blank ||
01749 nxt_line[cc_stmt_buf_idx] == tab) {
01750 cc_advance_idx();
01751 }
01752
01753 save_line_idx = pp_line_idx;
01754 save_cc_stmt_buf_idx = cc_stmt_buf_idx;
01755
01756 i = 0;
01757 paren_cnt = 0;
01758
01759 while ((nxt_line[cc_stmt_buf_idx] != rparen ||
01760 paren_cnt > 0) &&
01761 (nxt_line[cc_stmt_buf_idx] != comma ||
01762 paren_cnt > 0) &&
01763 nxt_line[cc_stmt_buf_idx] != eos) {
01764
01765 if (nxt_line[cc_stmt_buf_idx] == lparen ||
01766 nxt_line[cc_stmt_buf_idx] == lbrkt) {
01767 paren_cnt++;
01768 }
01769 else if (nxt_line[cc_stmt_buf_idx] == rparen ||
01770 nxt_line[cc_stmt_buf_idx] == rbrkt) {
01771 paren_cnt--;
01772 }
01773
01774 cc_advance_idx();
01775 i++;
01776 }
01777
01778 if (arg_head == NULL) {
01779 arg_head = alloc_arg_entry(i);
01780 arg_head->next = NULL;
01781 arg_tail = arg_head;
01782 }
01783 else {
01784 arg_tail->next = alloc_arg_entry(i);
01785 arg_tail = arg_tail->next;
01786 arg_tail->next = NULL;
01787 }
01788
01789 cc_stmt_buf_idx = save_cc_stmt_buf_idx;
01790 pp_line_idx = save_line_idx;
01791
01792 i = 0;
01793 paren_cnt = 0;
01794
01795 while ((nxt_line[cc_stmt_buf_idx] != rparen ||
01796 paren_cnt > 0) &&
01797 (nxt_line[cc_stmt_buf_idx] != comma ||
01798 paren_cnt > 0) &&
01799 nxt_line[cc_stmt_buf_idx] != eos) {
01800
01801 if (nxt_line[cc_stmt_buf_idx] == lparen ||
01802 nxt_line[cc_stmt_buf_idx] == lbrkt) {
01803 paren_cnt++;
01804 }
01805 else if (nxt_line[cc_stmt_buf_idx] == rparen ||
01806 nxt_line[cc_stmt_buf_idx] == rbrkt) {
01807 paren_cnt--;
01808 }
01809
01810 arg_tail->name[i] = nxt_line[cc_stmt_buf_idx];
01811 cc_advance_idx();
01812 i++;
01813 }
01814
01815 j = i - 1;
01816 while (arg_tail->name[j] == blank ||
01817 arg_tail->name[j] == tab) {
01818 j--;
01819 }
01820
01821 arg_tail->name[++j] = '\0';
01822 arg_tail->name_len = j;
01823
01824
01825 if (nxt_line[cc_stmt_buf_idx] == comma &&
01826 arg_num < CC_AT_NUM_ARGS(attr_idx)) {
01827 cc_advance_idx();
01828 }
01829 else if (nxt_line[cc_stmt_buf_idx] == rparen &&
01830 arg_num < CC_AT_NUM_ARGS(attr_idx)) {
01831
01832 ntr_next_msg_queue(PP_LINE_NUM, 1550, Warning,
01833 nxt_line_col[cc_stmt_buf_idx],
01834 CC_AT_NAME_PTR(attr_idx),
01835 0,
01836 STR_ARG);
01837 ok = FALSE;
01838 goto EXIT;
01839 }
01840
01841 arg_num++;
01842 }
01843
01844 if (nxt_line[cc_stmt_buf_idx] != rparen) {
01845
01846 ntr_next_msg_queue(PP_LINE_NUM, 1551, Warning,
01847 nxt_line_col[cc_stmt_buf_idx],
01848 CC_AT_NAME_PTR(attr_idx),
01849 0,
01850 STR_ARG);
01851 ok = FALSE;
01852 goto EXIT;
01853 }
01854
01855 insert_macro(attr_idx,
01856 arg_head,
01857 id_start_idx,
01858 col,
01859 save_pp_line_idx);
01860
01861 }
01862 else {
01863 ok = FALSE;
01864 }
01865
01866 EXIT:
01867
01868 while (arg_head != NULL) {
01869 arg_tail = arg_head->next;
01870 free_arg_entry(arg_head);
01871 arg_head = arg_tail;
01872 }
01873
01874 TRACE (Func_Exit, "scan_fortran_macro", NULL);
01875
01876 return(ok);
01877
01878 }
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896 void init_cond_comp(void)
01897
01898 {
01899 int ln_idx;
01900 int word;
01901
01902 TRACE (Func_Entry, "init_cond_comp", NULL);
01903
01904
01905
01906 for (word = 0; word < CC_NUM_ID_WDS; word++) {
01907 TOKEN_STR_WD(cc_initial_token, word) = 0;
01908 }
01909
01910 TOKEN_LEN(cc_initial_token) = 0;
01911 TOKEN_VALUE(cc_initial_token) = Cc_Tok_Unknown;
01912 TOKEN_ERR(cc_initial_token) = FALSE;
01913 TOKEN_KIND_STR(cc_initial_token)[0] = EOS;
01914 TOKEN_KIND_LEN(cc_initial_token) = 0;
01915 TOKEN_COLUMN(cc_initial_token) = 0;
01916 TOKEN_LINE(cc_initial_token) = 0;
01917
01918
01919 CHECK_INITIAL_ALLOC (cc_attr_tbl, NULL_IDX);
01920 CHECK_INITIAL_ALLOC (cc_ln_tbl, NULL_IDX);
01921 CHECK_INITIAL_ALLOC (cc_blk_stk_tbl, NULL_IDX);
01922
01923 ln_idx = cc_ln_tbl_idx + 1;
01924
01925 TBL_REALLOC_CK(cc_ln_tbl, 2);
01926 CLEAR_TBL_NTRY(cc_ln_tbl, ln_idx);
01927 CC_LN_NAME_IDX(ln_idx) = NAME_POOL_ZERO_IDX;
01928 CC_LN_NAME_LEN(ln_idx) = HOST_BYTES_PER_WORD;
01929 cc_ln_fw_idx = ln_idx;
01930
01931 CLEAR_TBL_NTRY(cc_ln_tbl, cc_ln_tbl_idx);
01932 CC_LN_NAME_IDX(cc_ln_tbl_idx) = NAME_POOL_ONES_IDX;
01933 CC_LN_NAME_LEN(cc_ln_tbl_idx) = HOST_BYTES_PER_WORD;
01934 cc_ln_lw_idx = cc_ln_tbl_idx;
01935
01936 TRACE (Func_Exit, "init_cond_comp", NULL);
01937
01938 return;
01939
01940 }
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958 void enter_predefined_macros(void)
01959
01960 {
01961 int attr_idx;
01962 int name_idx;
01963
01964
01965 # if defined(_TARGET_OS_UNICOS) || defined(_TARGET_OS_MAX)
01966
01967 union {long int_form;
01968 char char_form[9];
01969 } cpu_type;
01970
01971 # endif
01972
01973
01974 TRACE (Func_Entry, "enter_predefined_macros", NULL);
01975
01976
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986 cc_token = cc_initial_token;
01987
01988 strcpy(TOKEN_STR(cc_token), "__line__");
01989 TOKEN_LEN(cc_token) = 8;
01990
01991 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
01992 TOKEN_LEN(cc_token),
01993 &name_idx);
01994
01995
01996 if (attr_idx == NULL_IDX) {
01997 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
01998 PUT_VALUE_IN_AT_STR(attr_idx, 1);
01999 CC_AT_DEFINED(attr_idx) = TRUE;
02000 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02001 line_macro_idx = attr_idx;
02002 }
02003 else {
02004
02005 }
02006
02007
02008
02009
02010
02011 cc_token = cc_initial_token;
02012
02013 strcpy(TOKEN_STR(cc_token), "__LINE__");
02014 TOKEN_LEN(cc_token) = 8;
02015
02016 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02017 TOKEN_LEN(cc_token),
02018 &name_idx);
02019
02020
02021 if (attr_idx == NULL_IDX) {
02022 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02023 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02024 CC_AT_DEFINED(attr_idx) = TRUE;
02025 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02026 LINE_macro_idx = attr_idx;
02027 }
02028 else {
02029
02030 }
02031
02032
02033
02034
02035
02036 cc_token = cc_initial_token;
02037
02038 strcpy(TOKEN_STR(cc_token), "__file__");
02039 TOKEN_LEN(cc_token) = 8;
02040
02041 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02042 TOKEN_LEN(cc_token),
02043 &name_idx);
02044
02045
02046 if (attr_idx == NULL_IDX) {
02047 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02048 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02049 CC_AT_DEFINED(attr_idx) = TRUE;
02050 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02051 file_macro_idx = attr_idx;
02052 }
02053 else {
02054
02055 }
02056
02057
02058
02059
02060
02061 cc_token = cc_initial_token;
02062
02063 strcpy(TOKEN_STR(cc_token), "__FILE__");
02064 TOKEN_LEN(cc_token) = 8;
02065
02066 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02067 TOKEN_LEN(cc_token),
02068 &name_idx);
02069
02070
02071 if (attr_idx == NULL_IDX) {
02072 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02073 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02074 CC_AT_DEFINED(attr_idx) = TRUE;
02075 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02076 FILE_macro_idx = attr_idx;
02077 }
02078 else {
02079
02080 }
02081
02082
02083
02084
02085
02086 cc_token = cc_initial_token;
02087
02088 strcpy(TOKEN_STR(cc_token), "__date__");
02089 TOKEN_LEN(cc_token) = 8;
02090
02091 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02092 TOKEN_LEN(cc_token),
02093 &name_idx);
02094
02095
02096 if (attr_idx == NULL_IDX) {
02097 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02098 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02099 CC_AT_DEFINED(attr_idx) = TRUE;
02100 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02101 date_macro_idx = attr_idx;
02102 }
02103 else {
02104
02105 }
02106
02107
02108
02109
02110
02111 cc_token = cc_initial_token;
02112
02113 strcpy(TOKEN_STR(cc_token), "__DATE__");
02114 TOKEN_LEN(cc_token) = 8;
02115
02116 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02117 TOKEN_LEN(cc_token),
02118 &name_idx);
02119
02120
02121 if (attr_idx == NULL_IDX) {
02122 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02123 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02124 CC_AT_DEFINED(attr_idx) = TRUE;
02125 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02126 DATE_macro_idx = attr_idx;
02127 }
02128 else {
02129
02130 }
02131
02132
02133
02134
02135
02136 cc_token = cc_initial_token;
02137
02138 strcpy(TOKEN_STR(cc_token), "__time__");
02139 TOKEN_LEN(cc_token) = 8;
02140
02141 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02142 TOKEN_LEN(cc_token),
02143 &name_idx);
02144
02145
02146 if (attr_idx == NULL_IDX) {
02147 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02148 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02149 CC_AT_DEFINED(attr_idx) = TRUE;
02150 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02151 time_macro_idx = attr_idx;
02152 }
02153 else {
02154
02155 }
02156
02157
02158
02159
02160
02161 cc_token = cc_initial_token;
02162
02163 strcpy(TOKEN_STR(cc_token), "__TIME__");
02164 TOKEN_LEN(cc_token) = 8;
02165
02166 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02167 TOKEN_LEN(cc_token),
02168 &name_idx);
02169
02170
02171 if (attr_idx == NULL_IDX) {
02172 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02173 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02174 CC_AT_DEFINED(attr_idx) = TRUE;
02175 CC_AT_DYNAMIC_PREDEF(attr_idx) = TRUE;
02176 TIME_macro_idx = attr_idx;
02177 }
02178 else {
02179
02180 }
02181
02182
02183 # ifdef _UNICOS
02184
02185
02186
02187
02188
02189 cc_token = cc_initial_token;
02190
02191 strcpy(TOKEN_STR(cc_token), "_UNICOS");
02192 TOKEN_LEN(cc_token) = 7;
02193
02194 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02195 TOKEN_LEN(cc_token),
02196 &name_idx);
02197
02198
02199 if (attr_idx == NULL_IDX) {
02200 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02201 PUT_VALUE_IN_AT_STR(attr_idx, _UNICOS);
02202 CC_AT_DEFINED(attr_idx) = TRUE;
02203 }
02204
02205
02206 # endif
02207
02208
02209 #if defined(_HOST_OS_UNICOS) || defined(_HOST_OS_SOLARIS) || \
02210 defined(_HOST_OS_MAX) || (defined(_HOST_OS_IRIX) || defined(_HOST_OS_LINUX))
02211
02212
02213
02214
02215
02216 cc_token = cc_initial_token;
02217
02218 strcpy(TOKEN_STR(cc_token), "unix");
02219 TOKEN_LEN(cc_token) = 4;
02220
02221 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02222 TOKEN_LEN(cc_token),
02223 &name_idx);
02224
02225 if (attr_idx == NULL_IDX) {
02226 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02227 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02228 CC_AT_DEFINED(attr_idx) = TRUE;
02229 }
02230
02231
02232
02233
02234
02235
02236 cc_token = cc_initial_token;
02237
02238 strcpy(TOKEN_STR(cc_token), "__unix");
02239 TOKEN_LEN(cc_token) = 6;
02240
02241 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02242 TOKEN_LEN(cc_token),
02243 &name_idx);
02244
02245 if (attr_idx == NULL_IDX) {
02246 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02247 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02248 CC_AT_DEFINED(attr_idx) = TRUE;
02249 }
02250
02251 # endif
02252
02253
02254 #if defined(_TARGET_OS_UNICOS) || defined(_TARGET_OS_MAX)
02255
02256
02257
02258
02259
02260
02261
02262 cc_token = cc_initial_token;
02263
02264 strcpy(TOKEN_STR(cc_token), "cray");
02265 TOKEN_LEN(cc_token) = 4;
02266
02267 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02268 TOKEN_LEN(cc_token),
02269 &name_idx);
02270
02271
02272 if (attr_idx == NULL_IDX) {
02273 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02274 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02275 CC_AT_DEFINED(attr_idx) = TRUE;
02276 }
02277
02278
02279
02280
02281
02282
02283 cc_token = cc_initial_token;
02284
02285 strcpy(TOKEN_STR(cc_token), "CRAY");
02286 TOKEN_LEN(cc_token) = 4;
02287
02288 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02289 TOKEN_LEN(cc_token),
02290 &name_idx);
02291
02292
02293 if (attr_idx == NULL_IDX) {
02294 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02295 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02296 CC_AT_DEFINED(attr_idx) = TRUE;
02297 }
02298
02299
02300
02301
02302
02303
02304 cc_token = cc_initial_token;
02305
02306 strcpy(TOKEN_STR(cc_token), "_CRAY");
02307 TOKEN_LEN(cc_token) = 5;
02308
02309 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02310 TOKEN_LEN(cc_token),
02311 &name_idx);
02312
02313 if (attr_idx == NULL_IDX) {
02314 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02315 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02316 CC_AT_DEFINED(attr_idx) = TRUE;
02317 }
02318
02319
02320
02321
02322
02323
02324 cc_token = cc_initial_token;
02325
02326 strcpy(TOKEN_STR(cc_token), "_MEMSIZE");
02327 TOKEN_LEN(cc_token) = 8;
02328
02329 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02330 TOKEN_LEN(cc_token),
02331 &name_idx);
02332
02333 if (attr_idx == NULL_IDX) {
02334 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02335 PUT_VALUE_IN_AT_STR(attr_idx, target_machine.fld.mcmsz);
02336 CC_AT_DEFINED(attr_idx) = TRUE;
02337 }
02338
02339 #endif
02340
02341
02342 # ifdef _TARGET_OS_UNICOS
02343
02344 # if defined(_GETPMC_AVAILABLE)
02345 cpu_type.int_form = target_machine.fld.mcpmt;
02346 cpu_type.char_form[8] = '\0';
02347 # else
02348 strcpy(cpu_type.char_form, target_machine.fld.mcpmt);
02349 # endif
02350
02351 if (strcmp("CRAY-C90", cpu_type.char_form) == 0) {
02352
02353
02354
02355
02356
02357 cc_token = cc_initial_token;
02358
02359 strcpy(TOKEN_STR(cc_token), "_CRAYC90");
02360 TOKEN_LEN(cc_token) = 8;
02361
02362 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02363 TOKEN_LEN(cc_token),
02364 &name_idx);
02365
02366 if (attr_idx == NULL_IDX) {
02367 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02368 PUT_VALUE_IN_AT_STR(attr_idx, 128);
02369 CC_AT_DEFINED(attr_idx) = TRUE;
02370 }
02371
02372
02373
02374
02375
02376
02377 cc_token = cc_initial_token;
02378
02379 strcpy(TOKEN_STR(cc_token), "_MAXVL");
02380 TOKEN_LEN(cc_token) = 6;
02381
02382 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02383 TOKEN_LEN(cc_token),
02384 &name_idx);
02385
02386 if (attr_idx == NULL_IDX) {
02387 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02388 PUT_VALUE_IN_AT_STR(attr_idx, 128);
02389 CC_AT_DEFINED(attr_idx) = TRUE;
02390 }
02391 }
02392 else if (strcmp("CRAY-TS", cpu_type.char_form) == 0) {
02393
02394
02395
02396
02397
02398 cc_token = cc_initial_token;
02399
02400 strcpy(TOKEN_STR(cc_token), "_CRAYT90");
02401 TOKEN_LEN(cc_token) = 8;
02402
02403 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02404 TOKEN_LEN(cc_token),
02405 &name_idx);
02406
02407 if (attr_idx == NULL_IDX) {
02408 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02409 PUT_VALUE_IN_AT_STR(attr_idx, 128);
02410 CC_AT_DEFINED(attr_idx) = TRUE;
02411 }
02412
02413
02414
02415
02416
02417 cc_token = cc_initial_token;
02418
02419 strcpy(TOKEN_STR(cc_token), "_MAXVL");
02420 TOKEN_LEN(cc_token) = 6;
02421
02422 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02423 TOKEN_LEN(cc_token),
02424 &name_idx);
02425
02426 if (attr_idx == NULL_IDX) {
02427 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02428 PUT_VALUE_IN_AT_STR(attr_idx, 128);
02429 CC_AT_DEFINED(attr_idx) = TRUE;
02430 }
02431
02432
02433
02434
02435
02436
02437 cc_token = cc_initial_token;
02438
02439 strcpy(TOKEN_STR(cc_token), "_ADDR64");
02440 TOKEN_LEN(cc_token) = 7;
02441
02442 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02443 TOKEN_LEN(cc_token),
02444 &name_idx);
02445
02446 if (attr_idx == NULL_IDX) {
02447 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02448 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02449 CC_AT_DEFINED(attr_idx) = TRUE;
02450 }
02451 }
02452 else if (strcmp("CRAY-YMP", cpu_type.char_form) == 0) {
02453
02454
02455
02456
02457
02458 cc_token = cc_initial_token;
02459 strcpy(TOKEN_STR(cc_token), "_MAXVL");
02460 TOKEN_LEN(cc_token) = 6;
02461
02462 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02463 TOKEN_LEN(cc_token),
02464 &name_idx);
02465
02466
02467 if (attr_idx == NULL_IDX) {
02468 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02469 PUT_VALUE_IN_AT_STR(attr_idx, 64);
02470 CC_AT_DEFINED(attr_idx) = TRUE;
02471 }
02472 }
02473
02474 if (target_machine.fld.mcaddr32) {
02475
02476
02477
02478
02479
02480 cc_token = cc_initial_token;
02481
02482 strcpy(TOKEN_STR(cc_token), "YMP");
02483 TOKEN_LEN(cc_token) = 3;
02484
02485 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02486 TOKEN_LEN(cc_token),
02487 &name_idx);
02488
02489 if (attr_idx == NULL_IDX) {
02490 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02491 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02492 CC_AT_DEFINED(attr_idx) = TRUE;
02493 }
02494
02495
02496
02497
02498
02499
02500 cc_token = cc_initial_token;
02501
02502 strcpy(TOKEN_STR(cc_token), "_ADDR32");
02503 TOKEN_LEN(cc_token) = 7;
02504
02505 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02506 TOKEN_LEN(cc_token),
02507 &name_idx);
02508
02509 if (attr_idx == NULL_IDX) {
02510 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02511 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02512 CC_AT_DEFINED(attr_idx) = TRUE;
02513 }
02514 }
02515
02516
02517 if (target_triton && target_ieee) {
02518
02519
02520
02521
02522
02523 cc_token = cc_initial_token;
02524
02525 strcpy(TOKEN_STR(cc_token), "_CRAYIEEE");
02526 TOKEN_LEN(cc_token) = 9;
02527
02528 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02529 TOKEN_LEN(cc_token),
02530 &name_idx);
02531
02532 if (attr_idx == NULL_IDX) {
02533 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02534 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02535 CC_AT_DEFINED(attr_idx) = TRUE;
02536 }
02537
02538 }
02539
02540 # endif
02541
02542
02543 # ifdef _TARGET_OS_MAX
02544
02545
02546
02547
02548
02549 cc_token = cc_initial_token;
02550
02551 strcpy(TOKEN_STR(cc_token), "_CRAYMPP");
02552 TOKEN_LEN(cc_token) = 8;
02553
02554 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02555 TOKEN_LEN(cc_token),
02556 &name_idx);
02557
02558 if (attr_idx == NULL_IDX) {
02559 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02560 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02561 CC_AT_DEFINED(attr_idx) = TRUE;
02562 }
02563
02564
02565
02566
02567
02568
02569 # if defined(_GETPMC_AVAILABLE)
02570 cpu_type.int_form = target_machine.fld.mcpmt;
02571 cpu_type.char_form[8] = '\0';
02572 # else
02573 strcpy(cpu_type.char_form, target_machine.fld.mcpmt);
02574 # endif
02575
02576 cc_token = cc_initial_token;
02577
02578 if (strcmp("CRAY-T3D", cpu_type.char_form) == 0) {
02579 strcpy(TOKEN_STR(cc_token), "_CRAYT3D");
02580 }
02581 else {
02582 strcpy(TOKEN_STR(cc_token), "_CRAYT3E");
02583 }
02584
02585 TOKEN_LEN(cc_token) = 8;
02586
02587 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02588 TOKEN_LEN(cc_token),
02589 &name_idx);
02590
02591 if (attr_idx == NULL_IDX) {
02592 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02593 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02594 CC_AT_DEFINED(attr_idx) = TRUE;
02595 }
02596
02597
02598
02599
02600
02601
02602 cc_token = cc_initial_token;
02603
02604 strcpy(TOKEN_STR(cc_token), "_CRAYIEEE");
02605 TOKEN_LEN(cc_token) = 9;
02606
02607 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02608 TOKEN_LEN(cc_token),
02609 &name_idx);
02610
02611 if (attr_idx == NULL_IDX) {
02612 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02613 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02614 CC_AT_DEFINED(attr_idx) = TRUE;
02615 }
02616
02617
02618
02619
02620
02621 cc_token = cc_initial_token;
02622
02623 strcpy(TOKEN_STR(cc_token), "_ADDR64");
02624 TOKEN_LEN(cc_token) = 7;
02625
02626 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02627 TOKEN_LEN(cc_token),
02628 &name_idx);
02629
02630 if (attr_idx == NULL_IDX) {
02631 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02632 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02633 CC_AT_DEFINED(attr_idx) = TRUE;
02634 }
02635
02636
02637 # endif
02638
02639
02640 #ifdef _TARGET_OS_SOLARIS
02641
02642 cc_token = cc_initial_token;
02643
02644 strcpy(TOKEN_STR(cc_token), "__sparc");
02645 TOKEN_LEN(cc_token) = 7;
02646
02647 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02648 TOKEN_LEN(cc_token),
02649 &name_idx);
02650
02651 if (attr_idx == NULL_IDX) {
02652 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02653 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02654 CC_AT_DEFINED(attr_idx) = TRUE;
02655 }
02656
02657 cc_token = cc_initial_token;
02658
02659 strcpy(TOKEN_STR(cc_token), "sun");
02660 TOKEN_LEN(cc_token) = 3;
02661
02662 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02663 TOKEN_LEN(cc_token),
02664 &name_idx);
02665
02666 if (attr_idx == NULL_IDX) {
02667 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02668 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02669 CC_AT_DEFINED(attr_idx) = TRUE;
02670 }
02671
02672 cc_token = cc_initial_token;
02673
02674 strcpy(TOKEN_STR(cc_token), "_SUN");
02675 TOKEN_LEN(cc_token) = 4;
02676
02677 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02678 TOKEN_LEN(cc_token),
02679 &name_idx);
02680
02681 if (attr_idx == NULL_IDX) {
02682 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02683 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02684 CC_AT_DEFINED(attr_idx) = TRUE;
02685 }
02686
02687 cc_token = cc_initial_token;
02688
02689 strcpy(TOKEN_STR(cc_token), "sparc");
02690 TOKEN_LEN(cc_token) = 5;
02691
02692 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02693 TOKEN_LEN(cc_token),
02694 &name_idx);
02695
02696 if (attr_idx == NULL_IDX) {
02697 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02698 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02699 CC_AT_DEFINED(attr_idx) = TRUE;
02700 }
02701
02702 cc_token = cc_initial_token;
02703
02704 strcpy(TOKEN_STR(cc_token), "_SPARC");
02705 TOKEN_LEN(cc_token) = 6;
02706
02707 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token),
02708 TOKEN_LEN(cc_token),
02709 &name_idx);
02710
02711 if (attr_idx == NULL_IDX) {
02712 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx);
02713 PUT_VALUE_IN_AT_STR(attr_idx, 1);
02714 CC_AT_DEFINED(attr_idx) = TRUE;
02715 }
02716
02717
02718 #endif
02719
02720
02721 TRACE (Func_Exit, "enter_predefined_macros", NULL);
02722
02723 return;
02724
02725 }
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744 static void cc_get_token(boolean keyword_expected)
02745
02746 {
02747 int i;
02748 int idx;
02749 boolean its_unsigned = FALSE;
02750 char upper_str[CC_MAX_ID_LEN+1];
02751 char str[80];
02752 long64 the_constant;
02753
02754
02755 TRACE (Func_Entry, "cc_get_token", NULL);
02756
02757 cc_token = cc_initial_token;
02758
02759 TOKEN_LINE(cc_token) = CC_LA_CH_LINE;
02760 TOKEN_COLUMN(cc_token) = CC_LA_CH_COLUMN;
02761
02762 if (CC_LA_CH_VALUE == eos) {
02763 TOKEN_VALUE(cc_token) = Cc_Tok_EOS;
02764 }
02765 else if (CC_LA_CH_CLASS == Ch_Class_Letter ||
02766 CC_LA_CH_VALUE == underscore) {
02767
02768
02769 TOKEN_LEN(cc_token) = 0;
02770
02771 while (cc_stmt_buf[cc_stmt_buf_idx] != newline &&
02772 cc_stmt_buf[cc_stmt_buf_idx] != blank &&
02773 cc_stmt_buf[cc_stmt_buf_idx] != tab &&
02774 VALID_CC_ID_CHAR(cc_stmt_buf[cc_stmt_buf_idx])) {
02775
02776 if (TOKEN_LEN(cc_token) < CC_MAX_ID_LEN) {
02777 ADD_TO_CC_TOKEN_STR(cc_stmt_buf[cc_stmt_buf_idx],
02778 TOKEN_LEN(cc_token));
02779 }
02780
02781 cc_stmt_buf_idx++;
02782 }
02783
02784 cc_stmt_buf_idx--;
02785 CC_NEXT_LA_CH;
02786
02787 TOKEN_VALUE(cc_token) = Cc_Tok_Id;
02788
02789
02790
02791 if (keyword_expected) {
02792
02793 for (i = 0; i < TOKEN_LEN(cc_token); i++) {
02794 if (islower((TOKEN_STR(cc_token))[i])) {
02795 upper_str[i] = TOUPPER((TOKEN_STR(cc_token))[i]);
02796 }
02797 else {
02798 upper_str[i] = (TOKEN_STR(cc_token))[i];
02799 }
02800 }
02801
02802 upper_str[i] ='\0';
02803
02804 switch(upper_str[0]) {
02805 case 'D':
02806 if (TOKEN_LEN(cc_token) == 6 &&
02807 EQUAL_STRS(upper_str, "DEFINE")) {
02808 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Define;
02809 }
02810 else if (TOKEN_LEN(cc_token) == 7 &&
02811 EQUAL_STRS(upper_str, "DEFINED")) {
02812 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Defined;
02813 }
02814 break;
02815
02816 case 'E':
02817 if (TOKEN_LEN(cc_token) == 4 &&
02818 EQUAL_STRS(upper_str, "ELIF")) {
02819 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Elif;
02820 }
02821 else if (TOKEN_LEN(cc_token) == 4 &&
02822 EQUAL_STRS(upper_str, "ELSE")) {
02823 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Else;
02824 }
02825 else if (TOKEN_LEN(cc_token) == 5 &&
02826 EQUAL_STRS(upper_str, "ENDIF")) {
02827 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Endif;
02828 }
02829 else if (TOKEN_LEN(cc_token) == 5 &&
02830 EQUAL_STRS(upper_str, "ERROR")) {
02831 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Error;
02832 }
02833 break;
02834
02835 case 'I':
02836 if (TOKEN_LEN(cc_token) == 2 &&
02837 EQUAL_STRS(upper_str, "IF")) {
02838 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_If;
02839 }
02840 else if (TOKEN_LEN(cc_token) == 5 &&
02841 EQUAL_STRS(upper_str, "IFDEF")) {
02842 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Ifdef;
02843 }
02844 else if (TOKEN_LEN(cc_token) == 6 &&
02845 EQUAL_STRS(upper_str, "IFNDEF")) {
02846 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Ifndef;
02847 }
02848 else if (TOKEN_LEN(cc_token) == 7 &&
02849 EQUAL_STRS(upper_str, "INCLUDE")) {
02850 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Include;
02851 }
02852
02853 break;
02854
02855 case 'U':
02856 if (TOKEN_LEN(cc_token) == 5 &&
02857 EQUAL_STRS(upper_str, "UNDEF")) {
02858 TOKEN_VALUE(cc_token) = Cc_Tok_Kwd_Undef;
02859 }
02860
02861 break;
02862
02863 }
02864 }
02865 }
02866 else if (CC_LA_CH_CLASS == Ch_Class_Digit) {
02867
02868 idx = 0;
02869 if (CC_LA_CH_VALUE == ZERO) {
02870
02871
02872 str[idx] = CC_LA_CH_VALUE;
02873 idx++;
02874 CC_NEXT_LA_CH;
02875
02876 if (CC_LA_CH_VALUE == 'X' ||
02877 CC_LA_CH_VALUE == 'x') {
02878 str[idx] = CC_LA_CH_VALUE;
02879 idx++;
02880 CC_NEXT_LA_CH;
02881 }
02882 }
02883
02884 while (CC_LA_CH_CLASS == Ch_Class_Digit &&
02885 idx < 79) {
02886 str[idx] = CC_LA_CH_VALUE;
02887 CC_NEXT_LA_CH;
02888 idx++;
02889 }
02890
02891 str[idx] = '\0';
02892
02893 if (CC_LA_CH_VALUE == 'L' ||
02894 CC_LA_CH_VALUE == 'l') {
02895
02896 CC_NEXT_LA_CH;
02897
02898 if (CC_LA_CH_VALUE == 'U' ||
02899 CC_LA_CH_VALUE == 'u') {
02900
02901 CC_NEXT_LA_CH;
02902 its_unsigned = TRUE;
02903 }
02904 }
02905
02906 if (CC_LA_CH_VALUE == 'U' ||
02907 CC_LA_CH_VALUE == 'u') {
02908
02909 CC_NEXT_LA_CH;
02910 its_unsigned = TRUE;
02911
02912 if (CC_LA_CH_VALUE == 'L' ||
02913 CC_LA_CH_VALUE == 'l') {
02914
02915 CC_NEXT_LA_CH;
02916 }
02917 }
02918
02919 if (its_unsigned) {
02920 the_constant = (long64) strtoul(str, NULL, 0);
02921 }
02922 else {
02923 the_constant = (long64) strtol(str, NULL, 0);
02924 }
02925
02926 TOKEN_CONST_TBL_IDX(cc_token) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE,
02927 the_constant);
02928
02929 TOKEN_VALUE(cc_token) = Cc_Tok_Constant;
02930
02931 }
02932 else {
02933
02934 switch(CC_LA_CH_VALUE) {
02935
02936 case '#':
02937
02938 CC_NEXT_LA_CH;
02939 break;
02940
02941 case '+':
02942 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Add;
02943
02944 CC_NEXT_LA_CH;
02945 break;
02946
02947 case '/':
02948 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Div;
02949
02950 CC_NEXT_LA_CH;
02951 break;
02952
02953 case '%':
02954 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Mod;
02955
02956 CC_NEXT_LA_CH;
02957 break;
02958
02959 case '*':
02960 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Mult;
02961
02962 CC_NEXT_LA_CH;
02963 break;
02964
02965 case '-':
02966 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Sub;
02967
02968 CC_NEXT_LA_CH;
02969 break;
02970
02971 case '!':
02972 if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '=') {
02973 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Ne;
02974 CC_NEXT_LA_CH;
02975 }
02976 else {
02977 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Not;
02978 }
02979
02980 CC_NEXT_LA_CH;
02981 break;
02982
02983 case '~':
02984 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Bnot;
02985
02986 CC_NEXT_LA_CH;
02987 break;
02988
02989 case '^':
02990 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Neqv;
02991
02992 CC_NEXT_LA_CH;
02993 break;
02994
02995 case '=':
02996 if (cc_stmt_buf[cc_stmt_buf_idx+1] == '=') {
02997 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Eq;
02998 CC_NEXT_LA_CH;
02999 }
03000
03001 CC_NEXT_LA_CH;
03002 break;
03003
03004 case '>':
03005
03006 if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '=') {
03007 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Ge;
03008 CC_NEXT_LA_CH;
03009 }
03010 else if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '>') {
03011 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Rshift;
03012 CC_NEXT_LA_CH;
03013 }
03014 else {
03015 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Gt;
03016 }
03017
03018 CC_NEXT_LA_CH;
03019 break;
03020
03021 case '<':
03022
03023 if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '=') {
03024 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Le;
03025 CC_NEXT_LA_CH;
03026 }
03027 else if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '<') {
03028 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Lshift;
03029 CC_NEXT_LA_CH;
03030 }
03031 else {
03032 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Lt;
03033 }
03034
03035 CC_NEXT_LA_CH;
03036 break;
03037
03038 case '&':
03039
03040 if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '&') {
03041 TOKEN_VALUE(cc_token) = Cc_Tok_Op_And;
03042 CC_NEXT_LA_CH;
03043 }
03044 else {
03045 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Band;
03046 }
03047
03048 CC_NEXT_LA_CH;
03049 break;
03050
03051 case '|':
03052
03053 if (cc_stmt_buf[cc_stmt_buf_idx + 1] == '|') {
03054 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Or;
03055 CC_NEXT_LA_CH;
03056 }
03057 else {
03058 TOKEN_VALUE(cc_token) = Cc_Tok_Op_Bor;
03059 }
03060
03061 CC_NEXT_LA_CH;
03062 break;
03063
03064 }
03065
03066 }
03067
03068 TRACE (Func_Exit, "cc_get_token", NULL);
03069
03070 return;
03071
03072 }
03073
03074
03075
03076
03077
03078
03079
03080
03081
03082
03083
03084
03085
03086
03087
03088
03089
03090 static void cc_get_next_char(void)
03091
03092 {
03093
03094 int col;
03095 int line;
03096
03097
03098 TRACE (Func_Entry, "cc_get_next_char", NULL);
03099
03100 cc_stmt_buf_idx++;
03101
03102 BACK:
03103
03104
03105 while (cc_stmt_buf[cc_stmt_buf_idx] == blank ||
03106 cc_stmt_buf[cc_stmt_buf_idx] == tab) {
03107
03108 cc_stmt_buf_idx++;
03109 }
03110
03111 if (cc_stmt_buf[cc_stmt_buf_idx] == '/' &&
03112 cc_stmt_buf[cc_stmt_buf_idx + 1] == '*') {
03113
03114 cc_stmt_buf_idx += 2;
03115
03116 while (! (cc_stmt_buf[cc_stmt_buf_idx] == '*' &&
03117 cc_stmt_buf[cc_stmt_buf_idx + 1] == '/') &&
03118 cc_stmt_buf[cc_stmt_buf_idx] != newline) {
03119 cc_stmt_buf_idx++;
03120 }
03121
03122 if (cc_stmt_buf[cc_stmt_buf_idx] != newline) {
03123 cc_stmt_buf_idx += 2;
03124 goto BACK;
03125 }
03126 }
03127
03128 if (cc_stmt_buf[cc_stmt_buf_idx] == newline) {
03129 CC_LA_CH_VALUE = eos;
03130 }
03131 else {
03132 CC_LA_CH_VALUE = cc_stmt_buf[cc_stmt_buf_idx];
03133 }
03134
03135 find_line_and_col(cc_stmt_buf_idx, &line, &col);
03136 CC_LA_CH_LINE = line;
03137 CC_LA_CH_COLUMN = col;
03138 CC_LA_CH_CLASS = (CC_LA_CH_VALUE == (char) EOF) ?
03139 Ch_Class_EOF : ch_class[CC_LA_CH_VALUE];
03140
03141
03142 TRACE (Func_Exit, "cc_get_next_char", NULL);
03143
03144 return;
03145
03146 }
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159
03160
03161
03162
03163
03164 static void cc_get_stmt(void)
03165
03166 {
03167 int char_start_idx;
03168 int comment_start_idx;
03169 char delim;
03170 int idx;
03171 boolean in_char_context = FALSE;
03172 boolean is_define_dir = FALSE;
03173 int save_idx;
03174 int start_col;
03175 int start_line;
03176
03177 TRACE (Func_Entry, "cc_get_stmt", NULL);
03178
03179 cc_line_continued = FALSE;
03180
03181 cc_stmt_buf_len = cc_stmt_buf_idx;
03182 cc_stmt_buf_idx = NULL_IDX;
03183
03184 CC_NEXT_LA_CH;
03185
03186 CC_NEXT_LA_CH;
03187
03188 cc_get_token(TRUE);
03189
03190 if (TOKEN_VALUE(cc_token) == Cc_Tok_Kwd_Define) {
03191 is_define_dir = TRUE;
03192 }
03193
03194 cc_stmt_buf_idx = NULL_IDX;
03195
03196 while (cc_stmt_buf[++cc_stmt_buf_idx] != eos) {
03197
03198 if (cc_stmt_buf[cc_stmt_buf_idx] == QUOTE ||
03199 cc_stmt_buf[cc_stmt_buf_idx] == DBL_QUOTE) {
03200
03201 if (in_char_context) {
03202
03203 if (delim == cc_stmt_buf[cc_stmt_buf_idx] &&
03204 delim != cc_stmt_buf[cc_stmt_buf_idx+1]) {
03205 in_char_context = FALSE;
03206 }
03207 else if (delim == cc_stmt_buf[cc_stmt_buf_idx] &&
03208 delim == cc_stmt_buf[cc_stmt_buf_idx+1]) {
03209 cc_stmt_buf_idx++;
03210 }
03211 }
03212 else {
03213
03214
03215 in_char_context = TRUE;
03216 char_start_idx = cc_stmt_buf_idx;
03217 delim = cc_stmt_buf[cc_stmt_buf_idx];
03218 }
03219 }
03220
03221 if (! in_char_context &&
03222 cc_stmt_buf[cc_stmt_buf_idx] == '/' &&
03223 cc_stmt_buf[cc_stmt_buf_idx + 1] == '*') {
03224
03225 comment_start_idx = cc_stmt_buf_idx;
03226 start_line = cc_stmt_buf_line[cc_stmt_buf_num_lines].line;
03227 start_col = comment_start_idx -
03228 cc_stmt_buf_line[cc_stmt_buf_num_lines].start_idx;
03229 cc_stmt_buf_idx += 2;
03230
03231 while (! (cc_stmt_buf[cc_stmt_buf_idx] == '*' &&
03232 cc_stmt_buf[cc_stmt_buf_idx + 1] == '/')) {
03233
03234 # if 0
03235 if (cc_stmt_buf[cc_stmt_buf_idx] == eos ||
03236 cc_stmt_buf_idx >= MAX_STMT_CHAR_SIZE - MAX_SRC_LINE_SIZE) {
03237 ntr_next_msg_queue(start_line, xxxx, Error,
03238 start_col,
03239 (char *)NULL,
03240 0,
03241 NO_ARG);
03242 goto EXIT;
03243 }
03244 # endif
03245
03246 if (cc_stmt_buf[cc_stmt_buf_idx] == newline) {
03247 cc_stmt_buf_idx--;
03248 save_idx = cc_stmt_buf_idx;
03249 read_line(TRUE);
03250 cc_stmt_buf_len = cc_stmt_buf_idx;
03251 cc_line_continued = TRUE;
03252 cc_stmt_buf_idx = save_idx;
03253
03254 if (on_off_flags.preprocess_only || on_off_flags.save_dot_i) {
03255
03256 fprintf(dot_i_fptr, "\n");
03257 }
03258 }
03259 cc_stmt_buf_idx++;
03260 }
03261
03262 cc_stmt_buf_idx += 2;
03263 }
03264
03265
03266 if (cc_stmt_buf[cc_stmt_buf_idx] == newline &&
03267 cc_stmt_buf[cc_stmt_buf_idx - 1] == '\\') {
03268 cc_stmt_buf_idx -= 2;
03269
03270 save_idx = cc_stmt_buf_idx;
03271 read_line(TRUE);
03272 cc_stmt_buf_len = cc_stmt_buf_idx;
03273 cc_line_continued = TRUE;
03274 cc_stmt_buf_idx = save_idx;
03275
03276 if (on_off_flags.preprocess_only || on_off_flags.save_dot_i) {
03277
03278 fprintf(dot_i_fptr, "\n");
03279 }
03280
03281 }
03282 else if (is_define_dir &&
03283 cc_stmt_buf[cc_stmt_buf_idx] == amp &&
03284 source_form == Free_Form) {
03285
03286 idx = cc_stmt_buf_idx + 1;
03287
03288 while (cc_stmt_buf[idx] == blank ||
03289 cc_stmt_buf[idx] == tab) {
03290 idx++;
03291 }
03292
03293 if (cc_stmt_buf[idx] == '!' ||
03294 cc_stmt_buf[idx] == newline) {
03295
03296 cc_stmt_buf_idx--;
03297
03298 save_idx = cc_stmt_buf_idx;
03299 read_line(TRUE);
03300 cc_stmt_buf_len = cc_stmt_buf_idx;
03301 cc_line_continued = TRUE;
03302 cc_stmt_buf_idx = save_idx;
03303
03304 idx = cc_stmt_buf_idx + 1;
03305
03306 while (cc_stmt_buf[idx] == blank ||
03307 cc_stmt_buf[idx] == tab) {
03308 idx++;
03309 }
03310
03311 if (cc_stmt_buf[idx] == amp) {
03312 shift_cc_stmt_buf(idx+1,
03313 cc_stmt_buf_idx - idx);
03314 }
03315
03316 if (on_off_flags.preprocess_only || on_off_flags.save_dot_i) {
03317
03318 fprintf(dot_i_fptr, "\n");
03319 }
03320 }
03321 }
03322 else if (! in_char_context &&
03323 is_define_dir &&
03324 cc_stmt_buf[cc_stmt_buf_idx] == '!') {
03325
03326 idx = cc_stmt_buf_idx;
03327 while (cc_stmt_buf[idx] != newline) {
03328 idx++;
03329 }
03330
03331 if (cc_stmt_buf[idx-1] == '\\') {
03332 idx--;
03333 }
03334
03335 shift_cc_stmt_buf(idx,
03336 cc_stmt_buf_idx - idx);
03337 cc_stmt_buf_idx--;
03338
03339 }
03340 }
03341
03342 if (in_char_context) {
03343 find_line_and_col(char_start_idx, &start_line, &start_col);
03344 ntr_next_msg_queue(start_line, 1631, Warning,
03345 start_col,
03346 (char *)NULL,
03347 0,
03348 NO_ARG);
03349 }
03350
03351 # if 0
03352 EXIT:
03353 # endif
03354
03355 cc_stmt_buf_line[cc_stmt_buf_num_lines+1].line =
03356 cc_stmt_buf_line[cc_stmt_buf_num_lines].line;
03357 cc_stmt_buf_line[cc_stmt_buf_num_lines+1].start_idx = cc_stmt_buf_idx;
03358 cc_stmt_buf_len = cc_stmt_buf_idx;
03359 cc_stmt_buf[cc_stmt_buf_idx+1] = '\0';
03360 cc_stmt_buf_idx = NULL_IDX;
03361
03362 TRACE (Func_Exit, "cc_get_stmt", NULL);
03363
03364 return;
03365
03366 }
03367
03368
03369
03370
03371
03372
03373
03374
03375
03376
03377
03378
03379
03380
03381
03382
03383 static boolean parse_cc_expr (opnd_type *result)
03384
03385 {
03386 opnd_type opnd;
03387 boolean parsed_ok = TRUE;
03388
03389 TRACE (Func_Entry, "parse_cc_expr", NULL);
03390
03391 parsed_ok = parse_cc_level_8(&opnd);
03392
03393 COPY_OPND((*result), opnd)
03394
03395 # if 0
03396 print_ir(OPND_IDX(opnd));
03397 # endif
03398
03399 TRACE (Func_Exit, "parse_cc_expr", NULL);
03400
03401 return(parsed_ok);
03402 }
03403
03404
03405
03406
03407
03408
03409
03410
03411
03412
03413
03414
03415
03416
03417
03418
03419
03420 static boolean parse_cc_mult_opnd(opnd_type *result)
03421
03422 {
03423 int ir_idx = NULL_IDX;
03424 opnd_type opnd;
03425 boolean parsed_ok = TRUE;
03426
03427
03428 TRACE (Func_Entry, "parse_cc_mult_opnd", NULL);
03429
03430 if ((cc_stmt_buf[cc_stmt_buf_idx] == '!' &&
03431 cc_stmt_buf[cc_stmt_buf_idx+1] != '=') ||
03432 cc_stmt_buf[cc_stmt_buf_idx] == '~' ||
03433 cc_stmt_buf[cc_stmt_buf_idx] == '+' ||
03434 cc_stmt_buf[cc_stmt_buf_idx] == '-') {
03435
03436 cc_get_token(FALSE);
03437
03438 NTR_IR_TBL(ir_idx);
03439 OPND_FLD((*result)) = IR_Tbl_Idx;
03440 OPND_IDX((*result)) = ir_idx;
03441 switch (TOKEN_VALUE(cc_token)) {
03442 case Cc_Tok_Op_Add :
03443 IR_OPR(ir_idx) = Uplus_Opr;
03444 break;
03445 case Cc_Tok_Op_Sub :
03446 IR_OPR(ir_idx) = Uminus_Opr;
03447 break;
03448 case Cc_Tok_Op_Bnot :
03449 IR_OPR(ir_idx) = Bnot_Opr;
03450 break;
03451 case Cc_Tok_Op_Not :
03452 IR_OPR(ir_idx) = Not_Opr;
03453 break;
03454 }
03455
03456 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03457 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03458 }
03459
03460 parsed_ok = parse_cc_operand(&opnd);
03461
03462 if (ir_idx) {
03463 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03464 }
03465 else {
03466 COPY_OPND((*result), opnd);
03467 }
03468
03469 TRACE (Func_Exit, "parse_cc_mult_opnd", NULL);
03470
03471 return(parsed_ok);
03472 }
03473
03474
03475
03476
03477
03478
03479
03480
03481
03482
03483
03484
03485
03486
03487
03488
03489
03490 static boolean parse_cc_add_opnd(opnd_type *result)
03491
03492 {
03493 int ir_idx;
03494 opnd_type opnd;
03495 boolean parsed_ok = TRUE;
03496
03497 TRACE (Func_Entry, "parse_cc_add_opnd", NULL);
03498
03499 parsed_ok = parse_cc_mult_opnd(&opnd) && parsed_ok;
03500
03501 if (CC_LA_CH_VALUE == '+' ||
03502 CC_LA_CH_VALUE == '/' ||
03503 CC_LA_CH_VALUE == '%' ||
03504 CC_LA_CH_VALUE == '*' ||
03505 CC_LA_CH_VALUE == '-' ||
03506 CC_LA_CH_VALUE == '!' ||
03507 CC_LA_CH_VALUE == '~' ||
03508 CC_LA_CH_VALUE == '^' ||
03509 CC_LA_CH_VALUE == '=' ||
03510 CC_LA_CH_VALUE == '>' ||
03511 CC_LA_CH_VALUE == '<' ||
03512 CC_LA_CH_VALUE == '&' ||
03513 CC_LA_CH_VALUE == '|') {
03514
03515 cc_get_token(FALSE);
03516 }
03517
03518 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Mult ||
03519 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Div ||
03520 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Mod) {
03521
03522 NTR_IR_TBL(ir_idx);
03523 switch (TOKEN_VALUE(cc_token)) {
03524 case Cc_Tok_Op_Mult :
03525 IR_OPR(ir_idx) = Mult_Opr;
03526 break;
03527 case Cc_Tok_Op_Div :
03528 IR_OPR(ir_idx) = Div_Opr;
03529 break;
03530 case Cc_Tok_Op_Mod :
03531 IR_OPR(ir_idx) = Mod_Opr;
03532 break;
03533 }
03534 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03535 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03536
03537 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03538
03539 parsed_ok = parse_cc_mult_opnd(&opnd) && parsed_ok;
03540
03541 COPY_OPND(IR_OPND_R(ir_idx), opnd);
03542
03543 OPND_FLD(opnd) = IR_Tbl_Idx;
03544 OPND_IDX(opnd) = ir_idx;
03545
03546 if (CC_LA_CH_VALUE == '+' ||
03547 CC_LA_CH_VALUE == '/' ||
03548 CC_LA_CH_VALUE == '%' ||
03549 CC_LA_CH_VALUE == '*' ||
03550 CC_LA_CH_VALUE == '-' ||
03551 CC_LA_CH_VALUE == '!' ||
03552 CC_LA_CH_VALUE == '~' ||
03553 CC_LA_CH_VALUE == '^' ||
03554 CC_LA_CH_VALUE == '=' ||
03555 CC_LA_CH_VALUE == '>' ||
03556 CC_LA_CH_VALUE == '<' ||
03557 CC_LA_CH_VALUE == '&' ||
03558 CC_LA_CH_VALUE == '|') {
03559
03560 cc_get_token(FALSE);
03561 }
03562 }
03563
03564 COPY_OPND((*result), opnd)
03565
03566 TRACE (Func_Exit, "parse_cc_add_opnd", NULL);
03567
03568 return(parsed_ok);
03569 }
03570
03571
03572
03573
03574
03575
03576
03577
03578
03579
03580
03581
03582
03583
03584
03585
03586
03587 static boolean parse_cc_level_2(opnd_type *result)
03588
03589 {
03590 int ir_idx = NULL_IDX;
03591 opnd_type opnd;
03592 boolean parsed_ok = TRUE;
03593
03594 TRACE (Func_Entry, "parse_cc_level_2", NULL);
03595
03596 parsed_ok = parse_cc_add_opnd(&opnd);
03597
03598 if (ir_idx) {
03599 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03600 OPND_FLD(opnd) = IR_Tbl_Idx;
03601 OPND_IDX(opnd) = ir_idx;
03602 }
03603
03604 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Add ||
03605 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Sub) {
03606
03607 NTR_IR_TBL(ir_idx);
03608 switch (TOKEN_VALUE(cc_token)) {
03609 case Cc_Tok_Op_Add :
03610 IR_OPR(ir_idx) = Plus_Opr;
03611 break;
03612 case Cc_Tok_Op_Sub :
03613 IR_OPR(ir_idx) = Minus_Opr;
03614 }
03615 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03616 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03617
03618 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03619
03620 parsed_ok = parse_cc_add_opnd(&opnd) && parsed_ok;
03621
03622 COPY_OPND(IR_OPND_R(ir_idx), opnd);
03623
03624 OPND_FLD(opnd) = IR_Tbl_Idx;
03625 OPND_IDX(opnd) = ir_idx;
03626 }
03627
03628 COPY_OPND((*result), opnd)
03629
03630 TRACE (Func_Exit, "parse_cc_level_2", NULL);
03631
03632 return(parsed_ok);
03633 }
03634
03635
03636
03637
03638
03639
03640
03641
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651 static boolean parse_cc_level_3(opnd_type *result)
03652
03653 {
03654 int ir_idx = NULL_IDX;
03655 opnd_type opnd;
03656 boolean parsed_ok = TRUE;
03657
03658 TRACE (Func_Entry, "parse_cc_level_3", NULL);
03659
03660 parsed_ok = parse_cc_level_2(&opnd);
03661
03662 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Lshift ||
03663 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Rshift) {
03664
03665 NTR_IR_TBL(ir_idx);
03666 switch (TOKEN_VALUE(cc_token)) {
03667 case Cc_Tok_Op_Lshift :
03668 IR_OPR(ir_idx) = Shiftl_Opr;
03669 break;
03670 case Cc_Tok_Op_Rshift :
03671 IR_OPR(ir_idx) = Shiftr_Opr;
03672 }
03673 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03674 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03675
03676 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03677
03678 parsed_ok = parse_cc_level_2(&opnd) && parsed_ok;
03679
03680 COPY_OPND(IR_OPND_R(ir_idx), opnd);
03681
03682 OPND_FLD(opnd) = IR_Tbl_Idx;
03683 OPND_IDX(opnd) = ir_idx;
03684 }
03685
03686 COPY_OPND((*result), opnd)
03687
03688 TRACE (Func_Exit, "parse_cc_level_3", NULL);
03689
03690 return(parsed_ok);
03691 }
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702
03703
03704
03705
03706
03707
03708
03709 static boolean parse_cc_level_4(opnd_type *result)
03710
03711 {
03712 int ir_idx;
03713 opnd_type opnd;
03714 boolean parsed_ok = TRUE;
03715
03716 TRACE (Func_Entry, "parse_cc_level_4", NULL);
03717
03718 parsed_ok = parse_cc_level_3(&opnd);
03719
03720 if (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Ge ||
03721 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Gt ||
03722 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Le ||
03723 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Lt) {
03724
03725 NTR_IR_TBL(ir_idx);
03726 switch (TOKEN_VALUE(cc_token)) {
03727 case Cc_Tok_Op_Ge :
03728 IR_OPR(ir_idx) = Ge_Opr;
03729 break;
03730 case Cc_Tok_Op_Gt :
03731 IR_OPR(ir_idx) = Gt_Opr;
03732 break;
03733 case Cc_Tok_Op_Le :
03734 IR_OPR(ir_idx) = Le_Opr;
03735 break;
03736 case Cc_Tok_Op_Lt :
03737 IR_OPR(ir_idx) = Lt_Opr;
03738 break;
03739 }
03740 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03741 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03742
03743 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03744
03745 parsed_ok = parse_cc_level_3(&opnd) && parsed_ok;
03746
03747 COPY_OPND(IR_OPND_R(ir_idx), opnd);
03748
03749 OPND_FLD(opnd) = IR_Tbl_Idx;
03750 OPND_IDX(opnd) = ir_idx;
03751 }
03752
03753 COPY_OPND((*result), opnd)
03754
03755 TRACE (Func_Exit, "parse_cc_level_4", NULL);
03756
03757 return(parsed_ok);
03758 }
03759
03760
03761
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774
03775
03776 static boolean parse_cc_level_5(opnd_type *result)
03777
03778 {
03779 int ir_idx;
03780 opnd_type opnd;
03781 boolean parsed_ok = TRUE;
03782
03783 TRACE (Func_Entry, "parse_cc_level_5", NULL);
03784
03785 parsed_ok = parse_cc_level_4(&opnd);
03786
03787 if (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Eq ||
03788 TOKEN_VALUE(cc_token) == Cc_Tok_Op_Ne) {
03789
03790 NTR_IR_TBL(ir_idx);
03791 switch (TOKEN_VALUE(cc_token)) {
03792 case Cc_Tok_Op_Eq :
03793 IR_OPR(ir_idx) = Eq_Opr;
03794 break;
03795 case Cc_Tok_Op_Ne :
03796 IR_OPR(ir_idx) = Ne_Opr;
03797 break;
03798 }
03799 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03800 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03801
03802 COPY_OPND(IR_OPND_L(ir_idx), opnd);
03803
03804 parsed_ok = parse_cc_level_4(&opnd) && parsed_ok;
03805
03806 COPY_OPND(IR_OPND_R(ir_idx), opnd);
03807
03808 OPND_FLD(opnd) = IR_Tbl_Idx;
03809 OPND_IDX(opnd) = ir_idx;
03810 }
03811
03812 COPY_OPND((*result), opnd)
03813
03814 TRACE (Func_Exit, "parse_cc_level_5", NULL);
03815
03816 return(parsed_ok);
03817 }
03818
03819
03820
03821
03822
03823
03824
03825
03826
03827
03828
03829
03830
03831
03832
03833
03834
03835 static boolean parse_cc_or_opnd(opnd_type *result)
03836
03837 {
03838 int ir_idx;
03839 opnd_type opnd;
03840 boolean parsed_ok = TRUE;
03841
03842 TRACE (Func_Entry, "parse_cc_or_opnd", NULL);
03843
03844 parsed_ok = parse_cc_level_5(&opnd);
03845
03846 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Band) {
03847
03848 NTR_IR_TBL(ir_idx);
03849 IR_OPR(ir_idx) = Band_Opr;
03850 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03851 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03852
03853 COPY_OPND(IR_OPND_L(ir_idx), opnd)
03854
03855 parsed_ok = parse_cc_level_5(&opnd) && parsed_ok;
03856
03857 COPY_OPND(IR_OPND_R(ir_idx), opnd)
03858
03859 OPND_FLD(opnd) = IR_Tbl_Idx;
03860 OPND_IDX(opnd) = ir_idx;
03861 }
03862
03863 COPY_OPND((*result), opnd)
03864
03865 TRACE (Func_Exit, "parse_cc_or_opnd", NULL);
03866
03867 return(parsed_ok);
03868 }
03869
03870
03871
03872
03873
03874
03875
03876
03877
03878
03879
03880
03881
03882
03883
03884
03885
03886 static boolean parse_cc_level_6(opnd_type *result)
03887
03888 {
03889 int ir_idx;
03890 opnd_type opnd;
03891 boolean parsed_ok = TRUE;
03892
03893 TRACE (Func_Entry, "parse_cc_level_6", NULL);
03894
03895 parsed_ok = parse_cc_or_opnd(&opnd);
03896
03897 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Neqv) {
03898
03899 NTR_IR_TBL(ir_idx);
03900 IR_OPR(ir_idx) = Neqv_Opr;
03901 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03902 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03903
03904 COPY_OPND(IR_OPND_L(ir_idx), opnd)
03905
03906 parsed_ok = parse_cc_equiv_opnd(&opnd) && parsed_ok;
03907
03908 COPY_OPND(IR_OPND_R(ir_idx), opnd)
03909
03910 OPND_FLD(opnd) = IR_Tbl_Idx;
03911 OPND_IDX(opnd) = ir_idx;
03912 }
03913
03914 COPY_OPND((*result), opnd)
03915
03916 TRACE (Func_Exit, "parse_cc_level_6", NULL);
03917
03918 return(parsed_ok);
03919 }
03920
03921
03922
03923
03924
03925
03926
03927
03928
03929
03930
03931
03932
03933
03934
03935
03936
03937 static boolean parse_cc_equiv_opnd(opnd_type *result)
03938
03939 {
03940 int ir_idx;
03941 opnd_type opnd;
03942 boolean parsed_ok = TRUE;
03943
03944 TRACE (Func_Entry, "parse_cc_equiv_opnd", NULL);
03945
03946 parsed_ok = parse_cc_level_6(&opnd);
03947
03948 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Bor) {
03949
03950 NTR_IR_TBL(ir_idx);
03951 IR_OPR(ir_idx) = Bor_Opr;
03952 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token);
03953 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token);
03954
03955 COPY_OPND(IR_OPND_L(ir_idx), opnd)
03956
03957 parsed_ok = parse_cc_level_6(&opnd) && parsed_ok;
03958
03959 COPY_OPND(IR_OPND_R(ir_idx), opnd)
03960
03961 OPND_FLD(opnd) = IR_Tbl_Idx;
03962 OPND_IDX(opnd) = ir_idx;
03963 }
03964
03965 COPY_OPND((*result), opnd)
03966