make: unifdef for MAKETOOL and DISTRIBUTED (undefined)

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  *      doname.c
  28  *
  29  *      Figure out which targets are out of date and rebuild them
  30  */
  31 
  32 /*
  33  * Included files
  34  */
  35 #include <alloca.h>               /* alloca() */
  36 










  37 
  38 #include <fcntl.h>
  39 #include <mk/defs.h>
  40 #include <mksh/i18n.h>            /* get_char_semantics_value() */
  41 #include <mksh/macro.h>           /* getvar(), expand_value() */
  42 #include <mksh/misc.h>            /* getmem() */
  43 #include <poll.h>
  44 
  45 
  46 #include <signal.h>
  47 
  48 #       include <stropts.h>
  49 
  50 #include <sys/errno.h>
  51 #include <sys/stat.h>
  52 #include <sys/types.h>
  53 #include <sys/utsname.h>  /* uname() */
  54 #include <sys/wait.h>
  55 #include <unistd.h>               /* close() */
  56 
  57 /*
  58  * Defined macros
  59  */
  60 #       define LOCALHOST "localhost"
  61 
  62 #define MAXRULES 100
  63 






  64 #define SEND_MTOOL_MSG(cmds) 

  65 
  66 // Sleep for .1 seconds between stat()'s
  67 const int       STAT_RETRY_SLEEP_TIME = 100000;
  68 
  69 /*
  70  * typedefs & structs
  71  */
  72 
  73 /*
  74  * Static variables
  75  */
  76 static char     hostName[MAXNAMELEN] = "";
  77 static char     userName[MAXNAMELEN] = "";
  78 





  79 
  80 static int      second_pass = 0;
  81 
  82 /*
  83  * File table of contents
  84  */
  85 extern  Doname          doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
  86 extern  Doname          doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
  87 static  Boolean         check_dependencies(Doname *result, Property line, Boolean do_get, Name target, Name true_target, Boolean doing_subtree, Chain *out_of_date_tail, Property old_locals, Boolean implicit, Property *command, Name less, Boolean rechecking_target, Boolean recheck_conditionals);
  88 void            dynamic_dependencies(Name target);
  89 static  Doname          run_command(register Property line, Boolean print_machine);
  90 extern  Doname          execute_serial(Property line);
  91 extern  Name            vpath_translation(register Name cmd);
  92 extern  void            check_state(Name temp_file_name);
  93 static  void            read_dependency_file(register Name filename);
  94 static  void            check_read_state_file(void);
  95 static  void            do_assign(register Name line, register Name target);
  96 static  void            build_command_strings(Name target, register Property line);
  97 static  Doname          touch_command(register Property line, register Name target, Doname result);
  98 extern  void            update_target(Property line, Doname result);
  99 static  Doname          sccs_get(register Name target, register Property *command);
 100 extern  void            read_directory_of_file(register Name file);
 101 static  void            add_pattern_conditionals(register Name target);
 102 extern  void            set_locals(register Name target, register Property old_locals);
 103 extern  void            reset_locals(register Name target, register Property old_locals, register Property conditional, register int index);
 104 extern  Boolean         check_auto_dependencies(Name target, int auto_count, Name *automatics);
 105 static  void            delete_query_chain(Chain ch);
 106 
 107 // From read2.cc
 108 extern  Name            normalize_name(register wchar_t *name_string, register int length);
 109 
 110 








 111 
 112 /*
 113  * DONE.
 114  *
 115  *      doname_check(target, do_get, implicit, automatic)
 116  *
 117  *      Will call doname() and then inspect the return value
 118  *
 119  *      Return value:
 120  *                              Indication if the build failed or not
 121  *
 122  *      Parameters:
 123  *              target          The target to build
 124  *              do_get          Passed thru to doname()
 125  *              implicit        Passed thru to doname()
 126  *              automatic       Are we building a hidden dependency?
 127  *
 128  *      Global variables used:
 129  *              build_failed_seen       Set if -k is on and error occurs
 130  *              continue_after_error    Indicates that -k is on
 131  *              report_dependencies     No error msg if -P is on
 132  */
 133 Doname
 134 doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
 135 {
 136         int first_time = 1;
 137         (void) fflush(stdout);
 138 try_again:
 139         switch (doname(target, do_get, implicit, automatic)) {
 140         case build_ok:
 141                 second_pass = 0;
 142                 return build_ok;
 143         case build_running:
 144                 second_pass = 0;
 145                 return build_running;
 146         case build_failed:
 147                 if (!continue_after_error) {
 148                         fatal(catgets(catd, 1, 13, "Target `%s' not remade because of errors"),
 149                               target->string_mb);
 150                 }
 151                 build_failed_seen = true;
 152                 second_pass = 0;
 153                 return build_failed;
 154         case build_dont_know:
 155                 /*
 156                  * If we can't figure out how to build an automatic
 157                  * (hidden) dependency, we just ignore it.
 158                  * We later declare the target to be out of date just in
 159                  * case something changed.
 160                  * Also, don't complain if just reporting the dependencies
 161                  * and not building anything.
 162                  */
 163                 if (automatic || (report_dependencies_level > 0)) {
 164                         second_pass = 0;
 165                         return build_dont_know;
 166                 }
 167                 if(first_time) {
 168                         first_time = 0;
 169                         second_pass = 1;
 170                         goto try_again;
 171                 }
 172                 second_pass = 0;
 173                 if (continue_after_error && !svr4) {
 174                         warning(catgets(catd, 1, 14, "Don't know how to make target `%s'"),
 175                                 target->string_mb);
 176                         build_failed_seen = true;
 177                         return build_failed;
 178                 }
 179                 fatal(catgets(catd, 1, 15, "Don't know how to make target `%s'"), target->string_mb);
 180                 break;
 181         }
 182 #ifdef lint
 183         return build_failed;
 184 #endif
 185 }
 186 
 187 
 188 void
 189 enter_explicit_rule_from_dynamic_rule(Name target, Name source)
 190 {
 191         Property line, source_line;
 192         Dependency dependency;
 193 
 194         source_line = get_prop(source->prop, line_prop);
 195         line = maybe_append_prop(target, line_prop);
 196         line->body.line.sccs_command = false;
 197         line->body.line.target = target;
 198         if (line->body.line.command_template == NULL) {
 199                 line->body.line.command_template = source_line->body.line.command_template;
 200                 for (dependency = source_line->body.line.dependencies;
 201                      dependency != NULL;
 202                      dependency = dependency->next) {
 203                         enter_dependency(line, dependency->name, false);
 204                 }
 205                 line->body.line.less = target;
 206         }
 207         line->body.line.percent = NULL;
 208 }
 209 
 210 
 211 
 212 Name
 213 find_dyntarget(Name target)
 214 {
 215         Dyntarget               p;
 216         int                     i;
 217         String_rec              string;
 218         wchar_t                 buffer[STRING_BUFFER_LENGTH];
 219         wchar_t                 *pp, * bufend;
 220         wchar_t                 tbuffer[MAXPATHLEN];
 221         Wstring                 wcb(target);
 222 
 223         for (p = dyntarget_list; p != NULL; p = p->next) {
 224                 INIT_STRING_FROM_STACK(string, buffer);
 225                 expand_value(p->name, &string, false);
 226                 i = 0;
 227                 pp = string.buffer.start;
 228                 bufend = pp + STRING_BUFFER_LENGTH;
 229                 while((*pp != nul_char) && (pp < bufend)) {
 230                         if(iswspace(*pp)) {
 231                                 tbuffer[i] = nul_char;
 232                                 if(i > 0) {
 233                                         if (wcb.equal(tbuffer)) {
 234                                                 enter_explicit_rule_from_dynamic_rule(target, p->name);
 235                                                 return(target);
 236                                         }
 237                                 }
 238                                 pp++;
 239                                 i = 0;
 240                                 continue;
 241                         }
 242                         tbuffer[i] = *pp;
 243                         i++;
 244                         pp++;
 245                         if(*pp == nul_char) {
 246                                 tbuffer[i] = nul_char;
 247                                 if(i > 0) {
 248                                         if (wcb.equal(tbuffer)) {
 249                                                 enter_explicit_rule_from_dynamic_rule(target, p->name);
 250                                                 return(target);
 251                                         }
 252                                 }
 253                                 break;
 254                         }
 255                 }
 256         }
 257         return(NULL);
 258 }
 259 
 260 /*
 261  * DONE.
 262  *
 263  *      doname(target, do_get, implicit)
 264  *
 265  *      Chases all files the target depends on and builds any that
 266  *      are out of date. If the target is out of date it is then rebuilt.
 267  *
 268  *      Return value:
 269  *                              Indiates if build failed or nt
 270  *
 271  *      Parameters:
 272  *              target          Target to build
 273  *              do_get          Run sccs get is nessecary
 274  *              implicit        doname is trying to find an implicit rule
 275  *
 276  *      Global variables used:
 277  *              assign_done     True if command line assgnment has happened
 278  *              commands_done   Preserved for the case that we need local value
 279  *              debug_level     Should we trace make's actions?
 280  *              default_rule    The rule for ".DEFAULT", used as last resort
 281  *              empty_name      The Name "", used when looking for single sfx
 282  *              keep_state      Indicates that .KEEP_STATE is on
 283  *              parallel        True if building in parallel
 284  *              recursion_level Used for tracing
 285  *              report_dependencies make -P is on
 286  */
 287 Doname
 288 doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
 289 {
 290         Doname                  result = build_dont_know;
 291         Chain                   out_of_date_list = NULL;
 292 #ifdef TEAMWARE_MAKE_CMN
 293         Chain                   target_group;
 294 #endif
 295         Property                old_locals = NULL;
 296         register Property       line;
 297         Property                command = NULL;
 298         register Dependency     dependency;
 299         Name                    less = NULL;
 300         Name                    true_target = target;
 301         Name                    *automatics = NULL;
 302         register int            auto_count;
 303         Boolean                 rechecking_target = false;
 304         Boolean                 saved_commands_done;
 305         Boolean                 restart = false;
 306         Boolean                 save_parallel = parallel;
 307         Boolean                 doing_subtree = false;
 308 
 309         Boolean                 recheck_conditionals = false;
 310 
 311         if (target->state == build_running) {
 312                 return build_running;
 313         }
 314         line = get_prop(target->prop, line_prop);
 315 #ifdef TEAMWARE_MAKE_CMN
 316         if (line != NULL) {
 317                 /*
 318                  * If this target is a member of target group and one of the
 319                  * other members of the group is running, mark this target
 320                  * as running.
 321                  */
 322                 for (target_group = line->body.line.target_group;
 323                      target_group != NULL;
 324                      target_group = target_group->next) {
 325                         if (is_running(target_group->name)) {
 326                                 target->state = build_running;
 327                                 add_pending(target,
 328                                             recursion_level,
 329                                             do_get,
 330                                             implicit,
 331                                             false);
 332                                 return build_running;
 333                         }
 334                 }
 335         }
 336 #endif
 337         /*
 338          * If the target is a constructed one for a "::" target,
 339          * we need to consider that.
 340          */
 341         if (target->has_target_prop) {
 342                 true_target = get_prop(target->prop,
 343                                        target_prop)->body.target.target;
 344                 if (true_target->colon_splits > 0) {
 345                         /* Make sure we have a valid time for :: targets */
 346                         Property        time;
 347 
 348                         time = get_prop(true_target->prop, time_prop);
 349                         if (time != NULL) {
 350                                 true_target->stat.time = time->body.time.time;
 351                         }
 352                 }
 353         }
 354         (void) exists(true_target);
 355         /*
 356          * If the target has been processed, we don't need to do it again,
 357          * unless it depends on conditional macros or a delayed assignment,
 358          * or it has been done when KEEP_STATE is on.
 359          */
 360         if (target->state == build_ok) {
 361                 if((!keep_state || (!target->depends_on_conditional && !assign_done))) {
 362                         return build_ok;
 363                 } else {
 364                         recheck_conditionals = true;
 365                 }
 366         }
 367         if (target->state == build_subtree) {
 368                 /* A dynamic macro subtree is being built */
 369                 target->state = build_dont_know;
 370                 doing_subtree = true;
 371                 if (!target->checking_subtree) {
 372                         /*
 373                          * This target has been started before and therefore
 374                          * not all dependencies have to be built.
 375                          */
 376                         restart = true;
 377                 }
 378         } else if (target->state == build_pending) {
 379                 target->state = build_dont_know;
 380                 restart = true;
 381 /*
 382 #ifdef TEAMWARE_MAKE_CMN
 383         } else if (parallel &&
 384                    keep_state &&
 385                    (target->conditional_cnt > 0)) {
 386             if (!parallel_ok(target, false)) {
 387                 add_subtree(target, recursion_level, do_get, implicit);
 388                 target->state = build_running;
 389                 return build_running;
 390             }
 391 #endif
 392  */
 393         }
 394         /*
 395          * If KEEP_STATE is on, we have to rebuild the target if the
 396          * building of it caused new automatic dependencies to be reported.
 397          * This is where we restart the build.
 398          */
 399         if (line != NULL) {
 400                 line->body.line.percent = NULL;
 401         }
 402 recheck_target:
 403         /* Init all local variables */
 404         result = build_dont_know;
 405         out_of_date_list = NULL;
 406         command = NULL;
 407         less = NULL;
 408         auto_count = 0;
 409         if (!restart && line != NULL) {
 410                 /*
 411                  * If this target has never been built before, mark all
 412                  * of the dependencies as never built.
 413                  */
 414                 for (dependency = line->body.line.dependencies;
 415                      dependency != NULL;
 416                      dependency = dependency->next) {
 417                         dependency->built = false;
 418                 }
 419         }
 420         /* Save the set of automatic depes defined for this target */
 421         if (keep_state &&
 422             (line != NULL) &&
 423             (line->body.line.dependencies != NULL)) {
 424                 Name *p;
 425 
 426                 /*
 427                  * First run thru the dependency list to see how many
 428                  * autos there are.
 429                  */
 430                 for (dependency = line->body.line.dependencies;
 431                      dependency != NULL;
 432                      dependency = dependency->next) {
 433                         if (dependency->automatic && !dependency->stale) {
 434                                 auto_count++;
 435                         }
 436                 }
 437                 /* Create vector to hold the current autos */
 438                 automatics =
 439                   (Name *) alloca((int) (auto_count * sizeof (Name)));
 440                 /* Copy them */
 441                 for (p = automatics, dependency = line->body.line.dependencies;
 442                      dependency != NULL;
 443                      dependency = dependency->next) {
 444                         if (dependency->automatic && !dependency->stale) {
 445                                 *p++ = dependency->name;
 446                         }
 447                 }
 448         }
 449         if (debug_level > 1) {
 450                 (void) printf(NOCATGETS("%*sdoname(%s)\n"),
 451                               recursion_level,
 452                               "",
 453                               target->string_mb);
 454         }
 455         recursion_level++;
 456         /* Avoid infinite loops */
 457         if (target->state == build_in_progress) {
 458                 warning(catgets(catd, 1, 16, "Infinite loop: Target `%s' depends on itself"),
 459                         target->string_mb);
 460                 return build_ok;
 461         }
 462         target->state = build_in_progress;
 463 
 464         /* Activate conditional macros for the target */
 465         if (!target->added_pattern_conditionals) {
 466                 add_pattern_conditionals(target);
 467                 target->added_pattern_conditionals = true;
 468         }
 469         if (target->conditional_cnt > 0) {
 470                 old_locals = (Property) alloca(target->conditional_cnt *
 471                                                sizeof (Property_rec));
 472                 set_locals(target, old_locals);
 473         }
 474 
 475 /*
 476  * after making the call to dynamic_dependecies unconditional we can handle
 477  * target names that are same as file name. In this case $$@ in the 
 478  * dependencies did not mean anything. WIth this change it expands it
 479  * as expected.
 480  */
 481         if (!target->has_depe_list_expanded)
 482         {
 483                 dynamic_dependencies(target);
 484         }
 485 
 486 /*
 487  *      FIRST SECTION -- GO THROUGH DEPENDENCIES AND COLLECT EXPLICIT
 488  *      COMMANDS TO RUN
 489  */
 490         if ((line = get_prop(target->prop, line_prop)) != NULL) {
 491                 if (check_dependencies(&result,
 492                                        line,
 493                                        do_get,
 494                                        target,
 495                                        true_target,
 496                                        doing_subtree,
 497                                        &out_of_date_list,
 498                                        old_locals,
 499                                        implicit,
 500                                        &command,
 501                                        less,
 502                                        rechecking_target,
 503                                        recheck_conditionals)) {
 504                         return build_running;
 505                 }
 506                 if (line->body.line.query != NULL) {
 507                         delete_query_chain(line->body.line.query);
 508                 }
 509                 line->body.line.query = out_of_date_list;
 510         }
 511 
 512 
 513 /*
 514  * If the target is a :: type, do not try to find the rule for the target,
 515  * all actions will be taken by separate branches.
 516  * Else, we try to find an implicit rule using various methods,
 517  * we quit as soon as one is found.
 518  *
 519  * [tolik, 12 Sep 2002] Do not try to find implicit rule for the target
 520  * being rechecked - the target is being rechecked means that it already
 521  * has explicit dependencies derived from an implicit rule found
 522  * in previous step.
 523  */
 524         if (target->colon_splits == 0 && !rechecking_target) {
 525                 /* Look for percent matched rule */
 526                 if ((result == build_dont_know) &&
 527                     (command == NULL)) {
 528                         switch (find_percent_rule(
 529                                         target,
 530                                         &command,
 531                                         recheck_conditionals)) {
 532                         case build_failed:
 533                                 result = build_failed;
 534                                 break;
 535 #ifdef TEAMWARE_MAKE_CMN
 536                         case build_running:
 537                                 target->state = build_running;
 538                                 add_pending(target,
 539                                             --recursion_level,
 540                                             do_get,
 541                                             implicit,
 542                                             false);
 543                                 if (target->conditional_cnt > 0) {
 544                                         reset_locals(target,
 545                                                      old_locals,
 546                                                      get_prop(target->prop,
 547                                                              conditional_prop),
 548                                                      0);
 549                                 }
 550                                 return build_running;
 551 #endif
 552                         case build_ok:
 553                                 result = build_ok;
 554                                 break;
 555                         }
 556                 }
 557                 /* Look for double suffix rule */
 558                 if (result == build_dont_know) {
 559                         Property member;
 560 
 561                         if (target->is_member &&
 562                             ((member = get_prop(target->prop, member_prop)) !=
 563                              NULL)) {
 564                                 switch (find_ar_suffix_rule(target,
 565                                                 member->body.
 566                                                 member.member,
 567                                                 &command,
 568                                                 recheck_conditionals)) {
 569                                 case build_failed:
 570                                         result = build_failed;
 571                                         break;
 572 #ifdef TEAMWARE_MAKE_CMN
 573                                 case build_running:
 574                                         target->state = build_running;
 575                                         add_pending(target,
 576                                                     --recursion_level,
 577                                                     do_get,
 578                                                     implicit,
 579                                                     false);
 580                                     if (target->conditional_cnt > 0) {
 581                                             reset_locals(target,
 582                                                          old_locals,
 583                                                          get_prop(target->prop,
 584                                                              conditional_prop),
 585                                                          0);
 586                                     }
 587                                         return build_running;
 588 #endif
 589                                 default:
 590                                         /* ALWAYS bind $% for old style */
 591                                         /* ar rules */
 592                                         if (line == NULL) {
 593                                                 line =
 594                                                   maybe_append_prop(target,
 595                                                                     line_prop);
 596                                         }
 597                                         line->body.line.percent =
 598                                           member->body.member.member;
 599                                         break;
 600                                 }
 601                         } else {
 602                                 switch (find_double_suffix_rule(target,
 603                                                 &command,
 604                                                 recheck_conditionals)) {
 605                                 case build_failed:
 606                                         result = build_failed;
 607                                         break;
 608 #ifdef TEAMWARE_MAKE_CMN
 609                                 case build_running:
 610                                         target->state = build_running;
 611                                         add_pending(target,
 612                                                     --recursion_level,
 613                                                     do_get,
 614                                                     implicit,
 615                                                     false);
 616                                         if (target->conditional_cnt > 0) {
 617                                                 reset_locals(target,
 618                                                              old_locals,
 619                                                              get_prop(target->
 620                                                                       prop,
 621                                                                       conditional_prop),
 622                                                              0);
 623                                         }
 624                                         return build_running;
 625 #endif
 626                                 }
 627                         }
 628                 }
 629                 /* Look for single suffix rule */
 630 
 631 /* /tolik/
 632  * I commented !implicit to fix bug 1247448: Suffix Rules failed when combine with Pattern Matching Rules.
 633  * This caused problem with SVR4 tilde rules (infinite recursion). So I made some changes in "implicit.cc"
 634  */
 635 /* /tolik, 06.21.96/
 636  * Regression! See BugId 1255360
 637  * If more than one percent rules are defined for the same target then
 638  * the behaviour of 'make' with my previous fix may be different from one
 639  * of the 'old make'. 
 640  * The global variable second_pass (maybe it should be an argument to doname())
 641  * is intended to avoid this regression. It is set in doname_check().
 642  * First, 'make' will work as it worked before. Only when it is
 643  * going to say "don't know how to make target" it sets second_pass to true and
 644  * run 'doname' again but now trying to use Single Suffix Rules.
 645  */
 646                 if ((result == build_dont_know) && !automatic && (!implicit || second_pass) &&
 647                     ((line == NULL) ||
 648                      ((line->body.line.target != NULL) &&
 649                       !line->body.line.target->has_regular_dependency))) {
 650                         switch (find_suffix_rule(target,
 651                                                  target,
 652                                                  empty_name,
 653                                                  &command,
 654                                                  recheck_conditionals)) {
 655                         case build_failed:
 656                                 result = build_failed;
 657                                 break;
 658 #ifdef TEAMWARE_MAKE_CMN
 659                         case build_running:
 660                                 target->state = build_running;
 661                                 add_pending(target,
 662                                             --recursion_level,
 663                                             do_get,
 664                                             implicit,
 665                                             false);
 666                                 if (target->conditional_cnt > 0) {
 667                                         reset_locals(target,
 668                                                      old_locals,
 669                                                      get_prop(target->prop,
 670                                                              conditional_prop),
 671                                                      0);
 672                                 }
 673                                 return build_running;
 674 #endif
 675                         }
 676                 }
 677                 /* Try to sccs get */
 678                 if ((command == NULL) &&
 679                     (result == build_dont_know) &&
 680                     do_get) {
 681                         result = sccs_get(target, &command);
 682                 }
 683 
 684                 /* Use .DEFAULT rule if it is defined. */
 685                 if ((command == NULL) &&
 686                     (result == build_dont_know) &&
 687                     (true_target->colons == no_colon) &&
 688                     default_rule &&
 689                     !implicit) {
 690                         /* Make sure we have a line prop */
 691                         line = maybe_append_prop(target, line_prop);
 692                         command = line;
 693                         Boolean out_of_date;
 694                         if (true_target->is_member) {
 695                                 out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
 696                                                                         line->body.line.dependency_time);
 697                         } else {
 698                                 out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
 699                                                                     line->body.line.dependency_time);
 700                         }
 701                         if (build_unconditional || out_of_date) {
 702                                 line->body.line.is_out_of_date = true;
 703                                 if (debug_level > 0) {
 704                                         (void) printf(catgets(catd, 1, 17, "%*sBuilding %s using .DEFAULT because it is out of date\n"),
 705                                                       recursion_level,
 706                                                       "",
 707                                                       true_target->string_mb);
 708                                 }
 709                         }
 710                         line->body.line.sccs_command = false;
 711                         line->body.line.command_template = default_rule;
 712                         line->body.line.target = true_target;
 713                         line->body.line.star = NULL;
 714                         line->body.line.less = true_target;
 715                         line->body.line.percent = NULL;
 716                 }
 717         }
 718 
 719         /* We say "target up to date" if no cmd were executed for the target */
 720         if (!target->is_double_colon_parent) {
 721                 commands_done = false;
 722         }
 723 
 724         silent = silent_all;
 725         ignore_errors = ignore_errors_all;
 726         if  (posix)
 727         {
 728           if  (!silent)
 729           {
 730             silent = (Boolean) target->silent_mode;
 731           }
 732           if  (!ignore_errors)
 733           {
 734             ignore_errors = (Boolean) target->ignore_error_mode;
 735           }
 736         }
 737 
 738         int doname_dyntarget = 0;
 739 r_command:
 740         /* Run commands if any. */
 741         if ((command != NULL) &&
 742             (command->body.line.command_template != NULL)) {
 743                 if (result != build_failed) {
 744                         result = run_command(command, 
 745                                              (Boolean) ((parallel || save_parallel) && !silent));
 746                 }
 747                 switch (result) {
 748 #ifdef TEAMWARE_MAKE_CMN
 749                 case build_running:
 750                         add_running(target,
 751                                     true_target,
 752                                     command,
 753                                     --recursion_level,
 754                                     auto_count,
 755                                     automatics,
 756                                     do_get,
 757                                     implicit);
 758                         target->state = build_running;
 759                         if ((line = get_prop(target->prop,
 760                                              line_prop)) != NULL) {
 761                                 if (line->body.line.query != NULL) {
 762                                         delete_query_chain(line->body.line.query);
 763                                 }
 764                                 line->body.line.query = NULL;
 765                         }
 766                         if (target->conditional_cnt > 0) {
 767                                 reset_locals(target,
 768                                              old_locals,
 769                                              get_prop(target->prop,
 770                                                      conditional_prop),
 771                                              0);
 772                         }
 773                         return build_running;
 774                 case build_serial:
 775                         add_serial(target,
 776                                    --recursion_level,
 777                                    do_get,
 778                                    implicit);
 779                         target->state = build_running;
 780                         line = get_prop(target->prop, line_prop);
 781                         if (line != NULL) {
 782                                 if (line->body.line.query != NULL) {
 783                                         delete_query_chain(line->body.line.query);
 784                                 }
 785                                 line->body.line.query = NULL;
 786                         }
 787                         if (target->conditional_cnt > 0) {
 788                                 reset_locals(target,
 789                                              old_locals,
 790                                              get_prop(target->prop,
 791                                                      conditional_prop),
 792                                              0);
 793                         }
 794                         return build_running;
 795 #endif
 796                 case build_ok:
 797                         /* If all went OK set a nice timestamp */
 798                         if (true_target->stat.time == file_doesnt_exist) {
 799                                 true_target->stat.time = file_max_time;
 800                         }
 801                         break;
 802                 }
 803         } else {
 804                 /*
 805                  * If no command was found for the target, and it doesn't
 806                  * exist, and it is mentioned as a target in the makefile,
 807                  * we say it is extremely new and that it is OK.
 808                  */
 809                 if (target->colons != no_colon) {
 810                         if (true_target->stat.time == file_doesnt_exist){
 811                                 true_target->stat.time = file_max_time;
 812                         }
 813                         result = build_ok;
 814                 }
 815                 /*
 816                  * Trying dynamic targets.
 817                  */
 818                 if(!doname_dyntarget) {
 819                         doname_dyntarget = 1;
 820                         Name dtarg = find_dyntarget(target);
 821                         if(dtarg!=NULL) {
 822                                 if (!target->has_depe_list_expanded) {
 823                                         dynamic_dependencies(target);
 824                                 }
 825                                 if ((line = get_prop(target->prop, line_prop)) != NULL) {
 826                                         if (check_dependencies(&result,
 827                                                                line,
 828                                                                do_get,
 829                                                                target,
 830                                                                true_target,
 831                                                                doing_subtree,
 832                                                                &out_of_date_list,
 833                                                                old_locals,
 834                                                                implicit,
 835                                                                &command,
 836                                                                less,
 837                                                                rechecking_target,
 838                                                                recheck_conditionals))
 839                                         {
 840                                                 return build_running;
 841                                         }
 842                                         if (line->body.line.query != NULL) {
 843                                                 delete_query_chain(line->body.line.query);
 844                                         }
 845                                         line->body.line.query = out_of_date_list;
 846                                 }
 847                                 goto r_command;
 848                         }
 849                 }
 850                 /*
 851                  * If the file exists, it is OK that we couldnt figure
 852                  * out how to build it.
 853                  */
 854                 (void) exists(target);
 855                 if ((target->stat.time != file_doesnt_exist) &&
 856                     (result == build_dont_know)) {
 857                         result = build_ok;
 858                 }
 859         }
 860 
 861         /*
 862          * Some of the following is duplicated in the function finish_doname.
 863          * If anything is changed here, check to see if it needs to be
 864          * changed there.
 865          */
 866         if ((line = get_prop(target->prop, line_prop)) != NULL) {
 867                 if (line->body.line.query != NULL) {
 868                         delete_query_chain(line->body.line.query);
 869                 }
 870                 line->body.line.query = NULL;
 871         }
 872         target->state = result;
 873         parallel = save_parallel;
 874         if (target->conditional_cnt > 0) {
 875                 reset_locals(target,
 876                              old_locals,
 877                              get_prop(target->prop, conditional_prop),
 878                              0);
 879         }
 880         recursion_level--;
 881         if (target->is_member) {
 882                 Property member;
 883 
 884                 /* Propagate the timestamp from the member file to the member*/
 885                 if ((target->stat.time != file_max_time) &&
 886                     ((member = get_prop(target->prop, member_prop)) != NULL) &&
 887                     (exists(member->body.member.member) > file_doesnt_exist)) {
 888                         target->stat.time =
 889                           member->body.member.member->stat.time;
 890                 }
 891         }
 892         /*
 893          * Check if we found any new auto dependencies when we
 894          * built the target.
 895          */
 896         if ((result == build_ok) && check_auto_dependencies(target,
 897                                                             auto_count,
 898                                                             automatics)) {
 899                 if (debug_level > 0) {
 900                         (void) printf(catgets(catd, 1, 18, "%*sTarget `%s' acquired new dependencies from build, rechecking all dependencies\n"),
 901                                       recursion_level,
 902                                       "",
 903                                       true_target->string_mb);
 904                 }
 905                 rechecking_target = true;
 906                 saved_commands_done = commands_done;
 907                 goto recheck_target;
 908         }
 909 
 910         if (rechecking_target && !commands_done) {
 911                 commands_done = saved_commands_done;
 912         }
 913 
 914         return result;
 915 }
 916 
 917 /*
 918  * DONE.
 919  *
 920  *      check_dependencies(result, line, do_get,
 921  *                      target, true_target, doing_subtree, out_of_date_tail,
 922  *                      old_locals, implicit, command, less, rechecking_target)
 923  *
 924  *      Return value:
 925  *                              True returned if some dependencies left running
 926  *                              
 927  *      Parameters:
 928  *              result          Pointer to cell we update if build failed
 929  *              line            We get the dependencies from here
 930  *              do_get          Allow use of sccs get in recursive doname()
 931  *              target          The target to chase dependencies for
 932  *              true_target     The real one for :: and lib(member)
 933  *              doing_subtree   True if building a conditional macro subtree
 934  *              out_of_date_tail Used to set the $? list
 935  *              old_locals      Used for resetting the local macros
 936  *              implicit        Called when scanning for implicit rules?
 937  *              command         Place to stuff command
 938  *              less            Set to $< value
 939  *
 940  *      Global variables used:
 941  *              command_changed Set if we suspect .make.state needs rewrite
 942  *              debug_level     Should we trace actions?
 943  *              force           The Name " FORCE", compared against
 944  *              recursion_level Used for tracing
 945  *              rewrite_statefile Set if .make.state needs rewriting
 946  *              wait_name       The Name ".WAIT", compared against
 947  */
 948 static Boolean
 949 #ifdef TEAMWARE_MAKE_CMN
 950 check_dependencies(Doname *result, Property line, Boolean do_get, Name target, Name true_target, Boolean doing_subtree, Chain *out_of_date_tail, Property old_locals, Boolean implicit, Property *command, Name less, Boolean rechecking_target, Boolean recheck_conditionals)
 951 #else
 952 check_dependencies(Doname *result, Property line, Boolean do_get, Name target, Name true_target, Boolean, Chain *out_of_date_tail, Property, Boolean, Property *command, Name less, Boolean rechecking_target, Boolean recheck_conditionals)
 953 #endif
 954 {
 955         Boolean                 dependencies_running;
 956         register Dependency     dependency;
 957         Doname                  dep_result;
 958         Boolean                 dependency_changed = false;
 959 
 960         line->body.line.dependency_time = file_doesnt_exist;
 961         if (line->body.line.query != NULL) {
 962                 delete_query_chain(line->body.line.query);
 963         }
 964         line->body.line.query = NULL;
 965         line->body.line.is_out_of_date = false;
 966         dependencies_running = false;
 967         /*
 968          * Run thru all the dependencies and call doname() recursively
 969          * on each of them.
 970          */
 971         for (dependency = line->body.line.dependencies;
 972              dependency != NULL;
 973              dependency = dependency->next) {
 974                 Boolean this_dependency_changed = false;
 975 
 976                 if (!dependency->automatic &&
 977                     (rechecking_target || target->rechecking_target)) {
 978                         /*
 979                          * We only bother with the autos when rechecking
 980                          */
 981                         continue;
 982                 }
 983 
 984                 if (dependency->name == wait_name) {
 985                         /*
 986                          * The special target .WAIT means finish all of
 987                          * the prior dependencies before continuing.
 988                          */
 989                         if (dependencies_running) {
 990                                 break;
 991                         }










 992                 } else {
 993                         timestruc_t     depe_time = file_doesnt_exist;
 994 
 995 
 996                         if (true_target->is_member) {
 997                                 depe_time = exists(dependency->name);
 998                         }
 999                         if (dependency->built ||
1000                             (dependency->name->state == build_failed)) {
1001                                 dep_result = (Doname) dependency->name->state;
1002                         } else {
1003                                 dep_result = doname_check(dependency->name,
1004                                                           do_get,
1005                                                           false,
1006                                                           (Boolean) dependency->automatic);
1007                         }
1008                         if (true_target->is_member || dependency->name->is_member) {
1009                                 /* should compare only secs, cause lib members does not have nsec time resolution */
1010                                 if (depe_time.tv_sec != dependency->name->stat.time.tv_sec) {
1011                                         this_dependency_changed =
1012                                           dependency_changed =
1013                                             true;
1014                                 }
1015                         } else {
1016                                 if (depe_time != dependency->name->stat.time) {
1017                                         this_dependency_changed =
1018                                           dependency_changed =
1019                                             true;
1020                                 }
1021                         }
1022                         dependency->built = true;
1023                         switch (dep_result) {
1024                         case build_running:
1025                                 dependencies_running = true;
1026                                 continue;
1027                         case build_failed:
1028                                 *result = build_failed;
1029                                 break;
1030                         case build_dont_know:
1031 /*
1032  * If make can't figure out how to make a dependency, maybe the dependency
1033  * is out of date. In this case, we just declare the target out of date
1034  * and go on. If we really need the dependency, the make'ing of the target
1035  * will fail. This will only happen for automatic (hidden) dependencies.
1036  */
1037                                 if(!recheck_conditionals) {
1038                                         line->body.line.is_out_of_date = true;
1039                                 }
1040                                 /*
1041                                  * Make sure the dependency is not saved
1042                                  * in the state file.
1043                                  */
1044                                 dependency->stale = true;
1045                                 rewrite_statefile =
1046                                   command_changed =
1047                                     true;
1048                                 if (debug_level > 0) {
1049                                         (void) printf(catgets(catd, 1, 19, "Target %s rebuilt because dependency %s does not exist\n"),
1050                                                      true_target->string_mb,
1051                                                      dependency->name->string_mb);
1052                                 }
1053                                 break;
1054                         }
1055                         if (dependency->name->depends_on_conditional) {
1056                                 target->depends_on_conditional = true;
1057                         }
1058                         if (dependency->name == force) {
1059                                 target->stat.time =
1060                                   dependency->name->stat.time;
1061                         }
1062                         /*
1063                          * Propagate new timestamp from "member" to
1064                          * "lib.a(member)".
1065                          */
1066                         (void) exists(dependency->name);
1067 
1068                         /* Collect the timestamp of the youngest dependency */
1069                         line->body.line.dependency_time =
1070                           MAX(dependency->name->stat.time,
1071                               line->body.line.dependency_time);
1072 
1073                         /* Correction: do not consider nanosecs for members */
1074                         if(true_target->is_member || dependency->name->is_member) {
1075                                 line->body.line.dependency_time.tv_nsec = 0;
1076                         }
1077 
1078                         if (debug_level > 1) {
1079                                 (void) printf(catgets(catd, 1, 20, "%*sDate(%s)=%s \n"),
1080                                               recursion_level,
1081                                               "",
1082                                               dependency->name->string_mb,
1083                                               time_to_string(dependency->name->
1084                                                              stat.time));
1085                                 if (dependency->name->stat.time > line->body.line.dependency_time) {
1086                                         (void) printf(catgets(catd, 1, 21, "%*sDate-dependencies(%s) set to %s\n"),
1087                                                       recursion_level,
1088                                                       "",
1089                                                       true_target->string_mb,
1090                                                       time_to_string(line->body.line.
1091                                                                      dependency_time));
1092                                 }
1093                         }
1094 
1095                         /* Build the $? list */
1096                         if (true_target->is_member) {
1097                                 if (this_dependency_changed == true) {
1098                                         true_target->stat.time = dependency->name->stat.time;
1099                                         true_target->stat.time.tv_sec--;
1100                                 } else {
1101                                         /* Dina: 
1102                                          * The next statement is commented
1103                                          * out as a fix for bug #1051032.
1104                                          * if dependency hasn't changed
1105                                          * then there's no need to invalidate
1106                                          * true_target. This statemnt causes
1107                                          * make to take much longer to process
1108                                          * an already-built archive. Soren
1109                                          * said it was a quick fix for some
1110                                          * problem he doesn't remember.
1111                                         true_target->stat.time = file_no_time;
1112                                          */
1113                                         (void) exists(true_target);
1114                                 }
1115                         } else {
1116                                 (void) exists(true_target);
1117                         }
1118                         Boolean out_of_date;
1119                         if (true_target->is_member || dependency->name->is_member) {
1120                                 out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
1121                                                                         dependency->name->stat.time);
1122                         } else {
1123                                 out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
1124                                                                     dependency->name->stat.time);
1125                         }
1126                         if ((build_unconditional || out_of_date) &&
1127                             (dependency->name != force) &&
1128                             (dependency->stale == false)) {
1129                                 *out_of_date_tail = ALLOC(Chain);
1130                                 if (dependency->name->is_member &&
1131                                     (get_prop(dependency->name->prop,
1132                                               member_prop) != NULL)) {
1133                                         (*out_of_date_tail)->name =
1134                                           get_prop(dependency->name->prop,
1135                                                    member_prop)->
1136                                                      body.member.member;
1137                                 } else {
1138                                         (*out_of_date_tail)->name =
1139                                           dependency->name;
1140                                 }
1141                                 (*out_of_date_tail)->next = NULL;
1142                                 out_of_date_tail = &(*out_of_date_tail)->next;
1143                                 if (debug_level > 0) {
1144                                         if (dependency->name->stat.time == file_max_time) {
1145                                                 (void) printf(catgets(catd, 1, 22, "%*sBuilding %s because %s does not exist\n"),
1146                                                               recursion_level,
1147                                                               "",
1148                                                               true_target->string_mb,
1149                                                               dependency->name->string_mb);
1150                                         } else {
1151                                                 (void) printf(catgets(catd, 1, 23, "%*sBuilding %s because it is out of date relative to %s\n"),
1152                                                               recursion_level,
1153                                                               "",
1154                                                               true_target->string_mb,
1155                                                               dependency->name->string_mb);
1156                                         }
1157                                 }
1158                         }
1159                         if (dependency->name == force) {
1160                                 force->stat.time =
1161                                   file_max_time;
1162                                 force->state = build_dont_know;
1163                         }
1164                 }
1165         }
1166 #ifdef TEAMWARE_MAKE_CMN
1167         if (dependencies_running) {
1168                 if (doing_subtree) {
1169                         if (target->conditional_cnt > 0) {
1170                                 reset_locals(target,
1171                                              old_locals,
1172                                              get_prop(target->prop,
1173                                                       conditional_prop),
1174                                              0);
1175                         }
1176                         return true;
1177                 } else {
1178                         target->state = build_running;
1179                         add_pending(target,
1180                                     --recursion_level,
1181                                     do_get,
1182                                     implicit,
1183                                     false);
1184                         if (target->conditional_cnt > 0) {
1185                                 reset_locals(target,
1186                                              old_locals,
1187                                              get_prop(target->prop,
1188                                                       conditional_prop),
1189                                              0);
1190                         }
1191                         return true;
1192                 }
1193         }
1194 #endif
1195         /*
1196          * Collect the timestamp of the youngest double colon target
1197          * dependency.
1198          */
1199         if (target->is_double_colon_parent) {
1200                 for (dependency = line->body.line.dependencies;
1201                      dependency != NULL;
1202                      dependency = dependency->next) {
1203                         Property        tmp_line;
1204 
1205                         if ((tmp_line = get_prop(dependency->name->prop, line_prop)) != NULL) {
1206                                 if(tmp_line->body.line.dependency_time != file_max_time) {
1207                                         target->stat.time =
1208                                           MAX(tmp_line->body.line.dependency_time,
1209                                               target->stat.time);
1210                                 }
1211                         }
1212                 }
1213         }
1214         if ((true_target->is_member) && (dependency_changed == true)) {
1215                 true_target->stat.time = file_no_time;
1216         }
1217         /*
1218          * After scanning all the dependencies, we check the rule
1219          * if we found one.
1220          */
1221         if (line->body.line.command_template != NULL) {
1222                 if (line->body.line.command_template_redefined) {
1223                         warning(catgets(catd, 1, 24, "Too many rules defined for target %s"),
1224                                 target->string_mb);
1225                 }
1226                 *command = line;
1227                 /* Check if the target is out of date */
1228                 Boolean out_of_date;
1229                 if (true_target->is_member) {
1230                         out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
1231                                                                 line->body.line.dependency_time);
1232                 } else {
1233                         out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
1234                                                             line->body.line.dependency_time);
1235                 }
1236                 if (build_unconditional || out_of_date){
1237                         if(!recheck_conditionals) {
1238                                 line->body.line.is_out_of_date = true;
1239                         }
1240                 }
1241                 line->body.line.sccs_command = false;
1242                 line->body.line.target = true_target;
1243                 if(gnu_style) {
1244 
1245                         // set $< for explicit rule
1246                         if(line->body.line.dependencies != NULL) {
1247                                 less = line->body.line.dependencies->name;
1248                         }
1249 
1250                         // set $* for explicit rule
1251                         Name                    target_body;
1252                         Name                    tt = true_target;
1253                         Property                member;
1254                         register wchar_t        *target_end;
1255                         register Dependency     suffix;
1256                         register int            suffix_length;
1257                         Wstring                 targ_string;
1258                         Wstring                 suf_string;
1259 
1260                         if (true_target->is_member &&
1261                             ((member = get_prop(target->prop, member_prop)) !=
1262                              NULL)) {
1263                                 tt = member->body.member.member;
1264                         }
1265                         targ_string.init(tt);
1266                         target_end = targ_string.get_string() + tt->hash.length;
1267                         for (suffix = suffixes; suffix != NULL; suffix = suffix->next) {
1268                                 suffix_length = suffix->name->hash.length;
1269                                 suf_string.init(suffix->name);
1270                                 if (tt->hash.length < suffix_length) {
1271                                         continue;
1272                                 } else if (!IS_WEQUALN(suf_string.get_string(),
1273                                                 (target_end - suffix_length),
1274                                                 suffix_length)) {
1275                                         continue;
1276                                 }
1277                                 target_body = GETNAME(
1278                                         targ_string.get_string(),
1279                                         (int)(tt->hash.length - suffix_length)
1280                                 );
1281                                 line->body.line.star = target_body;
1282                         }
1283 
1284                         // set result = build_ok so that implicit rules are not used.
1285                         if(*result == build_dont_know) {
1286                                 *result = build_ok;
1287                         }
1288                 }
1289                 if (less != NULL) {
1290                         line->body.line.less = less;
1291                 }
1292         }
1293 
1294         return false;
1295 }
1296 
1297 /*
1298  *      dynamic_dependencies(target)
1299  *
1300  *      Checks if any dependency contains a macro ref
1301  *      If so, it replaces the dependency with the expanded version.
1302  *      Here, "$@" gets translated to target->string. That is
1303  *      the current name on the left of the colon in the
1304  *      makefile.  Thus,
1305  *              xyz:    s.$@.c
1306  *      translates into
1307  *              xyz:    s.xyz.c
1308  *
1309  *      Also, "$(@F)" translates to the same thing without a preceeding
1310  *      directory path (if one exists).
1311  *      Note, to enter "$@" on a dependency line in a makefile
1312  *      "$$@" must be typed. This is because make expands
1313  *      macros in dependency lists upon reading them.
1314  *      dynamic_dependencies() also expands file wildcards.
1315  *      If there are any Shell meta characters in the name,
1316  *      search the directory, and replace the dependency
1317  *      with the set of files the pattern matches
1318  *
1319  *      Parameters:
1320  *              target          Target to sanitize dependencies for
1321  *
1322  *      Global variables used:
1323  *              c_at            The Name "@", used to set macro value
1324  *              debug_level     Should we trace actions?
1325  *              dot             The Name ".", used to read directory
1326  *              recursion_level Used for tracing
1327  */
1328 void
1329 dynamic_dependencies(Name target)
1330 {
1331         wchar_t                 pattern[MAXPATHLEN];
1332         register wchar_t        *p;
1333         Property                line;
1334         register Dependency     dependency;
1335         register Dependency     *remove;
1336         String_rec              string;
1337         wchar_t                 buffer[MAXPATHLEN];
1338         register Boolean        set_at = false;
1339         register wchar_t        *start;
1340         Dependency              new_depe;
1341         register Boolean        reuse_cell;
1342         Dependency              first_member;
1343         Name                    directory;
1344         Name                    lib;
1345         Name                    member;
1346         Property                prop;
1347         Name                    true_target = target;
1348         wchar_t                 *library;
1349 
1350         if ((line = get_prop(target->prop, line_prop)) == NULL) {
1351                 return;
1352         }
1353         /* If the target is constructed from a "::" target we consider that */
1354         if (target->has_target_prop) {
1355                 true_target = get_prop(target->prop,
1356                                        target_prop)->body.target.target;
1357         }
1358         /* Scan all dependencies and process the ones that contain "$" chars */
1359         for (dependency = line->body.line.dependencies;
1360              dependency != NULL;
1361              dependency = dependency->next) {
1362                 if (!dependency->name->dollar) {
1363                         continue;
1364                 }
1365                 target->has_depe_list_expanded = true;
1366 
1367                 /* The make macro $@ is bound to the target name once per */
1368                 /* invocation of dynamic_dependencies() */
1369                 if (!set_at) {
1370                         (void) SETVAR(c_at, true_target, false);
1371                         set_at = true;
1372                 }
1373                 /* Expand this dependency string */
1374                 INIT_STRING_FROM_STACK(string, buffer);
1375                 expand_value(dependency->name, &string, false);
1376                 /* Scan the expanded string. It could contain whitespace */
1377                 /* which mean it expands to several dependencies */
1378                 start = string.buffer.start;
1379                 while (iswspace(*start)) {
1380                         start++;
1381                 }
1382                 /* Remove the cell (later) if the macro was empty */
1383                 if (start[0] == (int) nul_char) {
1384                         dependency->name = NULL;
1385                 }
1386 
1387 /* azv 10/26/95 to fix bug BID_1170218 */
1388                 if ((start[0] == (int) period_char) &&
1389                     (start[1] == (int) slash_char)) {
1390                         start += 2;
1391                 }
1392 /* azv */
1393 
1394                 first_member = NULL;
1395                 /* We use the original dependency cell for the first */
1396                 /* dependency from the expansion */
1397                 reuse_cell = true;
1398                 /* We also have to deal with dependencies that expand to */
1399                 /* lib.a(members) notation */
1400                 for (p = start; *p != (int) nul_char; p++) {
1401                         if ((*p == (int) parenleft_char)) {
1402                                 lib = GETNAME(start, p - start);
1403                                 lib->is_member = true;
1404                                 first_member = dependency;
1405                                 start = p + 1;
1406                                 while (iswspace(*start)) {
1407                                         start++;
1408                                 }
1409                                 break;
1410                         }
1411                 }
1412                 do {
1413                     /* First skip whitespace */
1414                         for (p = start; *p != (int) nul_char; p++) {
1415                                 if ((*p == (int) nul_char) ||
1416                                     iswspace(*p) ||
1417                                     (*p == (int) parenright_char)) {
1418                                         break;
1419                                 }
1420                         }
1421                         /* Enter dependency from expansion */
1422                         if (p != start) {
1423                                 /* Create new dependency cell if */
1424                                 /* this is not the first dependency */
1425                                 /* picked from the expansion */
1426                                 if (!reuse_cell) {
1427                                         new_depe = ALLOC(Dependency);
1428                                         new_depe->next = dependency->next;
1429                                         new_depe->automatic = false;
1430                                         new_depe->stale = false;
1431                                         new_depe->built = false;
1432                                         dependency->next = new_depe;
1433                                         dependency = new_depe;
1434                                 }
1435                                 reuse_cell = false;
1436                                 /* Internalize the dependency name */
1437                                 // tolik. Fix for bug 4110429: inconsistent expansion for macros that
1438                                 // include "//" and "/./"
1439                                 //dependency->name = GETNAME(start, p - start);
1440                                 dependency->name = normalize_name(start, p - start);
1441                                 if ((debug_level > 0) &&
1442                                     (first_member == NULL)) {
1443                                         (void) printf(catgets(catd, 1, 25, "%*sDynamic dependency `%s' for target `%s'\n"),
1444                                                       recursion_level,
1445                                                       "",
1446                                                       dependency->name->string_mb,
1447                                                       true_target->string_mb);
1448                                 }
1449                                 for (start = p; iswspace(*start); start++);
1450                                 p = start;
1451                         }
1452                 } while ((*p != (int) nul_char) &&
1453                          (*p != (int) parenright_char));
1454                 /* If the expansion was of lib.a(members) format we now */
1455                 /* enter the proper member cells */
1456                 if (first_member != NULL) {
1457                         /* Scan the new dependencies and transform them from */
1458                         /* "foo" to "lib.a(foo)" */
1459                         for (; 1; first_member = first_member->next) {
1460                                 /* Build "lib.a(foo)" name */
1461                                 INIT_STRING_FROM_STACK(string, buffer);
1462                                 APPEND_NAME(lib,
1463                                               &string,
1464                                               (int) lib->hash.length);
1465                                 append_char((int) parenleft_char, &string);
1466                                 APPEND_NAME(first_member->name,
1467                                               &string,
1468                                               FIND_LENGTH);
1469                                 append_char((int) parenright_char, &string);
1470                                 member = first_member->name;
1471                                 /* Replace "foo" with "lib.a(foo)" */
1472                                 first_member->name =
1473                                   GETNAME(string.buffer.start, FIND_LENGTH);
1474                                 if (string.free_after_use) {
1475                                         retmem(string.buffer.start);
1476                                 }
1477                                 if (debug_level > 0) {
1478                                         (void) printf(catgets(catd, 1, 26, "%*sDynamic dependency `%s' for target `%s'\n"),
1479                                                       recursion_level,
1480                                                       "",
1481                                                       first_member->name->
1482                                                       string_mb,
1483                                                       true_target->string_mb);
1484                                 }
1485                                 first_member->name->is_member = lib->is_member;
1486                                 /* Add member property to member */
1487                                 prop = maybe_append_prop(first_member->name,
1488                                                          member_prop);
1489                                 prop->body.member.library = lib;
1490                                 prop->body.member.entry = NULL;
1491                                 prop->body.member.member = member;
1492                                 if (first_member == dependency) {
1493                                         break;
1494                                 }
1495                         }
1496                 }
1497         }
1498         Wstring wcb;
1499         /* Then scan all the dependencies again. This time we want to expand */
1500         /* shell file wildcards */
1501         for (remove = &line->body.line.dependencies, dependency = *remove;
1502              dependency != NULL;
1503              dependency = *remove) {
1504                 if (dependency->name == NULL) {
1505                         dependency = *remove = (*remove)->next;
1506                         continue;
1507                 }
1508                 /* If dependency name string contains shell wildcards */
1509                 /* replace the name with the expansion */
1510                 if (dependency->name->wildcard) {
1511                         wcb.init(dependency->name);
1512                         if ((start = (wchar_t *) wschr(wcb.get_string(),
1513                                            (int) parenleft_char)) != NULL) {
1514                                 /* lib(*) type pattern */
1515                                 library = buffer;
1516                                 (void) wsncpy(buffer,
1517                                               wcb.get_string(),
1518                                               start - wcb.get_string());
1519                                 buffer[start-wcb.get_string()] =
1520                                   (int) nul_char;
1521                                 (void) wsncpy(pattern,
1522                                               start + 1,
1523 (int) (dependency->name->hash.length-(start-wcb.get_string())-2));
1524                                 pattern[dependency->name->hash.length -
1525                                         (start-wcb.get_string()) - 2] =
1526                                           (int) nul_char;
1527                         } else {
1528                                 library = NULL;
1529                                 (void) wsncpy(pattern,
1530                                               wcb.get_string(),
1531                                               (int) dependency->name->hash.length);
1532                                 pattern[dependency->name->hash.length] =
1533                                   (int) nul_char;
1534                         }
1535                         start = (wchar_t *) wsrchr(pattern, (int) slash_char);
1536                         if (start == NULL) {
1537                                 directory = dot;
1538                                 p = pattern;
1539                         } else {
1540                                 directory = GETNAME(pattern, start-pattern);
1541                                 p = start+1;
1542                         }
1543                         /* The expansion is handled by the read_dir() routine*/
1544                         if (read_dir(directory, p, line, library)) {
1545                                 *remove = (*remove)->next;
1546                         } else {
1547                                 remove = &dependency->next;
1548                         }
1549                 } else {
1550                         remove = &dependency->next;
1551                 }
1552         }
1553 
1554         /* Then unbind $@ */
1555         (void) SETVAR(c_at, (Name) NULL, false);
1556 }
1557 
1558 /*
1559  * DONE.
1560  *
1561  *      run_command(line)
1562  *
1563  *      Takes one Cmd_line and runs the commands from it.
1564  *
1565  *      Return value:
1566  *                              Indicates if the command failed or not
1567  *
1568  *      Parameters:
1569  *              line            The command line to run
1570  *
1571  *      Global variables used:
1572  *              commands_done   Set if we do run command
1573  *              current_line    Set to the line we run a command from
1574  *              current_target  Set to the target we run a command for
1575  *              file_number     Used to form temp file name
1576  *              keep_state      Indicates that .KEEP_STATE is on
1577  *              make_state      The Name ".make.state", used to check timestamp
1578  *              parallel        True if currently building in parallel
1579  *              parallel_process_cnt Count of parallel processes running
1580  *              quest           Indicates that make -q is on
1581  *              rewrite_statefile Set if we do run a command
1582  *              sunpro_dependencies The Name "SUNPRO_DEPENDENCIES", set value
1583  *              temp_file_directory Used to form temp fie name
1584  *              temp_file_name  Set to the name of the temp file
1585  *              touch           Indicates that make -t is on
1586  */
1587 static Doname
1588 run_command(register Property line, Boolean)
1589 {
1590         register Doname         result = build_ok;
1591         register Boolean        remember_only = false;
1592         register Name           target = line->body.line.target;
1593         wchar_t                 *string;
1594         char                    tmp_file_path[MAXPATHLEN];
1595 
1596         if (!line->body.line.is_out_of_date && target->rechecking_target) {
1597                 target->rechecking_target = false;
1598                 return build_ok;
1599         }
1600 
1601         /*
1602          * Build the command if we know the target is out of date,
1603          * or if we want to check cmd consistency.
1604          */
1605         if (line->body.line.is_out_of_date || keep_state) {
1606                 /* Hack for handling conditional macros in DMake. */
1607                 if (!line->body.line.dont_rebuild_command_used) {
1608                         build_command_strings(target, line);
1609                 }
1610         }
1611         /* Never mind */
1612         if (!line->body.line.is_out_of_date) {
1613                 return build_ok;
1614         }
1615         /* If quest, then exit(1) because the target is out of date */
1616         if (quest) {
1617                 if (posix) {
1618 #ifdef TEAMWARE_MAKE_CMN
1619                         result = execute_parallel(line, true);
1620 #else
1621                         result = execute_serial(line);
1622 #endif
1623                 }
1624                 exit_status = 1;
1625                 exit(1);
1626         }
1627         /* We actually had to do something this time */
1628         rewrite_statefile = commands_done = true;
1629         /*
1630          * If this is an sccs command, we have to do some extra checking
1631          * and possibly complain. If the file can't be gotten because it's
1632          * checked out, we complain and behave as if the command was
1633          * executed eventhough we ignored the command.
1634          */
1635         if (!touch &&
1636             line->body.line.sccs_command &&
1637             (target->stat.time != file_doesnt_exist) &&
1638             ((target->stat.mode & 0222) != 0)) {
1639                 fatal(catgets(catd, 1, 27, "%s is writable so it cannot be sccs gotten"),
1640                       target->string_mb);
1641                 target->has_complained = remember_only = true;
1642         }
1643         /*
1644          * If KEEP_STATE is on, we make sure we have the timestamp for
1645          * .make.state. If .make.state changes during the command run,
1646          * we reread .make.state after the command. We also setup the
1647          * environment variable that asks utilities to report dependencies.
1648          */
1649         if (!touch &&
1650             keep_state &&
1651             !remember_only) {
1652                 (void) exists(make_state);
1653                 if((strlen(temp_file_directory) == 1) && 
1654                         (temp_file_directory[0] == '/')) {
1655                    tmp_file_path[0] = '\0';
1656                 } else {
1657                    strcpy(tmp_file_path, temp_file_directory);
1658                 }
1659                 sprintf(mbs_buffer,
1660                                 NOCATGETS("%s/.make.dependency.%08x.%d.%d"),
1661                                 tmp_file_path,
1662                                 hostid,
1663                                 getpid(),
1664                                 file_number++);
1665                 MBSTOWCS(wcs_buffer, mbs_buffer);
1666                 Boolean fnd;
1667                 temp_file_name = getname_fn(wcs_buffer, FIND_LENGTH, false, &fnd);
1668                 temp_file_name->stat.is_file = true;
1669                 int len = 2*MAXPATHLEN + strlen(target->string_mb) + 2;
1670                 wchar_t *to = string = ALLOC_WC(len);
1671                 for (wchar_t *from = wcs_buffer; *from != (int) nul_char; ) {
1672                         if (*from == (int) space_char) {
1673                                 *to++ = (int) backslash_char;
1674                         }
1675                         *to++ = *from++;
1676                 }
1677                 *to++ = (int) space_char;
1678                 MBSTOWCS(to, target->string_mb);
1679                 Name sprodep_name = getname_fn(string, FIND_LENGTH, false, &fnd);
1680                 (void) SETVAR(sunpro_dependencies,
1681                               sprodep_name,
1682                               false);
1683                 retmem(string);
1684         } else {
1685                 temp_file_name = NULL;
1686         }
1687 
1688         /*
1689          * In case we are interrupted, we need to know what was going on.
1690          */
1691         current_target = target;
1692         /*
1693          * We also need to be able to save an empty command instead of the
1694          * interrupted one in .make.state.
1695          */
1696         current_line = line;
1697         if (remember_only) {
1698                 /* Empty block!!! */
1699         } else if (touch) {
1700                 result = touch_command(line, target, result);
1701                 if (posix) {
1702 #ifdef TEAMWARE_MAKE_CMN
1703                         result = execute_parallel(line, true);
1704 #else
1705                         result = execute_serial(line);
1706 #endif
1707                 }
1708         } else {
1709                 /*
1710                  * If this is not a touch run, we need to execute the
1711                  * proper command(s) for the target.
1712                  */
1713 #ifdef TEAMWARE_MAKE_CMN
1714                 if (parallel) {
1715                         if (!parallel_ok(target, true)) {
1716                                 /*
1717                                  * We are building in parallel, but
1718                                  * this target must be built in serial.
1719                                  */
1720                                 /*
1721                                  * If nothing else is building,
1722                                  * do this one, else wait.
1723                                  */
1724                                 if (parallel_process_cnt == 0) {
1725 #ifdef TEAMWARE_MAKE_CMN
1726                                         result = execute_parallel(line, true, target->localhost);
1727 #else
1728                                         result = execute_serial(line);
1729 #endif
1730                                 } else {
1731                                         current_target = NULL;
1732                                         current_line = NULL;
1733 /*
1734                                         line->body.line.command_used = NULL;
1735  */
1736                                         line->body.line.dont_rebuild_command_used = true;
1737                                         return build_serial;
1738                                 }
1739                         } else {
1740                                 result = execute_parallel(line, false);
1741                                 switch (result) {
1742                                 case build_running:
1743                                         return build_running;
1744                                 case build_serial:
1745                                         if (parallel_process_cnt == 0) {
1746 #ifdef TEAMWARE_MAKE_CMN
1747                                                 result = execute_parallel(line, true, target->localhost);
1748 #else
1749                                                 result = execute_serial(line);
1750 #endif
1751                                         } else {
1752                                                 current_target = NULL;
1753                                                 current_line = NULL;
1754                                                 target->parallel = false;
1755                                                 line->body.line.command_used =
1756                                                                         NULL;
1757                                                 return build_serial;
1758                                         }
1759                                 }
1760                         }
1761                 } else {
1762 #endif
1763 #ifdef TEAMWARE_MAKE_CMN
1764                         result = execute_parallel(line, true, target->localhost);
1765 #else
1766                         result = execute_serial(line);
1767 #endif
1768 #ifdef TEAMWARE_MAKE_CMN
1769                 }
1770 #endif
1771         }
1772         temp_file_name = NULL;
1773         if (report_dependencies_level == 0){
1774                 update_target(line, result);
1775         }
1776         current_target = NULL;
1777         current_line = NULL;
1778         return result;
1779 }
1780 
1781 /*
1782  *      execute_serial(line)
1783  *
1784  *      Runs thru the command line for the target and
1785  *      executes the rules one by one.
1786  *
1787  *      Return value:
1788  *                              The result of the command build
1789  *
1790  *      Parameters:     
1791  *              line            The command to execute
1792  *
1793  *      Static variables used:
1794  *
1795  *      Global variables used:
1796  *              continue_after_error -k flag
1797  *              do_not_exec_rule -n flag
1798  *              report_dependencies -P flag
1799  *              silent          Don't echo commands before executing
1800  *              temp_file_name  Temp file for auto dependencies
1801  *              vpath_defined   If true, translate path for command
1802  */
1803 Doname
1804 execute_serial(Property line)
1805 {
1806         int                     child_pid = 0;




1807         Boolean                 printed_serial;
1808         Doname                  result = build_ok;
1809         Cmd_line                rule, cmd_tail, command = NULL;
1810         char                    mbstring[MAXPATHLEN];
1811         int                     filed;
1812         Name                    target = line->body.line.target;
1813 
1814         SEND_MTOOL_MSG(
1815                 if (!sent_rsrc_info_msg) {
1816                         if (userName[0] == '\0') {
1817                                 avo_get_user(userName, NULL);
1818                         }
1819                         if (hostName[0] == '\0') {
1820                                 strcpy(hostName, avo_hostname());
1821                         }
1822                         send_rsrc_info_msg(1, hostName, userName);
1823                         sent_rsrc_info_msg = 1;
1824                 }
1825                 send_job_start_msg(line);
1826                 job_result_msg = new Avo_MToolJobResultMsg();
1827         );
1828 
1829         target->has_recursive_dependency = false;
1830         // We have to create a copy of the rules chain for processing because
1831         // the original one can be destroyed during .make.state file rereading.
1832         for (rule = line->body.line.command_used;
1833              rule != NULL;
1834              rule = rule->next) {
1835                 if (command == NULL) {
1836                         command = cmd_tail = ALLOC(Cmd_line);
1837                 } else {
1838                         cmd_tail->next = ALLOC(Cmd_line);
1839                         cmd_tail = cmd_tail->next;
1840                 }
1841                 *cmd_tail = *rule;
1842         }
1843         if (command) {
1844                 cmd_tail->next = NULL;
1845         }
1846         for (rule = command; rule != NULL; rule = rule->next) {
1847                 if (posix && (touch || quest) && !rule->always_exec) {
1848                         continue;
1849                 }
1850                 if (vpath_defined) {
1851                         rule->command_line =
1852                           vpath_translation(rule->command_line);
1853                 }
1854                 /* Echo command line, maybe. */
1855                 if ((rule->command_line->hash.length > 0) &&
1856                     !silent &&
1857                     (!rule->silent || do_not_exec_rule) &&
1858                     (report_dependencies_level == 0)) {
1859                         (void) printf("%s\n", rule->command_line->string_mb);
1860                         SEND_MTOOL_MSG(
1861                                 job_result_msg->appendOutput(AVO_STRDUP(rule->command_line->string_mb));
1862                         );
1863                 }
1864                 if (rule->command_line->hash.length > 0) {
1865                         SEND_MTOOL_MSG(
1866                                 (void) sprintf(mbstring,
1867                                                 NOCATGETS("%s/make.stdout.%d.%d.XXXXXX"),
1868                                                 tmpdir,
1869                                                 getpid(),
1870                                                 file_number++);
1871 
1872                                 int tmp_fd = mkstemp(mbstring);
1873                                 if(tmp_fd) {
1874                                         (void) close(tmp_fd);
1875                                 }
1876 
1877                                 stdout_file = strdup(mbstring);
1878                                 stderr_file = NULL;
1879                                 child_pid = pollResults(stdout_file,
1880                                                         (char *)NULL,
1881                                                         (char *)NULL);
1882                         );
1883                         /* Do assignment if command line prefixed with "=" */
1884                         if (rule->assign) {
1885                                 result = build_ok;
1886                                 do_assign(rule->command_line, target);
1887                         } else if (report_dependencies_level == 0) {
1888                                 /* Execute command line. */



1889                                 setvar_envvar();

1890                                 result = dosys(rule->command_line,
1891                                                (Boolean) rule->ignore_error,
1892                                                (Boolean) rule->make_refd,
1893                                                /* ds 98.04.23 bug #4085164. make should always show error messages */
1894                                                false,
1895                                                /* BOOLEAN(rule->silent &&
1896                                                        rule->ignore_error), */
1897                                                (Boolean) rule->always_exec,
1898                                                target,
1899                                                send_mtool_msgs);
1900                                 check_state(temp_file_name);
1901                         }
1902                         SEND_MTOOL_MSG(
1903                                 append_job_result_msg(job_result_msg);
1904                                 if (child_pid > 0) {
1905                                         kill(child_pid, SIGUSR1);
1906                                         while (!((waitpid(child_pid, 0, 0) == -1)
1907                                                 && (errno == ECHILD)));
1908                                 }
1909                                 child_pid = 0;
1910                                 (void) unlink(stdout_file);
1911                                 retmem_mb(stdout_file);
1912                                 stdout_file = NULL;
1913                         );
1914                 } else {
1915                         result = build_ok;
1916                 }
1917                 if (result == build_failed) {
1918                         if (silent || rule->silent) {
1919                                 (void) printf(catgets(catd, 1, 242, "The following command caused the error:\n%s\n"),
1920                                               rule->command_line->string_mb);
1921                                 SEND_MTOOL_MSG(
1922                                         job_result_msg->appendOutput(AVO_STRDUP(catgets(catd, 1, 243, "The following command caused the error:")));
1923                                         job_result_msg->appendOutput(AVO_STRDUP(rule->command_line->string_mb));
1924                                 );
1925                         }
1926                         if (!rule->ignore_error && !ignore_errors) {
1927                                 if (!continue_after_error) {
1928                                         SEND_MTOOL_MSG(
1929                                                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
1930                                                 xdr_msg = (RWCollectable*)
1931                                                         job_result_msg;
1932                                                 xdr(&xdrs, xdr_msg);
1933                                                 (void) fflush(mtool_msgs_fp);
1934                                                 delete job_result_msg;
1935                                         );
1936                                         fatal(catgets(catd, 1, 244, "Command failed for target `%s'"),
1937                                               target->string_mb);
1938                                 }
1939                                 /*
1940                                  * Make sure a failing command is not
1941                                  * saved in .make.state.
1942                                  */
1943                                 line->body.line.command_used = NULL;
1944                                 break;
1945                         } else {
1946                                 result = build_ok;
1947                         }
1948                 }
1949         }
1950         for (rule = command; rule != NULL; rule = cmd_tail) {
1951                 cmd_tail = rule->next;
1952                 free(rule);
1953         }
1954         command = NULL;
1955         SEND_MTOOL_MSG(
1956                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
1957                 xdr_msg = (RWCollectable*) job_result_msg;
1958                 xdr(&xdrs, xdr_msg);
1959                 (void) fflush(mtool_msgs_fp);
1960 
1961                 delete job_result_msg;
1962         );
1963         if (temp_file_name != NULL) {
1964                 free_name(temp_file_name);
1965         }
1966         temp_file_name = NULL;
1967 
1968         Property spro = get_prop(sunpro_dependencies->prop, macro_prop);
1969         if(spro != NULL) {
1970                 Name val = spro->body.macro.value;
1971                 if(val != NULL) {
1972                         free_name(val);
1973                         spro->body.macro.value = NULL;
1974                 }
1975         }
1976         spro = get_prop(sunpro_dependencies->prop, env_mem_prop);
1977         if(spro) {
1978                 char *val = spro->body.env_mem.value;
1979                 if(val != NULL) {
1980                         /* 
1981                          * Do not return memory allocated for SUNPRO_DEPENDENCIES
1982                          * It will be returned in setvar_daemon() in macro.cc 
1983                          */
1984                         //      retmem_mb(val);
1985                         spro->body.env_mem.value = NULL;
1986                 }
1987         }
1988         
1989         return result;
1990 }
1991 
1992 




























































































































