Print this page
make: unifdef for NSE (undefined)


  99         static pathpt           makefile_path;
 100         register int            n;
 101         char                    *path;
 102         register Source         source = ALLOC(Source);
 103         Property                orig_makefile = makefile;
 104         Dependency              *dpp;
 105         Dependency              dp;
 106         register int            length;
 107         wchar_t                 *previous_file_being_read = file_being_read;
 108         int                     previous_line_number = line_number;
 109         wchar_t                 previous_current_makefile[MAXPATHLEN];
 110         Makefile_type           save_makefile_type;
 111         Name                    normalized_makefile_name;
 112         register wchar_t        *string_start;
 113         register wchar_t        *string_end;
 114 
 115 
 116 
 117         wchar_t * wcb = get_wstring(makefile_name->string_mb);
 118 
 119 #ifdef NSE
 120         if (report_file){
 121                 wscpy(previous_current_makefile, current_makefile);
 122                 wscpy(current_makefile, wcb);
 123         }
 124 #endif 
 125         if (max_include_depth++ >= 40) {
 126                 fatal(catgets(catd, 1, 66, "Too many nested include statements"));
 127         }
 128         if (makefile->body.makefile.contents != NULL) {
 129                 retmem(makefile->body.makefile.contents);
 130         }
 131         source->inp_buf =
 132           source->inp_buf_ptr =
 133             source->inp_buf_end = NULL;
 134         source->error_converting = false;
 135         makefile->body.makefile.contents = NULL;
 136         makefile->body.makefile.size = 0;
 137         if ((makefile_name->hash.length != 1) ||
 138             (wcb[0] != (int) hyphen_char)) {
 139                 if ((makefile->body.makefile.contents == NULL) &&
 140                     (doname_it)) {
 141                         if (makefile_path == NULL) {
 142                                 add_dir_to_path(".",
 143                                                 &makefile_path,
 144                                                 -1);


 390                     source->string.text.p + num_mb_chars;
 391                 num_wc_chars = mbstowcs(source->string.text.p,
 392                                         stdin_text_p,
 393                                         num_mb_chars);
 394                 if ((int) num_wc_chars >= 0) {
 395                         source->string.text.end =
 396                           source->string.text.p + num_wc_chars;
 397                 }
 398                 (void) retmem_mb(stdin_text_p);
 399         }
 400         line_number = 1;
 401         if (trace_reader) {
 402                 (void) printf(catgets(catd, 1, 73, ">>>>>>>>>>>>>>>> Reading makefile %s\n"),
 403                               makefile_name->string_mb);
 404         }
 405         parse_makefile(makefile_name, source);
 406         if (trace_reader) {
 407                 (void) printf(catgets(catd, 1, 74, ">>>>>>>>>>>>>>>> End of makefile %s\n"),
 408                               makefile_name->string_mb);
 409         }
 410 #ifdef NSE
 411         if (report_file && (previous_current_makefile[0] != NULL)) {
 412                 wscpy(current_makefile, previous_current_makefile);
 413         }
 414 #endif
 415         if(file_being_read) {
 416                 retmem(file_being_read);
 417         }
 418         file_being_read = previous_file_being_read;
 419         line_number = previous_line_number;
 420         makefile_type = reading_nothing;
 421         max_include_depth--;
 422         if (make_state_locked) {
 423                 /* Unlock .make.state. */
 424                 unlink(make_state_lockfile);
 425                 make_state_locked = false;
 426                 retmem_mb(make_state_lockfile);
 427         }
 428         if (forget_after_parse) {
 429                 retmem(makefile->body.makefile.contents);
 430                 makefile->body.makefile.contents = NULL;
 431         }
 432         retmem_mb((char *)source);
 433         return succeeded;
 434 }




  99         static pathpt           makefile_path;
 100         register int            n;
 101         char                    *path;
 102         register Source         source = ALLOC(Source);
 103         Property                orig_makefile = makefile;
 104         Dependency              *dpp;
 105         Dependency              dp;
 106         register int            length;
 107         wchar_t                 *previous_file_being_read = file_being_read;
 108         int                     previous_line_number = line_number;
 109         wchar_t                 previous_current_makefile[MAXPATHLEN];
 110         Makefile_type           save_makefile_type;
 111         Name                    normalized_makefile_name;
 112         register wchar_t        *string_start;
 113         register wchar_t        *string_end;
 114 
 115 
 116 
 117         wchar_t * wcb = get_wstring(makefile_name->string_mb);
 118 






 119         if (max_include_depth++ >= 40) {
 120                 fatal(catgets(catd, 1, 66, "Too many nested include statements"));
 121         }
 122         if (makefile->body.makefile.contents != NULL) {
 123                 retmem(makefile->body.makefile.contents);
 124         }
 125         source->inp_buf =
 126           source->inp_buf_ptr =
 127             source->inp_buf_end = NULL;
 128         source->error_converting = false;
 129         makefile->body.makefile.contents = NULL;
 130         makefile->body.makefile.size = 0;
 131         if ((makefile_name->hash.length != 1) ||
 132             (wcb[0] != (int) hyphen_char)) {
 133                 if ((makefile->body.makefile.contents == NULL) &&
 134                     (doname_it)) {
 135                         if (makefile_path == NULL) {
 136                                 add_dir_to_path(".",
 137                                                 &makefile_path,
 138                                                 -1);


 384                     source->string.text.p + num_mb_chars;
 385                 num_wc_chars = mbstowcs(source->string.text.p,
 386                                         stdin_text_p,
 387                                         num_mb_chars);
 388                 if ((int) num_wc_chars >= 0) {
 389                         source->string.text.end =
 390                           source->string.text.p + num_wc_chars;
 391                 }
 392                 (void) retmem_mb(stdin_text_p);
 393         }
 394         line_number = 1;
 395         if (trace_reader) {
 396                 (void) printf(catgets(catd, 1, 73, ">>>>>>>>>>>>>>>> Reading makefile %s\n"),
 397                               makefile_name->string_mb);
 398         }
 399         parse_makefile(makefile_name, source);
 400         if (trace_reader) {
 401                 (void) printf(catgets(catd, 1, 74, ">>>>>>>>>>>>>>>> End of makefile %s\n"),
 402                               makefile_name->string_mb);
 403         }





 404         if(file_being_read) {
 405                 retmem(file_being_read);
 406         }
 407         file_being_read = previous_file_being_read;
 408         line_number = previous_line_number;
 409         makefile_type = reading_nothing;
 410         max_include_depth--;
 411         if (make_state_locked) {
 412                 /* Unlock .make.state. */
 413                 unlink(make_state_lockfile);
 414                 make_state_locked = false;
 415                 retmem_mb(make_state_lockfile);
 416         }
 417         if (forget_after_parse) {
 418                 retmem(makefile->body.makefile.contents);
 419                 makefile->body.makefile.contents = NULL;
 420         }
 421         retmem_mb((char *)source);
 422         return succeeded;
 423 }