|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2 of the GNU General Public License as 00007 published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU General Public License along 00021 with this program; if not, write the Free Software Foundation, Inc., 59 00022 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00023 00024 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00025 Mountain View, CA 94043, or: 00026 00027 http://www.sgi.com 00028 00029 For further information regarding this notice, see: 00030 00031 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00032 00033 */ 00034 00035 00036 00037 static char USMID[] = "\n@(#)5.0_pl/sources/cond_comp.c 5.8 09/21/99 00:21:13\n"; 00038 00039 /* 00040 * Linux workaround - not necessary for all linux machine 00041 */ 00042 /* #ifdef _LINUX_LINUX*/ 00043 # include <time.h> 00044 /* #else*/ 00045 # include <sys/time.h> 00046 /* #endif*/ 00047 00048 # include "defines.h" /* Machine dependent ifdefs */ 00049 00050 # include "host.m" /* Host machine dependent macros.*/ 00051 # include "host.h" /* Host machine dependent header.*/ 00052 # include "target.m" /* Target machine dependent macros.*/ 00053 # include "target.h" /* Target machine dependent header.*/ 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 |* function prototypes of static functions declared in this file *| 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 |* Description: *| 00114 |* Parse conditional compilation statements. *| 00115 |* *| 00116 |* Input parameters: *| 00117 |* NONE *| 00118 |* *| 00119 |* Output parameters: *| 00120 |* NONE *| 00121 |* *| 00122 |* Returns: *| 00123 |* NOTHING *| 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 /* issue message about redefinition */ 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 /* blk ok, change curr block to else block */ 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 /* blk_stk error */ 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 /* blk ok, change curr block to else block */ 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 /* blk error */ 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 /* blk ok, pop off the block */ 00320 00321 POP_CC_BLK_STK; 00322 00323 } 00324 else { 00325 /* blk error */ 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 /* Include file name length exceeds maximum. */ 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) { /* Include file name missing. */ 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) { /* Missing delimiter on include file name*/ 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 { /* check for comments */ 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 /* enter it in the symbol table for now BHJ */ 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 /* error, can't continue error line */ 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 /* this is a pound line directive coming in. Ftpp just ignored */ 00623 /* these, so I will too. */ 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 } /* parse_cc_line */ 00651 00652 /******************************************************************************\ 00653 |* *| 00654 |* Description: *| 00655 |* <description> *| 00656 |* *| 00657 |* Input parameters: *| 00658 |* NONE *| 00659 |* *| 00660 |* Output parameters: *| 00661 |* NONE *| 00662 |* *| 00663 |* Returns: *| 00664 |* NOTHING *| 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 /* macro with arguments. */ 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 /* swallow RPAREN */ 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 /* recursive macro definition */ 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 /* recursive macro definition */ 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 } /* parse_define_str */ 00870 00871 /******************************************************************************\ 00872 |* *| 00873 |* Description: *| 00874 |* <description> *| 00875 |* *| 00876 |* Input parameters: *| 00877 |* NONE *| 00878 |* *| 00879 |* Output parameters: *| 00880 |* NONE *| 00881 |* *| 00882 |* Returns: *| 00883 |* NOTHING *| 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 /* don't count comments */ 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 /* macro argument insertion point */ 00921 /* skip ahead 3 chars */ 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 /* comment */ 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 } /* copy_define_str */ 01005 01006 /******************************************************************************\ 01007 |* *| 01008 |* Description: *| 01009 |* <description> *| 01010 |* *| 01011 |* Input parameters: *| 01012 |* NONE *| 01013 |* *| 01014 |* Output parameters: *| 01015 |* NONE *| 01016 |* *| 01017 |* Returns: *| 01018 |* NOTHING *| 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 /* just parse through this, it is evaluated later */ 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 } /* scan_cc_line */ 01133 01134 /******************************************************************************\ 01135 |* *| 01136 |* Description: *| 01137 |* <description> *| 01138 |* *| 01139 |* Input parameters: *| 01140 |* NONE *| 01141 |* *| 01142 |* Output parameters: *| 01143 |* NONE *| 01144 |* *| 01145 |* Returns: *| 01146 |* NOTHING *| 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 /* advance to next line */ 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 } /* cc_advance_idx */ 01203 01204 /******************************************************************************\ 01205 |* *| 01206 |* Description: *| 01207 |* <description> *| 01208 |* *| 01209 |* Input parameters: *| 01210 |* NONE *| 01211 |* *| 01212 |* Output parameters: *| 01213 |* NONE *| 01214 |* *| 01215 |* Returns: *| 01216 |* NOTHING *| 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 /* reset line type for now */ 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 } /* scan_fixed_comment */ 01307 01308 /******************************************************************************\ 01309 |* *| 01310 |* Description: *| 01311 |* <description> *| 01312 |* *| 01313 |* Input parameters: *| 01314 |* NONE *| 01315 |* *| 01316 |* Output parameters: *| 01317 |* NONE *| 01318 |* *| 01319 |* Returns: *| 01320 |* NOTHING *| 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 } /* scan_fortran_stmt */ 01427 01428 /******************************************************************************\ 01429 |* *| 01430 |* Description: *| 01431 |* <description> *| 01432 |* *| 01433 |* Input parameters: *| 01434 |* NONE *| 01435 |* *| 01436 |* Output parameters: *| 01437 |* NONE *| 01438 |* *| 01439 |* Returns: *| 01440 |* NOTHING *| 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 /* 18Jan01[sos]: compute num_chars accounting for ending '\0' */ 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 } /* alloc_arg_entry */ 01470 01471 /******************************************************************************\ 01472 |* *| 01473 |* Description: *| 01474 |* <description> *| 01475 |* *| 01476 |* Input parameters: *| 01477 |* NONE *| 01478 |* *| 01479 |* Output parameters: *| 01480 |* NONE *| 01481 |* *| 01482 |* Returns: *| 01483 |* NOTHING *| 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 } /* free_arg_entry */ 01502 01503 /******************************************************************************\ 01504 |* *| 01505 |* Description: *| 01506 |* <description> *| 01507 |* *| 01508 |* Input parameters: *| 01509 |* NONE *| 01510 |* *| 01511 |* Output parameters: *| 01512 |* NONE *| 01513 |* *| 01514 |* Returns: *| 01515 |* NOTHING *| 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 /* macro with arguments. */ 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 /* not enough args */ 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 /* too many args */ 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 /* determine macro length */ 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 /* cc_stmt_buf_idx is the end of replacement */ 01653 /* id_start_idx is the start of replacement */ 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 } /* scan_cc_macro */ 01702 01703 /******************************************************************************\ 01704 |* *| 01705 |* Description: *| 01706 |* <description> *| 01707 |* *| 01708 |* Input parameters: *| 01709 |* NONE *| 01710 |* *| 01711 |* Output parameters: *| 01712 |* NONE *| 01713 |* *| 01714 |* Returns: *| 01715 |* NOTHING *| 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 /* macro with arguments. */ 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 /* not enough args */ 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 /* too many args */ 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 } /* scan_fortran_macro */ 01879 01880 /******************************************************************************\ 01881 |* *| 01882 |* Description: *| 01883 |* <description> *| 01884 |* *| 01885 |* Input parameters: *| 01886 |* NONE *| 01887 |* *| 01888 |* Output parameters: *| 01889 |* NONE *| 01890 |* *| 01891 |* Returns: *| 01892 |* NOTHING *| 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 /* initialize cc_initial_token used to initialize token */ 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; /* Zero word */ 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; /* Ones word */ 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 } /* init_cond_comp */ 01941 01942 /******************************************************************************\ 01943 |* *| 01944 |* Description: *| 01945 |* <description> *| 01946 |* *| 01947 |* Input parameters: *| 01948 |* NONE *| 01949 |* *| 01950 |* Output parameters: *| 01951 |* NONE *| 01952 |* *| 01953 |* Returns: *| 01954 |* NOTHING *| 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 |* These are dynamic predefined macros. *| 01978 |* Enter them without a string and save *| 01979 |* the index in global variables. *| 01980 \****************************************/ 01981 01982 /************\ 01983 |* __line__ *| 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 /* error, cannot be redefined */ 02005 } 02006 02007 /************\ 02008 |* __LINE__ *| 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 /* error, cannot be redefined */ 02030 } 02031 02032 /************\ 02033 |* __file__ *| 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 /* error, cannot be redefined */ 02055 } 02056 02057 /************\ 02058 |* __FILE__ *| 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 /* error, cannot be redefined */ 02080 } 02081 02082 /************\ 02083 |* __date__ *| 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 /* error, cannot be redefined */ 02105 } 02106 02107 /************\ 02108 |* __DATE__ *| 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 /* error, cannot be redefined */ 02130 } 02131 02132 /************\ 02133 |* __time__ *| 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 /* error, cannot be redefined */ 02155 } 02156 02157 /************\ 02158 |* __TIME__ *| 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 /* error, cannot be redefined */ 02180 } 02181 02182 02183 # ifdef _UNICOS 02184 02185 /*********************\ 02186 |* Predefine _UNICOS *| 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 |* Predefine unix *| 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 |* Predefine __unix *| 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 /* Define cray, _CRAY, and CRAY if the target is a PVP or MPP. */ 02257 02258 /******************\ 02259 |* Predefine cray *| 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 |* Predefine CRAY *| 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 |* Predefine _CRAY *| 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 |* Predefine _MEMSIZE *| 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 |* Predefine _CRAYC90 *| 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 |* Predefine _MAXVL to 128 *| 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 |* Predefine _CRAYT90 *| 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 |* Predefine _MAXVL to 128 *| 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 |* Predefine _ADDR64 *| 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 |* Predefine _MAXVL to 64 *| 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 |* Predefine YMP *| 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 |* Predefine _ADDR32 *| 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 |* Predefine _CRAYIEEE *| 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 |* Predefine _CRAYMPP *| 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 |* Predefine CRAY-T3D or CRAY-T3E *| 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 |* Predefine _CRAYIEEE *| 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 |* Predefine _ADDR64 *| 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 } /* enter_predefined_macros */ 02726 02727 02728 /******************************************************************************\ 02729 |* *| 02730 |* Description: *| 02731 |* <description> *| 02732 |* *| 02733 |* Input parameters: *| 02734 |* NONE *| 02735 |* *| 02736 |* Output parameters: *| 02737 |* NONE *| 02738 |* *| 02739 |* Returns: *| 02740 |* NOTHING *| 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 /* see if it is a keyword */ 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 /* possibly either oct or hex */ 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 /* just swallow it for now */ 02896 CC_NEXT_LA_CH; 02897 02898 if (CC_LA_CH_VALUE == 'U' || 02899 CC_LA_CH_VALUE == 'u') { 02900 /* just swallow it for now */ 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 /* just swallow it for now */ 02909 CC_NEXT_LA_CH; 02910 its_unsigned = TRUE; 02911 02912 if (CC_LA_CH_VALUE == 'L' || 02913 CC_LA_CH_VALUE == 'l') { 02914 /* just swallow it for now */ 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 } /* end switch */ 03065 03066 } 03067 03068 TRACE (Func_Exit, "cc_get_token", NULL); 03069 03070 return; 03071 03072 } /* cc_get_token */ 03073 03074 /******************************************************************************\ 03075 |* *| 03076 |* Description: *| 03077 |* <description> *| 03078 |* *| 03079 |* Input parameters: *| 03080 |* NONE *| 03081 |* *| 03082 |* Output parameters: *| 03083 |* NONE *| 03084 |* *| 03085 |* Returns: *| 03086 |* NOTHING *| 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 /* skip any leading white space */ 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 /* this is a comment */ 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 } /* cc_get_next_char */ 03147 03148 /******************************************************************************\ 03149 |* *| 03150 |* Description: *| 03151 |* <description> *| 03152 |* *| 03153 |* Input parameters: *| 03154 |* NONE *| 03155 |* *| 03156 |* Output parameters: *| 03157 |* NONE *| 03158 |* *| 03159 |* Returns: *| 03160 |* NOTHING *| 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 /* not in character context. */ 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 /* this is a comment */ 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 /* print blank line */ 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 /* print blank line */ 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 /* print blank line */ 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 } /* cc_get_stmt */ 03367 03368 /******************************************************************************\ 03369 |* *| 03370 |* Description: *| 03371 |* BNF level-5-expr { defined-binary-op level-5-expr } *| 03372 |* *| 03373 |* Input parameters: *| 03374 |* NONE *| 03375 |* *| 03376 |* Output parameters: *| 03377 |* NONE *| 03378 |* *| 03379 |* Returns: *| 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 } /* parse_cc_expr */ 03403 03404 /******************************************************************************\ 03405 |* *| 03406 |* Description: *| 03407 |* BNF [not-op] level-5-expr *| 03408 |* *| 03409 |* Input parameters: *| 03410 |* NONE *| 03411 |* *| 03412 |* Output parameters: *| 03413 |* NONE *| 03414 |* *| 03415 |* Returns: *| 03416 |* NOTHING *| 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 } /* parse_cc_mult_opnd */ 03473 03474 /******************************************************************************\ 03475 |* *| 03476 |* Description: *| 03477 |* BNF opnd {mult-op opnd} *| 03478 |* *| 03479 |* Input parameters: *| 03480 |* NONE *| 03481 |* *| 03482 |* Output parameters: *| 03483 |* NONE *| 03484 |* *| 03485 |* Returns: *| 03486 |* NOTHING *| 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 } /* parse_cc_add_opnd */ 03570 03571 /******************************************************************************\ 03572 |* *| 03573 |* Description: *| 03574 |* BNF [add-op] add-opnd {add-op add-opnd} *| 03575 |* *| 03576 |* Input parameters: *| 03577 |* NONE *| 03578 |* *| 03579 |* Output parameters: *| 03580 |* NONE *| 03581 |* *| 03582 |* Returns: *| 03583 |* NOTHING *| 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 } /* parse_cc_level_2 */ 03634 03635 /******************************************************************************\ 03636 |* *| 03637 |* Description: *| 03638 |* BNF shift-opnd {shift-op shift-opnd} *| 03639 |* *| 03640 |* Input parameters: *| 03641 |* NONE *| 03642 |* *| 03643 |* Output parameters: *| 03644 |* NONE *| 03645 |* *| 03646 |* Returns: *| 03647 |* NOTHING *| 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 } /* parse_cc_level_3 */ 03692 03693 /******************************************************************************\ 03694 |* *| 03695 |* Description: *| 03696 |* BNF [level-2-expr rel-op] level-2-expr *| 03697 |* *| 03698 |* Input parameters: *| 03699 |* NONE *| 03700 |* *| 03701 |* Output parameters: *| 03702 |* NONE *| 03703 |* *| 03704 |* Returns: *| 03705 |* NOTHING *| 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 } /* parse_cc_level_4 */ 03759 03760 /******************************************************************************\ 03761 |* *| 03762 |* Description: *| 03763 |* BNF [level-4-expr rel-op] level-4-expr *| 03764 |* *| 03765 |* Input parameters: *| 03766 |* NONE *| 03767 |* *| 03768 |* Output parameters: *| 03769 |* NONE *| 03770 |* *| 03771 |* Returns: *| 03772 |* NOTHING *| 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 } /* parse_cc_level_5 */ 03818 03819 /******************************************************************************\ 03820 |* *| 03821 |* Description: *| 03822 |* BNF and_opnd { and_op and_opnd } *| 03823 |* *| 03824 |* Input parameters: *| 03825 |* NONE *| 03826 |* *| 03827 |* Output parameters: *| 03828 |* NONE *| 03829 |* *| 03830 |* Returns: *| 03831 |* NOTHING *| 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 } /* parse_cc_or_opnd */ 03869 03870 /******************************************************************************\ 03871 |* *| 03872 |* Description: *| 03873 |* BNF equiv-opnd { equiv-op equiv-opnd } *| 03874 |* *| 03875 |* Input parameters: *| 03876 |* NONE *| 03877 |* *| 03878 |* Output parameters: *| 03879 |* NONE *| 03880 |* *| 03881 |* Returns: *| 03882 |* NOTHING *| 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 } /* parse_cc_level_6 */ 03920 03921 /******************************************************************************\ 03922 |* *| 03923 |* Description: *| 03924 |* BNF or_opnd { or_op or_opnd } *| 03925 |* *| 03926 |* Input parameters: *| 03927 |* NONE *| 03928 |* *| 03929 |* Output parameters: *| 03930 |* NONE *| 03931 |* *| 03932 |* Returns: *| 03933 |* NOTHING *| 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 03967 TRACE (Func_Exit, "parse_cc_equiv_opnd", NULL); 03968 03969 return(parsed_ok); 03970 } /* parse_cc_equiv_opnd */ 03971 03972 /******************************************************************************\ 03973 |* *| 03974 |* Description: *| 03975 |* BNF and_opnd { and_op and_opnd } *| 03976 |* *| 03977 |* Input parameters: *| 03978 |* NONE *| 03979 |* *| 03980 |* Output parameters: *| 03981 |* NONE *| 03982 |* *| 03983 |* Returns: *| 03984 |* NOTHING *| 03985 |* *| 03986 \******************************************************************************/ 03987 03988 static boolean parse_cc_level_7(opnd_type *result) 03989 03990 { 03991 int ir_idx; 03992 opnd_type opnd; 03993 boolean parsed_ok = TRUE; 03994 03995 TRACE (Func_Entry, "parse_cc_level_7", NULL); 03996 03997 parsed_ok = parse_cc_equiv_opnd(&opnd); 03998 03999 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_And) { 04000 04001 NTR_IR_TBL(ir_idx); 04002 IR_OPR(ir_idx) = And_Opr; 04003 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token); 04004 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token); 04005 04006 COPY_OPND(IR_OPND_L(ir_idx), opnd) 04007 04008 parsed_ok = parse_cc_equiv_opnd(&opnd) && parsed_ok; 04009 04010 COPY_OPND(IR_OPND_R(ir_idx), opnd) 04011 04012 OPND_FLD(opnd) = IR_Tbl_Idx; 04013 OPND_IDX(opnd) = ir_idx; 04014 } 04015 04016 COPY_OPND((*result), opnd) 04017 04018 TRACE (Func_Exit, "parse_cc_level_7", NULL); 04019 04020 return(parsed_ok); 04021 } /* parse_cc_level_7 */ 04022 04023 /******************************************************************************\ 04024 |* *| 04025 |* Description: *| 04026 |* BNF or_opnd { or_op or_opnd } *| 04027 |* *| 04028 |* Input parameters: *| 04029 |* NONE *| 04030 |* *| 04031 |* Output parameters: *| 04032 |* NONE *| 04033 |* *| 04034 |* Returns: *| 04035 |* NOTHING *| 04036 |* *| 04037 \******************************************************************************/ 04038 04039 static boolean parse_cc_level_8(opnd_type *result) 04040 04041 { 04042 int ir_idx; 04043 opnd_type opnd; 04044 boolean parsed_ok = TRUE; 04045 04046 TRACE (Func_Entry, "parse_cc_level_8", NULL); 04047 04048 parsed_ok = parse_cc_level_7(&opnd); 04049 04050 while (TOKEN_VALUE(cc_token) == Cc_Tok_Op_Or) { 04051 04052 NTR_IR_TBL(ir_idx); 04053 IR_OPR(ir_idx) = Or_Opr; 04054 IR_LINE_NUM(ir_idx) = TOKEN_LINE(cc_token); 04055 IR_COL_NUM(ir_idx) = TOKEN_COLUMN(cc_token); 04056 04057 COPY_OPND(IR_OPND_L(ir_idx), opnd) 04058 04059 parsed_ok = parse_cc_level_7(&opnd) && parsed_ok; 04060 04061 COPY_OPND(IR_OPND_R(ir_idx), opnd) 04062 04063 OPND_FLD(opnd) = IR_Tbl_Idx; 04064 OPND_IDX(opnd) = ir_idx; 04065 } 04066 04067 COPY_OPND((*result), opnd) 04068 04069 TRACE (Func_Exit, "parse_cc_level_8", NULL); 04070 04071 return(parsed_ok); 04072 } /* parse_cc_level_8 */ 04073 04074 /******************************************************************************\ 04075 |* *| 04076 |* Description: *| 04077 |* <description> *| 04078 |* *| 04079 |* Input parameters: *| 04080 |* NONE *| 04081 |* *| 04082 |* Output parameters: *| 04083 |* NONE *| 04084 |* *| 04085 |* Returns: *| 04086 |* NOTHING *| 04087 |* *| 04088 \******************************************************************************/ 04089 static boolean parse_cc_operand (opnd_type *the_opnd) 04090 04091 { 04092 int attr_idx; 04093 int col; 04094 int ir_idx; 04095 int line; 04096 int name_idx; 04097 int paren_cnt = 0; 04098 boolean parsed_ok = TRUE; 04099 04100 04101 TRACE (Func_Entry, "parse_cc_operand", NULL); 04102 04103 if (CC_LA_CH_VALUE == '(' ) { 04104 04105 line = CC_LA_CH_LINE; 04106 col = CC_LA_CH_COLUMN; 04107 04108 CC_NEXT_LA_CH; /* swallow ( */ 04109 04110 if (!parse_cc_expr(the_opnd)) { 04111 parsed_ok = FALSE; 04112 } 04113 else if (CC_LA_CH_VALUE == ')') { 04114 /* insert paren_opr */ 04115 NTR_IR_TBL(ir_idx); 04116 IR_OPR(ir_idx) = Paren_Opr; 04117 COPY_OPND(IR_OPND_L(ir_idx), (*the_opnd)); 04118 OPND_FLD((*the_opnd)) = IR_Tbl_Idx; 04119 OPND_IDX((*the_opnd)) = ir_idx; 04120 IR_LINE_NUM(ir_idx) = line; 04121 IR_COL_NUM(ir_idx) = col; 04122 04123 CC_NEXT_LA_CH; /* swallow ) */ 04124 goto EXIT; 04125 } 04126 else { 04127 /* unmatched paranthesis */ 04128 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error, 04129 CC_LA_CH_COLUMN, 04130 ")", 04131 0, 04132 STR_ARG); 04133 parsed_ok = FALSE; 04134 flush_cc_line(); 04135 } 04136 goto EXIT; 04137 } 04138 else if (CC_LA_CH_CLASS == Ch_Class_Digit || 04139 CC_LA_CH_CLASS == Ch_Class_Letter || 04140 CC_LA_CH_VALUE == underscore) { 04141 04142 cc_get_token(TRUE); 04143 04144 OPND_LINE_NUM((*the_opnd)) = TOKEN_LINE(cc_token); 04145 OPND_COL_NUM((*the_opnd)) = TOKEN_COLUMN(cc_token); 04146 OPND_FLD((*the_opnd)) = CN_Tbl_Idx; 04147 04148 switch (TOKEN_VALUE(cc_token)) { 04149 04150 case Cc_Tok_Id : 04151 case Cc_Tok_Kwd_Define : 04152 case Cc_Tok_Kwd_Elif : 04153 case Cc_Tok_Kwd_Else : 04154 case Cc_Tok_Kwd_Endif : 04155 case Cc_Tok_Kwd_If : 04156 case Cc_Tok_Kwd_Ifdef : 04157 case Cc_Tok_Kwd_Ifndef : 04158 case Cc_Tok_Kwd_Include : 04159 case Cc_Tok_Kwd_Undef : 04160 04161 /* all of these are identifiers. They can't be defined or */ 04162 /* the scan would have replaced them already. Replace them */ 04163 /* with a 0. */ 04164 04165 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token), 04166 TOKEN_LEN(cc_token), 04167 &name_idx); 04168 04169 if (attr_idx != NULL_IDX && 04170 CC_AT_DEFINED(attr_idx)) { 04171 04172 PRINTMSG(TOKEN_LINE(cc_token), 626, Internal, 04173 TOKEN_COLUMN(cc_token), 04174 "defined macro to be replaced", "parse_cc_operand"); 04175 04176 } 04177 04178 OPND_IDX((*the_opnd)) = C_INT_TO_CN(CG_INTEGER_DEFAULT_TYPE, 0); 04179 break; 04180 04181 case Cc_Tok_Constant : 04182 04183 OPND_IDX((*the_opnd)) = TOKEN_CONST_TBL_IDX(cc_token); 04184 break; 04185 04186 case Cc_Tok_Kwd_Defined : 04187 04188 while (CC_LA_CH_VALUE == '(') { 04189 paren_cnt++; 04190 CC_NEXT_LA_CH; 04191 } 04192 04193 cc_get_token(FALSE); 04194 04195 if (TOKEN_VALUE(cc_token) != Tok_Id) { 04196 ntr_next_msg_queue(TOKEN_LINE(cc_token), 1165, Error, 04197 TOKEN_COLUMN(cc_token), 04198 "IDENTIFIER", 04199 0, 04200 STR_ARG); 04201 parsed_ok = FALSE; 04202 flush_cc_line(); 04203 } 04204 else { 04205 04206 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token), 04207 TOKEN_LEN(cc_token), 04208 &name_idx); 04209 04210 04211 if (attr_idx != NULL_IDX && 04212 CC_AT_DEFINED(attr_idx)) { 04213 04214 /* defined, replace with 1 */ 04215 OPND_IDX((*the_opnd)) = CN_INTEGER_ONE_IDX; 04216 } 04217 else { 04218 /* else, replace with 0 */ 04219 OPND_IDX((*the_opnd)) = CN_INTEGER_ZERO_IDX; 04220 } 04221 } 04222 04223 while (paren_cnt) { 04224 if (CC_LA_CH_VALUE != ')') { 04225 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error, 04226 CC_LA_CH_COLUMN, 04227 ")", 04228 0, 04229 STR_ARG); 04230 parsed_ok = FALSE; 04231 flush_cc_line(); 04232 break; 04233 } 04234 else { 04235 CC_NEXT_LA_CH; 04236 paren_cnt--; 04237 } 04238 } 04239 04240 break; 04241 } 04242 } 04243 else { 04244 ntr_next_msg_queue(CC_LA_CH_LINE, 1165, Error, 04245 CC_LA_CH_COLUMN, 04246 "identifier or integer constant", 04247 0, 04248 STR_ARG); 04249 parsed_ok = FALSE; 04250 flush_cc_line(); 04251 } 04252 04253 EXIT: 04254 TRACE (Func_Exit, "parse_cc_operand", NULL); 04255 04256 return(parsed_ok); 04257 04258 } /* parse_cc_operand */ 04259 04260 /******************************************************************************\ 04261 |* *| 04262 |* Description: *| 04263 |* <description> *| 04264 |* *| 04265 |* Input parameters: *| 04266 |* NONE *| 04267 |* *| 04268 |* Output parameters: *| 04269 |* NONE *| 04270 |* *| 04271 |* Returns: *| 04272 |* NOTHING *| 04273 |* *| 04274 \******************************************************************************/ 04275 04276 static int srch_cc_sym_tbl (char *name_str, 04277 int name_len, 04278 int *name_idx) 04279 04280 { 04281 int idx; 04282 long tst_val; 04283 04284 04285 TRACE (Func_Entry, "srch_cc_sym_tbl", name_str); 04286 04287 tst_val = srch_name_tbl(name_str, 04288 name_len, 04289 &idx, 04290 cc_ln_tbl, 04291 str_pool, 04292 cc_ln_fw_idx, 04293 cc_ln_lw_idx); 04294 04295 *name_idx = idx; 04296 04297 if (tst_val != 0) { 04298 idx = NULL_IDX; 04299 TRACE (Func_Exit, "srch_cc_sym_tbl", NULL); 04300 } 04301 else { 04302 TRACE (Func_Exit, "srch_cc_sym_tbl", 04303 &str_pool[CC_LN_NAME_IDX(idx)].name_char); 04304 idx = CC_LN_ATTR_IDX(idx); 04305 } 04306 return (idx); 04307 04308 } /* srch_cc_sym_tbl */ 04309 04310 /******************************************************************************\ 04311 |* *| 04312 |* Description: *| 04313 |* ntr_cc_sym_tbl adds the token name to the the name pool, links it *| 04314 |* to an attribute table entry through the local name table, and *| 04315 |* reserves an attribute table entry for the identifier or label. *| 04316 |* The attribute table entry field name_idx is linked to the name in *| 04317 |* the name pool. *| 04318 |* *| 04319 |* Input parameters: *| 04320 |* token token containing identifier or label and *| 04321 |* length of name to be added to symbol table *| 04322 |* *| 04323 |* name_idx local name table index where entry is to *| 04324 |* be inserted *| 04325 |* *| 04326 |* Output parameters: *| 04327 |* NONE *| 04328 |* *| 04329 |* Returns: *| 04330 |* attribute table index of reserved entry *| 04331 |* *| 04332 \******************************************************************************/ 04333 04334 static int ntr_cc_sym_tbl(cc_token_type *token, 04335 int name_idx) 04336 04337 { 04338 register int attr_idx; 04339 register int i; 04340 register int np_idx; 04341 04342 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 04343 register long *name_tbl_base; /* name table base address */ 04344 # endif 04345 04346 04347 TRACE (Func_Entry, "ntr_cc_sym_tbl", TOKEN_STR(*token)); 04348 04349 TBL_REALLOC_CK(cc_ln_tbl, 1); /* add local name table entry */ 04350 04351 NTR_CC_NAME_POOL((long *) TOKEN_STR(*token), TOKEN_LEN(*token), np_idx); 04352 04353 /* reserve attribute table entry and fill in common definition fields */ 04354 04355 NTR_CC_ATTR_TBL(attr_idx); 04356 CC_AT_NAME_LEN(attr_idx) = TOKEN_LEN(*token); 04357 CC_AT_NAME_IDX(attr_idx) = np_idx; 04358 04359 cc_ln_lw_idx = cc_ln_tbl_idx; 04360 04361 /* Enter name in correct position. Link name pool and attribute table */ 04362 04363 04364 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 04365 04366 name_tbl_base = (long *) cc_ln_tbl; 04367 04368 for (i = cc_ln_tbl_idx; i >= name_idx; i--) { 04369 name_tbl_base [i] = name_tbl_base [i-1]; 04370 } 04371 # else 04372 04373 for (i = cc_ln_tbl_idx; i >= name_idx; i--) { 04374 cc_ln_tbl [i] = cc_ln_tbl [i-1]; 04375 } 04376 # endif 04377 04378 CLEAR_TBL_NTRY(cc_ln_tbl, name_idx); 04379 CC_LN_ATTR_IDX(name_idx) = attr_idx; 04380 CC_LN_NAME_IDX(name_idx) = np_idx; 04381 CC_LN_NAME_LEN(name_idx) = TOKEN_LEN(*token); 04382 04383 TRACE (Func_Exit, "ntr_cc_sym_tbl", TOKEN_STR(*token)); 04384 04385 return (attr_idx); 04386 04387 } /* ntr_cc_sym_tbl */ 04388 04389 /******************************************************************************\ 04390 |* *| 04391 |* Description: *| 04392 |* <description> *| 04393 |* *| 04394 |* Input parameters: *| 04395 |* NONE *| 04396 |* *| 04397 |* Output parameters: *| 04398 |* NONE *| 04399 |* *| 04400 |* Returns: *| 04401 |* NOTHING *| 04402 |* *| 04403 \******************************************************************************/ 04404 04405 static void flush_cc_line(void) 04406 04407 { 04408 int col; 04409 int line; 04410 04411 TRACE (Func_Entry, "flush_cc_line", NULL); 04412 04413 cc_stmt_buf_idx = cc_stmt_buf_len; 04414 04415 find_line_and_col(cc_stmt_buf_idx, &line, &col); 04416 CC_LA_CH_VALUE = eos; 04417 CC_LA_CH_LINE = line; 04418 CC_LA_CH_COLUMN = col; 04419 CC_LA_CH_CLASS = ch_class[CC_LA_CH_VALUE]; 04420 04421 cc_get_token(FALSE); 04422 04423 TRACE (Func_Exit, "flush_cc_line", NULL); 04424 04425 return; 04426 04427 } /* flush_cc_line */ 04428 04429 /******************************************************************************\ 04430 |* *| 04431 |* Description: *| 04432 |* Handle the command line -D option by putting the define in the table. *| 04433 |* *| 04434 |* Input parameters: *| 04435 |* NONE *| 04436 |* *| 04437 |* Output parameters: *| 04438 |* NONE *| 04439 |* *| 04440 |* Returns: *| 04441 |* NOTHING *| 04442 |* *| 04443 \******************************************************************************/ 04444 04445 boolean enter_cmd_line_cc_define(char *str, 04446 char *value, 04447 boolean is_define) 04448 04449 { 04450 int attr_idx; 04451 int idx; 04452 int name_idx; 04453 boolean ok = TRUE; 04454 int tidx; 04455 04456 TRACE (Func_Entry, "enter_cmd_line_cc_define", NULL); 04457 04458 idx = 0; 04459 while (str[idx] == ' ' || str[idx] == '\t') { 04460 idx++; 04461 } 04462 04463 tidx = 0; 04464 04465 if (ch_class[str[idx]] == Ch_Class_Letter || 04466 str[idx] == underscore) { 04467 04468 cc_token = cc_initial_token; 04469 04470 while (ch_class[str[idx]] == Ch_Class_Letter || 04471 ch_class[str[idx]] == Ch_Class_Digit || 04472 str[idx] == underscore || 04473 str[idx] == dollar || 04474 str[idx] == at_sign) { 04475 04476 (TOKEN_STR(cc_token))[tidx] = str[idx]; 04477 tidx++; 04478 idx++; 04479 } 04480 04481 TOKEN_LEN(cc_token) = tidx; 04482 04483 attr_idx = srch_cc_sym_tbl(TOKEN_STR(cc_token), 04484 TOKEN_LEN(cc_token), 04485 &name_idx); 04486 04487 if (attr_idx == NULL_IDX) { 04488 attr_idx = ntr_cc_sym_tbl(&cc_token, name_idx); 04489 } 04490 04491 if (is_define) { 04492 CC_AT_DEFINED(attr_idx) = TRUE; 04493 04494 if (value != NULL) { 04495 strcpy(temp_id_str.string, value); 04496 CC_AT_STR_LEN(attr_idx) = strlen(temp_id_str.string); 04497 NTR_CC_NAME_POOL(temp_id_str.words, CC_AT_STR_LEN(attr_idx), 04498 CC_AT_STR_IDX(attr_idx)); 04499 } 04500 else { 04501 PUT_VALUE_IN_AT_STR(attr_idx, 1); 04502 } 04503 } 04504 else { 04505 CC_AT_DEFINED(attr_idx) = FALSE; 04506 } 04507 } 04508 else { 04509 ok = FALSE; 04510 } 04511 04512 04513 TRACE (Func_Exit, "enter_cmd_line_cc_define", NULL); 04514 04515 return(ok); 04516 04517 } /* enter_cmd_line_cc_define */ 04518 04519 /******************************************************************************\ 04520 |* *| 04521 |* Description: *| 04522 |* <description> *| 04523 |* *| 04524 |* Input parameters: *| 04525 |* NONE *| 04526 |* *| 04527 |* Output parameters: *| 04528 |* NONE *| 04529 |* *| 04530 |* Returns: *| 04531 |* NOTHING *| 04532 |* *| 04533 \******************************************************************************/ 04534 04535 static int fold_cc_expr(opnd_type *opnd) 04536 04537 { 04538 int l_value; 04539 int ir_idx; 04540 opnd_type loc_opnd; 04541 int r_value; 04542 long result; 04543 04544 TRACE (Func_Entry, "fold_cc_expr", NULL); 04545 04546 switch (OPND_FLD((*opnd))) { 04547 case CN_Tbl_Idx : 04548 result = (long) CN_INT_TO_C(OPND_IDX((*opnd))); 04549 break; 04550 04551 case IR_Tbl_Idx : 04552 ir_idx = OPND_IDX((*opnd)); 04553 04554 COPY_OPND(loc_opnd, IR_OPND_L(ir_idx)); 04555 04556 l_value = fold_cc_expr(&loc_opnd); 04557 04558 if (IR_FLD_R(ir_idx) != NO_Tbl_Idx) { 04559 COPY_OPND(loc_opnd, IR_OPND_R(ir_idx)); 04560 04561 r_value = fold_cc_expr(&loc_opnd); 04562 } 04563 04564 switch (IR_OPR(ir_idx)) { 04565 case Uplus_Opr : 04566 result = l_value; 04567 break; 04568 04569 case Uminus_Opr : 04570 result = -l_value; 04571 break; 04572 04573 case Plus_Opr : 04574 result = l_value + r_value; 04575 break; 04576 04577 case Minus_Opr : 04578 result = l_value - r_value; 04579 break; 04580 04581 case Div_Opr : 04582 result = l_value / r_value; 04583 break; 04584 04585 case Mod_Opr : 04586 result = l_value % r_value; 04587 break; 04588 04589 case Mult_Opr : 04590 result = l_value * r_value; 04591 break; 04592 04593 case Not_Opr : 04594 result = (l_value != 0 ? 0 : 1); 04595 break; 04596 04597 case Bnot_Opr : 04598 result = ~l_value; 04599 break; 04600 04601 case Ne_Opr : 04602 result = (l_value != r_value ? 1 : 0); 04603 break; 04604 04605 case Eq_Opr : 04606 result = (l_value == r_value ? 1 : 0); 04607 break; 04608 04609 case Lt_Opr : 04610 result = (l_value < r_value ? 1 : 0); 04611 break; 04612 04613 case Le_Opr : 04614 result = (l_value <= r_value ? 1 : 0); 04615 break; 04616 04617 case Gt_Opr : 04618 result = (l_value > r_value ? 1 : 0); 04619 break; 04620 04621 case Ge_Opr : 04622 result = (l_value >= r_value ? 1 : 0); 04623 break; 04624 04625 case Neqv_Opr : 04626 result = l_value ^ r_value; 04627 break; 04628 04629 case And_Opr : 04630 result = (l_value && r_value ? 1 : 0); 04631 break; 04632 04633 case Band_Opr : 04634 result = l_value & r_value; 04635 break; 04636 04637 case Or_Opr : 04638 result = (l_value || r_value ? 1 : 0); 04639 break; 04640 04641 case Bor_Opr : 04642 result = l_value | r_value; 04643 break; 04644 04645 case Shiftl_Opr : 04646 result = l_value << r_value; 04647 break; 04648 04649 case Shiftr_Opr : 04650 result = l_value >> r_value; 04651 break; 04652 04653 case Paren_Opr : 04654 result = l_value; 04655 break; 04656 04657 default: 04658 PRINTMSG(IR_LINE_NUM(ir_idx), 1164, Internal, 04659 IR_COL_NUM(ir_idx), "parse_cc_line"); 04660 break; 04661 } 04662 break; 04663 04664 default: 04665 PRINTMSG(OPND_LINE_NUM((*opnd)), 1164, Internal, 04666 OPND_COL_NUM((*opnd)), "parse_cc_line"); 04667 break; 04668 } 04669 04670 TRACE (Func_Exit, "fold_cc_expr", NULL); 04671 04672 return(result); 04673 04674 } /* fold_cc_expr */ 04675 04676 /******************************************************************************\ 04677 |* *| 04678 |* Description: *| 04679 |* <description> *| 04680 |* *| 04681 |* Input parameters: *| 04682 |* NONE *| 04683 |* *| 04684 |* Output parameters: *| 04685 |* NONE *| 04686 |* *| 04687 |* Returns: *| 04688 |* NOTHING *| 04689 |* *| 04690 \******************************************************************************/ 04691 04692 static void find_line_and_col(int idx, 04693 int *line, 04694 int *col) 04695 04696 { 04697 int i = 1; 04698 04699 TRACE (Func_Entry,"find_line_and_col" , NULL); 04700 04701 if (cc_stmt_buf_num_lines == 1) { 04702 *line = cc_stmt_buf_line[1].line; 04703 *col = idx; 04704 } 04705 else { 04706 for (i = 2; i <= cc_stmt_buf_num_lines+1; i++) { 04707 if (cc_stmt_buf_line[i].start_idx >= idx) { 04708 *line = cc_stmt_buf_line[i-1].line; 04709 *col = idx - cc_stmt_buf_line[i-1].start_idx; 04710 break; 04711 } 04712 } 04713 # ifdef _DEBUG 04714 if (i > cc_stmt_buf_num_lines + 1) { 04715 PRINTMSG(PP_LINE_NUM, 626, Internal, 1, 04716 "valid line num", "find_line_and_col"); 04717 } 04718 # endif 04719 } 04720 04721 04722 TRACE (Func_Exit, "find_line_and_col", NULL); 04723 04724 return; 04725 04726 } /* find_line_and_col */ 04727 04728 /******************************************************************************\ 04729 |* *| 04730 |* Description: *| 04731 |* <description> *| 04732 |* *| 04733 |* Input parameters: *| 04734 |* NONE *| 04735 |* *| 04736 |* Output parameters: *| 04737 |* NONE *| 04738 |* *| 04739 |* Returns: *| 04740 |* NOTHING *| 04741 |* *| 04742 \******************************************************************************/ 04743 04744 static void shift_cc_stmt_buf(int start_idx, 04745 int shift) 04746 04747 { 04748 int i; 04749 04750 TRACE (Func_Entry, "shift_cc_stmt_buf", NULL); 04751 04752 if (shift > 0) { 04753 for (i = cc_stmt_buf_len+1; i >= start_idx; i--) { 04754 cc_stmt_buf[i+shift] = cc_stmt_buf[i]; 04755 } 04756 } 04757 else if (shift < 0) { 04758 for (i = start_idx; i <= cc_stmt_buf_len+1; i++) { 04759 cc_stmt_buf[i+shift] = cc_stmt_buf[i]; 04760 } 04761 } 04762 04763 for (i = 1; i <= cc_stmt_buf_num_lines + 1; i++) { 04764 if (cc_stmt_buf_line[i].start_idx >= start_idx) { 04765 cc_stmt_buf_line[i].start_idx += shift; 04766 } 04767 } 04768 04769 cc_stmt_buf_len += shift; 04770 04771 TRACE (Func_Exit, "shift_cc_stmt_buf", NULL); 04772 04773 return; 04774 04775 } /* shift_cc_stmt_buf */ 04776 04777 /******************************************************************************\ 04778 |* *| 04779 |* Description: *| 04780 |* <description> *| 04781 |* *| 04782 |* Input parameters: *| 04783 |* NONE *| 04784 |* *| 04785 |* Output parameters: *| 04786 |* NONE *| 04787 |* *| 04788 |* Returns: *| 04789 |* NOTHING *| 04790 |* *| 04791 \******************************************************************************/ 04792 04793 static void shift_nxt_line(int start_idx, 04794 int shift) 04795 04796 { 04797 int end_line; 04798 int i; 04799 int curr_line = NULL_IDX; 04800 04801 TRACE (Func_Entry, "shift_nxt_line", NULL); 04802 04803 for (i = 1; i <= nxt_line_num_lines; i++) { 04804 if (start_idx >= nxt_line_start_idx[i] && 04805 start_idx <= nxt_line_end_idx[i]) { 04806 curr_line = i; 04807 break; 04808 } 04809 } 04810 04811 # ifdef _DEBUG 04812 if (start_idx == NULL_IDX) { 04813 PRINTMSG(pp_nxt_line_num[1], 626, Internal, 1, 04814 "valid start_idx", "shift_nxt_line"); 04815 } 04816 # endif 04817 04818 if (extra_nxt_line) { 04819 end_line = extra_nxt_line; 04820 } 04821 else { 04822 end_line = nxt_line_num_lines; 04823 } 04824 04825 if (nxt_line_end_idx[end_line]+shift >= MAX_STMT_CHAR_SIZE) { 04826 PRINTMSG(pp_nxt_line_num[end_line], 1593, Limit, 0); 04827 } 04828 04829 if (shift > 0) { 04830 for (i = nxt_line_end_idx[end_line]; i >= start_idx; i--) { 04831 nxt_line[i+shift] = nxt_line[i]; 04832 nxt_line_col[i+shift] = nxt_line_col[i]; 04833 } 04834 } 04835 else if (shift < 0) { 04836 for (i = start_idx; i <= nxt_line_end_idx[end_line]; i++) { 04837 nxt_line[i+shift] = nxt_line[i]; 04838 nxt_line_col[i+shift] = nxt_line_col[i]; 04839 } 04840 } 04841 04842 nxt_line_end_idx[curr_line] += shift; 04843 pp_nxt_line_length[curr_line] += shift; 04844 pp_nxt_line_EOL[curr_line] += shift; 04845 pp_orig_line_size[curr_line] += shift; 04846 04847 for (i = curr_line + 1; i <= end_line; i++) { 04848 nxt_line_start_idx[i] += shift; 04849 nxt_line_end_idx[i] += shift; 04850 pp_nxt_line_EOL[i] += shift; 04851 } 04852 04853 TRACE (Func_Exit, "shift_nxt_line", NULL); 04854 04855 return; 04856 04857 } /* shift_nxt_line */ 04858 04859 /******************************************************************************\ 04860 |* *| 04861 |* Description: *| 04862 |* <description> *| 04863 |* *| 04864 |* Input parameters: *| 04865 |* NONE *| 04866 |* *| 04867 |* Output parameters: *| 04868 |* NONE *| 04869 |* *| 04870 |* Returns: *| 04871 |* NOTHING *| 04872 |* *| 04873 \******************************************************************************/ 04874 04875 static int expanded_macro_len(int attr_idx, 04876 cc_arg_type *arg_head) 04877 04878 { 04879 int arg_num; 04880 cc_arg_type *arg_tail; 04881 int i; 04882 int len; 04883 04884 TRACE (Func_Entry, "expanded_macro_len", NULL); 04885 04886 len = CC_AT_STR_LEN(attr_idx); 04887 04888 for (i = 0; i < CC_AT_STR_LEN(attr_idx); i++) { 04889 if ((CC_AT_STR_PTR(attr_idx))[i] == '\001') { 04890 i += 2; 04891 arg_num = 1; 04892 arg_tail = arg_head; 04893 while (arg_num != (CC_AT_STR_PTR(attr_idx))[i]) { 04894 arg_tail = arg_tail->next; 04895 arg_num++; 04896 } 04897 04898 len += (arg_tail->name_len - 3); 04899 } 04900 } 04901 04902 TRACE (Func_Exit, "expanded_macro_len", NULL); 04903 04904 return(len); 04905 04906 } /* expanded_macro_len */ 04907 04908 /******************************************************************************\ 04909 |* *| 04910 |* Description: *| 04911 |* <description> *| 04912 |* *| 04913 |* Input parameters: *| 04914 |* NONE *| 04915 |* *| 04916 |* Output parameters: *| 04917 |* NONE *| 04918 |* *| 04919 |* Returns: *| 04920 |* NOTHING *| 04921 |* *| 04922 \******************************************************************************/ 04923 04924 static void insert_macro(int attr_idx, 04925 cc_arg_type *arg_head, 04926 int id_start_idx, 04927 int col, 04928 int save_pp_line_idx) 04929 04930 { 04931 int arg_num; 04932 cc_arg_type *arg_tail; 04933 char *char_ptr; 04934 int i; 04935 int j; 04936 int k; 04937 int len; 04938 int end_idx; 04939 04940 TRACE (Func_Entry, "insert_macro", NULL); 04941 04942 /* cc_stmt_buf_idx is the end of replacement ')' */ 04943 /* id_start_idx is the start of replacement */ 04944 04945 end_idx = cc_stmt_buf_idx + 1; 04946 04947 adjust_continued_macro(id_start_idx, &end_idx); 04948 04949 len = expanded_macro_len(attr_idx, arg_head); 04950 04951 shift_nxt_line(end_idx, 04952 len-(end_idx - id_start_idx)); 04953 04954 char_ptr = CC_AT_STR_PTR(attr_idx); 04955 04956 j = 0; 04957 i = 0; 04958 while (i < len) { 04959 if (char_ptr[j] == '\001') { 04960 j += 2; 04961 arg_num = 1; 04962 arg_tail = arg_head; 04963 while (arg_num != char_ptr[j]) { 04964 arg_tail = arg_tail->next; 04965 arg_num++; 04966 } 04967 04968 for (k = 0; k < arg_tail->name_len; k++) { 04969 nxt_line[i+id_start_idx] = arg_tail->name[k]; 04970 nxt_line_col[i+id_start_idx] = col; 04971 i++; 04972 } 04973 } 04974 else { 04975 nxt_line[i+id_start_idx] = char_ptr[j]; 04976 nxt_line_col[i+id_start_idx] = col; 04977 i++; 04978 } 04979 04980 j++; 04981 } 04982 04983 cc_stmt_buf_idx = id_start_idx + len - 1; 04984 pp_line_idx = save_pp_line_idx; 04985 cc_advance_idx(); 04986 04987 04988 TRACE (Func_Exit, "insert_macro", NULL); 04989 04990 return; 04991 04992 } /* insert_macro */ 04993 04994 /******************************************************************************\ 04995 |* *| 04996 |* Description: *| 04997 |* <description> *| 04998 |* *| 04999 |* Input parameters: *| 05000 |* NONE *| 05001 |* *| 05002 |* Output parameters: *| 05003 |* NONE *| 05004 |* *| 05005 |* Returns: *| 05006 |* NOTHING *| 05007 |* *| 05008 \******************************************************************************/ 05009 05010 static void adjust_continued_macro(int start_idx, 05011 int *end_idx) 05012 05013 { 05014 int start_line = NULL_IDX; 05015 int end_line = NULL_IDX; 05016 int i; 05017 boolean keep_end_line = FALSE; 05018 05019 TRACE (Func_Entry, "adjust_continued_macro", NULL); 05020 05021 for (i = 1; i <= nxt_line_num_lines; i++) { 05022 if (start_idx >= nxt_line_start_idx[i] && 05023 start_idx <= nxt_line_end_idx[i]) { 05024 05025 start_line = i; 05026 } 05027 05028 if (*end_idx >= nxt_line_start_idx[i] && 05029 *end_idx <= nxt_line_end_idx[i]) { 05030 05031 end_line = i; 05032 } 05033 05034 if (start_line != NULL_IDX && end_line != NULL_IDX) { 05035 break; 05036 } 05037 } 05038 05039 if (end_line > start_line) { 05040 /* have continuation */ 05041 05042 for (i = *end_idx; i < pp_nxt_line_EOL[end_line]; i++) { 05043 if (nxt_line[i] != blank && 05044 nxt_line[i] != tab) { 05045 keep_end_line = TRUE; 05046 break; 05047 } 05048 } 05049 05050 if (keep_end_line) { 05051 /* blank out the end_line from nxt_line_idx to end_idx - 1 */ 05052 05053 for (i = pp_nxt_line_idx[end_line]+1; i < *end_idx; i++) { 05054 nxt_line[i] = blank; 05055 } 05056 05057 /* change end_line to the previous line */ 05058 05059 end_line--; 05060 } 05061 05062 *end_idx = pp_nxt_line_EOL[end_line]; 05063 05064 /* see if new end_line is still greater than start_line */ 05065 05066 if (end_line > start_line) { 05067 pp_orig_line_size[start_line] += nxt_line_end_idx[end_line] - 05068 nxt_line_end_idx[start_line]; 05069 nxt_line_end_idx[start_line] = nxt_line_end_idx[end_line]; 05070 pp_nxt_line_EOL[start_line] = pp_nxt_line_EOL[end_line]; 05071 pp_nxt_line_length[start_line] = nxt_line_end_idx[start_line] - 05072 nxt_line_start_idx[start_line]; 05073 05074 for (i = end_line + 1; 05075 i <= (extra_nxt_line ? extra_nxt_line : end_stmt_line_idx); 05076 i++) { 05077 nxt_line_start_idx[i-(end_line-start_line)] = nxt_line_start_idx[i]; 05078 nxt_line_end_idx[i-(end_line-start_line)] = nxt_line_end_idx[i]; 05079 pp_orig_line_size[i-(end_line-start_line)] = pp_orig_line_size[i]; 05080 pp_nxt_line_EOL[i-(end_line-start_line)] = pp_nxt_line_EOL[i]; 05081 pp_nxt_line_length[i-(end_line-start_line)] = pp_nxt_line_length[i]; 05082 pp_nxt_line_idx[i-(end_line-start_line)] = pp_nxt_line_idx[i]; 05083 pp_nxt_line_type[i-(end_line-start_line)] = pp_nxt_line_type[i]; 05084 pp_nxt_line_num[i-(end_line-start_line)] = pp_nxt_line_num[i]; 05085 pp_change_source_form[i-(end_line-start_line)] = 05086 pp_change_source_form[i]; 05087 pp_expected_line[i-(end_line-start_line)] = 05088 pp_expected_line[i]; 05089 } 05090 05091 nxt_line_num_lines -= (end_line - start_line); 05092 end_stmt_line_idx -= (end_line - start_line); 05093 05094 if (extra_nxt_line != NULL_IDX) { 05095 extra_nxt_line -= (end_line - start_line); 05096 } 05097 } 05098 } 05099 05100 TRACE (Func_Exit, "adjust_continued_macro", NULL); 05101 05102 return; 05103 05104 } /* adjust_continued_macro */ 05105 05106 /******************************************************************************\ 05107 |* *| 05108 |* Description: *| 05109 |* <description> *| 05110 |* *| 05111 |* Input parameters: *| 05112 |* NONE *| 05113 |* *| 05114 |* Output parameters: *| 05115 |* NONE *| 05116 |* *| 05117 |* Returns: *| 05118 |* NOTHING *| 05119 |* *| 05120 \******************************************************************************/ 05121 05122 static char *get_dynamic_predef_str(int attr_idx, 05123 int line) 05124 05125 { 05126 time_t clock; 05127 int file_line; 05128 int g_idx; 05129 struct tm *tmptr; 05130 05131 static char str[MAX_PATH_NAME_SIZE + 1]; 05132 05133 TRACE (Func_Entry, "get_dynamic_predef_str", NULL); 05134 05135 str[0] = '\0'; 05136 05137 if (attr_idx == line_macro_idx || attr_idx == LINE_macro_idx) { 05138 GLOBAL_LINE_TO_FILE_LINE(line, g_idx, file_line); 05139 sprintf(str, "%d", file_line); 05140 } 05141 else if (attr_idx == file_macro_idx || attr_idx == FILE_macro_idx) { 05142 get_curr_file_name(str); 05143 } 05144 else if (attr_idx == date_macro_idx || attr_idx == DATE_macro_idx) { 05145 clock = time(NULL); 05146 tmptr = localtime(&clock); 05147 sprintf(str, "\"%02d/%02d/%02d\"", 05148 tmptr->tm_mon+1, tmptr->tm_mday, 05149 (tmptr->tm_year % 100)); 05150 05151 } 05152 else if (attr_idx == time_macro_idx || attr_idx == TIME_macro_idx) { 05153 clock = time(NULL); 05154 tmptr = localtime(&clock); 05155 sprintf(str, "\"%02d:%02d:%02d\"", 05156 tmptr->tm_hour, tmptr->tm_min, tmptr->tm_sec); 05157 } 05158 05159 TRACE (Func_Exit, "get_dynamic_predef_str", NULL); 05160 05161 return(str); 05162 05163 } /* get_dynamic_predef_str */
1.7.6.1 