1993 
1994 /*
1995  *      vpath_translation(cmd)
1996  *
1997  *      Translates one command line by
1998  *      checking each word. If the word has an alias it is translated.
1999  *
2000  *      Return value:
2001  *                              The translated command
2002  *
2003  *      Parameters:
2004  *              cmd             Command to translate
2005  *
2006  *      Global variables used:
2007  */
2008 Name
2009 vpath_translation(register Name cmd)
2010 {
2011         wchar_t                 buffer[STRING_BUFFER_LENGTH];
2012         String_rec              new_cmd;
2013         wchar_t                 *p;
2014         wchar_t                 *start;
2015 
2016         if (!vpath_defined || (cmd == NULL) || (cmd->hash.length == 0)) {
2017                 return cmd;
2018         }
2019         INIT_STRING_FROM_STACK(new_cmd, buffer);
2020 
2021         Wstring wcb(cmd);
2022         p = wcb.get_string();
2023 
2024         while (*p != (int) nul_char) {
2025                 while (iswspace(*p) && (*p != (int) nul_char)) {
2026                         append_char(*p++, &new_cmd);
2027                 }
2028                 start = p;
2029                 while (!iswspace(*p) && (*p != (int) nul_char)) {
2030                         p++;
2031                 }
2032                 cmd = GETNAME(start, p - start);
2033                 if (cmd->has_vpath_alias_prop) {
2034                         cmd = get_prop(cmd->prop, vpath_alias_prop)->
2035                                                 body.vpath_alias.alias;
2036                         APPEND_NAME(cmd,
2037                                       &new_cmd,
2038                                       (int) cmd->hash.length);
2039                 } else {
2040                         append_string(start, &new_cmd, p - start);
2041                 }
2042         }
2043         cmd = GETNAME(new_cmd.buffer.start, FIND_LENGTH);
2044         if (new_cmd.free_after_use) {
2045                 retmem(new_cmd.buffer.start);
2046         }
2047         return cmd;
2048 }
2049 
2050 /*
2051  *      check_state(temp_file_name)
2052  *
2053  *      Reads and checks the state changed by the previously executed command.
2054  *
2055  *      Parameters:
2056  *              temp_file_name  The auto dependency temp file
2057  *
2058  *      Global variables used:
2059  */
2060 void
2061 check_state(Name temp_file_name)
2062 {
2063         if (!keep_state) {
2064                 return;
2065         }
2066 
2067         /*
2068          * Then read the temp file that now might 
2069          * contain dependency reports from utilities 
2070          */
2071         read_dependency_file(temp_file_name);
2072 
2073         /*
2074          * And reread .make.state if it
2075          * changed (the command ran recursive makes) 
2076          */
2077         check_read_state_file();
2078         if (temp_file_name != NULL) {
2079                 (void) unlink(temp_file_name->string_mb);
2080         }
2081 }
2082 
2083 /*
2084  *      read_dependency_file(filename)
2085  *
2086  *      Read the temp file used for reporting dependencies to make
2087  *
2088  *      Parameters:
2089  *              filename        The name of the file with the state info
2090  *
2091  *      Global variables used:
2092  *              makefile_type   The type of makefile being read
2093  *              read_trace_level Debug flag
2094  *              temp_file_number The always increasing number for unique files
2095  *              trace_reader    Debug flag
2096  */
2097 static void
2098 read_dependency_file(register Name filename)
2099 {
2100         register Makefile_type  save_makefile_type;
2101 
2102         if (filename == NULL) {
2103                 return;
2104         }
2105         filename->stat.time = file_no_time;
2106         if (exists(filename) > file_doesnt_exist) {
2107                 save_makefile_type = makefile_type;
2108                 makefile_type = reading_cpp_file;
2109                 if (read_trace_level > 1) {
2110                         trace_reader = true;
2111                 }
2112                 temp_file_number++;
2113                 (void) read_simple_file(filename,
2114                                         false,
2115                                         false,
2116                                         false,
2117                                         false,
2118                                         false,
2119                                         false);
2120                 trace_reader = false;
2121                 makefile_type = save_makefile_type;
2122         }
2123 }
2124 
2125 /*
2126  *      check_read_state_file()
2127  *
2128  *      Check if .make.state has changed
2129  *      If it has we reread it
2130  *
2131  *      Parameters:
2132  *
2133  *      Global variables used:
2134  *              make_state      Make state file name
2135  *              makefile_type   Type of makefile being read
2136  *              read_trace_level Debug flag
2137  *              trace_reader    Debug flag
2138  */
2139 static void
2140 check_read_state_file(void)
2141 {
2142         timestruc_t             previous = make_state->stat.time;
2143         register Makefile_type  save_makefile_type;
2144         register Property       makefile;
2145 
2146         make_state->stat.time = file_no_time;
2147         if ((exists(make_state) == file_doesnt_exist) ||
2148             (make_state->stat.time == previous)) {
2149                 return;
2150         }
2151         save_makefile_type = makefile_type;
2152         makefile_type = rereading_statefile;
2153         /* Make sure we clear the old cached contents of .make.state */
2154         makefile = maybe_append_prop(make_state, makefile_prop);
2155         if (makefile->body.makefile.contents != NULL) {
2156                 retmem(makefile->body.makefile.contents);
2157                 makefile->body.makefile.contents = NULL;
2158         }
2159         if (read_trace_level > 1) {
2160                 trace_reader = true;
2161         }
2162         temp_file_number++;
2163         (void) read_simple_file(make_state,
2164                                 false,
2165                                 false,
2166                                 false,
2167                                 false,
2168                                 false,
2169                                 true);
2170         trace_reader = false;
2171         makefile_type = save_makefile_type;
2172 }
2173 
2174 /*
2175  *      do_assign(line, target)
2176  *
2177  *      Handles runtime assignments for command lines prefixed with "=".
2178  *
2179  *      Parameters:
2180  *              line            The command that contains an assignment
2181  *              target          The Name of the target, used for error reports
2182  *
2183  *      Global variables used:
2184  *              assign_done     Set to indicate doname needs to reprocess
2185  */
2186 static void
2187 do_assign(register Name line, register Name target)
2188 {
2189         Wstring wcb(line);
2190         register wchar_t        *string = wcb.get_string();
2191         register wchar_t        *equal;
2192         register Name           name;
2193         register Boolean        append = false;
2194 
2195         /*
2196          * If any runtime assignments are done, doname() must reprocess all
2197          * targets in the future since the macro values used to build the
2198          * command lines for the targets might have changed.
2199          */
2200         assign_done = true;
2201         /* Skip white space. */
2202         while (iswspace(*string)) {
2203                 string++;
2204         }
2205         equal = string;
2206         /* Find "+=" or "=". */
2207         while (!iswspace(*equal) &&
2208                (*equal != (int) plus_char) &&
2209                (*equal != (int) equal_char)) {
2210                 equal++;
2211         }
2212         /* Internalize macro name. */
2213         name = GETNAME(string, equal - string);
2214         /* Skip over "+=" "=". */
2215         while (!((*equal == (int) nul_char) ||
2216                  (*equal == (int) equal_char) ||
2217                  (*equal == (int) plus_char))) {
2218                 equal++;
2219         }
2220         switch (*equal) {
2221         case nul_char:
2222                 fatal(catgets(catd, 1, 31, "= expected in rule `%s' for target `%s'"),
2223                       line->string_mb,
2224                       target->string_mb);
2225         case plus_char:
2226                 append = true;
2227                 equal++;
2228                 break;
2229         }
2230         equal++;
2231         /* Skip over whitespace in front of value. */
2232         while (iswspace(*equal)) {
2233                 equal++;
2234         }
2235         /* Enter new macro value. */
2236         enter_equal(name,
2237                     GETNAME(equal, wcb.get_string() + line->hash.length - equal),
2238                     append);
2239 }
2240 
2241 /*
2242  *      build_command_strings(target, line)
2243  *
2244  *      Builds the command string to used when
2245  *      building a target. If the string is different from the previous one
2246  *      is_out_of_date is set.
2247  *
2248  *      Parameters:
2249  *              target          Target to build commands for
2250  *              line            Where to stuff result
2251  *
2252  *      Global variables used:
2253  *              c_at            The Name "@", used to set macro value
2254  *              command_changed Set if command is different from old
2255  *              debug_level     Should we trace activities?
2256  *              do_not_exec_rule Always echo when running -n
2257  *              empty_name      The Name "", used for empty rule
2258  *              funny           Semantics of characters
2259  *              ignore_errors   Used to init field for line
2260  *              is_conditional  Set to false befor evaling macro, checked
2261  *                              after expanding macros
2262  *              keep_state      Indicates that .KEEP_STATE is on
2263  *              make_word_mentioned Set by macro eval, inits field for cmd
2264  *              query           The Name "?", used to set macro value
2265  *              query_mentioned Set by macro eval, inits field for cmd
2266  *              recursion_level Used for tracing
2267  *              silent          Used to init field for line
2268  */
2269 static void
2270 build_command_strings(Name target, register Property line)
2271 {
2272         String_rec              command_line;
2273         register Cmd_line       command_template = line->body.line.command_template;
2274         register Cmd_line       *insert = &line->body.line.command_used;
2275         register Cmd_line       used = *insert;
2276         wchar_t                 buffer[STRING_BUFFER_LENGTH];
2277         wchar_t                 *start;
2278         Name                    new_command_line;
2279         register Boolean        new_command_longer = false;
2280         register Boolean        ignore_all_command_dependency = true;
2281         Property                member;
2282         static Name             less_name;
2283         static Name             percent_name;
2284         static Name             star;
2285         Name                    tmp_name;
2286 
2287         if (less_name == NULL) {
2288                 MBSTOWCS(wcs_buffer, "<");
2289                 less_name = GETNAME(wcs_buffer, FIND_LENGTH);
2290                 MBSTOWCS(wcs_buffer, "%");
2291                 percent_name = GETNAME(wcs_buffer, FIND_LENGTH);
2292                 MBSTOWCS(wcs_buffer, "*");
2293                 star = GETNAME(wcs_buffer, FIND_LENGTH);
2294         }
2295 
2296         /* We have to check if a target depends on conditional macros */
2297         /* Targets that do must be reprocessed by doname() each time around */
2298         /* since the macro values used when building the target might have */
2299         /* changed */
2300         conditional_macro_used = false;
2301         /* If we are building a lib.a(member) target $@ should be bound */
2302         /* to lib.a */
2303         if (target->is_member &&
2304             ((member = get_prop(target->prop, member_prop)) != NULL)) {
2305                 target = member->body.member.library;
2306         }
2307         /* If we are building a "::" help target $@ should be bound to */
2308         /* the real target name */
2309         /* A lib.a(member) target is never :: */
2310         if (target->has_target_prop) {
2311                 target = get_prop(target->prop, target_prop)->
2312                   body.target.target;
2313         }
2314         /* Bind the magic macros that make supplies */
2315         tmp_name = target;
2316         if(tmp_name != NULL) {
2317                 if (tmp_name->has_vpath_alias_prop) {
2318                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2319                                         body.vpath_alias.alias;
2320                 }
2321         }
2322         (void) SETVAR(c_at, tmp_name, false);
2323 
2324         tmp_name = line->body.line.star;
2325         if(tmp_name != NULL) {
2326                 if (tmp_name->has_vpath_alias_prop) {
2327                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2328                                         body.vpath_alias.alias;
2329                 }
2330         }
2331         (void) SETVAR(star, tmp_name, false);
2332 
2333         tmp_name = line->body.line.less;
2334         if(tmp_name != NULL) {
2335                 if (tmp_name->has_vpath_alias_prop) {
2336                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2337                                         body.vpath_alias.alias;
2338                 }
2339         }
2340         (void) SETVAR(less_name, tmp_name, false);
2341 
2342         tmp_name = line->body.line.percent;
2343         if(tmp_name != NULL) {
2344                 if (tmp_name->has_vpath_alias_prop) {
2345                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2346                                         body.vpath_alias.alias;
2347                 }
2348         }
2349         (void) SETVAR(percent_name, tmp_name, false);
2350 
2351         /* $? is seldom used and it is expensive to build */
2352         /* so we store the list form and build the string on demand */
2353         Chain query_list = NULL;
2354         Chain *query_list_tail = &query_list;
2355 
2356         for (Chain ch = line->body.line.query; ch != NULL; ch = ch->next) {
2357                 *query_list_tail = ALLOC(Chain);
2358                 (*query_list_tail)->name = ch->name;
2359                 if ((*query_list_tail)->name->has_vpath_alias_prop) {
2360                         (*query_list_tail)->name =
2361                                 get_prop((*query_list_tail)->name->prop,
2362                                         vpath_alias_prop)->body.vpath_alias.alias;
2363                 }
2364                 (*query_list_tail)->next = NULL;
2365                 query_list_tail = &(*query_list_tail)->next;
2366         }
2367         (void) setvar_daemon(query,
2368                              (Name) query_list,
2369                              false,
2370                              chain_daemon,
2371                              false,
2372                              debug_level);
2373 
2374         /* build $^ */
2375         Chain hat_list = NULL;
2376         Chain *hat_list_tail = &hat_list;
2377 
2378         for (Dependency dependency = line->body.line.dependencies; 
2379                 dependency != NULL;
2380                 dependency = dependency->next) {
2381                 /* skip automatic dependencies */
2382                 if (!dependency->automatic) {
2383                         if ((dependency->name != force) &&
2384                                 (dependency->stale == false)) {
2385                                 *hat_list_tail = ALLOC(Chain);
2386                         
2387                                 if (dependency->name->is_member &&
2388                                         (get_prop(dependency->name->prop, member_prop) != NULL)) {
2389                                         (*hat_list_tail)->name = 
2390                                                         get_prop(dependency->name->prop,
2391                                                                 member_prop)->body.member.member;
2392                                 } else {
2393                                         (*hat_list_tail)->name = dependency->name;
2394                                 }
2395 
2396                                 if((*hat_list_tail)->name != NULL) {
2397                                         if ((*hat_list_tail)->name->has_vpath_alias_prop) {
2398                                                 (*hat_list_tail)->name =
2399                                                         get_prop((*hat_list_tail)->name->prop,
2400                                                                 vpath_alias_prop)->body.vpath_alias.alias;
2401                                         }
2402                                 }
2403 
2404                                 (*hat_list_tail)->next = NULL;
2405                                 hat_list_tail = &(*hat_list_tail)->next;
2406                         }
2407                 }
2408         }
2409         (void) setvar_daemon(hat,
2410                              (Name) hat_list,
2411                              false,
2412                              chain_daemon,
2413                              false,
2414                              debug_level);
2415 
2416 /* We have two command sequences we need to handle */
2417 /* The old one that we probably read from .make.state */
2418 /* and the new one we are building that will replace the old one */
2419 /* Even when KEEP_STATE is not on we build a new command sequence and store */
2420 /* it in the line prop. This command sequence is then executed by */
2421 /* run_command(). If KEEP_STATE is on it is also later written to */
2422 /* .make.state. The routine replaces the old command line by line with the */
2423 /* new one trying to reuse Cmd_lines */
2424 
2425         /* If there is no old command_used we have to start creating */
2426         /* Cmd_lines to keep the new cmd in */
2427         if (used == NULL) {
2428                 new_command_longer = true;
2429                 *insert = used = ALLOC(Cmd_line);
2430                 used->next = NULL;
2431                 used->command_line = NULL;
2432                 insert = &used->next;
2433         }
2434         /* Run thru the template for the new command and build the expanded */
2435         /* new command lines */
2436         for (;
2437              command_template != NULL;
2438              command_template = command_template->next, insert = &used->next, used = *insert) {
2439                 /* If there is no old command_used Cmd_line we need to */
2440                 /* create one and say that cmd consistency failed */
2441                 if (used == NULL) {
2442                         new_command_longer = true;
2443                         *insert = used = ALLOC(Cmd_line);
2444                         used->next = NULL;
2445                         used->command_line = empty_name;
2446                 }
2447                 /* Prepare the Cmd_line for the processing */
2448                 /* The command line prefixes "@-=?" are stripped and that */
2449                 /* information is saved in the Cmd_line */
2450                 used->assign = false;
2451                 used->ignore_error = ignore_errors;
2452                 used->silent = silent;
2453                 used->always_exec = false;
2454                 /* Expand the macros in the command line */
2455                 INIT_STRING_FROM_STACK(command_line, buffer);
2456                 make_word_mentioned =
2457                   query_mentioned =
2458                     false;
2459                 expand_value(command_template->command_line, &command_line, true);
2460                 /* If the macro $(MAKE) is mentioned in the command */
2461                 /* "make -n" runs actually execute the command */
2462                 used->make_refd = make_word_mentioned;
2463                 used->ignore_command_dependency = query_mentioned;
2464                 /* Strip the prefixes */
2465                 start = command_line.buffer.start;
2466                 for (;
2467                      iswspace(*start) ||
2468                      (get_char_semantics_value(*start) & (int) command_prefix_sem);
2469                      start++) {
2470                         switch (*start) {
2471                         case question_char:
2472                                 used->ignore_command_dependency = true;
2473                                 break;
2474                         case exclam_char:
2475                                 used->ignore_command_dependency = false;
2476                                 break;
2477                         case equal_char:
2478                                 used->assign = true;
2479                                 break;
2480                         case hyphen_char:
2481                                 used->ignore_error = true;
2482                                 break;
2483                         case at_char:
2484                                 if (!do_not_exec_rule) {
2485                                         used->silent = true;
2486                                 }
2487                                 break;
2488                         case plus_char:
2489                                 if(posix) {
2490                                   used->always_exec  = true;
2491                                 }
2492                                 break;
2493                         }
2494                 }
2495                 /* If all command lines of the template are prefixed with "?"*/
2496                 /* the VIRTUAL_ROOT is not used for cmd consistency checks */
2497                 if (!used->ignore_command_dependency) {
2498                         ignore_all_command_dependency = false;
2499                 }
2500                 /* Internalize the expanded and stripped command line */
2501                 new_command_line = GETNAME(start, FIND_LENGTH);
2502                 if ((used->command_line == NULL) &&
2503                     (line->body.line.sccs_command)) {
2504                         used->command_line = new_command_line;
2505                         new_command_longer = false;
2506                 }
2507                 /* Compare it with the old one for command consistency */
2508                 if (used->command_line != new_command_line) {
2509                         Name vpath_translated = vpath_translation(new_command_line);
2510                         if (keep_state &&
2511                             !used->ignore_command_dependency && (vpath_translated != used->command_line)) {
2512                                 if (debug_level > 0) {
2513                                         if (used->command_line != NULL
2514                                             && *used->command_line->string_mb !=
2515                                             '\0') {
2516                                                 (void) printf(catgets(catd, 1, 32, "%*sBuilding %s because new command \n\t%s\n%*sdifferent from old\n\t%s\n"),
2517                                                               recursion_level,
2518                                                               "",
2519                                                               target->string_mb,
2520                                                               vpath_translated->string_mb,
2521                                                               recursion_level,
2522                                                               "",
2523                                                               used->
2524                                                               command_line->
2525                                                               string_mb);
2526                                         } else {
2527                                                 (void) printf(catgets(catd, 1, 33, "%*sBuilding %s because new command \n\t%s\n%*sdifferent from empty old command\n"),
2528                                                               recursion_level,
2529                                                               "",
2530                                                               target->string_mb,
2531                                                               vpath_translated->string_mb,
2532                                                               recursion_level,
2533                                                               "");
2534                                         }
2535                                 }
2536                                 command_changed = true;
2537                                 line->body.line.is_out_of_date = true;
2538                         }
2539                         used->command_line = new_command_line;
2540                 }
2541                 if (command_line.free_after_use) {
2542                         retmem(command_line.buffer.start);
2543                 }
2544         }
2545         /* Check if the old command is longer than the new for */
2546         /* command consistency */
2547         if (used != NULL) {
2548                 *insert = NULL;
2549                 if (keep_state &&
2550                     !ignore_all_command_dependency) {
2551                         if (debug_level > 0) {
2552                                 (void) printf(catgets(catd, 1, 34, "%*sBuilding %s because new command shorter than old\n"),
2553                                               recursion_level,
2554                                               "",
2555                                               target->string_mb);
2556                         }
2557                         command_changed = true;
2558                         line->body.line.is_out_of_date = true;
2559                 }
2560         }
2561         /* Check if the new command is longer than the old command for */
2562         /* command consistency */
2563         if (new_command_longer &&
2564             !ignore_all_command_dependency &&
2565             keep_state) {
2566                 if (debug_level > 0) {
2567                         (void) printf(catgets(catd, 1, 35, "%*sBuilding %s because new command longer than old\n"),
2568                                       recursion_level,
2569                                       "",
2570                                       target->string_mb);
2571                 }
2572                 command_changed = true;
2573                 line->body.line.is_out_of_date = true;
2574         }
2575         /* Unbind the magic macros */
2576         (void) SETVAR(c_at, (Name) NULL, false);
2577         (void) SETVAR(star, (Name) NULL, false);
2578         (void) SETVAR(less_name, (Name) NULL, false);
2579         (void) SETVAR(percent_name, (Name) NULL, false);
2580         (void) SETVAR(query, (Name) NULL, false);
2581         if (query_list != NULL) {
2582                 delete_query_chain(query_list);
2583         }
2584         (void) SETVAR(hat, (Name) NULL, false);
2585         if (hat_list != NULL) {
2586                 delete_query_chain(hat_list);
2587         }
2588 
2589         if (conditional_macro_used) {
2590                 target->conditional_macro_list = cond_macro_list;
2591                 cond_macro_list = NULL;
2592                 target->depends_on_conditional = true;
2593         }
2594 }
2595 
2596 /*
2597  *      touch_command(line, target, result)
2598  *
2599  *      If this is an "make -t" run we do this.
2600  *      We touch all targets in the target group ("foo + fie:") if any.
2601  *
2602  *      Return value:
2603  *                              Indicates if the command failed or not
2604  *
2605  *      Parameters:
2606  *              line            The command line to update
2607  *              target          The target we are touching
2608  *              result          Initial value for the result we return
2609  *
2610  *      Global variables used:
2611  *              do_not_exec_rule Indicates that -n is on
2612  *              silent          Do not echo commands
2613  */
2614 static Doname
2615 touch_command(register Property line, register Name target, Doname result)
2616 {
2617         Name                    name;
2618         register Chain          target_group;
2619         String_rec              touch_string;
2620         wchar_t                 buffer[MAXPATHLEN];
2621         Name                    touch_cmd;
2622         Cmd_line                rule;
2623 








2624 
2625         SEND_MTOOL_MSG(
2626                 if (!sent_rsrc_info_msg) {
2627                         if (userName[0] == '\0') {
2628                                 avo_get_user(userName, NULL);
2629                         }
2630                         if (hostName[0] == '\0') {
2631                                 strcpy(hostName, avo_hostname());
2632                         }
2633                         send_rsrc_info_msg(1, hostName, userName);
2634                         sent_rsrc_info_msg = 1;
2635                 }
2636                 send_job_start_msg(line);
2637                 job_result_msg = new Avo_MToolJobResultMsg();
2638         );
2639         for (name = target, target_group = NULL; name != NULL;) {
2640                 if (!name->is_member) {
2641                         /*
2642                          * Build a touch command that can be passed
2643                          * to dosys(). If KEEP_STATE is on, "make -t"
2644                          * will save the proper command, not the
2645                          * "touch" in .make.state.
2646                          */
2647                         INIT_STRING_FROM_STACK(touch_string, buffer);
2648                         MBSTOWCS(wcs_buffer, NOCATGETS("touch "));
2649                         append_string(wcs_buffer, &touch_string, FIND_LENGTH);
2650                         touch_cmd = name;
2651                         if (name->has_vpath_alias_prop) {
2652                                 touch_cmd = get_prop(name->prop,
2653                                                  vpath_alias_prop)->
2654                                                    body.vpath_alias.alias;
2655                         }
2656                         APPEND_NAME(touch_cmd,
2657                                       &touch_string,
2658                                       FIND_LENGTH);
2659                         touch_cmd = GETNAME(touch_string.buffer.start,
2660                                             FIND_LENGTH);
2661                         if (touch_string.free_after_use) {
2662                                 retmem(touch_string.buffer.start);
2663                         }
2664                         if (!silent ||
2665                             do_not_exec_rule &&
2666                             (target_group == NULL)) {
2667                                 (void) printf("%s\n", touch_cmd->string_mb);
2668                                 SEND_MTOOL_MSG(
2669                                         job_result_msg->appendOutput(AVO_STRDUP(touch_cmd->string_mb));
2670                                 );
2671                         }
2672                         /* Run the touch command, or simulate it */
2673                         if (!do_not_exec_rule) {
2674 
2675                                 SEND_MTOOL_MSG(
2676                                         (void) sprintf(mbstring,
2677                                                         NOCATGETS("%s/make.stdout.%d.%d.XXXXXX"),
2678                                                         tmpdir,
2679                                                         getpid(),
2680                                                         file_number++);
2681                                 
2682                                         int tmp_fd = mkstemp(mbstring);
2683                                         if(tmp_fd) {
2684                                                 (void) close(tmp_fd);
2685                                         }
2686 
2687                                         stdout_file = strdup(mbstring);
2688                                         stderr_file = NULL;
2689                                         child_pid = pollResults(stdout_file,
2690                                                                 (char *)NULL,
2691                                                                 (char *)NULL);
2692                                 );
2693 
2694                                 result = dosys(touch_cmd,
2695                                                false,
2696                                                false,
2697                                                false,
2698                                                false,
2699                                                name,
2700                                                send_mtool_msgs);
2701 
2702                                 SEND_MTOOL_MSG(
2703                                         append_job_result_msg(job_result_msg);
2704                                         if (child_pid > 0) {
2705                                                 kill(child_pid, SIGUSR1);
2706                                                 while (!((waitpid(child_pid, 0, 0) == -1)
2707                                                         && (errno == ECHILD)));
2708                                         }
2709                                         child_pid = 0;
2710                                         (void) unlink(stdout_file);
2711                                         retmem_mb(stdout_file);
2712                                         stdout_file = NULL;
2713                                 );
2714 
2715                         } else {
2716                                 result = build_ok;
2717                         }
2718                 } else {
2719                         result = build_ok;
2720                 }
2721                 if (target_group == NULL) {
2722                         target_group = line->body.line.target_group;
2723                 } else {
2724                         target_group = target_group->next;
2725                 }
2726                 if (target_group != NULL) {
2727                         name = target_group->name;
2728                 } else {
2729                         name = NULL;
2730                 }
2731         }
2732         SEND_MTOOL_MSG(
2733                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
2734                 xdr_msg = (RWCollectable*) job_result_msg;
2735                 xdr(&xdrs, xdr_msg);
2736                 (void) fflush(mtool_msgs_fp);
2737                 delete job_result_msg;
2738         );
2739         return result;
2740 }
2741 
2742 /*
2743  *      update_target(line, result)
2744  *
2745  *      updates the status of a target after executing its commands.
2746  *
2747  *      Parameters:
2748  *              line            The command line block to update
2749  *              result          Indicates that build is OK so can update
2750  *
2751  *      Global variables used:
2752  *              do_not_exec_rule Indicates that -n is on
2753  *              touch           Fake the new timestamp if we are just touching
2754  */
2755 void
2756 update_target(Property line, Doname result)
2757 {
2758         Name                    target;
2759         Chain                   target_group;
2760         Property                line2;
2761         timestruc_t             old_stat_time;
2762         Property                member;
2763 
2764         /*
2765          * [tolik] Additional fix for bug 1063790. It was fixed
2766          * for serial make long ago, but DMake dumps core when
2767          * target is a symlink and sccs file is newer then target. 
2768          * In this case, finish_children() calls update_target()
2769          * with line==NULL.
2770          */
2771         if(line == NULL) {
2772                 /* XXX. Should we do anything here? */
2773                 return;
2774         }       
2775 
2776         target = line->body.line.target;
2777 
2778         if ((result == build_ok) && (line->body.line.command_used != NULL)) {
2779                 if (do_not_exec_rule ||
2780                     touch ||
2781                     (target->is_member &&
2782                      (line->body.line.command_template != NULL) &&
2783                      (line->body.line.command_template->command_line->string_mb[0] == 0) &&
2784                      (line->body.line.command_template->next == NULL))) {
2785                         /* If we are simulating execution we need to fake a */
2786                         /* new timestamp for the target we didnt build */
2787                         target->stat.time = file_max_time;
2788                 } else {
2789                         /*
2790                          * If we really built the target we read the new
2791                          * timestamp.
2792                          * Fix for bug #1110906: if .c file is newer than
2793                          * the corresponding .o file which is in an archive
2794                          * file, make will compile the .c file but it won't
2795                          * update the object in the .a file.
2796                          */
2797                         old_stat_time = target->stat.time;
2798                         target->stat.time = file_no_time;
2799                         (void) exists(target);
2800                         if ((target->is_member) &&
2801                             (target->stat.time == old_stat_time)) {
2802                                 member = get_prop(target->prop, member_prop);
2803                                 if (member != NULL) {
2804                                         target->stat.time = member->body.member.library->stat.time;
2805                                         target->stat.time.tv_sec++;
2806                                 }
2807                         }
2808                 }
2809                 /* If the target is part of a group we need to propagate the */
2810                 /* result of the run to all members */
2811                 for (target_group = line->body.line.target_group;
2812                      target_group != NULL;
2813                      target_group = target_group->next) {
2814                         target_group->name->stat.time = target->stat.time;
2815                         line2 = maybe_append_prop(target_group->name,
2816                                                   line_prop);
2817                         line2->body.line.command_used =
2818                           line->body.line.command_used;
2819                         line2->body.line.target = target_group->name;
2820                 }
2821         }
2822         target->has_built = true;
2823 }
2824 
2825 /*
2826  *      sccs_get(target, command)
2827  *
2828  *      Figures out if it possible to sccs get a file
2829  *      and builds the command to do it if it is.
2830  *
2831  *      Return value:
2832  *                              Indicates if sccs get failed or not
2833  *
2834  *      Parameters:
2835  *              target          Target to get
2836  *              command         Where to deposit command to use
2837  *
2838  *      Global variables used:
2839  *              debug_level     Should we trace activities?
2840  *              recursion_level Used for tracing
2841  *              sccs_get_rule   The rule to used for sccs getting
2842  */
2843 static Doname
2844 sccs_get(register Name target, register Property *command)
2845 {
2846         register int            result;
2847         char                    link[MAXPATHLEN];
2848         String_rec              string;
2849         wchar_t                 name[MAXPATHLEN];
2850         register wchar_t        *p;
2851         timestruc_t             sccs_time;
2852         register Property       line;
2853         int                     sym_link_depth = 0;
2854 
2855         /* For sccs, we need to chase symlinks. */
2856         while (target->stat.is_sym_link) {
2857                 if (sym_link_depth++ > 90) {
2858                         fatal(catgets(catd, 1, 95, "Can't read symbolic link `%s': Number of symbolic links encountered during path name traversal exceeds 90."),
2859                               target->string_mb);
2860                 }
2861                 /* Read the value of the link. */
2862                 result = readlink_vroot(target->string_mb,
2863                                         link,
2864                                         sizeof(link),
2865                                         NULL,
2866                                         VROOT_DEFAULT);
2867                 if (result == -1) {
2868                         fatal(catgets(catd, 1, 36, "Can't read symbolic link `%s': %s"),
2869                               target->string_mb, errmsg(errno));
2870                 }
2871                 link[result] = 0;
2872                 /* Use the value to build the proper filename. */
2873                 INIT_STRING_FROM_STACK(string, name);
2874 
2875                 Wstring wcb(target);
2876                 if ((link[0] != slash_char) &&
2877                     ((p = (wchar_t *) wsrchr(wcb.get_string(), slash_char)) != NULL)) {
2878                         append_string(wcb.get_string(), &string, p - wcb.get_string() + 1);
2879                 }
2880                 append_string(link, &string, result);
2881                 /* Replace the old name with the translated name. */
2882                 target = normalize_name(string.buffer.start, string.text.p - string.buffer.start);
2883                 (void) exists(target);
2884                 if (string.free_after_use) {
2885                         retmem(string.buffer.start);
2886                 }
2887         }
2888 
2889         /*
2890          * read_dir() also reads the ?/SCCS dir and saves information
2891          * about which files have SCSC/s. files.
2892          */
2893         if (target->stat.has_sccs == DONT_KNOW_SCCS) {
2894                 read_directory_of_file(target);
2895         }
2896         switch (target->stat.has_sccs) {
2897         case DONT_KNOW_SCCS:
2898                 /* We dont know by now there is no SCCS/s.* */
2899                 target->stat.has_sccs = NO_SCCS;
2900         case NO_SCCS:
2901                 /*
2902                  * If there is no SCCS/s.* but the plain file exists,
2903                  * we say things are OK.
2904                  */
2905                 if (target->stat.time > file_doesnt_exist) {
2906                         return build_ok;
2907                 }
2908                 /* If we cant find the plain file, we give up. */
2909                 return build_dont_know;
2910         case HAS_SCCS:
2911                 /*
2912                  * Pay dirt. We now need to figure out if the plain file
2913                  * is out of date relative to the SCCS/s.* file.
2914                  */
2915                 sccs_time = exists(get_prop(target->prop,
2916                                             sccs_prop)->body.sccs.file);
2917                 break;
2918         }
2919 
2920         if ((!target->has_complained &&
2921             (sccs_time != file_doesnt_exist) &&
2922             (sccs_get_rule != NULL))) {
2923                 /* only checking */
2924                 if (command == NULL) {
2925                         return build_ok;
2926                 }
2927                 /*
2928                  * We provide a command line for the target. The line is a
2929                  * "sccs get" command from default.mk.
2930                  */
2931                 line = maybe_append_prop(target, line_prop);
2932                 *command = line;
2933                 if (sccs_time > target->stat.time) {
2934                         /*
2935                          * And only if the plain file is out of date do we
2936                          * request execution of the command.
2937                          */
2938                         line->body.line.is_out_of_date = true;
2939                         if (debug_level > 0) {
2940                                 (void) printf(catgets(catd, 1, 37, "%*sSccs getting %s because s. file is younger than source file\n"),
2941                                               recursion_level,
2942                                               "",
2943                                               target->string_mb);
2944                         }
2945                 }
2946                 line->body.line.sccs_command = true;
2947                 line->body.line.command_template = sccs_get_rule;
2948                 if(!svr4 && (!allrules_read || posix)) {
2949                    if((target->prop) &&
2950                       (target->prop->body.sccs.file) &&
2951                       (target->prop->body.sccs.file->string_mb)) {
2952                       if((strlen(target->prop->body.sccs.file->string_mb) ==
2953                         strlen(target->string_mb) + 2) && 
2954                         (target->prop->body.sccs.file->string_mb[0] == 's') &&
2955                         (target->prop->body.sccs.file->string_mb[1] == '.')) {
2956 
2957                          line->body.line.command_template = get_posix_rule;
2958                       }
2959                    }
2960                 }
2961                 line->body.line.target = target;
2962                 /*
2963                  * Also make sure the rule is build with $* and $<
2964                  * bound properly.
2965                  */
2966                 line->body.line.star = NULL;
2967                 line->body.line.less = NULL;
2968                 line->body.line.percent = NULL;
2969                 return build_ok;
2970         }
2971         return build_dont_know;
2972 }
2973 
2974 /*
2975  *      read_directory_of_file(file)
2976  *
2977  *      Reads the directory the specified file lives in.
2978  *
2979  *      Parameters:
2980  *              file            The file we need to read dir for
2981  *
2982  *      Global variables used:
2983  *              dot             The Name ".", used as the default dir
2984  */
2985 void
2986 read_directory_of_file(register Name file)
2987 {
2988 
2989         Wstring file_string(file);
2990         wchar_t * wcb = file_string.get_string();
2991         wchar_t usr_include_buf[MAXPATHLEN];
2992         wchar_t usr_include_sys_buf[MAXPATHLEN];
2993 
2994         register Name           directory = dot;
2995         register wchar_t        *p = (wchar_t *) wsrchr(wcb,
2996                                                         (int) slash_char);
2997         register int            length = p - wcb;
2998         static Name             usr_include;
2999         static Name             usr_include_sys;
3000 
3001         if (usr_include == NULL) {
3002                 MBSTOWCS(usr_include_buf, NOCATGETS("/usr/include"));
3003                 usr_include = GETNAME(usr_include_buf, FIND_LENGTH);
3004                 MBSTOWCS(usr_include_sys_buf, NOCATGETS("/usr/include/sys"));
3005                 usr_include_sys = GETNAME(usr_include_sys_buf, FIND_LENGTH);
3006         }
3007 
3008         /*
3009          * If the filename contains a "/" we have to extract the path
3010          * Else the path defaults to ".".
3011          */
3012         if (p != NULL) {
3013                 /*
3014                  * Check some popular directories first to possibly
3015                  * save time. Compare string length first to gain speed.
3016                  */
3017                 if ((usr_include->hash.length == length) &&
3018                     IS_WEQUALN(usr_include_buf,
3019                                wcb,
3020                                length)) {
3021                         directory = usr_include;
3022                 } else if ((usr_include_sys->hash.length == length) &&
3023                            IS_WEQUALN(usr_include_sys_buf,
3024                                       wcb,
3025                                       length)) {
3026                         directory = usr_include_sys;
3027                 } else {
3028                         directory = GETNAME(wcb, length);
3029                 }
3030         }
3031         (void) read_dir(directory,
3032                         (wchar_t *) NULL,
3033                         (Property) NULL,
3034                         (wchar_t *) NULL);
3035 }
3036 
3037 /*
3038  *      add_pattern_conditionals(target)
3039  *
3040  *      Scan the list of conditionals defined for pattern targets and add any
3041  *      that match this target to its list of conditionals.
3042  *
3043  *      Parameters:
3044  *              target          The target we should add conditionals for
3045  *
3046  *      Global variables used:
3047  *              conditionals    The list of pattern conditionals
3048  */
3049 static void
3050 add_pattern_conditionals(register Name target)
3051 {
3052         register Property       conditional;
3053         Property                new_prop;
3054         Property                *previous;
3055         Name_rec                dummy;
3056         wchar_t                 *pattern;
3057         wchar_t                 *percent;
3058         int                     length;
3059 
3060         Wstring wcb(target);
3061         Wstring wcb1;
3062 
3063         for (conditional = get_prop(conditionals->prop, conditional_prop);
3064              conditional != NULL;
3065              conditional = get_prop(conditional->next, conditional_prop)) {
3066                 wcb1.init(conditional->body.conditional.target);
3067                 pattern = wcb1.get_string();
3068                 if (pattern[1] != 0) {
3069                         percent = (wchar_t *) wschr(pattern, (int) percent_char);
3070                         if (!wcb.equaln(pattern, percent-pattern) ||
3071                             !IS_WEQUAL(wcb.get_string(wcb.length()-wslen(percent+1)), percent+1)) {
3072                                 continue;
3073                         }
3074                 }
3075                 for (previous = &target->prop;
3076                      *previous != NULL;
3077                      previous = &(*previous)->next) {
3078                         if (((*previous)->type == conditional_prop) &&
3079                             ((*previous)->body.conditional.sequence >
3080                              conditional->body.conditional.sequence)) {
3081                                 break;
3082                         }
3083                 }
3084                 if (*previous == NULL) {
3085                         new_prop = append_prop(target, conditional_prop);
3086                 } else {
3087                         dummy.prop = NULL;
3088                         new_prop = append_prop(&dummy, conditional_prop);
3089                         new_prop->next = *previous;
3090                         *previous = new_prop;
3091                 }
3092                 target->conditional_cnt++;
3093                 new_prop->body.conditional = conditional->body.conditional;
3094         }
3095 }
3096 
3097 /*
3098  *      set_locals(target, old_locals)
3099  *
3100  *      Sets any conditional macros for the target.
3101  *      Each target carries a possibly empty set of conditional properties.
3102  *
3103  *      Parameters:
3104  *              target          The target to set conditional macros for
3105  *              old_locals      Space to store old values in
3106  *
3107  *      Global variables used:
3108  *              debug_level     Should we trace activity?
3109  *              is_conditional  We need to preserve this value
3110  *              recursion_level Used for tracing
3111  */
3112 void
3113 set_locals(register Name target, register Property old_locals)
3114 {
3115         register Property       conditional;
3116         register int            i;
3117         register Boolean        saved_conditional_macro_used;
3118         Chain                   cond_name;
3119         Chain                   cond_chain;
3120 
3121         if (target->dont_activate_cond_values) {
3122                 return;
3123         }
3124 
3125         saved_conditional_macro_used = conditional_macro_used;
3126 
3127         /* Scan the list of conditional properties and apply each one */
3128         for (conditional = get_prop(target->prop, conditional_prop), i = 0;
3129              conditional != NULL;
3130              conditional = get_prop(conditional->next, conditional_prop),
3131              i++) {
3132                 /* Save the old value */
3133                 old_locals[i].body.macro =
3134                   maybe_append_prop(conditional->body.conditional.name,
3135                                     macro_prop)->body.macro;
3136                 if (debug_level > 1) {
3137                         (void) printf(catgets(catd, 1, 38, "%*sActivating conditional value: "),
3138                                       recursion_level,
3139                                       "");
3140                 }
3141                 /* Set the conditional value. Macros are expanded when the */
3142                 /* macro is refd as usual */
3143                 if ((conditional->body.conditional.name != virtual_root) ||
3144                     (conditional->body.conditional.value != virtual_root)) {
3145                         (void) SETVAR(conditional->body.conditional.name,
3146                                       conditional->body.conditional.value,
3147                                       (Boolean) conditional->body.conditional.append);
3148                 }
3149                 cond_name = ALLOC(Chain);
3150                 cond_name->name = conditional->body.conditional.name;
3151         }
3152         /* Put this target on the front of the chain of conditional targets */
3153         cond_chain = ALLOC(Chain);
3154         cond_chain->name = target;
3155         cond_chain->next = conditional_targets;
3156         conditional_targets = cond_chain;
3157         conditional_macro_used = saved_conditional_macro_used;
3158 }
3159 
3160 /*
3161  *      reset_locals(target, old_locals, conditional, index)
3162  *
3163  *      Removes any conditional macros for the target.
3164  *
3165  *      Parameters:
3166  *              target          The target we are retoring values for
3167  *              old_locals      The values to restore
3168  *              conditional     The first conditional block for the target
3169  *              index           into the old_locals vector
3170  *      Global variables used:
3171  *              debug_level     Should we trace activities?
3172  *              recursion_level Used for tracing
3173  */
3174 void
3175 reset_locals(register Name target, register Property old_locals, register Property conditional, register int index)
3176 {
3177         register Property       this_conditional;
3178         Chain                   cond_chain;
3179 
3180         if (target->dont_activate_cond_values) {
3181                 return;
3182         }
3183 
3184         /* Scan the list of conditional properties and restore the old value */
3185         /* to each one Reverse the order relative to when we assigned macros */
3186         this_conditional = get_prop(conditional->next, conditional_prop);
3187         if (this_conditional != NULL) {
3188                 reset_locals(target, old_locals, this_conditional, index+1);
3189         } else {
3190                 /* Remove conditional target from chain */
3191                 if (conditional_targets == NULL ||
3192                     conditional_targets->name != target) {
3193                         warning(catgets(catd, 1, 39, "Internal error: reset target not at head of condtional_targets chain"));
3194                 } else {
3195                         cond_chain = conditional_targets->next;
3196                         retmem_mb((caddr_t) conditional_targets);
3197                         conditional_targets = cond_chain;
3198                 }
3199         }
3200         get_prop(conditional->body.conditional.name->prop,
3201                  macro_prop)->body.macro = old_locals[index].body.macro;
3202         if (conditional->body.conditional.name == virtual_root) {
3203                 (void) SETVAR(virtual_root, getvar(virtual_root), false);
3204         }
3205         if (debug_level > 1) {
3206                 if (old_locals[index].body.macro.value != NULL) {
3207                         (void) printf(catgets(catd, 1, 40, "%*sdeactivating conditional value: %s= %s\n"),
3208                                       recursion_level,
3209                                       "",
3210                                       conditional->body.conditional.name->
3211                                       string_mb,
3212                                       old_locals[index].body.macro.value->
3213                                       string_mb);
3214                 } else {
3215                         (void) printf(catgets(catd, 1, 41, "%*sdeactivating conditional value: %s =\n"),
3216                                       recursion_level,
3217                                       "",
3218                                       conditional->body.conditional.name->
3219                                       string_mb);
3220                 }
3221         }
3222 }
3223 
3224 /*
3225  *      check_auto_dependencies(target, auto_count, automatics)
3226  *
3227  *      Returns true if the target now has a dependency
3228  *      it didn't previously have (saved on automatics).
3229  *
3230  *      Return value:
3231  *                              true if new dependency found
3232  *
3233  *      Parameters:
3234  *              target          Target we check
3235  *              auto_count      Number of old automatic vars
3236  *              automatics      Saved old automatics
3237  *
3238  *      Global variables used:
3239  *              keep_state      Indicates that .KEEP_STATE is on
3240  */
3241 Boolean
3242 check_auto_dependencies(Name target, int auto_count, Name *automatics)
3243 {
3244         Name            *p;
3245         int             n;
3246         Property        line;
3247         Dependency      dependency;
3248 
3249         if (keep_state) {
3250                 if ((line = get_prop(target->prop, line_prop)) == NULL) {
3251                         return false;
3252                 }
3253                 /* Go thru new list of automatic depes */
3254                 for (dependency = line->body.line.dependencies;
3255                      dependency != NULL;
3256                      dependency = dependency->next) {
3257                         /* And make sure that each one existed before we */
3258                         /* built the target */
3259                         if (dependency->automatic && !dependency->stale) {
3260                                 for (n = auto_count, p = automatics;
3261                                      n > 0;
3262                                      n--) {
3263                                         if (*p++ == dependency->name) {
3264                                                 /* If we can find it on the */
3265                                                 /* saved list of autos we */
3266                                                 /* are OK  */
3267                                                 goto not_new;
3268                                         }
3269                                 }
3270                                 /* But if we scan over the old list */
3271                                 /* of auto. without finding it it is */
3272                                 /* new and we must check it */
3273                                 return true;
3274                         }
3275                 not_new:;
3276                 }
3277                 return false;
3278         } else {
3279                 return false;
3280         }
3281 }
3282 






























































































































































