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 #if defined(TEAMWARE_MAKE_CMN)
  37 #include <avo/util.h>             /* avo_get_user(), avo_hostname() */
  38 #endif
  39 
  40 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
  41 #       include <avo/strings.h>   /* AVO_STRDUP() */
  42 #       include <dm/Avo_MToolJobResultMsg.h>
  43 #       include <dm/Avo_MToolJobStartMsg.h>
  44 #       include <dm/Avo_MToolRsrcInfoMsg.h>
  45 #       include <dm/Avo_macro_defs.h> /* AVO_BLOCK_INTERUPTS & AVO_UNBLOCK_INTERUPTS */
  46 #       include <dmthread/Avo_ServerState.h>
  47 #       include <rw/pstream.h>
  48 #       include <rw/xdrstrea.h>
  49 #endif
  50 
  51 #include <fcntl.h>
  52 #include <mk/defs.h>
  53 #include <mksh/i18n.h>            /* get_char_semantics_value() */
  54 #include <mksh/macro.h>           /* getvar(), expand_value() */
  55 #include <mksh/misc.h>            /* getmem() */
  56 #include <poll.h>
  57 
  58 
  59 #include <signal.h>
  60 
  61 #       include <stropts.h>
  62 
  63 #include <sys/errno.h>
  64 #include <sys/stat.h>
  65 #include <sys/types.h>
  66 #include <sys/utsname.h>  /* uname() */
  67 #include <sys/wait.h>
  68 #include <unistd.h>               /* close() */
  69 
  70 /*
  71  * Defined macros
  72  */
  73 #       define LOCALHOST "localhost"
  74 
  75 #define MAXRULES 100
  76 
  77 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
  78 #define SEND_MTOOL_MSG(cmds) \
  79         if (send_mtool_msgs) { \
  80                 cmds \
  81         }
  82 #else
  83 #define SEND_MTOOL_MSG(cmds) 
  84 #endif
  85 
  86 // Sleep for .1 seconds between stat()'s
  87 const int       STAT_RETRY_SLEEP_TIME = 100000;
  88 
  89 /*
  90  * typedefs & structs
  91  */
  92 
  93 /*
  94  * Static variables
  95  */
  96 static char     hostName[MAXNAMELEN] = "";
  97 static char     userName[MAXNAMELEN] = "";
  98 
  99 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
 100         static FILE     *mtool_msgs_fp;
 101         static XDR      xdrs;
 102         static int      sent_rsrc_info_msg = 0;
 103 #endif
 104 
 105 static int      second_pass = 0;
 106 
 107 /*
 108  * File table of contents
 109  */
 110 extern  Doname          doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
 111 extern  Doname          doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
 112 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);
 113 void            dynamic_dependencies(Name target);
 114 static  Doname          run_command(register Property line, Boolean print_machine);
 115 extern  Doname          execute_serial(Property line);
 116 extern  Name            vpath_translation(register Name cmd);
 117 extern  void            check_state(Name temp_file_name);
 118 static  void            read_dependency_file(register Name filename);
 119 static  void            check_read_state_file(void);
 120 static  void            do_assign(register Name line, register Name target);
 121 static  void            build_command_strings(Name target, register Property line);
 122 static  Doname          touch_command(register Property line, register Name target, Doname result);
 123 extern  void            update_target(Property line, Doname result);
 124 static  Doname          sccs_get(register Name target, register Property *command);
 125 extern  void            read_directory_of_file(register Name file);
 126 static  void            add_pattern_conditionals(register Name target);
 127 extern  void            set_locals(register Name target, register Property old_locals);
 128 extern  void            reset_locals(register Name target, register Property old_locals, register Property conditional, register int index);
 129 extern  Boolean         check_auto_dependencies(Name target, int auto_count, Name *automatics);
 130 static  void            delete_query_chain(Chain ch);
 131 
 132 // From read2.cc
 133 extern  Name            normalize_name(register wchar_t *name_string, register int length);
 134 
 135 
 136 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
 137         static void             append_job_result_msg(Avo_MToolJobResultMsg *job_result_msg);
 138         static int              pollResults(char *outFn, char *errFn, char *hostNm);
 139         static void             pollResultsAction(char *outFn, char *errFn);
 140         static void             rxmGetNextResultsBlock(int fd);
 141         static int              us_sleep(unsigned int nusecs);
 142         extern "C" void         Avo_PollResultsAction_Sigusr1Handler(int foo);
 143 #endif
 144 
 145 /*
 146  * DONE.
 147  *
 148  *      doname_check(target, do_get, implicit, automatic)
 149  *
 150  *      Will call doname() and then inspect the return value
 151  *
 152  *      Return value:
 153  *                              Indication if the build failed or not
 154  *
 155  *      Parameters:
 156  *              target          The target to build
 157  *              do_get          Passed thru to doname()
 158  *              implicit        Passed thru to doname()
 159  *              automatic       Are we building a hidden dependency?
 160  *
 161  *      Global variables used:
 162  *              build_failed_seen       Set if -k is on and error occurs
 163  *              continue_after_error    Indicates that -k is on
 164  *              report_dependencies     No error msg if -P is on
 165  */
 166 Doname
 167 doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
 168 {
 169         int first_time = 1;
 170         (void) fflush(stdout);
 171 try_again:
 172         switch (doname(target, do_get, implicit, automatic)) {
 173         case build_ok:
 174                 second_pass = 0;
 175                 return build_ok;
 176         case build_running:
 177                 second_pass = 0;
 178                 return build_running;
 179         case build_failed:
 180                 if (!continue_after_error) {
 181                         fatal(catgets(catd, 1, 13, "Target `%s' not remade because of errors"),
 182                               target->string_mb);
 183                 }
 184                 build_failed_seen = true;
 185                 second_pass = 0;
 186                 return build_failed;
 187         case build_dont_know:
 188                 /*
 189                  * If we can't figure out how to build an automatic
 190                  * (hidden) dependency, we just ignore it.
 191                  * We later declare the target to be out of date just in
 192                  * case something changed.
 193                  * Also, don't complain if just reporting the dependencies
 194                  * and not building anything.
 195                  */
 196                 if (automatic || (report_dependencies_level > 0)) {
 197                         second_pass = 0;
 198                         return build_dont_know;
 199                 }
 200                 if(first_time) {
 201                         first_time = 0;
 202                         second_pass = 1;
 203                         goto try_again;
 204                 }
 205                 second_pass = 0;
 206                 if (continue_after_error && !svr4) {
 207                         warning(catgets(catd, 1, 14, "Don't know how to make target `%s'"),
 208                                 target->string_mb);
 209                         build_failed_seen = true;
 210                         return build_failed;
 211                 }
 212                 fatal(catgets(catd, 1, 15, "Don't know how to make target `%s'"), target->string_mb);
 213                 break;
 214         }
 215 #ifdef lint
 216         return build_failed;
 217 #endif
 218 }
 219 
 220 
 221 void
 222 enter_explicit_rule_from_dynamic_rule(Name target, Name source)
 223 {
 224         Property line, source_line;
 225         Dependency dependency;
 226 
 227         source_line = get_prop(source->prop, line_prop);
 228         line = maybe_append_prop(target, line_prop);
 229         line->body.line.sccs_command = false;
 230         line->body.line.target = target;
 231         if (line->body.line.command_template == NULL) {
 232                 line->body.line.command_template = source_line->body.line.command_template;
 233                 for (dependency = source_line->body.line.dependencies;
 234                      dependency != NULL;
 235                      dependency = dependency->next) {
 236                         enter_dependency(line, dependency->name, false);
 237                 }
 238                 line->body.line.less = target;
 239         }
 240         line->body.line.percent = NULL;
 241 }
 242 
 243 
 244 
 245 Name
 246 find_dyntarget(Name target)
 247 {
 248         Dyntarget               p;
 249         int                     i;
 250         String_rec              string;
 251         wchar_t                 buffer[STRING_BUFFER_LENGTH];
 252         wchar_t                 *pp, * bufend;
 253         wchar_t                 tbuffer[MAXPATHLEN];
 254         Wstring                 wcb(target);
 255 
 256         for (p = dyntarget_list; p != NULL; p = p->next) {
 257                 INIT_STRING_FROM_STACK(string, buffer);
 258                 expand_value(p->name, &string, false);
 259                 i = 0;
 260                 pp = string.buffer.start;
 261                 bufend = pp + STRING_BUFFER_LENGTH;
 262                 while((*pp != nul_char) && (pp < bufend)) {
 263                         if(iswspace(*pp)) {
 264                                 tbuffer[i] = nul_char;
 265                                 if(i > 0) {
 266                                         if (wcb.equal(tbuffer)) {
 267                                                 enter_explicit_rule_from_dynamic_rule(target, p->name);
 268                                                 return(target);
 269                                         }
 270                                 }
 271                                 pp++;
 272                                 i = 0;
 273                                 continue;
 274                         }
 275                         tbuffer[i] = *pp;
 276                         i++;
 277                         pp++;
 278                         if(*pp == nul_char) {
 279                                 tbuffer[i] = nul_char;
 280                                 if(i > 0) {
 281                                         if (wcb.equal(tbuffer)) {
 282                                                 enter_explicit_rule_from_dynamic_rule(target, p->name);
 283                                                 return(target);
 284                                         }
 285                                 }
 286                                 break;
 287                         }
 288                 }
 289         }
 290         return(NULL);
 291 }
 292 
 293 /*
 294  * DONE.
 295  *
 296  *      doname(target, do_get, implicit)
 297  *
 298  *      Chases all files the target depends on and builds any that
 299  *      are out of date. If the target is out of date it is then rebuilt.
 300  *
 301  *      Return value:
 302  *                              Indiates if build failed or nt
 303  *
 304  *      Parameters:
 305  *              target          Target to build
 306  *              do_get          Run sccs get is nessecary
 307  *              implicit        doname is trying to find an implicit rule
 308  *
 309  *      Global variables used:
 310  *              assign_done     True if command line assgnment has happened
 311  *              commands_done   Preserved for the case that we need local value
 312  *              debug_level     Should we trace make's actions?
 313  *              default_rule    The rule for ".DEFAULT", used as last resort
 314  *              empty_name      The Name "", used when looking for single sfx
 315  *              keep_state      Indicates that .KEEP_STATE is on
 316  *              parallel        True if building in parallel
 317  *              recursion_level Used for tracing
 318  *              report_dependencies make -P is on
 319  */
 320 Doname
 321 doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
 322 {
 323         Doname                  result = build_dont_know;
 324         Chain                   out_of_date_list = NULL;
 325 #ifdef TEAMWARE_MAKE_CMN
 326         Chain                   target_group;
 327 #endif
 328         Property                old_locals = NULL;
 329         register Property       line;
 330         Property                command = NULL;
 331         register Dependency     dependency;
 332         Name                    less = NULL;
 333         Name                    true_target = target;
 334         Name                    *automatics = NULL;
 335         register int            auto_count;
 336         Boolean                 rechecking_target = false;
 337         Boolean                 saved_commands_done;
 338         Boolean                 restart = false;
 339         Boolean                 save_parallel = parallel;
 340         Boolean                 doing_subtree = false;
 341 
 342         Boolean                 recheck_conditionals = false;
 343 
 344         if (target->state == build_running) {
 345                 return build_running;
 346         }
 347         line = get_prop(target->prop, line_prop);
 348 #ifdef TEAMWARE_MAKE_CMN
 349         if (line != NULL) {
 350                 /*
 351                  * If this target is a member of target group and one of the
 352                  * other members of the group is running, mark this target
 353                  * as running.
 354                  */
 355                 for (target_group = line->body.line.target_group;
 356                      target_group != NULL;
 357                      target_group = target_group->next) {
 358                         if (is_running(target_group->name)) {
 359                                 target->state = build_running;
 360                                 add_pending(target,
 361                                             recursion_level,
 362                                             do_get,
 363                                             implicit,
 364                                             false);
 365                                 return build_running;
 366                         }
 367                 }
 368         }
 369 #endif
 370         /*
 371          * If the target is a constructed one for a "::" target,
 372          * we need to consider that.
 373          */
 374         if (target->has_target_prop) {
 375                 true_target = get_prop(target->prop,
 376                                        target_prop)->body.target.target;
 377                 if (true_target->colon_splits > 0) {
 378                         /* Make sure we have a valid time for :: targets */
 379                         Property        time;
 380 
 381                         time = get_prop(true_target->prop, time_prop);
 382                         if (time != NULL) {
 383                                 true_target->stat.time = time->body.time.time;
 384                         }
 385                 }
 386         }
 387         (void) exists(true_target);
 388         /*
 389          * If the target has been processed, we don't need to do it again,
 390          * unless it depends on conditional macros or a delayed assignment,
 391          * or it has been done when KEEP_STATE is on.
 392          */
 393         if (target->state == build_ok) {
 394                 if((!keep_state || (!target->depends_on_conditional && !assign_done))) {
 395                         return build_ok;
 396                 } else {
 397                         recheck_conditionals = true;
 398                 }
 399         }
 400         if (target->state == build_subtree) {
 401                 /* A dynamic macro subtree is being built */
 402                 target->state = build_dont_know;
 403                 doing_subtree = true;
 404                 if (!target->checking_subtree) {
 405                         /*
 406                          * This target has been started before and therefore
 407                          * not all dependencies have to be built.
 408                          */
 409                         restart = true;
 410                 }
 411         } else if (target->state == build_pending) {
 412                 target->state = build_dont_know;
 413                 restart = true;
 414 /*
 415 #ifdef TEAMWARE_MAKE_CMN
 416         } else if (parallel &&
 417                    keep_state &&
 418                    (target->conditional_cnt > 0)) {
 419             if (!parallel_ok(target, false)) {
 420                 add_subtree(target, recursion_level, do_get, implicit);
 421                 target->state = build_running;
 422                 return build_running;
 423             }
 424 #endif
 425  */
 426         }
 427         /*
 428          * If KEEP_STATE is on, we have to rebuild the target if the
 429          * building of it caused new automatic dependencies to be reported.
 430          * This is where we restart the build.
 431          */
 432         if (line != NULL) {
 433                 line->body.line.percent = NULL;
 434         }
 435 recheck_target:
 436         /* Init all local variables */
 437         result = build_dont_know;
 438         out_of_date_list = NULL;
 439         command = NULL;
 440         less = NULL;
 441         auto_count = 0;
 442         if (!restart && line != NULL) {
 443                 /*
 444                  * If this target has never been built before, mark all
 445                  * of the dependencies as never built.
 446                  */
 447                 for (dependency = line->body.line.dependencies;
 448                      dependency != NULL;
 449                      dependency = dependency->next) {
 450                         dependency->built = false;
 451                 }
 452         }
 453         /* Save the set of automatic depes defined for this target */
 454         if (keep_state &&
 455             (line != NULL) &&
 456             (line->body.line.dependencies != NULL)) {
 457                 Name *p;
 458 
 459                 /*
 460                  * First run thru the dependency list to see how many
 461                  * autos there are.
 462                  */
 463                 for (dependency = line->body.line.dependencies;
 464                      dependency != NULL;
 465                      dependency = dependency->next) {
 466                         if (dependency->automatic && !dependency->stale) {
 467                                 auto_count++;
 468                         }
 469                 }
 470                 /* Create vector to hold the current autos */
 471                 automatics =
 472                   (Name *) alloca((int) (auto_count * sizeof (Name)));
 473                 /* Copy them */
 474                 for (p = automatics, dependency = line->body.line.dependencies;
 475                      dependency != NULL;
 476                      dependency = dependency->next) {
 477                         if (dependency->automatic && !dependency->stale) {
 478                                 *p++ = dependency->name;
 479                         }
 480                 }
 481         }
 482         if (debug_level > 1) {
 483                 (void) printf(NOCATGETS("%*sdoname(%s)\n"),
 484                               recursion_level,
 485                               "",
 486                               target->string_mb);
 487         }
 488         recursion_level++;
 489         /* Avoid infinite loops */
 490         if (target->state == build_in_progress) {
 491                 warning(catgets(catd, 1, 16, "Infinite loop: Target `%s' depends on itself"),
 492                         target->string_mb);
 493                 return build_ok;
 494         }
 495         target->state = build_in_progress;
 496 
 497         /* Activate conditional macros for the target */
 498         if (!target->added_pattern_conditionals) {
 499                 add_pattern_conditionals(target);
 500                 target->added_pattern_conditionals = true;
 501         }
 502         if (target->conditional_cnt > 0) {
 503                 old_locals = (Property) alloca(target->conditional_cnt *
 504                                                sizeof (Property_rec));
 505                 set_locals(target, old_locals);
 506         }
 507 
 508 /*
 509  * after making the call to dynamic_dependecies unconditional we can handle
 510  * target names that are same as file name. In this case $$@ in the 
 511  * dependencies did not mean anything. WIth this change it expands it
 512  * as expected.
 513  */
 514         if (!target->has_depe_list_expanded)
 515         {
 516                 dynamic_dependencies(target);
 517         }
 518 
 519 /*
 520  *      FIRST SECTION -- GO THROUGH DEPENDENCIES AND COLLECT EXPLICIT
 521  *      COMMANDS TO RUN
 522  */
 523         if ((line = get_prop(target->prop, line_prop)) != NULL) {
 524                 if (check_dependencies(&result,
 525                                        line,
 526                                        do_get,
 527                                        target,
 528                                        true_target,
 529                                        doing_subtree,
 530                                        &out_of_date_list,
 531                                        old_locals,
 532                                        implicit,
 533                                        &command,
 534                                        less,
 535                                        rechecking_target,
 536                                        recheck_conditionals)) {
 537                         return build_running;
 538                 }
 539                 if (line->body.line.query != NULL) {
 540                         delete_query_chain(line->body.line.query);
 541                 }
 542                 line->body.line.query = out_of_date_list;
 543         }
 544 
 545 
 546 /*
 547  * If the target is a :: type, do not try to find the rule for the target,
 548  * all actions will be taken by separate branches.
 549  * Else, we try to find an implicit rule using various methods,
 550  * we quit as soon as one is found.
 551  *
 552  * [tolik, 12 Sep 2002] Do not try to find implicit rule for the target
 553  * being rechecked - the target is being rechecked means that it already
 554  * has explicit dependencies derived from an implicit rule found
 555  * in previous step.
 556  */
 557         if (target->colon_splits == 0 && !rechecking_target) {
 558                 /* Look for percent matched rule */
 559                 if ((result == build_dont_know) &&
 560                     (command == NULL)) {
 561                         switch (find_percent_rule(
 562                                         target,
 563                                         &command,
 564                                         recheck_conditionals)) {
 565                         case build_failed:
 566                                 result = build_failed;
 567                                 break;
 568 #ifdef TEAMWARE_MAKE_CMN
 569                         case build_running:
 570                                 target->state = build_running;
 571                                 add_pending(target,
 572                                             --recursion_level,
 573                                             do_get,
 574                                             implicit,
 575                                             false);
 576                                 if (target->conditional_cnt > 0) {
 577                                         reset_locals(target,
 578                                                      old_locals,
 579                                                      get_prop(target->prop,
 580                                                              conditional_prop),
 581                                                      0);
 582                                 }
 583                                 return build_running;
 584 #endif
 585                         case build_ok:
 586                                 result = build_ok;
 587                                 break;
 588                         }
 589                 }
 590                 /* Look for double suffix rule */
 591                 if (result == build_dont_know) {
 592                         Property member;
 593 
 594                         if (target->is_member &&
 595                             ((member = get_prop(target->prop, member_prop)) !=
 596                              NULL)) {
 597                                 switch (find_ar_suffix_rule(target,
 598                                                 member->body.
 599                                                 member.member,
 600                                                 &command,
 601                                                 recheck_conditionals)) {
 602                                 case build_failed:
 603                                         result = build_failed;
 604                                         break;
 605 #ifdef TEAMWARE_MAKE_CMN
 606                                 case build_running:
 607                                         target->state = build_running;
 608                                         add_pending(target,
 609                                                     --recursion_level,
 610                                                     do_get,
 611                                                     implicit,
 612                                                     false);
 613                                     if (target->conditional_cnt > 0) {
 614                                             reset_locals(target,
 615                                                          old_locals,
 616                                                          get_prop(target->prop,
 617                                                              conditional_prop),
 618                                                          0);
 619                                     }
 620                                         return build_running;
 621 #endif
 622                                 default:
 623                                         /* ALWAYS bind $% for old style */
 624                                         /* ar rules */
 625                                         if (line == NULL) {
 626                                                 line =
 627                                                   maybe_append_prop(target,
 628                                                                     line_prop);
 629                                         }
 630                                         line->body.line.percent =
 631                                           member->body.member.member;
 632                                         break;
 633                                 }
 634                         } else {
 635                                 switch (find_double_suffix_rule(target,
 636                                                 &command,
 637                                                 recheck_conditionals)) {
 638                                 case build_failed:
 639                                         result = build_failed;
 640                                         break;
 641 #ifdef TEAMWARE_MAKE_CMN
 642                                 case build_running:
 643                                         target->state = build_running;
 644                                         add_pending(target,
 645                                                     --recursion_level,
 646                                                     do_get,
 647                                                     implicit,
 648                                                     false);
 649                                         if (target->conditional_cnt > 0) {
 650                                                 reset_locals(target,
 651                                                              old_locals,
 652                                                              get_prop(target->
 653                                                                       prop,
 654                                                                       conditional_prop),
 655                                                              0);
 656                                         }
 657                                         return build_running;
 658 #endif
 659                                 }
 660                         }
 661                 }
 662                 /* Look for single suffix rule */
 663 
 664 /* /tolik/
 665  * I commented !implicit to fix bug 1247448: Suffix Rules failed when combine with Pattern Matching Rules.
 666  * This caused problem with SVR4 tilde rules (infinite recursion). So I made some changes in "implicit.cc"
 667  */
 668 /* /tolik, 06.21.96/
 669  * Regression! See BugId 1255360
 670  * If more than one percent rules are defined for the same target then
 671  * the behaviour of 'make' with my previous fix may be different from one
 672  * of the 'old make'. 
 673  * The global variable second_pass (maybe it should be an argument to doname())
 674  * is intended to avoid this regression. It is set in doname_check().
 675  * First, 'make' will work as it worked before. Only when it is
 676  * going to say "don't know how to make target" it sets second_pass to true and
 677  * run 'doname' again but now trying to use Single Suffix Rules.
 678  */
 679                 if ((result == build_dont_know) && !automatic && (!implicit || second_pass) &&
 680                     ((line == NULL) ||
 681                      ((line->body.line.target != NULL) &&
 682                       !line->body.line.target->has_regular_dependency))) {
 683                         switch (find_suffix_rule(target,
 684                                                  target,
 685                                                  empty_name,
 686                                                  &command,
 687                                                  recheck_conditionals)) {
 688                         case build_failed:
 689                                 result = build_failed;
 690                                 break;
 691 #ifdef TEAMWARE_MAKE_CMN
 692                         case build_running:
 693                                 target->state = build_running;
 694                                 add_pending(target,
 695                                             --recursion_level,
 696                                             do_get,
 697                                             implicit,
 698                                             false);
 699                                 if (target->conditional_cnt > 0) {
 700                                         reset_locals(target,
 701                                                      old_locals,
 702                                                      get_prop(target->prop,
 703                                                              conditional_prop),
 704                                                      0);
 705                                 }
 706                                 return build_running;
 707 #endif
 708                         }
 709                 }
 710                 /* Try to sccs get */
 711                 if ((command == NULL) &&
 712                     (result == build_dont_know) &&
 713                     do_get) {
 714                         result = sccs_get(target, &command);
 715                 }
 716 
 717                 /* Use .DEFAULT rule if it is defined. */
 718                 if ((command == NULL) &&
 719                     (result == build_dont_know) &&
 720                     (true_target->colons == no_colon) &&
 721                     default_rule &&
 722                     !implicit) {
 723                         /* Make sure we have a line prop */
 724                         line = maybe_append_prop(target, line_prop);
 725                         command = line;
 726                         Boolean out_of_date;
 727                         if (true_target->is_member) {
 728                                 out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
 729                                                                         line->body.line.dependency_time);
 730                         } else {
 731                                 out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
 732                                                                     line->body.line.dependency_time);
 733                         }
 734                         if (build_unconditional || out_of_date) {
 735                                 line->body.line.is_out_of_date = true;
 736                                 if (debug_level > 0) {
 737                                         (void) printf(catgets(catd, 1, 17, "%*sBuilding %s using .DEFAULT because it is out of date\n"),
 738                                                       recursion_level,
 739                                                       "",
 740                                                       true_target->string_mb);
 741                                 }
 742                         }
 743                         line->body.line.sccs_command = false;
 744                         line->body.line.command_template = default_rule;
 745                         line->body.line.target = true_target;
 746                         line->body.line.star = NULL;
 747                         line->body.line.less = true_target;
 748                         line->body.line.percent = NULL;
 749                 }
 750         }
 751 
 752         /* We say "target up to date" if no cmd were executed for the target */
 753         if (!target->is_double_colon_parent) {
 754                 commands_done = false;
 755         }
 756 
 757         silent = silent_all;
 758         ignore_errors = ignore_errors_all;
 759         if  (posix)
 760         {
 761           if  (!silent)
 762           {
 763             silent = (Boolean) target->silent_mode;
 764           }
 765           if  (!ignore_errors)
 766           {
 767             ignore_errors = (Boolean) target->ignore_error_mode;
 768           }
 769         }
 770 
 771         int doname_dyntarget = 0;
 772 r_command:
 773         /* Run commands if any. */
 774         if ((command != NULL) &&
 775             (command->body.line.command_template != NULL)) {
 776                 if (result != build_failed) {
 777                         result = run_command(command, 
 778                                              (Boolean) ((parallel || save_parallel) && !silent));
 779                 }
 780                 switch (result) {
 781 #ifdef TEAMWARE_MAKE_CMN
 782                 case build_running:
 783                         add_running(target,
 784                                     true_target,
 785                                     command,
 786                                     --recursion_level,
 787                                     auto_count,
 788                                     automatics,
 789                                     do_get,
 790                                     implicit);
 791                         target->state = build_running;
 792                         if ((line = get_prop(target->prop,
 793                                              line_prop)) != NULL) {
 794                                 if (line->body.line.query != NULL) {
 795                                         delete_query_chain(line->body.line.query);
 796                                 }
 797                                 line->body.line.query = NULL;
 798                         }
 799                         if (target->conditional_cnt > 0) {
 800                                 reset_locals(target,
 801                                              old_locals,
 802                                              get_prop(target->prop,
 803                                                      conditional_prop),
 804                                              0);
 805                         }
 806                         return build_running;
 807                 case build_serial:
 808                         add_serial(target,
 809                                    --recursion_level,
 810                                    do_get,
 811                                    implicit);
 812                         target->state = build_running;
 813                         line = get_prop(target->prop, line_prop);
 814                         if (line != NULL) {
 815                                 if (line->body.line.query != NULL) {
 816                                         delete_query_chain(line->body.line.query);
 817                                 }
 818                                 line->body.line.query = NULL;
 819                         }
 820                         if (target->conditional_cnt > 0) {
 821                                 reset_locals(target,
 822                                              old_locals,
 823                                              get_prop(target->prop,
 824                                                      conditional_prop),
 825                                              0);
 826                         }
 827                         return build_running;
 828 #endif
 829                 case build_ok:
 830                         /* If all went OK set a nice timestamp */
 831                         if (true_target->stat.time == file_doesnt_exist) {
 832                                 true_target->stat.time = file_max_time;
 833                         }
 834                         break;
 835                 }
 836         } else {
 837                 /*
 838                  * If no command was found for the target, and it doesn't
 839                  * exist, and it is mentioned as a target in the makefile,
 840                  * we say it is extremely new and that it is OK.
 841                  */
 842                 if (target->colons != no_colon) {
 843                         if (true_target->stat.time == file_doesnt_exist){
 844                                 true_target->stat.time = file_max_time;
 845                         }
 846                         result = build_ok;
 847                 }
 848                 /*
 849                  * Trying dynamic targets.
 850                  */
 851                 if(!doname_dyntarget) {
 852                         doname_dyntarget = 1;
 853                         Name dtarg = find_dyntarget(target);
 854                         if(dtarg!=NULL) {
 855                                 if (!target->has_depe_list_expanded) {
 856                                         dynamic_dependencies(target);
 857                                 }
 858                                 if ((line = get_prop(target->prop, line_prop)) != NULL) {
 859                                         if (check_dependencies(&result,
 860                                                                line,
 861                                                                do_get,
 862                                                                target,
 863                                                                true_target,
 864                                                                doing_subtree,
 865                                                                &out_of_date_list,
 866                                                                old_locals,
 867                                                                implicit,
 868                                                                &command,
 869                                                                less,
 870                                                                rechecking_target,
 871                                                                recheck_conditionals))
 872                                         {
 873                                                 return build_running;
 874                                         }
 875                                         if (line->body.line.query != NULL) {
 876                                                 delete_query_chain(line->body.line.query);
 877                                         }
 878                                         line->body.line.query = out_of_date_list;
 879                                 }
 880                                 goto r_command;
 881                         }
 882                 }
 883                 /*
 884                  * If the file exists, it is OK that we couldnt figure
 885                  * out how to build it.
 886                  */
 887                 (void) exists(target);
 888                 if ((target->stat.time != file_doesnt_exist) &&
 889                     (result == build_dont_know)) {
 890                         result = build_ok;
 891                 }
 892         }
 893 
 894         /*
 895          * Some of the following is duplicated in the function finish_doname.
 896          * If anything is changed here, check to see if it needs to be
 897          * changed there.
 898          */
 899         if ((line = get_prop(target->prop, line_prop)) != NULL) {
 900                 if (line->body.line.query != NULL) {
 901                         delete_query_chain(line->body.line.query);
 902                 }
 903                 line->body.line.query = NULL;
 904         }
 905         target->state = result;
 906         parallel = save_parallel;
 907         if (target->conditional_cnt > 0) {
 908                 reset_locals(target,
 909                              old_locals,
 910                              get_prop(target->prop, conditional_prop),
 911                              0);
 912         }
 913         recursion_level--;
 914         if (target->is_member) {
 915                 Property member;
 916 
 917                 /* Propagate the timestamp from the member file to the member*/
 918                 if ((target->stat.time != file_max_time) &&
 919                     ((member = get_prop(target->prop, member_prop)) != NULL) &&
 920                     (exists(member->body.member.member) > file_doesnt_exist)) {
 921                         target->stat.time =
 922                           member->body.member.member->stat.time;
 923                 }
 924         }
 925         /*
 926          * Check if we found any new auto dependencies when we
 927          * built the target.
 928          */
 929         if ((result == build_ok) && check_auto_dependencies(target,
 930                                                             auto_count,
 931                                                             automatics)) {
 932                 if (debug_level > 0) {
 933                         (void) printf(catgets(catd, 1, 18, "%*sTarget `%s' acquired new dependencies from build, rechecking all dependencies\n"),
 934                                       recursion_level,
 935                                       "",
 936                                       true_target->string_mb);
 937                 }
 938                 rechecking_target = true;
 939                 saved_commands_done = commands_done;
 940                 goto recheck_target;
 941         }
 942 
 943         if (rechecking_target && !commands_done) {
 944                 commands_done = saved_commands_done;
 945         }
 946 
 947         return result;
 948 }
 949 
 950 /*
 951  * DONE.
 952  *
 953  *      check_dependencies(result, line, do_get,
 954  *                      target, true_target, doing_subtree, out_of_date_tail,
 955  *                      old_locals, implicit, command, less, rechecking_target)
 956  *
 957  *      Return value:
 958  *                              True returned if some dependencies left running
 959  *                              
 960  *      Parameters:
 961  *              result          Pointer to cell we update if build failed
 962  *              line            We get the dependencies from here
 963  *              do_get          Allow use of sccs get in recursive doname()
 964  *              target          The target to chase dependencies for
 965  *              true_target     The real one for :: and lib(member)
 966  *              doing_subtree   True if building a conditional macro subtree
 967  *              out_of_date_tail Used to set the $? list
 968  *              old_locals      Used for resetting the local macros
 969  *              implicit        Called when scanning for implicit rules?
 970  *              command         Place to stuff command
 971  *              less            Set to $< value
 972  *
 973  *      Global variables used:
 974  *              command_changed Set if we suspect .make.state needs rewrite
 975  *              debug_level     Should we trace actions?
 976  *              force           The Name " FORCE", compared against
 977  *              recursion_level Used for tracing
 978  *              rewrite_statefile Set if .make.state needs rewriting
 979  *              wait_name       The Name ".WAIT", compared against
 980  */
 981 static Boolean
 982 #ifdef TEAMWARE_MAKE_CMN
 983 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)
 984 #else
 985 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)
 986 #endif
 987 {
 988         Boolean                 dependencies_running;
 989         register Dependency     dependency;
 990         Doname                  dep_result;
 991         Boolean                 dependency_changed = false;
 992 
 993         line->body.line.dependency_time = file_doesnt_exist;
 994         if (line->body.line.query != NULL) {
 995                 delete_query_chain(line->body.line.query);
 996         }
 997         line->body.line.query = NULL;
 998         line->body.line.is_out_of_date = false;
 999         dependencies_running = false;
1000         /*
1001          * Run thru all the dependencies and call doname() recursively
1002          * on each of them.
1003          */
1004         for (dependency = line->body.line.dependencies;
1005              dependency != NULL;
1006              dependency = dependency->next) {
1007                 Boolean this_dependency_changed = false;
1008 
1009                 if (!dependency->automatic &&
1010                     (rechecking_target || target->rechecking_target)) {
1011                         /*
1012                          * We only bother with the autos when rechecking
1013                          */
1014                         continue;
1015                 }
1016 
1017                 if (dependency->name == wait_name) {
1018                         /*
1019                          * The special target .WAIT means finish all of
1020                          * the prior dependencies before continuing.
1021                          */
1022                         if (dependencies_running) {
1023                                 break;
1024                         }
1025 #ifdef DISTRIBUTED
1026                 } else if ((!parallel_ok(dependency->name, false)) &&
1027                            (dependencies_running)) {
1028                         /*
1029                          * If we can't execute the current dependency in
1030                          * parallel, hold off the dependency processing
1031                          * to preserve the order of the dependencies.
1032                          */
1033                         break;
1034 #endif
1035                 } else {
1036                         timestruc_t     depe_time = file_doesnt_exist;
1037 
1038 
1039                         if (true_target->is_member) {
1040                                 depe_time = exists(dependency->name);
1041                         }
1042                         if (dependency->built ||
1043                             (dependency->name->state == build_failed)) {
1044                                 dep_result = (Doname) dependency->name->state;
1045                         } else {
1046                                 dep_result = doname_check(dependency->name,
1047                                                           do_get,
1048                                                           false,
1049                                                           (Boolean) dependency->automatic);
1050                         }
1051                         if (true_target->is_member || dependency->name->is_member) {
1052                                 /* should compare only secs, cause lib members does not have nsec time resolution */
1053                                 if (depe_time.tv_sec != dependency->name->stat.time.tv_sec) {
1054                                         this_dependency_changed =
1055                                           dependency_changed =
1056                                             true;
1057                                 }
1058                         } else {
1059                                 if (depe_time != dependency->name->stat.time) {
1060                                         this_dependency_changed =
1061                                           dependency_changed =
1062                                             true;
1063                                 }
1064                         }
1065                         dependency->built = true;
1066                         switch (dep_result) {
1067                         case build_running:
1068                                 dependencies_running = true;
1069                                 continue;
1070                         case build_failed:
1071                                 *result = build_failed;
1072                                 break;
1073                         case build_dont_know:
1074 /*
1075  * If make can't figure out how to make a dependency, maybe the dependency
1076  * is out of date. In this case, we just declare the target out of date
1077  * and go on. If we really need the dependency, the make'ing of the target
1078  * will fail. This will only happen for automatic (hidden) dependencies.
1079  */
1080                                 if(!recheck_conditionals) {
1081                                         line->body.line.is_out_of_date = true;
1082                                 }
1083                                 /*
1084                                  * Make sure the dependency is not saved
1085                                  * in the state file.
1086                                  */
1087                                 dependency->stale = true;
1088                                 rewrite_statefile =
1089                                   command_changed =
1090                                     true;
1091                                 if (debug_level > 0) {
1092                                         (void) printf(catgets(catd, 1, 19, "Target %s rebuilt because dependency %s does not exist\n"),
1093                                                      true_target->string_mb,
1094                                                      dependency->name->string_mb);
1095                                 }
1096                                 break;
1097                         }
1098                         if (dependency->name->depends_on_conditional) {
1099                                 target->depends_on_conditional = true;
1100                         }
1101                         if (dependency->name == force) {
1102                                 target->stat.time =
1103                                   dependency->name->stat.time;
1104                         }
1105                         /*
1106                          * Propagate new timestamp from "member" to
1107                          * "lib.a(member)".
1108                          */
1109                         (void) exists(dependency->name);
1110 
1111                         /* Collect the timestamp of the youngest dependency */
1112                         line->body.line.dependency_time =
1113                           MAX(dependency->name->stat.time,
1114                               line->body.line.dependency_time);
1115 
1116                         /* Correction: do not consider nanosecs for members */
1117                         if(true_target->is_member || dependency->name->is_member) {
1118                                 line->body.line.dependency_time.tv_nsec = 0;
1119                         }
1120 
1121                         if (debug_level > 1) {
1122                                 (void) printf(catgets(catd, 1, 20, "%*sDate(%s)=%s \n"),
1123                                               recursion_level,
1124                                               "",
1125                                               dependency->name->string_mb,
1126                                               time_to_string(dependency->name->
1127                                                              stat.time));
1128                                 if (dependency->name->stat.time > line->body.line.dependency_time) {
1129                                         (void) printf(catgets(catd, 1, 21, "%*sDate-dependencies(%s) set to %s\n"),
1130                                                       recursion_level,
1131                                                       "",
1132                                                       true_target->string_mb,
1133                                                       time_to_string(line->body.line.
1134                                                                      dependency_time));
1135                                 }
1136                         }
1137 
1138                         /* Build the $? list */
1139                         if (true_target->is_member) {
1140                                 if (this_dependency_changed == true) {
1141                                         true_target->stat.time = dependency->name->stat.time;
1142                                         true_target->stat.time.tv_sec--;
1143                                 } else {
1144                                         /* Dina: 
1145                                          * The next statement is commented
1146                                          * out as a fix for bug #1051032.
1147                                          * if dependency hasn't changed
1148                                          * then there's no need to invalidate
1149                                          * true_target. This statemnt causes
1150                                          * make to take much longer to process
1151                                          * an already-built archive. Soren
1152                                          * said it was a quick fix for some
1153                                          * problem he doesn't remember.
1154                                         true_target->stat.time = file_no_time;
1155                                          */
1156                                         (void) exists(true_target);
1157                                 }
1158                         } else {
1159                                 (void) exists(true_target);
1160                         }
1161                         Boolean out_of_date;
1162                         if (true_target->is_member || dependency->name->is_member) {
1163                                 out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
1164                                                                         dependency->name->stat.time);
1165                         } else {
1166                                 out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
1167                                                                     dependency->name->stat.time);
1168                         }
1169                         if ((build_unconditional || out_of_date) &&
1170                             (dependency->name != force) &&
1171                             (dependency->stale == false)) {
1172                                 *out_of_date_tail = ALLOC(Chain);
1173                                 if (dependency->name->is_member &&
1174                                     (get_prop(dependency->name->prop,
1175                                               member_prop) != NULL)) {
1176                                         (*out_of_date_tail)->name =
1177                                           get_prop(dependency->name->prop,
1178                                                    member_prop)->
1179                                                      body.member.member;
1180                                 } else {
1181                                         (*out_of_date_tail)->name =
1182                                           dependency->name;
1183                                 }
1184                                 (*out_of_date_tail)->next = NULL;
1185                                 out_of_date_tail = &(*out_of_date_tail)->next;
1186                                 if (debug_level > 0) {
1187                                         if (dependency->name->stat.time == file_max_time) {
1188                                                 (void) printf(catgets(catd, 1, 22, "%*sBuilding %s because %s does not exist\n"),
1189                                                               recursion_level,
1190                                                               "",
1191                                                               true_target->string_mb,
1192                                                               dependency->name->string_mb);
1193                                         } else {
1194                                                 (void) printf(catgets(catd, 1, 23, "%*sBuilding %s because it is out of date relative to %s\n"),
1195                                                               recursion_level,
1196                                                               "",
1197                                                               true_target->string_mb,
1198                                                               dependency->name->string_mb);
1199                                         }
1200                                 }
1201                         }
1202                         if (dependency->name == force) {
1203                                 force->stat.time =
1204                                   file_max_time;
1205                                 force->state = build_dont_know;
1206                         }
1207                 }
1208         }
1209 #ifdef TEAMWARE_MAKE_CMN
1210         if (dependencies_running) {
1211                 if (doing_subtree) {
1212                         if (target->conditional_cnt > 0) {
1213                                 reset_locals(target,
1214                                              old_locals,
1215                                              get_prop(target->prop,
1216                                                       conditional_prop),
1217                                              0);
1218                         }
1219                         return true;
1220                 } else {
1221                         target->state = build_running;
1222                         add_pending(target,
1223                                     --recursion_level,
1224                                     do_get,
1225                                     implicit,
1226                                     false);
1227                         if (target->conditional_cnt > 0) {
1228                                 reset_locals(target,
1229                                              old_locals,
1230                                              get_prop(target->prop,
1231                                                       conditional_prop),
1232                                              0);
1233                         }
1234                         return true;
1235                 }
1236         }
1237 #endif
1238         /*
1239          * Collect the timestamp of the youngest double colon target
1240          * dependency.
1241          */
1242         if (target->is_double_colon_parent) {
1243                 for (dependency = line->body.line.dependencies;
1244                      dependency != NULL;
1245                      dependency = dependency->next) {
1246                         Property        tmp_line;
1247 
1248                         if ((tmp_line = get_prop(dependency->name->prop, line_prop)) != NULL) {
1249                                 if(tmp_line->body.line.dependency_time != file_max_time) {
1250                                         target->stat.time =
1251                                           MAX(tmp_line->body.line.dependency_time,
1252                                               target->stat.time);
1253                                 }
1254                         }
1255                 }
1256         }
1257         if ((true_target->is_member) && (dependency_changed == true)) {
1258                 true_target->stat.time = file_no_time;
1259         }
1260         /*
1261          * After scanning all the dependencies, we check the rule
1262          * if we found one.
1263          */
1264         if (line->body.line.command_template != NULL) {
1265                 if (line->body.line.command_template_redefined) {
1266                         warning(catgets(catd, 1, 24, "Too many rules defined for target %s"),
1267                                 target->string_mb);
1268                 }
1269                 *command = line;
1270                 /* Check if the target is out of date */
1271                 Boolean out_of_date;
1272                 if (true_target->is_member) {
1273                         out_of_date = (Boolean) OUT_OF_DATE_SEC(true_target->stat.time,
1274                                                                 line->body.line.dependency_time);
1275                 } else {
1276                         out_of_date = (Boolean) OUT_OF_DATE(true_target->stat.time,
1277                                                             line->body.line.dependency_time);
1278                 }
1279                 if (build_unconditional || out_of_date){
1280                         if(!recheck_conditionals) {
1281                                 line->body.line.is_out_of_date = true;
1282                         }
1283                 }
1284                 line->body.line.sccs_command = false;
1285                 line->body.line.target = true_target;
1286                 if(gnu_style) {
1287 
1288                         // set $< for explicit rule
1289                         if(line->body.line.dependencies != NULL) {
1290                                 less = line->body.line.dependencies->name;
1291                         }
1292 
1293                         // set $* for explicit rule
1294                         Name                    target_body;
1295                         Name                    tt = true_target;
1296                         Property                member;
1297                         register wchar_t        *target_end;
1298                         register Dependency     suffix;
1299                         register int            suffix_length;
1300                         Wstring                 targ_string;
1301                         Wstring                 suf_string;
1302 
1303                         if (true_target->is_member &&
1304                             ((member = get_prop(target->prop, member_prop)) !=
1305                              NULL)) {
1306                                 tt = member->body.member.member;
1307                         }
1308                         targ_string.init(tt);
1309                         target_end = targ_string.get_string() + tt->hash.length;
1310                         for (suffix = suffixes; suffix != NULL; suffix = suffix->next) {
1311                                 suffix_length = suffix->name->hash.length;
1312                                 suf_string.init(suffix->name);
1313                                 if (tt->hash.length < suffix_length) {
1314                                         continue;
1315                                 } else if (!IS_WEQUALN(suf_string.get_string(),
1316                                                 (target_end - suffix_length),
1317                                                 suffix_length)) {
1318                                         continue;
1319                                 }
1320                                 target_body = GETNAME(
1321                                         targ_string.get_string(),
1322                                         (int)(tt->hash.length - suffix_length)
1323                                 );
1324                                 line->body.line.star = target_body;
1325                         }
1326 
1327                         // set result = build_ok so that implicit rules are not used.
1328                         if(*result == build_dont_know) {
1329                                 *result = build_ok;
1330                         }
1331                 }
1332                 if (less != NULL) {
1333                         line->body.line.less = less;
1334                 }
1335         }
1336 
1337         return false;
1338 }
1339 
1340 /*
1341  *      dynamic_dependencies(target)
1342  *
1343  *      Checks if any dependency contains a macro ref
1344  *      If so, it replaces the dependency with the expanded version.
1345  *      Here, "$@" gets translated to target->string. That is
1346  *      the current name on the left of the colon in the
1347  *      makefile.  Thus,
1348  *              xyz:    s.$@.c
1349  *      translates into
1350  *              xyz:    s.xyz.c
1351  *
1352  *      Also, "$(@F)" translates to the same thing without a preceeding
1353  *      directory path (if one exists).
1354  *      Note, to enter "$@" on a dependency line in a makefile
1355  *      "$$@" must be typed. This is because make expands
1356  *      macros in dependency lists upon reading them.
1357  *      dynamic_dependencies() also expands file wildcards.
1358  *      If there are any Shell meta characters in the name,
1359  *      search the directory, and replace the dependency
1360  *      with the set of files the pattern matches
1361  *
1362  *      Parameters:
1363  *              target          Target to sanitize dependencies for
1364  *
1365  *      Global variables used:
1366  *              c_at            The Name "@", used to set macro value
1367  *              debug_level     Should we trace actions?
1368  *              dot             The Name ".", used to read directory
1369  *              recursion_level Used for tracing
1370  */
1371 void
1372 dynamic_dependencies(Name target)
1373 {
1374         wchar_t                 pattern[MAXPATHLEN];
1375         register wchar_t        *p;
1376         Property                line;
1377         register Dependency     dependency;
1378         register Dependency     *remove;
1379         String_rec              string;
1380         wchar_t                 buffer[MAXPATHLEN];
1381         register Boolean        set_at = false;
1382         register wchar_t        *start;
1383         Dependency              new_depe;
1384         register Boolean        reuse_cell;
1385         Dependency              first_member;
1386         Name                    directory;
1387         Name                    lib;
1388         Name                    member;
1389         Property                prop;
1390         Name                    true_target = target;
1391         wchar_t                 *library;
1392 
1393         if ((line = get_prop(target->prop, line_prop)) == NULL) {
1394                 return;
1395         }
1396         /* If the target is constructed from a "::" target we consider that */
1397         if (target->has_target_prop) {
1398                 true_target = get_prop(target->prop,
1399                                        target_prop)->body.target.target;
1400         }
1401         /* Scan all dependencies and process the ones that contain "$" chars */
1402         for (dependency = line->body.line.dependencies;
1403              dependency != NULL;
1404              dependency = dependency->next) {
1405                 if (!dependency->name->dollar) {
1406                         continue;
1407                 }
1408                 target->has_depe_list_expanded = true;
1409 
1410                 /* The make macro $@ is bound to the target name once per */
1411                 /* invocation of dynamic_dependencies() */
1412                 if (!set_at) {
1413                         (void) SETVAR(c_at, true_target, false);
1414                         set_at = true;
1415                 }
1416                 /* Expand this dependency string */
1417                 INIT_STRING_FROM_STACK(string, buffer);
1418                 expand_value(dependency->name, &string, false);
1419                 /* Scan the expanded string. It could contain whitespace */
1420                 /* which mean it expands to several dependencies */
1421                 start = string.buffer.start;
1422                 while (iswspace(*start)) {
1423                         start++;
1424                 }
1425                 /* Remove the cell (later) if the macro was empty */
1426                 if (start[0] == (int) nul_char) {
1427                         dependency->name = NULL;
1428                 }
1429 
1430 /* azv 10/26/95 to fix bug BID_1170218 */
1431                 if ((start[0] == (int) period_char) &&
1432                     (start[1] == (int) slash_char)) {
1433                         start += 2;
1434                 }
1435 /* azv */
1436 
1437                 first_member = NULL;
1438                 /* We use the original dependency cell for the first */
1439                 /* dependency from the expansion */
1440                 reuse_cell = true;
1441                 /* We also have to deal with dependencies that expand to */
1442                 /* lib.a(members) notation */
1443                 for (p = start; *p != (int) nul_char; p++) {
1444                         if ((*p == (int) parenleft_char)) {
1445                                 lib = GETNAME(start, p - start);
1446                                 lib->is_member = true;
1447                                 first_member = dependency;
1448                                 start = p + 1;
1449                                 while (iswspace(*start)) {
1450                                         start++;
1451                                 }
1452                                 break;
1453                         }
1454                 }
1455                 do {
1456                     /* First skip whitespace */
1457                         for (p = start; *p != (int) nul_char; p++) {
1458                                 if ((*p == (int) nul_char) ||
1459                                     iswspace(*p) ||
1460                                     (*p == (int) parenright_char)) {
1461                                         break;
1462                                 }
1463                         }
1464                         /* Enter dependency from expansion */
1465                         if (p != start) {
1466                                 /* Create new dependency cell if */
1467                                 /* this is not the first dependency */
1468                                 /* picked from the expansion */
1469                                 if (!reuse_cell) {
1470                                         new_depe = ALLOC(Dependency);
1471                                         new_depe->next = dependency->next;
1472                                         new_depe->automatic = false;
1473                                         new_depe->stale = false;
1474                                         new_depe->built = false;
1475                                         dependency->next = new_depe;
1476                                         dependency = new_depe;
1477                                 }
1478                                 reuse_cell = false;
1479                                 /* Internalize the dependency name */
1480                                 // tolik. Fix for bug 4110429: inconsistent expansion for macros that
1481                                 // include "//" and "/./"
1482                                 //dependency->name = GETNAME(start, p - start);
1483                                 dependency->name = normalize_name(start, p - start);
1484                                 if ((debug_level > 0) &&
1485                                     (first_member == NULL)) {
1486                                         (void) printf(catgets(catd, 1, 25, "%*sDynamic dependency `%s' for target `%s'\n"),
1487                                                       recursion_level,
1488                                                       "",
1489                                                       dependency->name->string_mb,
1490                                                       true_target->string_mb);
1491                                 }
1492                                 for (start = p; iswspace(*start); start++);
1493                                 p = start;
1494                         }
1495                 } while ((*p != (int) nul_char) &&
1496                          (*p != (int) parenright_char));
1497                 /* If the expansion was of lib.a(members) format we now */
1498                 /* enter the proper member cells */
1499                 if (first_member != NULL) {
1500                         /* Scan the new dependencies and transform them from */
1501                         /* "foo" to "lib.a(foo)" */
1502                         for (; 1; first_member = first_member->next) {
1503                                 /* Build "lib.a(foo)" name */
1504                                 INIT_STRING_FROM_STACK(string, buffer);
1505                                 APPEND_NAME(lib,
1506                                               &string,
1507                                               (int) lib->hash.length);
1508                                 append_char((int) parenleft_char, &string);
1509                                 APPEND_NAME(first_member->name,
1510                                               &string,
1511                                               FIND_LENGTH);
1512                                 append_char((int) parenright_char, &string);
1513                                 member = first_member->name;
1514                                 /* Replace "foo" with "lib.a(foo)" */
1515                                 first_member->name =
1516                                   GETNAME(string.buffer.start, FIND_LENGTH);
1517                                 if (string.free_after_use) {
1518                                         retmem(string.buffer.start);
1519                                 }
1520                                 if (debug_level > 0) {
1521                                         (void) printf(catgets(catd, 1, 26, "%*sDynamic dependency `%s' for target `%s'\n"),
1522                                                       recursion_level,
1523                                                       "",
1524                                                       first_member->name->
1525                                                       string_mb,
1526                                                       true_target->string_mb);
1527                                 }
1528                                 first_member->name->is_member = lib->is_member;
1529                                 /* Add member property to member */
1530                                 prop = maybe_append_prop(first_member->name,
1531                                                          member_prop);
1532                                 prop->body.member.library = lib;
1533                                 prop->body.member.entry = NULL;
1534                                 prop->body.member.member = member;
1535                                 if (first_member == dependency) {
1536                                         break;
1537                                 }
1538                         }
1539                 }
1540         }
1541         Wstring wcb;
1542         /* Then scan all the dependencies again. This time we want to expand */
1543         /* shell file wildcards */
1544         for (remove = &line->body.line.dependencies, dependency = *remove;
1545              dependency != NULL;
1546              dependency = *remove) {
1547                 if (dependency->name == NULL) {
1548                         dependency = *remove = (*remove)->next;
1549                         continue;
1550                 }
1551                 /* If dependency name string contains shell wildcards */
1552                 /* replace the name with the expansion */
1553                 if (dependency->name->wildcard) {
1554                         wcb.init(dependency->name);
1555                         if ((start = (wchar_t *) wschr(wcb.get_string(),
1556                                            (int) parenleft_char)) != NULL) {
1557                                 /* lib(*) type pattern */
1558                                 library = buffer;
1559                                 (void) wsncpy(buffer,
1560                                               wcb.get_string(),
1561                                               start - wcb.get_string());
1562                                 buffer[start-wcb.get_string()] =
1563                                   (int) nul_char;
1564                                 (void) wsncpy(pattern,
1565                                               start + 1,
1566 (int) (dependency->name->hash.length-(start-wcb.get_string())-2));
1567                                 pattern[dependency->name->hash.length -
1568                                         (start-wcb.get_string()) - 2] =
1569                                           (int) nul_char;
1570                         } else {
1571                                 library = NULL;
1572                                 (void) wsncpy(pattern,
1573                                               wcb.get_string(),
1574                                               (int) dependency->name->hash.length);
1575                                 pattern[dependency->name->hash.length] =
1576                                   (int) nul_char;
1577                         }
1578                         start = (wchar_t *) wsrchr(pattern, (int) slash_char);
1579                         if (start == NULL) {
1580                                 directory = dot;
1581                                 p = pattern;
1582                         } else {
1583                                 directory = GETNAME(pattern, start-pattern);
1584                                 p = start+1;
1585                         }
1586                         /* The expansion is handled by the read_dir() routine*/
1587                         if (read_dir(directory, p, line, library)) {
1588                                 *remove = (*remove)->next;
1589                         } else {
1590                                 remove = &dependency->next;
1591                         }
1592                 } else {
1593                         remove = &dependency->next;
1594                 }
1595         }
1596 
1597         /* Then unbind $@ */
1598         (void) SETVAR(c_at, (Name) NULL, false);
1599 }
1600 
1601 /*
1602  * DONE.
1603  *
1604  *      run_command(line)
1605  *
1606  *      Takes one Cmd_line and runs the commands from it.
1607  *
1608  *      Return value:
1609  *                              Indicates if the command failed or not
1610  *
1611  *      Parameters:
1612  *              line            The command line to run
1613  *
1614  *      Global variables used:
1615  *              commands_done   Set if we do run command
1616  *              current_line    Set to the line we run a command from
1617  *              current_target  Set to the target we run a command for
1618  *              file_number     Used to form temp file name
1619  *              keep_state      Indicates that .KEEP_STATE is on
1620  *              make_state      The Name ".make.state", used to check timestamp
1621  *              parallel        True if currently building in parallel
1622  *              parallel_process_cnt Count of parallel processes running
1623  *              quest           Indicates that make -q is on
1624  *              rewrite_statefile Set if we do run a command
1625  *              sunpro_dependencies The Name "SUNPRO_DEPENDENCIES", set value
1626  *              temp_file_directory Used to form temp fie name
1627  *              temp_file_name  Set to the name of the temp file
1628  *              touch           Indicates that make -t is on
1629  */
1630 static Doname
1631 run_command(register Property line, Boolean)
1632 {
1633         register Doname         result = build_ok;
1634         register Boolean        remember_only = false;
1635         register Name           target = line->body.line.target;
1636         wchar_t                 *string;
1637         char                    tmp_file_path[MAXPATHLEN];
1638 
1639         if (!line->body.line.is_out_of_date && target->rechecking_target) {
1640                 target->rechecking_target = false;
1641                 return build_ok;
1642         }
1643 
1644         /*
1645          * Build the command if we know the target is out of date,
1646          * or if we want to check cmd consistency.
1647          */
1648         if (line->body.line.is_out_of_date || keep_state) {
1649                 /* Hack for handling conditional macros in DMake. */
1650                 if (!line->body.line.dont_rebuild_command_used) {
1651                         build_command_strings(target, line);
1652                 }
1653         }
1654         /* Never mind */
1655         if (!line->body.line.is_out_of_date) {
1656                 return build_ok;
1657         }
1658         /* If quest, then exit(1) because the target is out of date */
1659         if (quest) {
1660                 if (posix) {
1661 #ifdef TEAMWARE_MAKE_CMN
1662                         result = execute_parallel(line, true);
1663 #else
1664                         result = execute_serial(line);
1665 #endif
1666                 }
1667                 exit_status = 1;
1668                 exit(1);
1669         }
1670         /* We actually had to do something this time */
1671         rewrite_statefile = commands_done = true;
1672         /*
1673          * If this is an sccs command, we have to do some extra checking
1674          * and possibly complain. If the file can't be gotten because it's
1675          * checked out, we complain and behave as if the command was
1676          * executed eventhough we ignored the command.
1677          */
1678         if (!touch &&
1679             line->body.line.sccs_command &&
1680             (target->stat.time != file_doesnt_exist) &&
1681             ((target->stat.mode & 0222) != 0)) {
1682                 fatal(catgets(catd, 1, 27, "%s is writable so it cannot be sccs gotten"),
1683                       target->string_mb);
1684                 target->has_complained = remember_only = true;
1685         }
1686         /*
1687          * If KEEP_STATE is on, we make sure we have the timestamp for
1688          * .make.state. If .make.state changes during the command run,
1689          * we reread .make.state after the command. We also setup the
1690          * environment variable that asks utilities to report dependencies.
1691          */
1692         if (!touch &&
1693             keep_state &&
1694             !remember_only) {
1695                 (void) exists(make_state);
1696                 if((strlen(temp_file_directory) == 1) && 
1697                         (temp_file_directory[0] == '/')) {
1698                    tmp_file_path[0] = '\0';
1699                 } else {
1700                    strcpy(tmp_file_path, temp_file_directory);
1701                 }
1702                 sprintf(mbs_buffer,
1703                                 NOCATGETS("%s/.make.dependency.%08x.%d.%d"),
1704                                 tmp_file_path,
1705                                 hostid,
1706                                 getpid(),
1707                                 file_number++);
1708                 MBSTOWCS(wcs_buffer, mbs_buffer);
1709                 Boolean fnd;
1710                 temp_file_name = getname_fn(wcs_buffer, FIND_LENGTH, false, &fnd);
1711                 temp_file_name->stat.is_file = true;
1712                 int len = 2*MAXPATHLEN + strlen(target->string_mb) + 2;
1713                 wchar_t *to = string = ALLOC_WC(len);
1714                 for (wchar_t *from = wcs_buffer; *from != (int) nul_char; ) {
1715                         if (*from == (int) space_char) {
1716                                 *to++ = (int) backslash_char;
1717                         }
1718                         *to++ = *from++;
1719                 }
1720                 *to++ = (int) space_char;
1721                 MBSTOWCS(to, target->string_mb);
1722                 Name sprodep_name = getname_fn(string, FIND_LENGTH, false, &fnd);
1723                 (void) SETVAR(sunpro_dependencies,
1724                               sprodep_name,
1725                               false);
1726                 retmem(string);
1727         } else {
1728                 temp_file_name = NULL;
1729         }
1730 
1731         /*
1732          * In case we are interrupted, we need to know what was going on.
1733          */
1734         current_target = target;
1735         /*
1736          * We also need to be able to save an empty command instead of the
1737          * interrupted one in .make.state.
1738          */
1739         current_line = line;
1740         if (remember_only) {
1741                 /* Empty block!!! */
1742         } else if (touch) {
1743                 result = touch_command(line, target, result);
1744                 if (posix) {
1745 #ifdef TEAMWARE_MAKE_CMN
1746                         result = execute_parallel(line, true);
1747 #else
1748                         result = execute_serial(line);
1749 #endif
1750                 }
1751         } else {
1752                 /*
1753                  * If this is not a touch run, we need to execute the
1754                  * proper command(s) for the target.
1755                  */
1756 #ifdef TEAMWARE_MAKE_CMN
1757                 if (parallel) {
1758                         if (!parallel_ok(target, true)) {
1759                                 /*
1760                                  * We are building in parallel, but
1761                                  * this target must be built in serial.
1762                                  */
1763                                 /*
1764                                  * If nothing else is building,
1765                                  * do this one, else wait.
1766                                  */
1767                                 if (parallel_process_cnt == 0) {
1768 #ifdef TEAMWARE_MAKE_CMN
1769                                         result = execute_parallel(line, true, target->localhost);
1770 #else
1771                                         result = execute_serial(line);
1772 #endif
1773                                 } else {
1774                                         current_target = NULL;
1775                                         current_line = NULL;
1776 /*
1777                                         line->body.line.command_used = NULL;
1778  */
1779                                         line->body.line.dont_rebuild_command_used = true;
1780                                         return build_serial;
1781                                 }
1782                         } else {
1783                                 result = execute_parallel(line, false);
1784                                 switch (result) {
1785                                 case build_running:
1786                                         return build_running;
1787                                 case build_serial:
1788                                         if (parallel_process_cnt == 0) {
1789 #ifdef TEAMWARE_MAKE_CMN
1790                                                 result = execute_parallel(line, true, target->localhost);
1791 #else
1792                                                 result = execute_serial(line);
1793 #endif
1794                                         } else {
1795                                                 current_target = NULL;
1796                                                 current_line = NULL;
1797                                                 target->parallel = false;
1798                                                 line->body.line.command_used =
1799                                                                         NULL;
1800                                                 return build_serial;
1801                                         }
1802                                 }
1803                         }
1804                 } else {
1805 #endif
1806 #ifdef TEAMWARE_MAKE_CMN
1807                         result = execute_parallel(line, true, target->localhost);
1808 #else
1809                         result = execute_serial(line);
1810 #endif
1811 #ifdef TEAMWARE_MAKE_CMN
1812                 }
1813 #endif
1814         }
1815         temp_file_name = NULL;
1816         if (report_dependencies_level == 0){
1817                 update_target(line, result);
1818         }
1819         current_target = NULL;
1820         current_line = NULL;
1821         return result;
1822 }
1823 
1824 /*
1825  *      execute_serial(line)
1826  *
1827  *      Runs thru the command line for the target and
1828  *      executes the rules one by one.
1829  *
1830  *      Return value:
1831  *                              The result of the command build
1832  *
1833  *      Parameters:     
1834  *              line            The command to execute
1835  *
1836  *      Static variables used:
1837  *
1838  *      Global variables used:
1839  *              continue_after_error -k flag
1840  *              do_not_exec_rule -n flag
1841  *              report_dependencies -P flag
1842  *              silent          Don't echo commands before executing
1843  *              temp_file_name  Temp file for auto dependencies
1844  *              vpath_defined   If true, translate path for command
1845  */
1846 Doname
1847 execute_serial(Property line)
1848 {
1849         int                     child_pid = 0;
1850 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
1851         Avo_MToolJobResultMsg   *job_result_msg;
1852         RWCollectable           *xdr_msg;
1853 #endif
1854         Boolean                 printed_serial;
1855         Doname                  result = build_ok;
1856         Cmd_line                rule, cmd_tail, command = NULL;
1857         char                    mbstring[MAXPATHLEN];
1858         int                     filed;
1859         Name                    target = line->body.line.target;
1860 
1861         SEND_MTOOL_MSG(
1862                 if (!sent_rsrc_info_msg) {
1863                         if (userName[0] == '\0') {
1864                                 avo_get_user(userName, NULL);
1865                         }
1866                         if (hostName[0] == '\0') {
1867                                 strcpy(hostName, avo_hostname());
1868                         }
1869                         send_rsrc_info_msg(1, hostName, userName);
1870                         sent_rsrc_info_msg = 1;
1871                 }
1872                 send_job_start_msg(line);
1873                 job_result_msg = new Avo_MToolJobResultMsg();
1874         );
1875 
1876         target->has_recursive_dependency = false;
1877         // We have to create a copy of the rules chain for processing because
1878         // the original one can be destroyed during .make.state file rereading.
1879         for (rule = line->body.line.command_used;
1880              rule != NULL;
1881              rule = rule->next) {
1882                 if (command == NULL) {
1883                         command = cmd_tail = ALLOC(Cmd_line);
1884                 } else {
1885                         cmd_tail->next = ALLOC(Cmd_line);
1886                         cmd_tail = cmd_tail->next;
1887                 }
1888                 *cmd_tail = *rule;
1889         }
1890         if (command) {
1891                 cmd_tail->next = NULL;
1892         }
1893         for (rule = command; rule != NULL; rule = rule->next) {
1894                 if (posix && (touch || quest) && !rule->always_exec) {
1895                         continue;
1896                 }
1897                 if (vpath_defined) {
1898                         rule->command_line =
1899                           vpath_translation(rule->command_line);
1900                 }
1901                 /* Echo command line, maybe. */
1902                 if ((rule->command_line->hash.length > 0) &&
1903                     !silent &&
1904                     (!rule->silent || do_not_exec_rule) &&
1905                     (report_dependencies_level == 0)) {
1906                         (void) printf("%s\n", rule->command_line->string_mb);
1907                         SEND_MTOOL_MSG(
1908                                 job_result_msg->appendOutput(AVO_STRDUP(rule->command_line->string_mb));
1909                         );
1910                 }
1911                 if (rule->command_line->hash.length > 0) {
1912                         SEND_MTOOL_MSG(
1913                                 (void) sprintf(mbstring,
1914                                                 NOCATGETS("%s/make.stdout.%d.%d.XXXXXX"),
1915                                                 tmpdir,
1916                                                 getpid(),
1917                                                 file_number++);
1918 
1919                                 int tmp_fd = mkstemp(mbstring);
1920                                 if(tmp_fd) {
1921                                         (void) close(tmp_fd);
1922                                 }
1923 
1924                                 stdout_file = strdup(mbstring);
1925                                 stderr_file = NULL;
1926                                 child_pid = pollResults(stdout_file,
1927                                                         (char *)NULL,
1928                                                         (char *)NULL);
1929                         );
1930                         /* Do assignment if command line prefixed with "=" */
1931                         if (rule->assign) {
1932                                 result = build_ok;
1933                                 do_assign(rule->command_line, target);
1934                         } else if (report_dependencies_level == 0) {
1935                                 /* Execute command line. */
1936 #ifdef DISTRIBUTED
1937                                 setvar_envvar((Avo_DoJobMsg *)NULL);
1938 #else
1939                                 setvar_envvar();
1940 #endif
1941                                 result = dosys(rule->command_line,
1942                                                (Boolean) rule->ignore_error,
1943                                                (Boolean) rule->make_refd,
1944                                                /* ds 98.04.23 bug #4085164. make should always show error messages */
1945                                                false,
1946                                                /* BOOLEAN(rule->silent &&
1947                                                        rule->ignore_error), */
1948                                                (Boolean) rule->always_exec,
1949                                                target,
1950                                                send_mtool_msgs);
1951                                 check_state(temp_file_name);
1952                         }
1953                         SEND_MTOOL_MSG(
1954                                 append_job_result_msg(job_result_msg);
1955                                 if (child_pid > 0) {
1956                                         kill(child_pid, SIGUSR1);
1957                                         while (!((waitpid(child_pid, 0, 0) == -1)
1958                                                 && (errno == ECHILD)));
1959                                 }
1960                                 child_pid = 0;
1961                                 (void) unlink(stdout_file);
1962                                 retmem_mb(stdout_file);
1963                                 stdout_file = NULL;
1964                         );
1965                 } else {
1966                         result = build_ok;
1967                 }
1968                 if (result == build_failed) {
1969                         if (silent || rule->silent) {
1970                                 (void) printf(catgets(catd, 1, 242, "The following command caused the error:\n%s\n"),
1971                                               rule->command_line->string_mb);
1972                                 SEND_MTOOL_MSG(
1973                                         job_result_msg->appendOutput(AVO_STRDUP(catgets(catd, 1, 243, "The following command caused the error:")));
1974                                         job_result_msg->appendOutput(AVO_STRDUP(rule->command_line->string_mb));
1975                                 );
1976                         }
1977                         if (!rule->ignore_error && !ignore_errors) {
1978                                 if (!continue_after_error) {
1979                                         SEND_MTOOL_MSG(
1980                                                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
1981                                                 xdr_msg = (RWCollectable*)
1982                                                         job_result_msg;
1983                                                 xdr(&xdrs, xdr_msg);
1984                                                 (void) fflush(mtool_msgs_fp);
1985                                                 delete job_result_msg;
1986                                         );
1987                                         fatal(catgets(catd, 1, 244, "Command failed for target `%s'"),
1988                                               target->string_mb);
1989                                 }
1990                                 /*
1991                                  * Make sure a failing command is not
1992                                  * saved in .make.state.
1993                                  */
1994                                 line->body.line.command_used = NULL;
1995                                 break;
1996                         } else {
1997                                 result = build_ok;
1998                         }
1999                 }
2000         }
2001         for (rule = command; rule != NULL; rule = cmd_tail) {
2002                 cmd_tail = rule->next;
2003                 free(rule);
2004         }
2005         command = NULL;
2006         SEND_MTOOL_MSG(
2007                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
2008                 xdr_msg = (RWCollectable*) job_result_msg;
2009                 xdr(&xdrs, xdr_msg);
2010                 (void) fflush(mtool_msgs_fp);
2011 
2012                 delete job_result_msg;
2013         );
2014         if (temp_file_name != NULL) {
2015                 free_name(temp_file_name);
2016         }
2017         temp_file_name = NULL;
2018 
2019         Property spro = get_prop(sunpro_dependencies->prop, macro_prop);
2020         if(spro != NULL) {
2021                 Name val = spro->body.macro.value;
2022                 if(val != NULL) {
2023                         free_name(val);
2024                         spro->body.macro.value = NULL;
2025                 }
2026         }
2027         spro = get_prop(sunpro_dependencies->prop, env_mem_prop);
2028         if(spro) {
2029                 char *val = spro->body.env_mem.value;
2030                 if(val != NULL) {
2031                         /* 
2032                          * Do not return memory allocated for SUNPRO_DEPENDENCIES
2033                          * It will be returned in setvar_daemon() in macro.cc 
2034                          */
2035                         //      retmem_mb(val);
2036                         spro->body.env_mem.value = NULL;
2037                 }
2038         }
2039         
2040         return result;
2041 }
2042 
2043 
2044 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
2045 
2046 /*
2047  * Create and send an Avo_MToolRsrcInfoMsg.
2048  */
2049 void
2050 send_rsrc_info_msg(int max_jobs, char *hostname, char *username)
2051 {
2052         static int              first = 1;
2053         Avo_MToolRsrcInfoMsg    *msg;
2054         RWSlistCollectables     server_list;
2055         Avo_ServerState         *server_state;
2056         RWCollectable           *xdr_msg;
2057 
2058         if (!first) {
2059                 return;
2060         }
2061         first = 0;
2062 
2063         create_xdrs_ptr();
2064 
2065         server_state = new Avo_ServerState(max_jobs, hostname, username);
2066         server_list.append(server_state);
2067         msg = new Avo_MToolRsrcInfoMsg(&server_list);
2068 
2069         xdr_msg = (RWCollectable *)msg;
2070         xdr(get_xdrs_ptr(), xdr_msg);
2071         (void) fflush(get_mtool_msgs_fp());
2072 
2073         delete server_state;
2074         delete msg;
2075 }
2076 
2077 /*
2078  * Create and send an Avo_MToolJobStartMsg.
2079  */
2080 void
2081 send_job_start_msg(Property line)
2082 {
2083         int                     cmd_options = 0;
2084         Avo_MToolJobStartMsg    *msg;
2085         Cmd_line                rule;
2086         Name                    target = line->body.line.target;
2087         RWCollectable           *xdr_msg;
2088 
2089         if (userName[0] == '\0') {
2090                 avo_get_user(userName, NULL);
2091         }
2092         if (hostName[0] == '\0') {
2093                 strcpy(hostName, avo_hostname());
2094         }
2095 
2096         msg = new Avo_MToolJobStartMsg();
2097         msg->setJobId(++job_msg_id);
2098         msg->setTarget(AVO_STRDUP(target->string_mb));
2099         msg->setHost(AVO_STRDUP(hostName));
2100         msg->setUser(AVO_STRDUP(userName));
2101 
2102         for (rule = line->body.line.command_used;
2103              rule != NULL;
2104              rule = rule->next) {
2105                 if (posix && (touch || quest) && !rule->always_exec) {
2106                         continue;
2107                 }
2108                 if (vpath_defined) {
2109                         rule->command_line =
2110                           vpath_translation(rule->command_line);
2111                 }
2112                 cmd_options = 0;
2113                 if (rule->ignore_error || ignore_errors) {
2114                         cmd_options |= ignore_mask;
2115                 }
2116                 if (rule->silent || silent) {
2117                         cmd_options |= silent_mask;
2118                 }
2119                 if (rule->command_line->meta) {
2120                         cmd_options |= meta_mask;
2121                 }
2122                 if (!touch && (rule->command_line->hash.length > 0)) {
2123                         msg->appendCmd(new Avo_DmakeCommand(rule->command_line->string_mb, cmd_options));
2124                 }
2125         }
2126 
2127         xdr_msg = (RWCollectable*) msg;
2128         xdr(&xdrs, xdr_msg);
2129         (void) fflush(mtool_msgs_fp);
2130 
2131 /* tolik, 08/39/2002.
2132    I commented out this code because it causes using unallocated memory.
2133         delete msg;
2134 */
2135 }
2136 
2137 /*
2138  * Append the stdout/err to Avo_MToolJobResultMsg.
2139  */
2140 static void
2141 append_job_result_msg(Avo_MToolJobResultMsg *job_result_msg)
2142 {
2143         FILE            *fp;
2144         char            line[MAXPATHLEN];
2145         char            stdout_file2[MAXPATHLEN];
2146 
2147         if (stdout_file != NULL) {
2148                 fp = fopen(stdout_file, "r");
2149                 if (fp == NULL) {
2150                         /* Hmmm... what should we do here? */
2151                         warning(catgets(catd, 1, 326, "fopen() of stdout_file failed. Output may be lost"));
2152                         return;
2153                 }
2154                 while (fgets(line, MAXPATHLEN, fp) != NULL) {
2155                         if (line[strlen(line) - 1] == '\n') {
2156                                 line[strlen(line) - 1] = '\0';
2157                         }
2158                         job_result_msg->appendOutput(AVO_STRDUP(line));
2159                 }
2160                 (void) fclose(fp);
2161                 us_sleep(STAT_RETRY_SLEEP_TIME);
2162         } else {
2163                 /* Hmmm... stdout_file shouldn't be NULL */
2164                 warning(catgets(catd, 1, 327, "Internal stdout_file variable shouldn't be NULL. Output may be lost"));
2165         }
2166 }
2167 #endif /* TEAMWARE_MAKE_CMN */
2168 
2169 /*
2170  *      vpath_translation(cmd)
2171  *
2172  *      Translates one command line by
2173  *      checking each word. If the word has an alias it is translated.
2174  *
2175  *      Return value:
2176  *                              The translated command
2177  *
2178  *      Parameters:
2179  *              cmd             Command to translate
2180  *
2181  *      Global variables used:
2182  */
2183 Name
2184 vpath_translation(register Name cmd)
2185 {
2186         wchar_t                 buffer[STRING_BUFFER_LENGTH];
2187         String_rec              new_cmd;
2188         wchar_t                 *p;
2189         wchar_t                 *start;
2190 
2191         if (!vpath_defined || (cmd == NULL) || (cmd->hash.length == 0)) {
2192                 return cmd;
2193         }
2194         INIT_STRING_FROM_STACK(new_cmd, buffer);
2195 
2196         Wstring wcb(cmd);
2197         p = wcb.get_string();
2198 
2199         while (*p != (int) nul_char) {
2200                 while (iswspace(*p) && (*p != (int) nul_char)) {
2201                         append_char(*p++, &new_cmd);
2202                 }
2203                 start = p;
2204                 while (!iswspace(*p) && (*p != (int) nul_char)) {
2205                         p++;
2206                 }
2207                 cmd = GETNAME(start, p - start);
2208                 if (cmd->has_vpath_alias_prop) {
2209                         cmd = get_prop(cmd->prop, vpath_alias_prop)->
2210                                                 body.vpath_alias.alias;
2211                         APPEND_NAME(cmd,
2212                                       &new_cmd,
2213                                       (int) cmd->hash.length);
2214                 } else {
2215                         append_string(start, &new_cmd, p - start);
2216                 }
2217         }
2218         cmd = GETNAME(new_cmd.buffer.start, FIND_LENGTH);
2219         if (new_cmd.free_after_use) {
2220                 retmem(new_cmd.buffer.start);
2221         }
2222         return cmd;
2223 }
2224 
2225 /*
2226  *      check_state(temp_file_name)
2227  *
2228  *      Reads and checks the state changed by the previously executed command.
2229  *
2230  *      Parameters:
2231  *              temp_file_name  The auto dependency temp file
2232  *
2233  *      Global variables used:
2234  */
2235 void
2236 check_state(Name temp_file_name)
2237 {
2238         if (!keep_state) {
2239                 return;
2240         }
2241 
2242         /*
2243          * Then read the temp file that now might 
2244          * contain dependency reports from utilities 
2245          */
2246         read_dependency_file(temp_file_name);
2247 
2248         /*
2249          * And reread .make.state if it
2250          * changed (the command ran recursive makes) 
2251          */
2252         check_read_state_file();
2253         if (temp_file_name != NULL) {
2254                 (void) unlink(temp_file_name->string_mb);
2255         }
2256 }
2257 
2258 /*
2259  *      read_dependency_file(filename)
2260  *
2261  *      Read the temp file used for reporting dependencies to make
2262  *
2263  *      Parameters:
2264  *              filename        The name of the file with the state info
2265  *
2266  *      Global variables used:
2267  *              makefile_type   The type of makefile being read
2268  *              read_trace_level Debug flag
2269  *              temp_file_number The always increasing number for unique files
2270  *              trace_reader    Debug flag
2271  */
2272 static void
2273 read_dependency_file(register Name filename)
2274 {
2275         register Makefile_type  save_makefile_type;
2276 
2277         if (filename == NULL) {
2278                 return;
2279         }
2280         filename->stat.time = file_no_time;
2281         if (exists(filename) > file_doesnt_exist) {
2282                 save_makefile_type = makefile_type;
2283                 makefile_type = reading_cpp_file;
2284                 if (read_trace_level > 1) {
2285                         trace_reader = true;
2286                 }
2287                 temp_file_number++;
2288                 (void) read_simple_file(filename,
2289                                         false,
2290                                         false,
2291                                         false,
2292                                         false,
2293                                         false,
2294                                         false);
2295                 trace_reader = false;
2296                 makefile_type = save_makefile_type;
2297         }
2298 }
2299 
2300 /*
2301  *      check_read_state_file()
2302  *
2303  *      Check if .make.state has changed
2304  *      If it has we reread it
2305  *
2306  *      Parameters:
2307  *
2308  *      Global variables used:
2309  *              make_state      Make state file name
2310  *              makefile_type   Type of makefile being read
2311  *              read_trace_level Debug flag
2312  *              trace_reader    Debug flag
2313  */
2314 static void
2315 check_read_state_file(void)
2316 {
2317         timestruc_t             previous = make_state->stat.time;
2318         register Makefile_type  save_makefile_type;
2319         register Property       makefile;
2320 
2321         make_state->stat.time = file_no_time;
2322         if ((exists(make_state) == file_doesnt_exist) ||
2323             (make_state->stat.time == previous)) {
2324                 return;
2325         }
2326         save_makefile_type = makefile_type;
2327         makefile_type = rereading_statefile;
2328         /* Make sure we clear the old cached contents of .make.state */
2329         makefile = maybe_append_prop(make_state, makefile_prop);
2330         if (makefile->body.makefile.contents != NULL) {
2331                 retmem(makefile->body.makefile.contents);
2332                 makefile->body.makefile.contents = NULL;
2333         }
2334         if (read_trace_level > 1) {
2335                 trace_reader = true;
2336         }
2337         temp_file_number++;
2338         (void) read_simple_file(make_state,
2339                                 false,
2340                                 false,
2341                                 false,
2342                                 false,
2343                                 false,
2344                                 true);
2345         trace_reader = false;
2346         makefile_type = save_makefile_type;
2347 }
2348 
2349 /*
2350  *      do_assign(line, target)
2351  *
2352  *      Handles runtime assignments for command lines prefixed with "=".
2353  *
2354  *      Parameters:
2355  *              line            The command that contains an assignment
2356  *              target          The Name of the target, used for error reports
2357  *
2358  *      Global variables used:
2359  *              assign_done     Set to indicate doname needs to reprocess
2360  */
2361 static void
2362 do_assign(register Name line, register Name target)
2363 {
2364         Wstring wcb(line);
2365         register wchar_t        *string = wcb.get_string();
2366         register wchar_t        *equal;
2367         register Name           name;
2368         register Boolean        append = false;
2369 
2370         /*
2371          * If any runtime assignments are done, doname() must reprocess all
2372          * targets in the future since the macro values used to build the
2373          * command lines for the targets might have changed.
2374          */
2375         assign_done = true;
2376         /* Skip white space. */
2377         while (iswspace(*string)) {
2378                 string++;
2379         }
2380         equal = string;
2381         /* Find "+=" or "=". */
2382         while (!iswspace(*equal) &&
2383                (*equal != (int) plus_char) &&
2384                (*equal != (int) equal_char)) {
2385                 equal++;
2386         }
2387         /* Internalize macro name. */
2388         name = GETNAME(string, equal - string);
2389         /* Skip over "+=" "=". */
2390         while (!((*equal == (int) nul_char) ||
2391                  (*equal == (int) equal_char) ||
2392                  (*equal == (int) plus_char))) {
2393                 equal++;
2394         }
2395         switch (*equal) {
2396         case nul_char:
2397                 fatal(catgets(catd, 1, 31, "= expected in rule `%s' for target `%s'"),
2398                       line->string_mb,
2399                       target->string_mb);
2400         case plus_char:
2401                 append = true;
2402                 equal++;
2403                 break;
2404         }
2405         equal++;
2406         /* Skip over whitespace in front of value. */
2407         while (iswspace(*equal)) {
2408                 equal++;
2409         }
2410         /* Enter new macro value. */
2411         enter_equal(name,
2412                     GETNAME(equal, wcb.get_string() + line->hash.length - equal),
2413                     append);
2414 }
2415 
2416 /*
2417  *      build_command_strings(target, line)
2418  *
2419  *      Builds the command string to used when
2420  *      building a target. If the string is different from the previous one
2421  *      is_out_of_date is set.
2422  *
2423  *      Parameters:
2424  *              target          Target to build commands for
2425  *              line            Where to stuff result
2426  *
2427  *      Global variables used:
2428  *              c_at            The Name "@", used to set macro value
2429  *              command_changed Set if command is different from old
2430  *              debug_level     Should we trace activities?
2431  *              do_not_exec_rule Always echo when running -n
2432  *              empty_name      The Name "", used for empty rule
2433  *              funny           Semantics of characters
2434  *              ignore_errors   Used to init field for line
2435  *              is_conditional  Set to false befor evaling macro, checked
2436  *                              after expanding macros
2437  *              keep_state      Indicates that .KEEP_STATE is on
2438  *              make_word_mentioned Set by macro eval, inits field for cmd
2439  *              query           The Name "?", used to set macro value
2440  *              query_mentioned Set by macro eval, inits field for cmd
2441  *              recursion_level Used for tracing
2442  *              silent          Used to init field for line
2443  */
2444 static void
2445 build_command_strings(Name target, register Property line)
2446 {
2447         String_rec              command_line;
2448         register Cmd_line       command_template = line->body.line.command_template;
2449         register Cmd_line       *insert = &line->body.line.command_used;
2450         register Cmd_line       used = *insert;
2451         wchar_t                 buffer[STRING_BUFFER_LENGTH];
2452         wchar_t                 *start;
2453         Name                    new_command_line;
2454         register Boolean        new_command_longer = false;
2455         register Boolean        ignore_all_command_dependency = true;
2456         Property                member;
2457         static Name             less_name;
2458         static Name             percent_name;
2459         static Name             star;
2460         Name                    tmp_name;
2461 
2462         if (less_name == NULL) {
2463                 MBSTOWCS(wcs_buffer, "<");
2464                 less_name = GETNAME(wcs_buffer, FIND_LENGTH);
2465                 MBSTOWCS(wcs_buffer, "%");
2466                 percent_name = GETNAME(wcs_buffer, FIND_LENGTH);
2467                 MBSTOWCS(wcs_buffer, "*");
2468                 star = GETNAME(wcs_buffer, FIND_LENGTH);
2469         }
2470 
2471         /* We have to check if a target depends on conditional macros */
2472         /* Targets that do must be reprocessed by doname() each time around */
2473         /* since the macro values used when building the target might have */
2474         /* changed */
2475         conditional_macro_used = false;
2476         /* If we are building a lib.a(member) target $@ should be bound */
2477         /* to lib.a */
2478         if (target->is_member &&
2479             ((member = get_prop(target->prop, member_prop)) != NULL)) {
2480                 target = member->body.member.library;
2481         }
2482         /* If we are building a "::" help target $@ should be bound to */
2483         /* the real target name */
2484         /* A lib.a(member) target is never :: */
2485         if (target->has_target_prop) {
2486                 target = get_prop(target->prop, target_prop)->
2487                   body.target.target;
2488         }
2489         /* Bind the magic macros that make supplies */
2490         tmp_name = target;
2491         if(tmp_name != NULL) {
2492                 if (tmp_name->has_vpath_alias_prop) {
2493                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2494                                         body.vpath_alias.alias;
2495                 }
2496         }
2497         (void) SETVAR(c_at, tmp_name, false);
2498 
2499         tmp_name = line->body.line.star;
2500         if(tmp_name != NULL) {
2501                 if (tmp_name->has_vpath_alias_prop) {
2502                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2503                                         body.vpath_alias.alias;
2504                 }
2505         }
2506         (void) SETVAR(star, tmp_name, false);
2507 
2508         tmp_name = line->body.line.less;
2509         if(tmp_name != NULL) {
2510                 if (tmp_name->has_vpath_alias_prop) {
2511                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2512                                         body.vpath_alias.alias;
2513                 }
2514         }
2515         (void) SETVAR(less_name, tmp_name, false);
2516 
2517         tmp_name = line->body.line.percent;
2518         if(tmp_name != NULL) {
2519                 if (tmp_name->has_vpath_alias_prop) {
2520                         tmp_name = get_prop(tmp_name->prop, vpath_alias_prop)->
2521                                         body.vpath_alias.alias;
2522                 }
2523         }
2524         (void) SETVAR(percent_name, tmp_name, false);
2525 
2526         /* $? is seldom used and it is expensive to build */
2527         /* so we store the list form and build the string on demand */
2528         Chain query_list = NULL;
2529         Chain *query_list_tail = &query_list;
2530 
2531         for (Chain ch = line->body.line.query; ch != NULL; ch = ch->next) {
2532                 *query_list_tail = ALLOC(Chain);
2533                 (*query_list_tail)->name = ch->name;
2534                 if ((*query_list_tail)->name->has_vpath_alias_prop) {
2535                         (*query_list_tail)->name =
2536                                 get_prop((*query_list_tail)->name->prop,
2537                                         vpath_alias_prop)->body.vpath_alias.alias;
2538                 }
2539                 (*query_list_tail)->next = NULL;
2540                 query_list_tail = &(*query_list_tail)->next;
2541         }
2542         (void) setvar_daemon(query,
2543                              (Name) query_list,
2544                              false,
2545                              chain_daemon,
2546                              false,
2547                              debug_level);
2548 
2549         /* build $^ */
2550         Chain hat_list = NULL;
2551         Chain *hat_list_tail = &hat_list;
2552 
2553         for (Dependency dependency = line->body.line.dependencies; 
2554                 dependency != NULL;
2555                 dependency = dependency->next) {
2556                 /* skip automatic dependencies */
2557                 if (!dependency->automatic) {
2558                         if ((dependency->name != force) &&
2559                                 (dependency->stale == false)) {
2560                                 *hat_list_tail = ALLOC(Chain);
2561                         
2562                                 if (dependency->name->is_member &&
2563                                         (get_prop(dependency->name->prop, member_prop) != NULL)) {
2564                                         (*hat_list_tail)->name = 
2565                                                         get_prop(dependency->name->prop,
2566                                                                 member_prop)->body.member.member;
2567                                 } else {
2568                                         (*hat_list_tail)->name = dependency->name;
2569                                 }
2570 
2571                                 if((*hat_list_tail)->name != NULL) {
2572                                         if ((*hat_list_tail)->name->has_vpath_alias_prop) {
2573                                                 (*hat_list_tail)->name =
2574                                                         get_prop((*hat_list_tail)->name->prop,
2575                                                                 vpath_alias_prop)->body.vpath_alias.alias;
2576                                         }
2577                                 }
2578 
2579                                 (*hat_list_tail)->next = NULL;
2580                                 hat_list_tail = &(*hat_list_tail)->next;
2581                         }
2582                 }
2583         }
2584         (void) setvar_daemon(hat,
2585                              (Name) hat_list,
2586                              false,
2587                              chain_daemon,
2588                              false,
2589                              debug_level);
2590 
2591 /* We have two command sequences we need to handle */
2592 /* The old one that we probably read from .make.state */
2593 /* and the new one we are building that will replace the old one */
2594 /* Even when KEEP_STATE is not on we build a new command sequence and store */
2595 /* it in the line prop. This command sequence is then executed by */
2596 /* run_command(). If KEEP_STATE is on it is also later written to */
2597 /* .make.state. The routine replaces the old command line by line with the */
2598 /* new one trying to reuse Cmd_lines */
2599 
2600         /* If there is no old command_used we have to start creating */
2601         /* Cmd_lines to keep the new cmd in */
2602         if (used == NULL) {
2603                 new_command_longer = true;
2604                 *insert = used = ALLOC(Cmd_line);
2605                 used->next = NULL;
2606                 used->command_line = NULL;
2607                 insert = &used->next;
2608         }
2609         /* Run thru the template for the new command and build the expanded */
2610         /* new command lines */
2611         for (;
2612              command_template != NULL;
2613              command_template = command_template->next, insert = &used->next, used = *insert) {
2614                 /* If there is no old command_used Cmd_line we need to */
2615                 /* create one and say that cmd consistency failed */
2616                 if (used == NULL) {
2617                         new_command_longer = true;
2618                         *insert = used = ALLOC(Cmd_line);
2619                         used->next = NULL;
2620                         used->command_line = empty_name;
2621                 }
2622                 /* Prepare the Cmd_line for the processing */
2623                 /* The command line prefixes "@-=?" are stripped and that */
2624                 /* information is saved in the Cmd_line */
2625                 used->assign = false;
2626                 used->ignore_error = ignore_errors;
2627                 used->silent = silent;
2628                 used->always_exec = false;
2629                 /* Expand the macros in the command line */
2630                 INIT_STRING_FROM_STACK(command_line, buffer);
2631                 make_word_mentioned =
2632                   query_mentioned =
2633                     false;
2634                 expand_value(command_template->command_line, &command_line, true);
2635                 /* If the macro $(MAKE) is mentioned in the command */
2636                 /* "make -n" runs actually execute the command */
2637                 used->make_refd = make_word_mentioned;
2638                 used->ignore_command_dependency = query_mentioned;
2639                 /* Strip the prefixes */
2640                 start = command_line.buffer.start;
2641                 for (;
2642                      iswspace(*start) ||
2643                      (get_char_semantics_value(*start) & (int) command_prefix_sem);
2644                      start++) {
2645                         switch (*start) {
2646                         case question_char:
2647                                 used->ignore_command_dependency = true;
2648                                 break;
2649                         case exclam_char:
2650                                 used->ignore_command_dependency = false;
2651                                 break;
2652                         case equal_char:
2653                                 used->assign = true;
2654                                 break;
2655                         case hyphen_char:
2656                                 used->ignore_error = true;
2657                                 break;
2658                         case at_char:
2659                                 if (!do_not_exec_rule) {
2660                                         used->silent = true;
2661                                 }
2662                                 break;
2663                         case plus_char:
2664                                 if(posix) {
2665                                   used->always_exec  = true;
2666                                 }
2667                                 break;
2668                         }
2669                 }
2670                 /* If all command lines of the template are prefixed with "?"*/
2671                 /* the VIRTUAL_ROOT is not used for cmd consistency checks */
2672                 if (!used->ignore_command_dependency) {
2673                         ignore_all_command_dependency = false;
2674                 }
2675                 /* Internalize the expanded and stripped command line */
2676                 new_command_line = GETNAME(start, FIND_LENGTH);
2677                 if ((used->command_line == NULL) &&
2678                     (line->body.line.sccs_command)) {
2679                         used->command_line = new_command_line;
2680                         new_command_longer = false;
2681                 }
2682                 /* Compare it with the old one for command consistency */
2683                 if (used->command_line != new_command_line) {
2684                         Name vpath_translated = vpath_translation(new_command_line);
2685                         if (keep_state &&
2686                             !used->ignore_command_dependency && (vpath_translated != used->command_line)) {
2687                                 if (debug_level > 0) {
2688                                         if (used->command_line != NULL
2689                                             && *used->command_line->string_mb !=
2690                                             '\0') {
2691                                                 (void) printf(catgets(catd, 1, 32, "%*sBuilding %s because new command \n\t%s\n%*sdifferent from old\n\t%s\n"),
2692                                                               recursion_level,
2693                                                               "",
2694                                                               target->string_mb,
2695                                                               vpath_translated->string_mb,
2696                                                               recursion_level,
2697                                                               "",
2698                                                               used->
2699                                                               command_line->
2700                                                               string_mb);
2701                                         } else {
2702                                                 (void) printf(catgets(catd, 1, 33, "%*sBuilding %s because new command \n\t%s\n%*sdifferent from empty old command\n"),
2703                                                               recursion_level,
2704                                                               "",
2705                                                               target->string_mb,
2706                                                               vpath_translated->string_mb,
2707                                                               recursion_level,
2708                                                               "");
2709                                         }
2710                                 }
2711                                 command_changed = true;
2712                                 line->body.line.is_out_of_date = true;
2713                         }
2714                         used->command_line = new_command_line;
2715                 }
2716                 if (command_line.free_after_use) {
2717                         retmem(command_line.buffer.start);
2718                 }
2719         }
2720         /* Check if the old command is longer than the new for */
2721         /* command consistency */
2722         if (used != NULL) {
2723                 *insert = NULL;
2724                 if (keep_state &&
2725                     !ignore_all_command_dependency) {
2726                         if (debug_level > 0) {
2727                                 (void) printf(catgets(catd, 1, 34, "%*sBuilding %s because new command shorter than old\n"),
2728                                               recursion_level,
2729                                               "",
2730                                               target->string_mb);
2731                         }
2732                         command_changed = true;
2733                         line->body.line.is_out_of_date = true;
2734                 }
2735         }
2736         /* Check if the new command is longer than the old command for */
2737         /* command consistency */
2738         if (new_command_longer &&
2739             !ignore_all_command_dependency &&
2740             keep_state) {
2741                 if (debug_level > 0) {
2742                         (void) printf(catgets(catd, 1, 35, "%*sBuilding %s because new command longer than old\n"),
2743                                       recursion_level,
2744                                       "",
2745                                       target->string_mb);
2746                 }
2747                 command_changed = true;
2748                 line->body.line.is_out_of_date = true;
2749         }
2750         /* Unbind the magic macros */
2751         (void) SETVAR(c_at, (Name) NULL, false);
2752         (void) SETVAR(star, (Name) NULL, false);
2753         (void) SETVAR(less_name, (Name) NULL, false);
2754         (void) SETVAR(percent_name, (Name) NULL, false);
2755         (void) SETVAR(query, (Name) NULL, false);
2756         if (query_list != NULL) {
2757                 delete_query_chain(query_list);
2758         }
2759         (void) SETVAR(hat, (Name) NULL, false);
2760         if (hat_list != NULL) {
2761                 delete_query_chain(hat_list);
2762         }
2763 
2764         if (conditional_macro_used) {
2765                 target->conditional_macro_list = cond_macro_list;
2766                 cond_macro_list = NULL;
2767                 target->depends_on_conditional = true;
2768         }
2769 }
2770 
2771 /*
2772  *      touch_command(line, target, result)
2773  *
2774  *      If this is an "make -t" run we do this.
2775  *      We touch all targets in the target group ("foo + fie:") if any.
2776  *
2777  *      Return value:
2778  *                              Indicates if the command failed or not
2779  *
2780  *      Parameters:
2781  *              line            The command line to update
2782  *              target          The target we are touching
2783  *              result          Initial value for the result we return
2784  *
2785  *      Global variables used:
2786  *              do_not_exec_rule Indicates that -n is on
2787  *              silent          Do not echo commands
2788  */
2789 static Doname
2790 touch_command(register Property line, register Name target, Doname result)
2791 {
2792         Name                    name;
2793         register Chain          target_group;
2794         String_rec              touch_string;
2795         wchar_t                 buffer[MAXPATHLEN];
2796         Name                    touch_cmd;
2797         Cmd_line                rule;
2798 
2799 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
2800         Avo_MToolJobResultMsg   *job_result_msg;
2801         RWCollectable           *xdr_msg;
2802         int                     child_pid = 0;
2803         wchar_t                 string[MAXPATHLEN];
2804         char                    mbstring[MAXPATHLEN];
2805         int                     filed;
2806 #endif
2807 
2808         SEND_MTOOL_MSG(
2809                 if (!sent_rsrc_info_msg) {
2810                         if (userName[0] == '\0') {
2811                                 avo_get_user(userName, NULL);
2812                         }
2813                         if (hostName[0] == '\0') {
2814                                 strcpy(hostName, avo_hostname());
2815                         }
2816                         send_rsrc_info_msg(1, hostName, userName);
2817                         sent_rsrc_info_msg = 1;
2818                 }
2819                 send_job_start_msg(line);
2820                 job_result_msg = new Avo_MToolJobResultMsg();
2821         );
2822         for (name = target, target_group = NULL; name != NULL;) {
2823                 if (!name->is_member) {
2824                         /*
2825                          * Build a touch command that can be passed
2826                          * to dosys(). If KEEP_STATE is on, "make -t"
2827                          * will save the proper command, not the
2828                          * "touch" in .make.state.
2829                          */
2830                         INIT_STRING_FROM_STACK(touch_string, buffer);
2831                         MBSTOWCS(wcs_buffer, NOCATGETS("touch "));
2832                         append_string(wcs_buffer, &touch_string, FIND_LENGTH);
2833                         touch_cmd = name;
2834                         if (name->has_vpath_alias_prop) {
2835                                 touch_cmd = get_prop(name->prop,
2836                                                  vpath_alias_prop)->
2837                                                    body.vpath_alias.alias;
2838                         }
2839                         APPEND_NAME(touch_cmd,
2840                                       &touch_string,
2841                                       FIND_LENGTH);
2842                         touch_cmd = GETNAME(touch_string.buffer.start,
2843                                             FIND_LENGTH);
2844                         if (touch_string.free_after_use) {
2845                                 retmem(touch_string.buffer.start);
2846                         }
2847                         if (!silent ||
2848                             do_not_exec_rule &&
2849                             (target_group == NULL)) {
2850                                 (void) printf("%s\n", touch_cmd->string_mb);
2851                                 SEND_MTOOL_MSG(
2852                                         job_result_msg->appendOutput(AVO_STRDUP(touch_cmd->string_mb));
2853                                 );
2854                         }
2855                         /* Run the touch command, or simulate it */
2856                         if (!do_not_exec_rule) {
2857 
2858                                 SEND_MTOOL_MSG(
2859                                         (void) sprintf(mbstring,
2860                                                         NOCATGETS("%s/make.stdout.%d.%d.XXXXXX"),
2861                                                         tmpdir,
2862                                                         getpid(),
2863                                                         file_number++);
2864                                 
2865                                         int tmp_fd = mkstemp(mbstring);
2866                                         if(tmp_fd) {
2867                                                 (void) close(tmp_fd);
2868                                         }
2869 
2870                                         stdout_file = strdup(mbstring);
2871                                         stderr_file = NULL;
2872                                         child_pid = pollResults(stdout_file,
2873                                                                 (char *)NULL,
2874                                                                 (char *)NULL);
2875                                 );
2876 
2877                                 result = dosys(touch_cmd,
2878                                                false,
2879                                                false,
2880                                                false,
2881                                                false,
2882                                                name,
2883                                                send_mtool_msgs);
2884 
2885                                 SEND_MTOOL_MSG(
2886                                         append_job_result_msg(job_result_msg);
2887                                         if (child_pid > 0) {
2888                                                 kill(child_pid, SIGUSR1);
2889                                                 while (!((waitpid(child_pid, 0, 0) == -1)
2890                                                         && (errno == ECHILD)));
2891                                         }
2892                                         child_pid = 0;
2893                                         (void) unlink(stdout_file);
2894                                         retmem_mb(stdout_file);
2895                                         stdout_file = NULL;
2896                                 );
2897 
2898                         } else {
2899                                 result = build_ok;
2900                         }
2901                 } else {
2902                         result = build_ok;
2903                 }
2904                 if (target_group == NULL) {
2905                         target_group = line->body.line.target_group;
2906                 } else {
2907                         target_group = target_group->next;
2908                 }
2909                 if (target_group != NULL) {
2910                         name = target_group->name;
2911                 } else {
2912                         name = NULL;
2913                 }
2914         }
2915         SEND_MTOOL_MSG(
2916                 job_result_msg->setResult(job_msg_id, (result == build_ok) ? 0 : 1, DONE);
2917                 xdr_msg = (RWCollectable*) job_result_msg;
2918                 xdr(&xdrs, xdr_msg);
2919                 (void) fflush(mtool_msgs_fp);
2920                 delete job_result_msg;
2921         );
2922         return result;
2923 }
2924 
2925 /*
2926  *      update_target(line, result)
2927  *
2928  *      updates the status of a target after executing its commands.
2929  *
2930  *      Parameters:
2931  *              line            The command line block to update
2932  *              result          Indicates that build is OK so can update
2933  *
2934  *      Global variables used:
2935  *              do_not_exec_rule Indicates that -n is on
2936  *              touch           Fake the new timestamp if we are just touching
2937  */
2938 void
2939 update_target(Property line, Doname result)
2940 {
2941         Name                    target;
2942         Chain                   target_group;
2943         Property                line2;
2944         timestruc_t             old_stat_time;
2945         Property                member;
2946 
2947         /*
2948          * [tolik] Additional fix for bug 1063790. It was fixed
2949          * for serial make long ago, but DMake dumps core when
2950          * target is a symlink and sccs file is newer then target. 
2951          * In this case, finish_children() calls update_target()
2952          * with line==NULL.
2953          */
2954         if(line == NULL) {
2955                 /* XXX. Should we do anything here? */
2956                 return;
2957         }       
2958 
2959         target = line->body.line.target;
2960 
2961         if ((result == build_ok) && (line->body.line.command_used != NULL)) {
2962                 if (do_not_exec_rule ||
2963                     touch ||
2964                     (target->is_member &&
2965                      (line->body.line.command_template != NULL) &&
2966                      (line->body.line.command_template->command_line->string_mb[0] == 0) &&
2967                      (line->body.line.command_template->next == NULL))) {
2968                         /* If we are simulating execution we need to fake a */
2969                         /* new timestamp for the target we didnt build */
2970                         target->stat.time = file_max_time;
2971                 } else {
2972                         /*
2973                          * If we really built the target we read the new
2974                          * timestamp.
2975                          * Fix for bug #1110906: if .c file is newer than
2976                          * the corresponding .o file which is in an archive
2977                          * file, make will compile the .c file but it won't
2978                          * update the object in the .a file.
2979                          */
2980                         old_stat_time = target->stat.time;
2981                         target->stat.time = file_no_time;
2982                         (void) exists(target);
2983                         if ((target->is_member) &&
2984                             (target->stat.time == old_stat_time)) {
2985                                 member = get_prop(target->prop, member_prop);
2986                                 if (member != NULL) {
2987                                         target->stat.time = member->body.member.library->stat.time;
2988                                         target->stat.time.tv_sec++;
2989                                 }
2990                         }
2991                 }
2992                 /* If the target is part of a group we need to propagate the */
2993                 /* result of the run to all members */
2994                 for (target_group = line->body.line.target_group;
2995                      target_group != NULL;
2996                      target_group = target_group->next) {
2997                         target_group->name->stat.time = target->stat.time;
2998                         line2 = maybe_append_prop(target_group->name,
2999                                                   line_prop);
3000                         line2->body.line.command_used =
3001                           line->body.line.command_used;
3002                         line2->body.line.target = target_group->name;
3003                 }
3004         }
3005         target->has_built = true;
3006 }
3007 
3008 /*
3009  *      sccs_get(target, command)
3010  *
3011  *      Figures out if it possible to sccs get a file
3012  *      and builds the command to do it if it is.
3013  *
3014  *      Return value:
3015  *                              Indicates if sccs get failed or not
3016  *
3017  *      Parameters:
3018  *              target          Target to get
3019  *              command         Where to deposit command to use
3020  *
3021  *      Global variables used:
3022  *              debug_level     Should we trace activities?
3023  *              recursion_level Used for tracing
3024  *              sccs_get_rule   The rule to used for sccs getting
3025  */
3026 static Doname
3027 sccs_get(register Name target, register Property *command)
3028 {
3029         register int            result;
3030         char                    link[MAXPATHLEN];
3031         String_rec              string;
3032         wchar_t                 name[MAXPATHLEN];
3033         register wchar_t        *p;
3034         timestruc_t             sccs_time;
3035         register Property       line;
3036         int                     sym_link_depth = 0;
3037 
3038         /* For sccs, we need to chase symlinks. */
3039         while (target->stat.is_sym_link) {
3040                 if (sym_link_depth++ > 90) {
3041                         fatal(catgets(catd, 1, 95, "Can't read symbolic link `%s': Number of symbolic links encountered during path name traversal exceeds 90."),
3042                               target->string_mb);
3043                 }
3044                 /* Read the value of the link. */
3045                 result = readlink_vroot(target->string_mb,
3046                                         link,
3047                                         sizeof(link),
3048                                         NULL,
3049                                         VROOT_DEFAULT);
3050                 if (result == -1) {
3051                         fatal(catgets(catd, 1, 36, "Can't read symbolic link `%s': %s"),
3052                               target->string_mb, errmsg(errno));
3053                 }
3054                 link[result] = 0;
3055                 /* Use the value to build the proper filename. */
3056                 INIT_STRING_FROM_STACK(string, name);
3057 
3058                 Wstring wcb(target);
3059                 if ((link[0] != slash_char) &&
3060                     ((p = (wchar_t *) wsrchr(wcb.get_string(), slash_char)) != NULL)) {
3061                         append_string(wcb.get_string(), &string, p - wcb.get_string() + 1);
3062                 }
3063                 append_string(link, &string, result);
3064                 /* Replace the old name with the translated name. */
3065                 target = normalize_name(string.buffer.start, string.text.p - string.buffer.start);
3066                 (void) exists(target);
3067                 if (string.free_after_use) {
3068                         retmem(string.buffer.start);
3069                 }
3070         }
3071 
3072         /*
3073          * read_dir() also reads the ?/SCCS dir and saves information
3074          * about which files have SCSC/s. files.
3075          */
3076         if (target->stat.has_sccs == DONT_KNOW_SCCS) {
3077                 read_directory_of_file(target);
3078         }
3079         switch (target->stat.has_sccs) {
3080         case DONT_KNOW_SCCS:
3081                 /* We dont know by now there is no SCCS/s.* */
3082                 target->stat.has_sccs = NO_SCCS;
3083         case NO_SCCS:
3084                 /*
3085                  * If there is no SCCS/s.* but the plain file exists,
3086                  * we say things are OK.
3087                  */
3088                 if (target->stat.time > file_doesnt_exist) {
3089                         return build_ok;
3090                 }
3091                 /* If we cant find the plain file, we give up. */
3092                 return build_dont_know;
3093         case HAS_SCCS:
3094                 /*
3095                  * Pay dirt. We now need to figure out if the plain file
3096                  * is out of date relative to the SCCS/s.* file.
3097                  */
3098                 sccs_time = exists(get_prop(target->prop,
3099                                             sccs_prop)->body.sccs.file);
3100                 break;
3101         }
3102 
3103         if ((!target->has_complained &&
3104             (sccs_time != file_doesnt_exist) &&
3105             (sccs_get_rule != NULL))) {
3106                 /* only checking */
3107                 if (command == NULL) {
3108                         return build_ok;
3109                 }
3110                 /*
3111                  * We provide a command line for the target. The line is a
3112                  * "sccs get" command from default.mk.
3113                  */
3114                 line = maybe_append_prop(target, line_prop);
3115                 *command = line;
3116                 if (sccs_time > target->stat.time) {
3117                         /*
3118                          * And only if the plain file is out of date do we
3119                          * request execution of the command.
3120                          */
3121                         line->body.line.is_out_of_date = true;
3122                         if (debug_level > 0) {
3123                                 (void) printf(catgets(catd, 1, 37, "%*sSccs getting %s because s. file is younger than source file\n"),
3124                                               recursion_level,
3125                                               "",
3126                                               target->string_mb);
3127                         }
3128                 }
3129                 line->body.line.sccs_command = true;
3130                 line->body.line.command_template = sccs_get_rule;
3131                 if(!svr4 && (!allrules_read || posix)) {
3132                    if((target->prop) &&
3133                       (target->prop->body.sccs.file) &&
3134                       (target->prop->body.sccs.file->string_mb)) {
3135                       if((strlen(target->prop->body.sccs.file->string_mb) ==
3136                         strlen(target->string_mb) + 2) && 
3137                         (target->prop->body.sccs.file->string_mb[0] == 's') &&
3138                         (target->prop->body.sccs.file->string_mb[1] == '.')) {
3139 
3140                          line->body.line.command_template = get_posix_rule;
3141                       }
3142                    }
3143                 }
3144                 line->body.line.target = target;
3145                 /*
3146                  * Also make sure the rule is build with $* and $<
3147                  * bound properly.
3148                  */
3149                 line->body.line.star = NULL;
3150                 line->body.line.less = NULL;
3151                 line->body.line.percent = NULL;
3152                 return build_ok;
3153         }
3154         return build_dont_know;
3155 }
3156 
3157 /*
3158  *      read_directory_of_file(file)
3159  *
3160  *      Reads the directory the specified file lives in.
3161  *
3162  *      Parameters:
3163  *              file            The file we need to read dir for
3164  *
3165  *      Global variables used:
3166  *              dot             The Name ".", used as the default dir
3167  */
3168 void
3169 read_directory_of_file(register Name file)
3170 {
3171 
3172         Wstring file_string(file);
3173         wchar_t * wcb = file_string.get_string();
3174         wchar_t usr_include_buf[MAXPATHLEN];
3175         wchar_t usr_include_sys_buf[MAXPATHLEN];
3176 
3177         register Name           directory = dot;
3178         register wchar_t        *p = (wchar_t *) wsrchr(wcb,
3179                                                         (int) slash_char);
3180         register int            length = p - wcb;
3181         static Name             usr_include;
3182         static Name             usr_include_sys;
3183 
3184         if (usr_include == NULL) {
3185                 MBSTOWCS(usr_include_buf, NOCATGETS("/usr/include"));
3186                 usr_include = GETNAME(usr_include_buf, FIND_LENGTH);
3187                 MBSTOWCS(usr_include_sys_buf, NOCATGETS("/usr/include/sys"));
3188                 usr_include_sys = GETNAME(usr_include_sys_buf, FIND_LENGTH);
3189         }
3190 
3191         /*
3192          * If the filename contains a "/" we have to extract the path
3193          * Else the path defaults to ".".
3194          */
3195         if (p != NULL) {
3196                 /*
3197                  * Check some popular directories first to possibly
3198                  * save time. Compare string length first to gain speed.
3199                  */
3200                 if ((usr_include->hash.length == length) &&
3201                     IS_WEQUALN(usr_include_buf,
3202                                wcb,
3203                                length)) {
3204                         directory = usr_include;
3205                 } else if ((usr_include_sys->hash.length == length) &&
3206                            IS_WEQUALN(usr_include_sys_buf,
3207                                       wcb,
3208                                       length)) {
3209                         directory = usr_include_sys;
3210                 } else {
3211                         directory = GETNAME(wcb, length);
3212                 }
3213         }
3214         (void) read_dir(directory,
3215                         (wchar_t *) NULL,
3216                         (Property) NULL,
3217                         (wchar_t *) NULL);
3218 }
3219 
3220 /*
3221  *      add_pattern_conditionals(target)
3222  *
3223  *      Scan the list of conditionals defined for pattern targets and add any
3224  *      that match this target to its list of conditionals.
3225  *
3226  *      Parameters:
3227  *              target          The target we should add conditionals for
3228  *
3229  *      Global variables used:
3230  *              conditionals    The list of pattern conditionals
3231  */
3232 static void
3233 add_pattern_conditionals(register Name target)
3234 {
3235         register Property       conditional;
3236         Property                new_prop;
3237         Property                *previous;
3238         Name_rec                dummy;
3239         wchar_t                 *pattern;
3240         wchar_t                 *percent;
3241         int                     length;
3242 
3243         Wstring wcb(target);
3244         Wstring wcb1;
3245 
3246         for (conditional = get_prop(conditionals->prop, conditional_prop);
3247              conditional != NULL;
3248              conditional = get_prop(conditional->next, conditional_prop)) {
3249                 wcb1.init(conditional->body.conditional.target);
3250                 pattern = wcb1.get_string();
3251                 if (pattern[1] != 0) {
3252                         percent = (wchar_t *) wschr(pattern, (int) percent_char);
3253                         if (!wcb.equaln(pattern, percent-pattern) ||
3254                             !IS_WEQUAL(wcb.get_string(wcb.length()-wslen(percent+1)), percent+1)) {
3255                                 continue;
3256                         }
3257                 }
3258                 for (previous = &target->prop;
3259                      *previous != NULL;
3260                      previous = &(*previous)->next) {
3261                         if (((*previous)->type == conditional_prop) &&
3262                             ((*previous)->body.conditional.sequence >
3263                              conditional->body.conditional.sequence)) {
3264                                 break;
3265                         }
3266                 }
3267                 if (*previous == NULL) {
3268                         new_prop = append_prop(target, conditional_prop);
3269                 } else {
3270                         dummy.prop = NULL;
3271                         new_prop = append_prop(&dummy, conditional_prop);
3272                         new_prop->next = *previous;
3273                         *previous = new_prop;
3274                 }
3275                 target->conditional_cnt++;
3276                 new_prop->body.conditional = conditional->body.conditional;
3277         }
3278 }
3279 
3280 /*
3281  *      set_locals(target, old_locals)
3282  *
3283  *      Sets any conditional macros for the target.
3284  *      Each target carries a possibly empty set of conditional properties.
3285  *
3286  *      Parameters:
3287  *              target          The target to set conditional macros for
3288  *              old_locals      Space to store old values in
3289  *
3290  *      Global variables used:
3291  *              debug_level     Should we trace activity?
3292  *              is_conditional  We need to preserve this value
3293  *              recursion_level Used for tracing
3294  */
3295 void
3296 set_locals(register Name target, register Property old_locals)
3297 {
3298         register Property       conditional;
3299         register int            i;
3300         register Boolean        saved_conditional_macro_used;
3301         Chain                   cond_name;
3302         Chain                   cond_chain;
3303 
3304 #ifdef DISTRIBUTED
3305         if (target->dont_activate_cond_values) {
3306                 return;
3307         }
3308 #endif
3309 
3310         saved_conditional_macro_used = conditional_macro_used;
3311 
3312         /* Scan the list of conditional properties and apply each one */
3313         for (conditional = get_prop(target->prop, conditional_prop), i = 0;
3314              conditional != NULL;
3315              conditional = get_prop(conditional->next, conditional_prop),
3316              i++) {
3317                 /* Save the old value */
3318                 old_locals[i].body.macro =
3319                   maybe_append_prop(conditional->body.conditional.name,
3320                                     macro_prop)->body.macro;
3321                 if (debug_level > 1) {
3322                         (void) printf(catgets(catd, 1, 38, "%*sActivating conditional value: "),
3323                                       recursion_level,
3324                                       "");
3325                 }
3326                 /* Set the conditional value. Macros are expanded when the */
3327                 /* macro is refd as usual */
3328                 if ((conditional->body.conditional.name != virtual_root) ||
3329                     (conditional->body.conditional.value != virtual_root)) {
3330                         (void) SETVAR(conditional->body.conditional.name,
3331                                       conditional->body.conditional.value,
3332                                       (Boolean) conditional->body.conditional.append);
3333                 }
3334                 cond_name = ALLOC(Chain);
3335                 cond_name->name = conditional->body.conditional.name;
3336         }
3337         /* Put this target on the front of the chain of conditional targets */
3338         cond_chain = ALLOC(Chain);
3339         cond_chain->name = target;
3340         cond_chain->next = conditional_targets;
3341         conditional_targets = cond_chain;
3342         conditional_macro_used = saved_conditional_macro_used;
3343 }
3344 
3345 /*
3346  *      reset_locals(target, old_locals, conditional, index)
3347  *
3348  *      Removes any conditional macros for the target.
3349  *
3350  *      Parameters:
3351  *              target          The target we are retoring values for
3352  *              old_locals      The values to restore
3353  *              conditional     The first conditional block for the target
3354  *              index           into the old_locals vector
3355  *      Global variables used:
3356  *              debug_level     Should we trace activities?
3357  *              recursion_level Used for tracing
3358  */
3359 void
3360 reset_locals(register Name target, register Property old_locals, register Property conditional, register int index)
3361 {
3362         register Property       this_conditional;
3363         Chain                   cond_chain;
3364 
3365 #ifdef DISTRIBUTED
3366         if (target->dont_activate_cond_values) {
3367                 return;
3368         }
3369 #endif
3370 
3371         /* Scan the list of conditional properties and restore the old value */
3372         /* to each one Reverse the order relative to when we assigned macros */
3373         this_conditional = get_prop(conditional->next, conditional_prop);
3374         if (this_conditional != NULL) {
3375                 reset_locals(target, old_locals, this_conditional, index+1);
3376         } else {
3377                 /* Remove conditional target from chain */
3378                 if (conditional_targets == NULL ||
3379                     conditional_targets->name != target) {
3380                         warning(catgets(catd, 1, 39, "Internal error: reset target not at head of condtional_targets chain"));
3381                 } else {
3382                         cond_chain = conditional_targets->next;
3383                         retmem_mb((caddr_t) conditional_targets);
3384                         conditional_targets = cond_chain;
3385                 }
3386         }
3387         get_prop(conditional->body.conditional.name->prop,
3388                  macro_prop)->body.macro = old_locals[index].body.macro;
3389         if (conditional->body.conditional.name == virtual_root) {
3390                 (void) SETVAR(virtual_root, getvar(virtual_root), false);
3391         }
3392         if (debug_level > 1) {
3393                 if (old_locals[index].body.macro.value != NULL) {
3394                         (void) printf(catgets(catd, 1, 40, "%*sdeactivating conditional value: %s= %s\n"),
3395                                       recursion_level,
3396                                       "",
3397                                       conditional->body.conditional.name->
3398                                       string_mb,
3399                                       old_locals[index].body.macro.value->
3400                                       string_mb);
3401                 } else {
3402                         (void) printf(catgets(catd, 1, 41, "%*sdeactivating conditional value: %s =\n"),
3403                                       recursion_level,
3404                                       "",
3405                                       conditional->body.conditional.name->
3406                                       string_mb);
3407                 }
3408         }
3409 }
3410 
3411 /*
3412  *      check_auto_dependencies(target, auto_count, automatics)
3413  *
3414  *      Returns true if the target now has a dependency
3415  *      it didn't previously have (saved on automatics).
3416  *
3417  *      Return value:
3418  *                              true if new dependency found
3419  *
3420  *      Parameters:
3421  *              target          Target we check
3422  *              auto_count      Number of old automatic vars
3423  *              automatics      Saved old automatics
3424  *
3425  *      Global variables used:
3426  *              keep_state      Indicates that .KEEP_STATE is on
3427  */
3428 Boolean
3429 check_auto_dependencies(Name target, int auto_count, Name *automatics)
3430 {
3431         Name            *p;
3432         int             n;
3433         Property        line;
3434         Dependency      dependency;
3435 
3436         if (keep_state) {
3437                 if ((line = get_prop(target->prop, line_prop)) == NULL) {
3438                         return false;
3439                 }
3440                 /* Go thru new list of automatic depes */
3441                 for (dependency = line->body.line.dependencies;
3442                      dependency != NULL;
3443                      dependency = dependency->next) {
3444                         /* And make sure that each one existed before we */
3445                         /* built the target */
3446                         if (dependency->automatic && !dependency->stale) {
3447                                 for (n = auto_count, p = automatics;
3448                                      n > 0;
3449                                      n--) {
3450                                         if (*p++ == dependency->name) {
3451                                                 /* If we can find it on the */
3452                                                 /* saved list of autos we */
3453                                                 /* are OK  */
3454                                                 goto not_new;
3455                                         }
3456                                 }
3457                                 /* But if we scan over the old list */
3458                                 /* of auto. without finding it it is */
3459                                 /* new and we must check it */
3460                                 return true;
3461                         }
3462                 not_new:;
3463                 }
3464                 return false;
3465         } else {
3466                 return false;
3467         }
3468 }
3469 
3470 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
3471 void
3472 create_xdrs_ptr(void)
3473 {
3474         static int      xdrs_init = 0;
3475 
3476         if (!xdrs_init) {
3477                 xdrs_init = 1;
3478                 mtool_msgs_fp = fdopen(mtool_msgs_fd, "a");
3479                 xdrstdio_create(&xdrs,
3480                                 mtool_msgs_fp,
3481                                 XDR_ENCODE);
3482         }
3483 }
3484 
3485 XDR *
3486 get_xdrs_ptr(void)
3487 {
3488         return &xdrs;
3489 }
3490 
3491 FILE *
3492 get_mtool_msgs_fp(void)
3493 {
3494         return mtool_msgs_fp;
3495 }
3496 
3497 int
3498 get_job_msg_id(void)
3499 {
3500         return job_msg_id;
3501 }
3502 
3503 // Continuously poll and show the results of remotely executing a job,
3504 // i.e., output the stdout and stderr files.
3505 
3506 static int
3507 pollResults(char *outFn, char *errFn, char *hostNm)
3508 {
3509         int             child;
3510 
3511         child = fork();
3512         switch (child) {
3513         case -1:
3514                 break;
3515         case 0:
3516                 enable_interrupt((void (*) (int))SIG_DFL);
3517                 (void) sigset(SIGUSR1, Avo_PollResultsAction_Sigusr1Handler);
3518                 pollResultsAction(outFn, errFn);
3519 
3520                 exit(0);
3521                 break;
3522         default:
3523                 break;
3524         }
3525         return child;
3526 }
3527 
3528 // This is the PollResultsAction SIGUSR1 handler.
3529 
3530 static bool_t pollResultsActionTimeToFinish = FALSE;
3531 
3532 extern "C" void
3533 Avo_PollResultsAction_Sigusr1Handler(int foo)
3534 {
3535         pollResultsActionTimeToFinish = TRUE;
3536 }
3537 
3538 static void
3539 pollResultsAction(char *outFn, char *errFn)
3540 {
3541         int                     fd;
3542         time_t                  file_time = 0;
3543         long                    file_time_nsec = 0;
3544         struct stat             statbuf;
3545         int                     stat_rc;
3546 
3547         // Keep stat'ing until file exists.
3548         while (((stat_rc = stat(outFn, &statbuf)) != 0) &&
3549                (errno == ENOENT) && 
3550                !pollResultsActionTimeToFinish) {
3551                 us_sleep(STAT_RETRY_SLEEP_TIME);
3552         }
3553         // The previous stat() could be failed due to EINTR
3554         // So one more try is needed
3555         if (stat_rc != 0 && stat(outFn, &statbuf) != 0) {
3556                 // stat() failed
3557                 warning(NOCATGETS("Internal error: stat(\"%s\", ...) failed: %s\n"),
3558                         outFn, strerror(errno));
3559                 exit(1);
3560         }
3561 
3562         if ((fd = open(outFn, O_RDONLY)) < 0
3563                 && (errno != EINTR || (fd = open(outFn, O_RDONLY)) < 0)) {
3564                 // open() failed
3565                 warning(NOCATGETS("Internal error: open(\"%s\", O_RDONLY) failed: %s\n"),
3566                         outFn, strerror(errno));
3567                 exit(1);
3568         }
3569 
3570         while (!pollResultsActionTimeToFinish && stat(outFn, &statbuf) == 0) {
3571                 if ((statbuf.st_mtim.tv_sec > file_time) ||
3572                     ((statbuf.st_mtim.tv_sec == file_time) &&
3573                     (statbuf.st_mtim.tv_nsec > file_time_nsec))
3574                    ) {
3575                         file_time = statbuf.st_mtim.tv_sec;
3576                         file_time_nsec = statbuf.st_mtim.tv_nsec;
3577                         rxmGetNextResultsBlock(fd);
3578                 }
3579                 us_sleep(STAT_RETRY_SLEEP_TIME);
3580         }
3581         // Check for the rest of output
3582         rxmGetNextResultsBlock(fd);
3583 
3584         (void) close(fd);
3585 }
3586 
3587 static void
3588 rxmGetNextResultsBlock(int fd)
3589 {
3590         size_t                  to_read = 8 * 1024;
3591         ssize_t                 bytes_read;
3592         ssize_t                 bytes_written;
3593         char                    results_buf[8 * 1024];
3594         sigset_t                newset;
3595         sigset_t                oldset;
3596 
3597         // Read some more from the output/results file.
3598         // Hopefully the kernel managed to prefetch the stuff.
3599         bytes_read = read(fd, results_buf, to_read);
3600         while (bytes_read > 0) {
3601                 AVO_BLOCK_INTERUPTS;
3602                 bytes_written = write(1, results_buf, bytes_read);
3603                 AVO_UNBLOCK_INTERUPTS;
3604                 if (bytes_written != bytes_read) {
3605                         // write() failed
3606                         warning(NOCATGETS("Internal error: write(1, ...) failed: %s\n"),
3607                                 strerror(errno));
3608                         exit(1);
3609                 }
3610                 bytes_read = read(fd, results_buf, to_read);
3611         }
3612 }
3613 
3614 // Generic, interruptable microsecond resolution sleep member function.
3615 
3616 static int
3617 us_sleep(unsigned int nusecs)
3618 {
3619         struct pollfd dummy;
3620         int timeout;
3621 
3622         if ((timeout = nusecs/1000) <= 0) {
3623                 timeout = 1;
3624         }
3625         return poll(&dummy, 0, timeout);
3626 }
3627 #endif /* TEAMWARE_MAKE_CMN */
3628 
3629 // Recursively delete each of the Chain struct on the chain.
3630 
3631 static void
3632 delete_query_chain(Chain ch)
3633 {
3634         if (ch == NULL) {
3635                 return;
3636         } else {
3637                 delete_query_chain(ch->next);
3638                 retmem_mb((char *) ch);
3639         }
3640 }
3641 
3642 Doname
3643 target_can_be_built(register Name target) {
3644         Doname          result = build_dont_know;
3645         Name            true_target = target;
3646         Property        line;
3647 
3648         if (target == wait_name) {
3649                 return(build_ok);
3650         }
3651         /*
3652          * If the target is a constructed one for a "::" target,
3653          * we need to consider that.
3654          */
3655         if (target->has_target_prop) {
3656                 true_target = get_prop(target->prop,
3657                                        target_prop)->body.target.target;
3658         }
3659 
3660         (void) exists(true_target);
3661 
3662         if (true_target->state == build_running) {
3663                 return(build_running);
3664         }
3665         if (true_target->stat.time != file_doesnt_exist) {
3666                 result = build_ok;
3667         }
3668 
3669         /* get line property for the target */
3670         line = get_prop(true_target->prop, line_prop);
3671 
3672         /* first check for explicit rule */
3673         if (line != NULL && line->body.line.command_template != NULL) {
3674                 result = build_ok;
3675         }
3676         /* try to find pattern rule */
3677         if (result == build_dont_know) {
3678                 result = find_percent_rule(target, NULL, false);
3679         }
3680         
3681         /* try to find double suffix rule */
3682         if (result == build_dont_know) {
3683                 if (target->is_member) {
3684                         Property member = get_prop(target->prop, member_prop);
3685                         if (member != NULL && member->body.member.member != NULL) {
3686                                 result = find_ar_suffix_rule(target, member->body.member.member, NULL, false);
3687                         } else {
3688                                 result = find_double_suffix_rule(target, NULL, false);
3689                         }
3690                 } else {
3691                         result = find_double_suffix_rule(target, NULL, false);
3692                 }
3693         }
3694         
3695         /* try to find suffix rule */
3696         if ((result == build_dont_know) && second_pass) {
3697                 result = find_suffix_rule(target, target, empty_name, NULL, false);
3698         }
3699         
3700         /* check for sccs */
3701         if (result == build_dont_know) {
3702                 result = sccs_get(target, NULL);
3703         }
3704         
3705         /* try to find dyn target */
3706         if (result == build_dont_know) {
3707                 Name dtarg = find_dyntarget(target);
3708                 if (dtarg != NULL) {
3709                         result = target_can_be_built(dtarg);
3710                 }
3711         }
3712         
3713         /* check whether target was mentioned in makefile */
3714         if (result == build_dont_know) {
3715                 if (target->colons != no_colon) {
3716                         result = build_ok;
3717                 }
3718         }
3719 
3720         /* result */
3721         return result;
3722 }