3283 
3284 // Recursively delete each of the Chain struct on the chain.
3285 
3286 static void
3287 delete_query_chain(Chain ch)
3288 {
3289         if (ch == NULL) {
3290                 return;
3291         } else {
3292                 delete_query_chain(ch->next);
3293                 retmem_mb((char *) ch);
3294         }
3295 }
3296 
3297 Doname
3298 target_can_be_built(register Name target) {
3299         Doname          result = build_dont_know;
3300         Name            true_target = target;
3301         Property        line;
3302 
3303         if (target == wait_name) {
3304                 return(build_ok);
3305         }
3306         /*
3307          * If the target is a constructed one for a "::" target,
3308          * we need to consider that.
3309          */
3310         if (target->has_target_prop) {
3311                 true_target = get_prop(target->prop,
3312                                        target_prop)->body.target.target;
3313         }
3314 
3315         (void) exists(true_target);
3316 
3317         if (true_target->state == build_running) {
3318                 return(build_running);
3319         }
3320         if (true_target->stat.time != file_doesnt_exist) {
3321                 result = build_ok;
3322         }
3323 
3324         /* get line property for the target */
3325         line = get_prop(true_target->prop, line_prop);
3326 
3327         /* first check for explicit rule */
3328         if (line != NULL && line->body.line.command_template != NULL) {
3329                 result = build_ok;
3330         }
3331         /* try to find pattern rule */
3332         if (result == build_dont_know) {
3333                 result = find_percent_rule(target, NULL, false);
3334         }
3335         
3336         /* try to find double suffix rule */
3337         if (result == build_dont_know) {
3338                 if (target->is_member) {
3339                         Property member = get_prop(target->prop, member_prop);
3340                         if (member != NULL && member->body.member.member != NULL) {
3341                                 result = find_ar_suffix_rule(target, member->body.member.member, NULL, false);
3342                         } else {
3343                                 result = find_double_suffix_rule(target, NULL, false);
3344                         }
3345                 } else {
3346                         result = find_double_suffix_rule(target, NULL, false);
3347                 }
3348         }
3349         
3350         /* try to find suffix rule */
3351         if ((result == build_dont_know) && second_pass) {
3352                 result = find_suffix_rule(target, target, empty_name, NULL, false);
3353         }
3354         
3355         /* check for sccs */
3356         if (result == build_dont_know) {
3357                 result = sccs_get(target, NULL);
3358         }
3359         
3360         /* try to find dyn target */
3361         if (result == build_dont_know) {
3362                 Name dtarg = find_dyntarget(target);
3363                 if (dtarg != NULL) {
3364                         result = target_can_be_built(dtarg);
3365                 }
3366         }
3367         
3368         /* check whether target was mentioned in makefile */
3369         if (result == build_dont_know) {
3370                 if (target->colons != no_colon) {
3371                         result = build_ok;
3372                 }
3373         }
3374 
3375         /* result */
3376         return result;
3377 }
--- EOF ---