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 2005 Sun Microsystems, Inc. All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  *      read.c
  28  *
  29  *      This file contains the makefile reader.
  30  */
  31 
  32 /*
  33  * Included files
  34  */
  35 #include <mk/defs.h>
  36 #include <mksh/dosys.h>           /* sh_command2string() */
  37 #include <mksh/macro.h>           /* expand_value() */
  38 #include <mksh/misc.h>            /* retmem() */
  39 #include <stdarg.h>               /* va_list, va_start(), va_end() */
  40 #include <libintl.h>
  41 
  42 /*
  43  * Defined macros
  44  */
  45 
  46 /*
  47  * typedefs & structs
  48  */
  49 
  50 /*
  51  * Static variables
  52  */
  53 static  Boolean         built_last_make_run_seen;
  54 
  55 /*
  56  * File table of contents
  57  */
  58 static  Name_vector     enter_member_name(register wchar_t *lib_start, register wchar_t *member_start, register wchar_t *string_end, Name_vector current_names, Name_vector *extra_names);
  59 extern  Name            normalize_name(register wchar_t *name_string, register int length);
  60 static  void            read_suffixes_list(register Name_vector depes);
  61 static  void            make_relative(wchar_t *to, wchar_t *result);
  62 static  void            print_rule(register Cmd_line command);
  63 static  void            sh_transform(Name *name, Name *value);
  64 
  65 
  66 /*
  67  *      enter_name(string, tail_present, string_start, string_end,
  68  *            current_names, extra_names, target_group_seen)
  69  *
  70  *      Take one string and enter it as a name. The string is passed in
  71  *      two parts. A make string and possibly a C string to append to it.
  72  *      The result is stuffed in the vector current_names.
  73  *      extra_names points to a vector that is used if current_names overflows.
  74  *      This is allocad in the calling routine.
  75  *      Here we handle the "lib.a[members]" notation.
  76  *
  77  *      Return value:
  78  *                              The name vector that was used
  79  *
  80  *      Parameters:
  81  *              tail_present    Indicates if both C and make string was passed
  82  *              string_start    C string
  83  *              string_end      Pointer to char after last in C string
  84  *              string          make style string with head of name
  85  *              current_names   Vector to deposit the name in
  86  *              extra_names     Where to get next name vector if we run out
  87  *              target_group_seen Pointer to boolean that is set if "+" is seen
  88  *
  89  *      Global variables used:
  90  *              makefile_type   When we read a report file we normalize paths
  91  *              plus            Points to the Name "+"
  92  */
  93 
  94 Name_vector
  95 enter_name(String string, Boolean tail_present, register wchar_t *string_start, register wchar_t *string_end, Name_vector current_names, Name_vector *extra_names, Boolean *target_group_seen)
  96 {
  97         Name                    name;
  98         register wchar_t        *cp;
  99         wchar_t                 ch;
 100 
 101         /* If we were passed a separate tail of the name we append it to the */
 102         /* make string with the rest of it */
 103         if (tail_present) {
 104                 append_string(string_start, string, string_end - string_start);
 105                 string_start = string->buffer.start;
 106                 string_end = string->text.p;
 107         }
 108         ch = *string_end;
 109         *string_end = (int) nul_char;
 110         /*
 111          * Check if there are any ( or [ that are not prefixed with $.
 112          * If there are, we have to deal with the lib.a(members) format.
 113          */
 114         for (cp = (wchar_t *) wschr(string_start, (int) parenleft_char);
 115              cp != NULL;
 116              cp = (wchar_t *) wschr(cp + 1, (int) parenleft_char)) {
 117                 if (*(cp - 1) != (int) dollar_char) {
 118                         *string_end = ch;
 119                         return enter_member_name(string_start,
 120                                                  cp,
 121                                                  string_end,
 122                                                  current_names,
 123                                                  extra_names);
 124                 }
 125         }
 126         *string_end = ch;
 127 
 128         if (makefile_type == reading_cpp_file) {
 129                 /* Remove extra ../ constructs if we are reading from a report file */
 130                 name = normalize_name(string_start, string_end - string_start);
 131         } else {
 132                 /*
 133                  * /tolik, fix bug 1197477/
 134                  * Normalize every target name before entering.
 135                  * ..//obj/a.o and ../obj//a.o are not two different targets.
 136                  * There is only one target ../obj/a.o
 137                  */
 138                 /*name = GETNAME(string_start, string_end - string_start);*/
 139                 name = normalize_name(string_start, string_end - string_start);
 140         }
 141 
 142         /* Internalize the name. Detect the name "+" (target group here) */
 143 if(current_names->used != 0 && current_names->names[current_names->used-1] == plus) {
 144         if(name == plus) {
 145                 return current_names;
 146         }
 147 }
 148         /* If the current_names vector is full we patch in the one from */
 149         /* extra_names */
 150         if (current_names->used == VSIZEOF(current_names->names)) {
 151                 if (current_names->next != NULL) {
 152                         current_names = current_names->next;
 153                 } else {
 154                         current_names->next = *extra_names;
 155                         *extra_names = NULL;
 156                         current_names = current_names->next;
 157                         current_names->used = 0;
 158                         current_names->next = NULL;
 159                 }
 160         }
 161         current_names->target_group[current_names->used] = NULL;
 162         current_names->names[current_names->used++] = name;
 163         if (name == plus) {
 164                 *target_group_seen = true;
 165         }
 166         if (tail_present && string->free_after_use) {
 167                 retmem(string->buffer.start);
 168         }
 169         return current_names;
 170 }
 171 
 172 /*
 173  *      enter_member_name(lib_start, member_start, string_end,
 174  *                current_names, extra_names)
 175  *
 176  *      A string has been found to contain member names.
 177  *      (The "lib.a[members]" and "lib.a(members)" notation)
 178  *      Handle it pretty much as enter_name() does for simple names.
 179  *
 180  *      Return value:
 181  *                              The name vector that was used
 182  *
 183  *      Parameters:
 184  *              lib_start       Points to the of start of "lib.a(member.o)"
 185  *              member_start    Points to "member.o" from above string.
 186  *              string_end      Points to char after last of above string.
 187  *              current_names   Vector to deposit the name in
 188  *              extra_names     Where to get next name vector if we run out
 189  *
 190  *      Global variables used:
 191  */
 192 static Name_vector
 193 enter_member_name(register wchar_t *lib_start, register wchar_t *member_start, register wchar_t *string_end, Name_vector current_names, Name_vector *extra_names)
 194 {
 195         register Boolean        entry = false;
 196         wchar_t                 buffer[STRING_BUFFER_LENGTH];
 197         Name                    lib;
 198         Name                    member;
 199         Name                    name;
 200         Property                prop;
 201         wchar_t                 *memberp;
 202         wchar_t                 *q;
 203         register int            paren_count;
 204         register Boolean        has_dollar;
 205         register wchar_t        *cq;
 206         Name                    long_member_name = NULL;
 207 
 208         /* Internalize the name of the library */
 209         lib = GETNAME(lib_start, member_start - lib_start);
 210         lib->is_member = true;
 211         member_start++;
 212         if (*member_start == (int) parenleft_char) {
 213                 /* This is really the "lib.a((entries))" format */
 214                 entry = true;
 215                 member_start++;
 216         }
 217         /* Move the library name to the buffer where we intend to build the */
 218         /* "lib.a(member)" for each member */
 219         (void) wsncpy(buffer, lib_start, member_start - lib_start);
 220         memberp = buffer + (member_start-lib_start);
 221         while (1) {
 222                 long_member_name = NULL;
 223                 /* Skip leading spaces */
 224                 for (;
 225                      (member_start < string_end) && iswspace(*member_start);
 226                      member_start++);
 227                 /* Find the end of the member name. Allow nested (). Detect $*/
 228                 for (cq = memberp, has_dollar = false, paren_count = 0;
 229                      (member_start < string_end) &&
 230                      ((*member_start != (int) parenright_char) ||
 231                       (paren_count > 0)) &&
 232                      !iswspace(*member_start);
 233                      *cq++ = *member_start++) {
 234                         switch (*member_start) {
 235                         case parenleft_char:
 236                                 paren_count++;
 237                                 break;
 238                         case parenright_char:
 239                                 paren_count--;
 240                                 break;
 241                         case dollar_char:
 242                                 has_dollar = true;
 243                         }
 244                 }
 245                 /* Internalize the member name */
 246                 member = GETNAME(memberp, cq - memberp);
 247                 *cq = 0;
 248                 if ((q = (wchar_t *) wsrchr(memberp, (int) slash_char)) == NULL) {
 249                         q = memberp;
 250                 }
 251                 if ((cq - q > (int) ar_member_name_len) &&
 252                     !has_dollar) {
 253                         *cq++ = (int) parenright_char;
 254                         if (entry) {
 255                                 *cq++ = (int) parenright_char;
 256                         }
 257                         long_member_name = GETNAME(buffer, cq - buffer);
 258                         cq = q + (int) ar_member_name_len;
 259                 }
 260                 *cq++ = (int) parenright_char;
 261                 if (entry) {
 262                         *cq++ = (int) parenright_char;
 263                 }
 264                 /* Internalize the "lib.a(member)" notation for this member */
 265                 name = GETNAME(buffer, cq - buffer);
 266                 name->is_member = lib->is_member;
 267                 if (long_member_name != NULL) {
 268                         prop = append_prop(name, long_member_name_prop);
 269                         name->has_long_member_name = true;
 270                         prop->body.long_member_name.member_name =
 271                           long_member_name;
 272                 }
 273                 /* And add the member prop */
 274                 prop = append_prop(name, member_prop);
 275                 prop->body.member.library = lib;
 276                 if (entry) {
 277                         /* "lib.a((entry))" notation */
 278                         prop->body.member.entry = member;
 279                         prop->body.member.member = NULL;
 280                 } else {
 281                         /* "lib.a(member)" Notation */
 282                         prop->body.member.entry = NULL;
 283                         prop->body.member.member = member;
 284                 }
 285                 /* Handle overflow of current_names */
 286                 if (current_names->used == VSIZEOF(current_names->names)) {
 287                         if (current_names->next != NULL) {
 288                                 current_names = current_names->next;
 289                         } else {
 290                                 if (*extra_names == NULL) {
 291                                         current_names =
 292                                           current_names->next =
 293                                             ALLOC(Name_vector);
 294                                 } else {
 295                                         current_names =
 296                                           current_names->next =
 297                                             *extra_names;
 298                                         *extra_names = NULL;
 299                                 }
 300                                 current_names->used = 0;
 301                                 current_names->next = NULL;
 302                         }
 303                 }
 304                 current_names->target_group[current_names->used] = NULL;
 305                 current_names->names[current_names->used++] = name;
 306                 while (iswspace(*member_start)) {
 307                         member_start++;
 308                 }
 309                 /* Check if there are more members */
 310                 if ((*member_start == (int) parenright_char) ||
 311                     (member_start >= string_end)) {
 312                         return current_names;
 313                 }
 314         }
 315         /* NOTREACHED */
 316 }
 317 
 318 /*
 319  *      normalize_name(name_string, length)
 320  *
 321  *      Take a namestring and remove redundant ../, // and ./ constructs
 322  *
 323  *      Return value:
 324  *                              The normalized name
 325  *
 326  *      Parameters:
 327  *              name_string     Path string to normalize
 328  *              length          Length of that string
 329  *
 330  *      Global variables used:
 331  *              dot             The Name ".", compared against
 332  *              dotdot          The Name "..", compared against
 333  */
 334 Name
 335 normalize_name(register wchar_t *name_string, register int length)
 336 {
 337         static Name             dotdot;
 338         register wchar_t        *string = ALLOC_WC(length + 1);
 339         register wchar_t        *string2;
 340         register wchar_t        *cdp;
 341         wchar_t                 *current_component;
 342         Name                    name;
 343         register int            count;
 344 
 345         if (dotdot == NULL) {
 346                 MBSTOWCS(wcs_buffer, "..");
 347                 dotdot = GETNAME(wcs_buffer, FIND_LENGTH);
 348         }
 349 
 350         /*
 351          * Copy string removing ./ and //.
 352          * First strip leading ./
 353          */
 354         while ((length > 1) &&
 355                (name_string[0] == (int) period_char) &&
 356                (name_string[1] == (int) slash_char)) {
 357                 name_string += 2;
 358                 length -= 2;
 359                 while ((length > 0) && (name_string[0] == (int) slash_char)) {
 360                         name_string++;
 361                         length--;
 362                 }
 363         }
 364         /* Then copy the rest of the string removing /./ & // */
 365         cdp = string;
 366         while (length > 0) {
 367                 if (((length > 2) &&
 368                      (name_string[0] == (int) slash_char) &&
 369                      (name_string[1] == (int) period_char) &&
 370                      (name_string[2] == (int) slash_char)) ||
 371                     ((length == 2) &&
 372                      (name_string[0] == (int) slash_char) &&
 373                      (name_string[1] == (int) period_char))) {
 374                         name_string += 2;
 375                         length -= 2;
 376                         continue;
 377                 }
 378                 if ((length > 1) &&
 379                     (name_string[0] == (int) slash_char) &&
 380                     (name_string[1] == (int) slash_char)) {
 381                         name_string++;
 382                         length--;
 383                         continue;
 384                 }
 385                 *cdp++ = *name_string++;
 386                 length--;
 387         }
 388         *cdp = (int) nul_char;
 389         /*
 390          * Now scan for <name>/../ and remove such combinations iff <name>
 391          * is not another ..
 392          * Each time something is removed, the whole process is restarted.
 393          */
 394 removed_one:
 395         name_string = string;
 396         string2 = name_string;          /*save for free*/
 397         current_component =
 398           cdp =
 399             string =
 400               ALLOC_WC((length = wslen(name_string)) + 1);
 401         while (length > 0) {
 402                 if (((length > 3) &&
 403                      (name_string[0] == (int) slash_char) &&
 404                      (name_string[1] == (int) period_char) &&
 405                      (name_string[2] == (int) period_char) &&
 406                      (name_string[3] == (int) slash_char)) ||
 407                     ((length == 3) &&
 408                      (name_string[0] == (int) slash_char) &&
 409                      (name_string[1] == (int) period_char) &&
 410                      (name_string[2] == (int) period_char))) {
 411                         /* Positioned on the / that starts a /.. sequence */
 412                         if (((count = cdp - current_component) != 0) &&
 413                             (exists(name = GETNAME(string, cdp - string)) > file_doesnt_exist) &&
 414                             (!name->stat.is_sym_link)) {
 415                                 name = GETNAME(current_component, count);
 416                                 if(name != dotdot) {
 417                                         cdp = current_component;
 418                                         name_string += 3;
 419                                         length -= 3;
 420                                         if (length > 0) {
 421                                                 name_string++;  /* skip slash */
 422                                                 length--;
 423                                                 while (length > 0) {
 424                                                         *cdp++ = *name_string++;
 425                                                         length--;
 426                                                 }
 427                                         }
 428                                         *cdp = (int) nul_char;
 429                                         retmem(string2);
 430                                         goto removed_one;
 431                                 }
 432                         }
 433                 }
 434                 if ((*cdp++ = *name_string++) == (int) slash_char) {
 435                         current_component = cdp;
 436                 }
 437                 length--;
 438         }
 439         *cdp = (int) nul_char;
 440         if (string[0] == (int) nul_char) {
 441                 name = dot;
 442         } else {
 443                 name = GETNAME(string, FIND_LENGTH);
 444         }
 445         retmem(string);
 446         retmem(string2);
 447         return name;
 448 }
 449 
 450 /*
 451  *      find_target_groups(target_list)
 452  *
 453  *      If a "+" was seen when the target list was scanned we need to extract
 454  *      the groups. Each target in the name vector that is a member of a
 455  *      group gets a pointer to a chain of all the members stuffed in its
 456  *      target_group vector slot
 457  *
 458  *      Parameters:
 459  *              target_list     The list of targets that contains "+"
 460  *
 461  *      Global variables used:
 462  *              plus            The Name "+", compared against
 463  */
 464 Chain
 465 find_target_groups(register Name_vector target_list, register int i, Boolean reset)
 466 {
 467         static Chain            target_group = NULL;
 468         static Chain            tail_target_group = NULL;
 469         static Name             *next;
 470         static Boolean  clear_target_group = false;
 471 
 472         if (reset) {
 473                 target_group = NULL;
 474                 tail_target_group = NULL;
 475                 clear_target_group = false;
 476         }
 477 
 478         /* Scan the list of targets */
 479         /* If the previous target terminated a group */
 480         /* we flush the pointer to that member chain */
 481         if (clear_target_group) {
 482                 clear_target_group = false;
 483                 target_group = NULL;
 484         }
 485         /* Pick up a pointer to the cell with */
 486         /* the next target */
 487         if (i + 1 != target_list->used) {
 488                 next = &target_list->names[i + 1];
 489         } else {
 490                 next = (target_list->next != NULL) ?
 491                   &target_list->next->names[0] : NULL;
 492         }
 493         /* We have four states here :
 494          *      0:      No target group started and next element is not "+" 
 495          *              This is not interesting.
 496          *      1:      A target group is being built and the next element 
 497          *              is not "+". This terminates the group.
 498          *      2:      No target group started and the next member is "+" 
 499          *              This is the first target in a group.
 500          *      3:      A target group started and the next member is a "+" 
 501          *              The group continues.
 502          */
 503         switch ((target_group ? 1 : 0) +
 504                 (next && (*next == plus) ?
 505                  2 : 0)) {
 506               case 0:   /* Not target_group */
 507                 break;
 508               case 1:   /* Last group member */
 509                 /* We need to keep this pointer so */
 510                 /* we can stuff it for last member */
 511                 clear_target_group = true;
 512                 /* fall into */
 513               case 3:   /* Middle group member */
 514                 /* Add this target to the */
 515                 /* current chain */
 516                 tail_target_group->next = ALLOC(Chain);
 517                 tail_target_group = tail_target_group->next;
 518                 tail_target_group->next = NULL;
 519                 tail_target_group->name = target_list->names[i];
 520                 break;
 521               case 2:   /* First group member */
 522                 /* Start a new chain */
 523                 target_group = tail_target_group = ALLOC(Chain);
 524                 target_group->next = NULL;
 525                 target_group->name = target_list->names[i];
 526                 break;
 527         }
 528         /* Stuff the current chain, if any, in the */
 529         /* targets group slot */
 530         target_list->target_group[i] = target_group;
 531         if ((next != NULL) &&
 532             (*next == plus)) {
 533                 *next = NULL;
 534         }
 535         return (tail_target_group);
 536 }
 537 
 538 /*
 539  *      enter_dependencies(target, target_group, depes, command, separator)
 540  *
 541  *      Take one target and a list of dependencies and process the whole thing.
 542  *      The target might be special in some sense in which case that is handled
 543  *
 544  *      Parameters:
 545  *              target          The target we want to enter
 546  *              target_group    Non-NULL if target is part of a group this time
 547  *              depes           A list of dependencies for the target
 548  *              command         The command the target should be entered with
 549  *              separator       Indicates if this is a ":" or a "::" rule
 550  *
 551  *      Static variables used:
 552  *              built_last_make_run_seen If the previous target was
 553  *                                      .BUILT_LAST_MAKE_RUN we say to rewrite
 554  *                                      the state file later on
 555  *
 556  *      Global variables used:
 557  *              command_changed Set to indicate if .make.state needs rewriting
 558  *              default_target_to_build Set to the target if reading makefile
 559  *                                      and this is the first regular target
 560  *              force           The Name " FORCE", used with "::" targets
 561  *              makefile_type   We do different things for makefile vs. report
 562  *              not_auto        The Name ".NOT_AUTO", compared against
 563  *              recursive_name  The Name ".RECURSIVE", compared against
 564  *              temp_file_number Used to figure out when to clear stale
 565  *                                      automatic dependencies
 566  *              trace_reader    Indicates that we should echo stuff we read
 567  */
 568 void
 569 enter_dependencies(register Name target, Chain target_group, register Name_vector depes, register Cmd_line command, register Separator separator)
 570 {
 571         register int            i;
 572         register Property       line;
 573         Name                    name;
 574         Name                    directory;
 575         wchar_t                 *namep;
 576         char                    *mb_namep;
 577         Dependency              dp;
 578         Dependency              *dpp;
 579         Property                line2;
 580         wchar_t                 relative[MAXPATHLEN];
 581         register int            recursive_state;
 582         Boolean                 register_as_auto;
 583         Boolean                 not_auto_found;
 584         char                    *slash;
 585         Wstring                 depstr;
 586 
 587         /* Check if this is a .RECURSIVE line */
 588         if ((depes->used >= 3) &&
 589             (depes->names[0] == recursive_name)) {
 590                 target->has_recursive_dependency = true;
 591                 depes->names[0] = NULL;
 592                 recursive_state = 0;
 593                 dp = NULL;
 594                 dpp = &dp;
 595                 /* Read the dependencies. They are "<directory> <target-made>*/
 596                 /* <makefile>*" */
 597                 for (; depes != NULL; depes = depes->next) {
 598                         for (i = 0; i < depes->used; i++) {
 599                                 if (depes->names[i] != NULL) {
 600                                         switch (recursive_state++) {
 601                                         case 0: /* Directory */
 602                                         {
 603                                                 depstr.init(depes->names[i]);
 604                                                 make_relative(depstr.get_string(),
 605                                                               relative);
 606                                                 directory =
 607                                                   GETNAME(relative,
 608                                                           FIND_LENGTH);
 609                                         }
 610                                                 break;
 611                                         case 1: /* Target */
 612                                                 name = depes->names[i];
 613                                                 break;
 614                                         default:        /* Makefiles */
 615                                                 *dpp = ALLOC(Dependency);
 616                                                 (*dpp)->next = NULL;
 617                                                 (*dpp)->name = depes->names[i];
 618                                                 (*dpp)->automatic = false;
 619                                                 (*dpp)->stale = false;
 620                                                 (*dpp)->built = false;
 621                                                 dpp = &((*dpp)->next);
 622                                                 break;
 623                                         }
 624                                 }
 625                         }
 626                 }
 627                 /* Check if this recursion already has been reported else */
 628                 /* enter the recursive prop for the target */
 629                 /* The has_built flag is used to tell if this .RECURSIVE */
 630                 /* was discovered from this run (read from a tmp file) */
 631                 /* or was from discovered from the original .make.state */
 632                 /* file */
 633                 for (line = get_prop(target->prop, recursive_prop);
 634                      line != NULL;
 635                      line = get_prop(line->next, recursive_prop)) {
 636                         if ((line->body.recursive.directory == directory) &&
 637                             (line->body.recursive.target == name)) {
 638                                 line->body.recursive.makefiles = dp;
 639                                 line->body.recursive.has_built = 
 640                                   (Boolean)
 641                                     (makefile_type == reading_cpp_file);
 642                                 return;
 643                         }
 644                 }
 645                 line2 = append_prop(target, recursive_prop);
 646                 line2->body.recursive.directory = directory;
 647                 line2->body.recursive.target = name;
 648                 line2->body.recursive.makefiles = dp;
 649                 line2->body.recursive.has_built = 
 650                     (Boolean) (makefile_type == reading_cpp_file);
 651                 line2->body.recursive.in_depinfo = false;
 652                 return;
 653         }
 654         /* If this is the first target that doesnt start with a "." in the */
 655         /* makefile we remember that */
 656         Wstring tstr(target);
 657         wchar_t * wcb = tstr.get_string();
 658         if ((makefile_type == reading_makefile) &&
 659             (default_target_to_build == NULL) &&
 660             ((wcb[0] != (int) period_char) ||
 661              wschr(wcb, (int) slash_char))) {
 662 
 663 /* BID 1181577: $(EMPTY_MACRO) + $(EMPTY_MACRO):
 664 ** The target with empty name cannot be default_target_to_build
 665 */
 666                 if (target->hash.length != 0)
 667                         default_target_to_build = target;
 668         }
 669         /* Check if the line is ":" or "::" */
 670         if (makefile_type == reading_makefile) {
 671                 if (target->colons == no_colon) {
 672                         target->colons = separator;
 673                 } else {
 674                         if (target->colons != separator) {
 675                                 fatal_reader(gettext(":/:: conflict for target `%s'"),
 676                                              target->string_mb);
 677                         }
 678                 }
 679                 if (target->colons == two_colon) {
 680                         if (depes->used == 0) {
 681                                 /* If this is a "::" type line with no */
 682                                 /* dependencies we add one "FRC" type */
 683                                 /* dependency for free */
 684                                 depes->used = 1; /* Force :: targets with no
 685                                                   * depes to always run */
 686                                 depes->names[0] = force;
 687                         }
 688                         /* Do not delete "::" type targets when interrupted */
 689                         target->stat.is_precious = true;
 690                         /*
 691                          * Build a synthetic target "<number>%target"
 692                          * for "target".
 693                          */
 694                         mb_namep = getmem((int) (strlen(target->string_mb) + 10));
 695                         namep = ALLOC_WC((int) (target->hash.length + 10));
 696                         slash = strrchr(target->string_mb, (int) slash_char);
 697                         if (slash == NULL) {
 698                                 (void) sprintf(mb_namep,
 699                                                 "%d@%s",
 700                                                 target->colon_splits++,
 701                                                 target->string_mb);
 702                         } else {
 703                                 *slash = 0;
 704                                 (void) sprintf(mb_namep,
 705                                                 "%s/%d@%s",
 706                                                 target->string_mb,
 707                                                 target->colon_splits++,
 708                                                 slash + 1);
 709                                 *slash = (int) slash_char;
 710                         }
 711                         MBSTOWCS(namep, mb_namep);
 712                         retmem_mb(mb_namep);
 713                         name = GETNAME(namep, FIND_LENGTH);
 714                         retmem(namep);
 715                         if (trace_reader) {
 716                                 (void) printf("%s:\t", target->string_mb);
 717                         }
 718                         /* Make "target" depend on "<number>%target */
 719                         line2 = maybe_append_prop(target, line_prop);
 720                         enter_dependency(line2, name, true);
 721                         line2->body.line.target = target;
 722                         /* Put a prop on "<number>%target that makes */
 723                         /* appear as "target" */
 724                         /* when it is processed */
 725                         maybe_append_prop(name, target_prop)->
 726                           body.target.target = target;
 727                         target->is_double_colon_parent = true;
 728                         name->is_double_colon = true;
 729                         name->has_target_prop = true;
 730                         if (trace_reader) {
 731                                 (void) printf("\n");
 732                         }
 733                         (target = name)->stat.is_file = true;
 734                 }
 735         }
 736         /* This really is a regular dependency line. Just enter it */
 737         line = maybe_append_prop(target, line_prop);
 738         line->body.line.target = target;
 739         /* Depending on what kind of makefile we are reading we have to */
 740         /* treat things differently */
 741         switch (makefile_type) {
 742         case reading_makefile:
 743                 /* Reading regular makefile. Just notice whether this */
 744                 /* redefines the rule for the  target */
 745                 if (command != NULL) {
 746                         if (line->body.line.command_template != NULL) {
 747                                 line->body.line.command_template_redefined =
 748                                   true;
 749                                 if ((wcb[0] == (int) period_char) &&
 750                                     !wschr(wcb, (int) slash_char)) {
 751                                         line->body.line.command_template =
 752                                           command;
 753                                 }
 754                         } else {
 755                                 line->body.line.command_template = command;
 756                         }
 757                 } else {
 758                         if ((wcb[0] == (int) period_char) &&
 759                             !wschr(wcb, (int) slash_char)) {
 760                                 line->body.line.command_template = command;
 761                         }
 762                 }
 763                 break;
 764         case rereading_statefile:
 765                 /* Rereading the statefile. We only enter thing that changed */
 766                 /* since the previous time we read it */
 767                 if (!built_last_make_run_seen) {
 768                         for (Cmd_line next, cmd = command; cmd != NULL; cmd = next) {
 769                                 next = cmd->next;
 770                                 free(cmd);
 771                         }
 772                         return;
 773                 }
 774                 built_last_make_run_seen = false;
 775                 command_changed = true;
 776                 target->ran_command = true;
 777         case reading_statefile:
 778                 /* Reading the statefile for the first time. Enter the rules */
 779                 /* as "Commands used" not "templates to use" */
 780                 if (command != NULL) {
 781                         for (Cmd_line next, cmd = line->body.line.command_used;
 782                              cmd != NULL; cmd = next) {
 783                                 next = cmd->next;
 784                                 free(cmd);
 785                         }
 786                         line->body.line.command_used = command;
 787                 }
 788         case reading_cpp_file:
 789                 /* Reading report file from programs that reports */
 790                 /* dependencies. If this is the first time the target is */
 791                 /* read from this reportfile we clear all old */
 792                 /* automatic depes */
 793                 if (target->temp_file_number == temp_file_number) {
 794                         break;
 795                 }
 796                 target->temp_file_number = temp_file_number;
 797                 command_changed = true;
 798                 if (line != NULL) {
 799                         for (dp = line->body.line.dependencies;
 800                              dp != NULL;
 801                              dp = dp->next) {
 802                                 if (dp->automatic) {
 803                                         dp->stale = true;
 804                                 }
 805                         }
 806                 }
 807                 break;
 808         default:
 809                 fatal_reader(gettext("Internal error. Unknown makefile type %d"),
 810                              makefile_type);
 811         }
 812         /* A target may only be involved in one target group */
 813         if (line->body.line.target_group != NULL) {
 814                 if (target_group != NULL) {
 815                         fatal_reader(gettext("Too many target groups for target `%s'"),
 816                                      target->string_mb);
 817                 }
 818         } else {
 819                 line->body.line.target_group = target_group;
 820         }
 821 
 822         if (trace_reader) {
 823                 (void) printf("%s:\t", target->string_mb);
 824         }
 825         /* Enter the dependencies */
 826         register_as_auto = BOOLEAN(makefile_type != reading_makefile);
 827         not_auto_found = false;
 828         for (;
 829              (depes != NULL) && !not_auto_found;
 830              depes = depes->next) {
 831                 for (i = 0; i < depes->used; i++) {
 832                         /* the dependency .NOT_AUTO signals beginning of
 833                          * explicit dependancies which were put at end of
 834                          * list in .make.state file - we stop entering
 835                          * dependencies at this point
 836                          */
 837                         if (depes->names[i] == not_auto) {
 838                                 not_auto_found = true;
 839                                 break;
 840                         }
 841                         enter_dependency(line,
 842                                          depes->names[i],
 843                                          register_as_auto);
 844                 }
 845         }
 846         if (trace_reader) {
 847                 (void) printf("\n");
 848                 print_rule(command);
 849         }
 850 }
 851 
 852 /*
 853  *      enter_dependency(line, depe, automatic)
 854  *
 855  *      Enter one dependency. Do not enter duplicates.
 856  *
 857  *      Parameters:
 858  *              line            The line block that the dependeny is
 859  *                              entered for
 860  *              depe            The dependency to enter
 861  *              automatic       Used to set the field "automatic"
 862  *
 863  *      Global variables used:
 864  *              makefile_type   We do different things for makefile vs. report
 865  *              trace_reader    Indicates that we should echo stuff we read
 866  *              wait_name       The Name ".WAIT", compared against
 867  */
 868 void
 869 enter_dependency(Property line, register Name depe, Boolean automatic)
 870 {
 871         register Dependency     dp;
 872         register Dependency     *insert;
 873 
 874         if (trace_reader) {
 875                 (void) printf("%s ", depe->string_mb);
 876         }
 877         /* Find the end of the list and check for duplicates */
 878         for (insert = &line->body.line.dependencies, dp = *insert;
 879              dp != NULL;
 880              insert = &dp->next, dp = *insert) {
 881                 if ((dp->name == depe) && (depe != wait_name)) {
 882                         if (dp->automatic) {
 883                                 dp->automatic = automatic;
 884                                 if (automatic) {
 885                                         dp->built = false;
 886                                         depe->stat.is_file = true;
 887                                 }
 888                         }
 889                         dp->stale = false;
 890                         return;
 891                 }
 892         }
 893         /* Insert the new dependency since we couldnt find it */
 894         dp = *insert = ALLOC(Dependency);
 895         dp->name = depe;
 896         dp->next = NULL;
 897         dp->automatic = automatic;
 898         dp->stale = false;
 899         dp->built = false;
 900         depe->stat.is_file = true;
 901 
 902         if ((makefile_type == reading_makefile) &&
 903             (line != NULL) &&
 904             (line->body.line.target != NULL)) {
 905                 line->body.line.target->has_regular_dependency = true;
 906         }
 907 }
 908 
 909 /*
 910  *      enter_percent(target, depes, command)
 911  *
 912  *      Enter "x%y : a%b" type lines
 913  *      % patterns are stored in four parts head and tail for target and source
 914  *
 915  *      Parameters:
 916  *              target          Left hand side of pattern
 917  *              depes           The dependency list with the rh pattern
 918  *              command         The command for the pattern
 919  *
 920  *      Global variables used:
 921  *              empty_name      The Name "", compared against
 922  *              percent_list    The list of all percent rules, added to
 923  *              trace_reader    Indicates that we should echo stuff we read
 924  */
 925 Percent
 926 enter_percent(register Name target, Chain target_group, register Name_vector depes, Cmd_line command)
 927 {
 928         register Percent        result = ALLOC(Percent);
 929         register Percent        depe;
 930         register Percent        *depe_tail = &result->dependencies;
 931         register Percent        *insert;
 932         register wchar_t        *cp, *cp1;
 933         Name_vector             nvp;
 934         int                     i;
 935         int                     pattern;
 936 
 937         result->next = NULL;
 938         result->patterns = NULL;
 939         result->patterns_total = 0;
 940         result->command_template = command;
 941         result->being_expanded = false;
 942         result->name = target;
 943         result->dependencies = NULL;
 944         result->target_group = target_group;
 945 
 946         /* get patterns count */
 947         Wstring wcb(target);
 948         cp = wcb.get_string();
 949         while (true) {
 950                 cp = (wchar_t *) wschr(cp, (int) percent_char);
 951                 if (cp != NULL) {
 952                         result->patterns_total++;
 953                         cp++;
 954                 } else {
 955                         break;
 956                 }
 957         }
 958         result->patterns_total++;
 959 
 960         /* allocate storage for patterns */
 961         result->patterns = (Name *) getmem(sizeof(Name) * result->patterns_total);
 962 
 963         /* then create patterns */
 964         cp = wcb.get_string();
 965         pattern = 0;
 966         while (true) {
 967                 cp1 = (wchar_t *) wschr(cp, (int) percent_char);
 968                 if (cp1 != NULL) {
 969                         result->patterns[pattern] = GETNAME(cp, cp1 - cp);
 970                         cp = cp1 + 1;
 971                         pattern++;
 972                 } else {
 973                         result->patterns[pattern] = GETNAME(cp, (int) target->hash.length - (cp - wcb.get_string()));
 974                         break;
 975                 }
 976         }
 977 
 978         Wstring wcb1;
 979 
 980         /* build dependencies list */
 981         for (nvp = depes; nvp != NULL; nvp = nvp->next) {
 982                 for (i = 0; i < nvp->used; i++) {
 983                         depe = ALLOC(Percent);
 984                         depe->next = NULL;
 985                         depe->patterns = NULL;
 986                         depe->patterns_total = 0;
 987                         depe->name = nvp->names[i];
 988                         depe->dependencies = NULL;
 989                         depe->command_template = NULL;
 990                         depe->being_expanded = false;
 991                         depe->target_group = NULL;
 992 
 993                         *depe_tail = depe;
 994                         depe_tail = &depe->next;
 995 
 996                         if (depe->name->percent) {
 997                                 /* get patterns count */
 998                                 wcb1.init(depe->name);
 999                                 cp = wcb1.get_string();
1000                                 while (true) {
1001                                         cp = (wchar_t *) wschr(cp, (int) percent_char);
1002                                         if (cp != NULL) {
1003                                                 depe->patterns_total++;
1004                                                 cp++;
1005                                         } else {
1006                                                 break;
1007                                         }
1008                                 }
1009                                 depe->patterns_total++;
1010 
1011                                 /* allocate storage for patterns */
1012                                 depe->patterns = (Name *) getmem(sizeof(Name) * depe->patterns_total);
1013 
1014                                 /* then create patterns */
1015                                 cp = wcb1.get_string();
1016                                 pattern = 0;
1017                                 while (true) {
1018                                         cp1 = (wchar_t *) wschr(cp, (int) percent_char);
1019                                         if (cp1 != NULL) {
1020                                                 depe->patterns[pattern] = GETNAME(cp, cp1 - cp);
1021                                                 cp = cp1 + 1;
1022                                                 pattern++;
1023                                         } else {
1024                                                 depe->patterns[pattern] = GETNAME(cp, (int) depe->name->hash.length - (cp - wcb1.get_string()));
1025                                                 break;
1026                                         }
1027                                 }
1028                         }
1029                 }
1030         }
1031 
1032         /* Find the end of the percent list and append the new pattern */
1033         for (insert = &percent_list; (*insert) != NULL; insert = &(*insert)->next);
1034         *insert = result;
1035 
1036         if (trace_reader) {
1037                 (void) printf("%s:", result->name->string_mb);
1038 
1039                 for (depe = result->dependencies; depe != NULL; depe = depe->next) {
1040                         (void) printf(" %s", depe->name->string_mb);
1041                 }
1042 
1043                 (void) printf("\n");
1044 
1045                 print_rule(command);
1046         }
1047 
1048         return result;
1049 }
1050 
1051 /*
1052  *      enter_dyntarget(target)
1053  *
1054  *      Enter "$$(MACRO) : b" type lines
1055  *
1056  *      Parameters:
1057  *              target          Left hand side of pattern
1058  *
1059  *      Global variables used:
1060  *              dyntarget_list  The list of all percent rules, added to
1061  *              trace_reader    Indicates that we should echo stuff we read
1062  */
1063 Dyntarget
1064 enter_dyntarget(register Name target)
1065 {
1066         register Dyntarget      result = ALLOC(Dyntarget);
1067         Dyntarget               p;
1068         Dyntarget               *insert;
1069         int                             i;
1070 
1071         result->next = NULL;
1072         result->name = target;
1073 
1074 
1075         /* Find the end of the dyntarget list and append the new pattern */
1076         for (insert = &dyntarget_list, p = *insert;
1077              p != NULL;
1078              insert = &p->next, p = *insert);
1079         *insert = result;
1080 
1081         if (trace_reader) {
1082                 (void) printf("Dynamic target %s:\n", result->name->string_mb);
1083         }
1084         return( result);
1085 }
1086 
1087 
1088 /*
1089  *      special_reader(target, depes, command)
1090  *
1091  *      Read the pseudo targets make knows about
1092  *      This handles the special targets that should not be entered as regular
1093  *      target/dependency sets.
1094  *
1095  *      Parameters:
1096  *              target          The special target
1097  *              depes           The list of dependencies it was entered with
1098  *              command         The command it was entered with
1099  *
1100  *      Static variables used:
1101  *              built_last_make_run_seen Set to indicate .BUILT_LAST... seen
1102  *
1103  *      Global variables used:
1104  *              all_parallel    Set to indicate that everything runs parallel
1105  *              svr4            Set when ".SVR4" target is read
1106  *              svr4_name       The Name ".SVR4"
1107  *              posix           Set when ".POSIX" target is read
1108  *              posix_name      The Name ".POSIX"
1109  *              current_make_version The Name "<current version number>"
1110  *              default_rule    Set when ".DEFAULT" target is read
1111  *              default_rule_name The Name ".DEFAULT", used for tracing
1112  *              dot_keep_state  The Name ".KEEP_STATE", used for tracing
1113  *              ignore_errors   Set if ".IGNORE" target is read
1114  *              ignore_name     The Name ".IGNORE", used for tracing
1115  *              keep_state      Set if ".KEEP_STATE" target is read
1116  *              no_parallel_name The Name ".NO_PARALLEL", used for tracing
1117  *              only_parallel   Set to indicate only some targets runs parallel
1118  *              parallel_name   The Name ".PARALLEL", used for tracing
1119  *              precious        The Name ".PRECIOUS", used for tracing
1120  *              sccs_get_name   The Name ".SCCS_GET", used for tracing
1121  *              sccs_get_posix_name The Name ".SCCS_GET_POSIX", used for tracing
1122  *              get_name        The Name ".GET", used for tracing
1123  *              sccs_get_rule   Set when ".SCCS_GET" target is read
1124  *              silent          Set when ".SILENT" target is read
1125  *              silent_name     The Name ".SILENT", used for tracing
1126  *              trace_reader    Indicates that we should echo stuff we read
1127  */
1128 void
1129 special_reader(Name target, register Name_vector depes, Cmd_line command)
1130 {
1131         register int            n;
1132 
1133         switch (target->special_reader) {
1134 
1135         case svr4_special:
1136                 if (depes->used != 0) {
1137                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1138                                      target->string_mb);
1139                 }
1140                 svr4  = true;
1141                 posix  = false;
1142                 keep_state = false;
1143                 all_parallel = false;
1144                 only_parallel = false;
1145                 if (trace_reader) {
1146                         (void) printf("%s:\n", svr4_name->string_mb);
1147                 }
1148                 break;
1149 
1150         case posix_special:
1151                 if(svr4)
1152                   break;
1153                 if (depes->used != 0) {
1154                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1155                                      target->string_mb);
1156                 }
1157                 posix  = true;
1158                         /* with posix on, use the posix get rule */
1159                 sccs_get_rule = sccs_get_posix_rule;
1160                         /* turn keep state off being SunPro make specific */
1161                 keep_state = false;
1162                 /* Use /usr/xpg4/bin/sh on Solaris */
1163                 MBSTOWCS(wcs_buffer, "/usr/xpg4/bin/sh");
1164                 (void) SETVAR(shell_name, GETNAME(wcs_buffer, FIND_LENGTH), false);
1165                 if (trace_reader) {
1166                         (void) printf("%s:\n", posix_name->string_mb);
1167                 }
1168                 break;
1169 
1170         case built_last_make_run_special:
1171                 built_last_make_run_seen = true;
1172                 break;
1173 
1174         case default_special:
1175                 if (depes->used != 0) {
1176                         warning(gettext("Illegal dependency list for target `%s'"),
1177                                 target->string_mb);
1178                 }
1179                 default_rule = command;
1180                 if (trace_reader) {
1181                         (void) printf("%s:\n",
1182                                       default_rule_name->string_mb);
1183                         print_rule(command);
1184                 }
1185                 break;
1186 
1187 
1188         case ignore_special:
1189                 if ((depes->used != 0) &&(!posix)){
1190                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1191                                      target->string_mb);
1192                 }
1193                 if (depes->used == 0)
1194                 {
1195                    ignore_errors_all = true;
1196                 }
1197                 if(svr4) {
1198                   ignore_errors_all = true;
1199                   break;
1200                 }
1201                 for (; depes != NULL; depes = depes->next) {
1202                         for (n = 0; n < depes->used; n++) {
1203                                 depes->names[n]->ignore_error_mode = true;
1204                         }
1205                 }
1206                 if (trace_reader) {
1207                         (void) printf("%s:\n", ignore_name->string_mb);
1208                 }
1209                 break;
1210 
1211         case keep_state_special:
1212                 if(svr4)
1213                   break;
1214                         /* ignore keep state, being SunPro make specific */
1215                 if(posix)
1216                   break;
1217                 if (depes->used != 0) {
1218                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1219                                      target->string_mb);
1220                 }
1221                 keep_state = true;
1222                 if (trace_reader) {
1223                         (void) printf("%s:\n",
1224                                       dot_keep_state->string_mb);
1225                 }
1226                 break;
1227 
1228         case keep_state_file_special:
1229                 if(svr4)
1230                   break;
1231                 if(posix)
1232                   break;
1233                         /* it's not necessary to specify KEEP_STATE, if this 
1234                         ** is given, so set the keep_state.
1235                         */
1236                 keep_state = true;
1237                 if (depes->used != 0) {
1238                    if((!make_state) ||(!strcmp(make_state->string_mb,".make.state"))) {
1239                      make_state = depes->names[0];
1240                    }
1241                 }
1242                 break;
1243         case make_version_special:
1244                 if(svr4)
1245                   break;
1246                 if (depes->used != 1) {
1247                         fatal_reader(gettext("Illegal dependency list for target `%s'"),
1248                                      target->string_mb);
1249                 }
1250                 if (depes->names[0] != current_make_version) {
1251                         /*
1252                          * Special case the fact that version 1.0 and 1.1
1253                          * are identical.
1254                          */
1255                         if (!IS_EQUAL(depes->names[0]->string_mb,
1256                                       "VERSION-1.1") ||
1257                             !IS_EQUAL(current_make_version->string_mb,
1258                                       "VERSION-1.0")) {
1259                                 /*
1260                                  * Version mismatches should cause the
1261                                  * .make.state file to be skipped.
1262                                  * This is currently not true - it is read
1263                                  * anyway.
1264                                  */
1265                                 warning(gettext("Version mismatch between current version `%s' and `%s'"),
1266                                         current_make_version->string_mb,
1267                                         depes->names[0]->string_mb);
1268                         }
1269                 }
1270                 break;
1271 
1272         case no_parallel_special:
1273                 if(svr4)
1274                   break;
1275                 /* Set the no_parallel bit for all the targets on */
1276                 /* the dependency list */
1277                 if (depes->used == 0) {
1278                         /* only those explicitly made parallel */
1279                         only_parallel = true;
1280                         all_parallel = false;
1281                 }
1282                 for (; depes != NULL; depes = depes->next) {
1283                         for (n = 0; n < depes->used; n++) {
1284                                 if (trace_reader) {
1285                                         (void) printf("%s:\t%s\n",
1286                                                       no_parallel_name->string_mb,
1287                                                       depes->names[n]->string_mb);
1288                                 }
1289                                 depes->names[n]->no_parallel = true;
1290                                 depes->names[n]->parallel = false;
1291                         }
1292                 }
1293                 break;
1294 
1295         case parallel_special:
1296                 if(svr4)
1297                   break;
1298                 if (depes->used == 0) {
1299                         /* everything runs in parallel */
1300                         all_parallel = true;
1301                         only_parallel = false;
1302                 }
1303                 /* Set the parallel bit for all the targets on */
1304                 /* the dependency list */
1305                 for (; depes != NULL; depes = depes->next) {
1306                         for (n = 0; n < depes->used; n++) {
1307                                 if (trace_reader) {
1308                                         (void) printf("%s:\t%s\n",
1309                                                       parallel_name->string_mb,
1310                                                       depes->names[n]->string_mb);
1311                                 }
1312                                 depes->names[n]->parallel = true;
1313                                 depes->names[n]->no_parallel = false;
1314                         }
1315                 }
1316                 break;
1317 
1318         case localhost_special:
1319                 if(svr4)
1320                   break;
1321                 /* Set the no_parallel bit for all the targets on */
1322                 /* the dependency list */
1323                 if (depes->used == 0) {
1324                         /* only those explicitly made parallel */
1325                         only_parallel = true;
1326                         all_parallel = false;
1327                 }
1328                 for (; depes != NULL; depes = depes->next) {
1329                         for (n = 0; n < depes->used; n++) {
1330                                 if (trace_reader) {
1331                                         (void) printf("%s:\t%s\n",
1332                                                       localhost_name->string_mb,
1333                                                       depes->names[n]->string_mb);
1334                                 }
1335                                 depes->names[n]->no_parallel = true;
1336                                 depes->names[n]->parallel = false;
1337                                 depes->names[n]->localhost = true;
1338                         }
1339                 }
1340                 break;
1341 
1342         case precious_special:
1343                 if (depes->used == 0) {
1344                         /* everything is precious      */
1345                         all_precious = true;
1346                 } else {
1347                         all_precious = false;
1348                 }
1349                 if(svr4) {
1350                   all_precious = true;
1351                   break;
1352                 }
1353                 /* Set the precious bit for all the targets on */
1354                 /* the dependency list */
1355                 for (; depes != NULL; depes = depes->next) {
1356                         for (n = 0; n < depes->used; n++) {
1357                                 if (trace_reader) {
1358                                         (void) printf("%s:\t%s\n",
1359                                                       precious->string_mb,
1360                                                       depes->names[n]->string_mb);
1361                                 }
1362                                 depes->names[n]->stat.is_precious = true;
1363                         }
1364                 }
1365                 break;
1366 
1367         case sccs_get_special:
1368                 if (depes->used != 0) {
1369                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1370                                      target->string_mb);
1371                 }
1372                 sccs_get_rule = command;
1373                 sccs_get_org_rule = command;
1374                 if (trace_reader) {
1375                         (void) printf("%s:\n", sccs_get_name->string_mb);
1376                         print_rule(command);
1377                 }
1378                 break;
1379 
1380         case sccs_get_posix_special:
1381                 if (depes->used != 0) {
1382                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1383                                      target->string_mb);
1384                 }
1385                 sccs_get_posix_rule = command;
1386                 if (trace_reader) {
1387                         (void) printf("%s:\n", sccs_get_posix_name->string_mb);
1388                         print_rule(command);
1389                 }
1390                 break;
1391 
1392         case get_posix_special:
1393                 if (depes->used != 0) {
1394                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1395                                      target->string_mb);
1396                 }
1397                 get_posix_rule = command;
1398                 if (trace_reader) {
1399                         (void) printf("%s:\n", get_posix_name->string_mb);
1400                         print_rule(command);
1401                 }
1402                 break;
1403 
1404         case get_special:
1405                 if(!svr4) {
1406                   break;
1407                 }
1408                 if (depes->used != 0) {
1409                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1410                                      target->string_mb);
1411                 }
1412                 get_rule = command;
1413                 sccs_get_rule = command;
1414                 if (trace_reader) {
1415                         (void) printf("%s:\n", get_name->string_mb);
1416                         print_rule(command);
1417                 }
1418                 break;
1419 
1420         case silent_special:
1421                 if ((depes->used != 0) && (!posix)){
1422                         fatal_reader(gettext("Illegal dependencies for target `%s'"),
1423                                      target->string_mb);
1424                 }
1425                 if (depes->used == 0)
1426                 {
1427                    silent_all = true;
1428                 }
1429                 if(svr4) {
1430                   silent_all = true;
1431                   break;
1432                 }
1433                 for (; depes != NULL; depes = depes->next) {
1434                         for (n = 0; n < depes->used; n++) {
1435                                 depes->names[n]->silent_mode = true;
1436                         }
1437                 }
1438                 if (trace_reader) {
1439                         (void) printf("%s:\n", silent_name->string_mb);
1440                 }
1441                 break;
1442 
1443         case suffixes_special:
1444                 read_suffixes_list(depes);
1445                 break;
1446 
1447         default:
1448 
1449                 fatal_reader(gettext("Internal error: Unknown special reader"));
1450         }
1451 }
1452 
1453 /*
1454  *      read_suffixes_list(depes)
1455  *
1456  *      Read the special list .SUFFIXES. If it is empty the old list is
1457  *      cleared. Else the new one is appended. Suffixes with ~ are extracted
1458  *      and marked.
1459  *
1460  *      Parameters:
1461  *              depes           The list of suffixes
1462  *
1463  *      Global variables used:
1464  *              hashtab         The central hashtable for Names.
1465  *              suffixes        The list of suffixes, set or appended to
1466  *              suffixes_name   The Name ".SUFFIXES", used for tracing
1467  *              trace_reader    Indicates that we should echo stuff we read
1468  */
1469 static void
1470 read_suffixes_list(register Name_vector depes)
1471 {
1472         register int            n;
1473         register Dependency     dp;
1474         register Dependency     *insert_dep;
1475         register Name           np;
1476         Name                    np2;
1477         register Boolean        first = true;
1478 
1479         if (depes->used == 0) {
1480                 /* .SUFFIXES with no dependency list clears the */
1481                 /* suffixes list */
1482                 for (Name_set::iterator np = hashtab.begin(), e = hashtab.end(); np != e; np++) {
1483                                 np->with_squiggle =
1484                                   np->without_squiggle =
1485                                     false;
1486                 }
1487                 suffixes = NULL;
1488                 if (trace_reader) {
1489                         (void) printf("%s:\n", suffixes_name->string_mb);
1490                 }
1491                 return;
1492         }
1493         Wstring str;
1494         /* Otherwise we append to the list */
1495         for (; depes != NULL; depes = depes->next) {
1496                 for (n = 0; n < depes->used; n++) {
1497                         np = depes->names[n];
1498                         /* Find the end of the list and check if the */
1499                         /* suffix already has been entered */
1500                         for (insert_dep = &suffixes, dp = *insert_dep;
1501                              dp != NULL;
1502                              insert_dep = &dp->next, dp = *insert_dep) {
1503                                 if (dp->name == np) {
1504                                         goto duplicate_suffix;
1505                                 }
1506                         }
1507                         if (trace_reader) {
1508                                 if (first) {
1509                                         (void) printf("%s:\t",
1510                                                       suffixes_name->string_mb);
1511                                         first = false;
1512                                 }
1513                                 (void) printf("%s ", depes->names[n]->string_mb);
1514                         }
1515                 if(!(posix|svr4)) {
1516                         /* If the suffix is suffixed with "~" we */
1517                         /* strip that and mark the suffix nameblock */
1518                         str.init(np);
1519                         wchar_t * wcb = str.get_string();
1520                         if (wcb[np->hash.length - 1] ==
1521                             (int) tilde_char) {
1522                                 np2 = GETNAME(wcb,
1523                                               (int)(np->hash.length - 1));
1524                                 np2->with_squiggle = true;
1525                                 if (np2->without_squiggle) {
1526                                         continue;
1527                                 }
1528                                 np = np2;
1529                         }
1530                 }
1531                         np->without_squiggle = true;
1532                         /* Add the suffix to the list */
1533                         dp = *insert_dep = ALLOC(Dependency);
1534                         insert_dep = &dp->next;
1535                         dp->next = NULL;
1536                         dp->name = np;
1537                         dp->built = false;
1538                 duplicate_suffix:;
1539                 }
1540         }
1541         if (trace_reader) {
1542                 (void) printf("\n");
1543         }
1544 }
1545 
1546 /*
1547  *      make_relative(to, result)
1548  *
1549  *      Given a file name compose a relative path name from it to the
1550  *      current directory.
1551  *
1552  *      Parameters:
1553  *              to              The path we want to make relative
1554  *              result          Where to put the resulting relative path
1555  *
1556  *      Global variables used:
1557  */
1558 static void
1559 make_relative(wchar_t *to, wchar_t *result)
1560 {
1561         wchar_t                 *from;
1562         wchar_t                 *allocated;
1563         wchar_t                 *cp;
1564         wchar_t                 *tocomp;
1565         int                     ncomps;
1566         int                     i;
1567         int                     len;
1568 
1569         /* Check if the path is already relative. */
1570         if (to[0] != (int) slash_char) {
1571                 (void) wscpy(result, to);
1572                 return;
1573         }
1574 
1575         MBSTOWCS(wcs_buffer, get_current_path());
1576         from = allocated = (wchar_t *) wsdup(wcs_buffer);
1577 
1578         /*
1579          * Find the number of components in the from name.
1580          * ncomp = number of slashes + 1.
1581          */
1582         ncomps = 1;
1583         for (cp = from; *cp != (int) nul_char; cp++) {
1584                 if (*cp == (int) slash_char) {
1585                         ncomps++;
1586                 }
1587         }
1588 
1589         /*
1590          * See how many components match to determine how many "..",
1591          * if any, will be needed.
1592          */
1593         result[0] = (int) nul_char;
1594         tocomp = to;
1595         while ((*from != (int) nul_char) && (*from == *to)) {
1596                 if (*from == (int) slash_char) {
1597                         ncomps--;
1598                         tocomp = &to[1];
1599                 }
1600                 from++;
1601                 to++;
1602         }
1603 
1604         /*
1605          * Now for some special cases. Check for exact matches and
1606          * for either name terminating exactly.
1607          */
1608         if (*from == (int) nul_char) {
1609                 if (*to == (int) nul_char) {
1610                         MBSTOWCS(wcs_buffer, ".");
1611                         (void) wscpy(result, wcs_buffer);
1612                         retmem(allocated);
1613                         return;
1614                 }
1615                 if (*to == (int) slash_char) {
1616                         ncomps--;
1617                         tocomp = &to[1];
1618                 }
1619         } else if ((*from == (int) slash_char) && (*to == (int) nul_char)) {
1620                 ncomps--;
1621                 tocomp = to;
1622         }
1623         /* Add on the ".."s. */
1624         for (i = 0; i < ncomps; i++) {
1625                 MBSTOWCS(wcs_buffer, "../");
1626                 (void) wscat(result, wcs_buffer);
1627         }
1628 
1629         /* Add on the remainder of the to name, if any. */
1630         if (*tocomp == (int) nul_char) {
1631                 len = wslen(result);
1632                 result[len - 1] = (int) nul_char;
1633         } else {
1634                 (void) wscat(result, tocomp);
1635         }
1636         retmem(allocated);
1637         return;
1638 }
1639 
1640 /*
1641  *      print_rule(command)
1642  *
1643  *      Used when tracing the reading of rules
1644  *
1645  *      Parameters:
1646  *              command         Command to print
1647  *
1648  *      Global variables used:
1649  */
1650 static void
1651 print_rule(register Cmd_line command)
1652 {
1653         for (; command != NULL; command = command->next) {
1654                 (void) printf("\t%s\n", command->command_line->string_mb);
1655         }
1656 }
1657 
1658 /*
1659  *      enter_conditional(target, name, value, append)
1660  *
1661  *      Enter "target := MACRO= value" constructs
1662  *
1663  *      Parameters:
1664  *              target          The target the macro is for
1665  *              name            The name of the macro
1666  *              value           The value for the macro
1667  *              append          Indicates if the assignment is appending or not
1668  *
1669  *      Global variables used:
1670  *              conditionals    A special Name that stores all conditionals
1671  *                              where the target is a % pattern
1672  *              trace_reader    Indicates that we should echo stuff we read
1673  */
1674 void
1675 enter_conditional(register Name target, Name name, Name value, register Boolean append)
1676 {
1677         register Property       conditional;
1678         static int              sequence;
1679         Name                    orig_target = target;
1680 
1681         if (name == target_arch) {
1682                 enter_conditional(target, virtual_root, virtual_root, false);
1683         }
1684 
1685         if (target->percent) {
1686                 target = conditionals;
1687         }
1688         
1689         if (name->colon) {
1690                 sh_transform(&name, &value);
1691         }
1692 
1693         /* Count how many conditionals we must activate before building the */
1694         /* target */
1695         if (target->percent) {
1696                 target = conditionals;
1697         }
1698 
1699         target->conditional_cnt++;
1700         maybe_append_prop(name, macro_prop)->body.macro.is_conditional = true;
1701         /* Add the property for the target */
1702         conditional = append_prop(target, conditional_prop);
1703         conditional->body.conditional.target = orig_target;
1704         conditional->body.conditional.name = name;
1705         conditional->body.conditional.value = value;
1706         conditional->body.conditional.sequence = sequence++;
1707         conditional->body.conditional.append = append;
1708         if (trace_reader) {
1709                 if (value == NULL) {
1710                         (void) printf("%s := %s %c=\n",
1711                                       target->string_mb,
1712                                       name->string_mb,
1713                                       append ?
1714                                       (int) plus_char : (int) space_char);
1715                 } else {
1716                         (void) printf("%s := %s %c= %s\n",
1717                                       target->string_mb,
1718                                       name->string_mb,
1719                                       append ?
1720                                       (int) plus_char : (int) space_char,
1721                                       value->string_mb);
1722                 }
1723         }
1724 }
1725 
1726 /*
1727  *      enter_equal(name, value, append)
1728  *
1729  *      Enter "MACRO= value" constructs
1730  *
1731  *      Parameters:
1732  *              name            The name of the macro
1733  *              value           The value for the macro
1734  *              append          Indicates if the assignment is appending or not
1735  *
1736  *      Global variables used:
1737  *              trace_reader    Indicates that we should echo stuff we read
1738  */
1739 void
1740 enter_equal(Name name, Name value, register Boolean append)
1741 {
1742         wchar_t         *string;
1743         Name            temp;
1744 
1745         if (name->colon) {
1746                 sh_transform(&name, &value);
1747         }
1748         (void) SETVAR(name, value, append);
1749 
1750         /* if we're setting FC, we want to set F77 to the same value. */
1751         Wstring nms(name);
1752         wchar_t * wcb = nms.get_string();
1753         string = wcb;
1754         if (string[0]=='F' &&
1755             string[1]=='C' &&
1756             string[2]=='\0') {
1757                 MBSTOWCS(wcs_buffer, "F77");
1758                 temp = GETNAME(wcs_buffer, FIND_LENGTH);
1759                 (void) SETVAR(temp, value, append);
1760 /*
1761                 fprintf(stderr, gettext("warning: FC is obsolete, use F77 instead\n"));
1762  */
1763         }
1764 
1765         if (trace_reader) {
1766                 if (value == NULL) {
1767                         (void) printf("%s %c=\n",
1768                                       name->string_mb,
1769                                       append ?
1770                                       (int) plus_char : (int) space_char);
1771                 } else {
1772                         (void) printf("%s %c= %s\n",
1773                                       name->string_mb,
1774                                       append ?
1775                                       (int) plus_char : (int) space_char,
1776                                       value->string_mb);
1777                 }
1778         }
1779 }
1780 
1781 /*
1782  *      sh_transform(name, value)
1783  *
1784  *      Parameters:
1785  *              name    The name of the macro we might transform
1786  *              value   The value to transform
1787  *
1788  */
1789 static void
1790 sh_transform(Name *name, Name *value)
1791 {
1792         /* Check if we need :sh transform */
1793         wchar_t         *colon;
1794         String_rec      command;
1795         String_rec      destination;
1796         wchar_t         buffer[1000];
1797         wchar_t         buffer1[1000];
1798 
1799         static wchar_t  colon_sh[4];
1800         static wchar_t  colon_shell[7];
1801 
1802         if (colon_sh[0] == (int) nul_char) {
1803                 MBSTOWCS(colon_sh, ":sh");
1804                 MBSTOWCS(colon_shell, ":shell");
1805         }
1806         Wstring nms((*name));
1807         wchar_t * wcb = nms.get_string();
1808 
1809         colon = (wchar_t *) wsrchr(wcb, (int) colon_char);
1810         if ((colon != NULL) && (IS_WEQUAL(colon, colon_sh) || IS_WEQUAL(colon, colon_shell))) {
1811                 INIT_STRING_FROM_STACK(destination, buffer);
1812 
1813                 if(*value == NULL) {
1814                         buffer[0] = 0;
1815                 } else {
1816                         Wstring wcb1((*value));
1817                         if (IS_WEQUAL(colon, colon_shell)) {
1818                                 INIT_STRING_FROM_STACK(command, buffer1);
1819                                 expand_value(*value, &command, false);
1820                         } else {
1821                                 command.text.p = wcb1.get_string() + (*value)->hash.length;
1822                                 command.text.end = command.text.p;
1823                                 command.buffer.start = wcb1.get_string();
1824                                 command.buffer.end = command.text.p;
1825                         }
1826                         sh_command2string(&command, &destination);
1827                 }
1828 
1829                 (*value) = GETNAME(destination.buffer.start, FIND_LENGTH);
1830                 *colon = (int) nul_char;
1831                 (*name) = GETNAME(wcb, FIND_LENGTH);
1832                 *colon = (int) colon_char;
1833         }
1834 }
1835 
1836 /*
1837  *      fatal_reader(format, args...)
1838  *
1839  *      Parameters:
1840  *              format          printf style format string
1841  *              args            arguments to match the format
1842  *
1843  *      Global variables used:
1844  *              file_being_read Name of the makefile being read
1845  *              line_number     Line that is being read
1846  *              report_pwd      Indicates whether current path should be shown
1847  *              temp_file_name  When reading tempfile we report that name
1848  */
1849 /*VARARGS*/
1850 void
1851 fatal_reader(char * pattern, ...)
1852 {
1853         va_list args;
1854         char    message[1000];
1855 
1856         va_start(args, pattern);
1857         if (file_being_read != NULL) {
1858                 WCSTOMBS(mbs_buffer, file_being_read);
1859                 if (line_number != 0) {
1860                         (void) sprintf(message,
1861                                        gettext("%s, line %d: %s"),
1862                                        mbs_buffer,
1863                                        line_number,
1864                                        pattern);
1865                 } else {
1866                         (void) sprintf(message,
1867                                        "%s: %s",
1868                                        mbs_buffer,
1869                                        pattern);
1870                 }
1871                 pattern = message;
1872         }
1873 
1874         (void) fflush(stdout);
1875         (void) fprintf(stderr, gettext("%s: Fatal error in reader: "),
1876             getprogname());
1877         (void) vfprintf(stderr, pattern, args);
1878         (void) fprintf(stderr, "\n");
1879         va_end(args);
1880 
1881         if (temp_file_name != NULL) {
1882                 (void) fprintf(stderr,
1883                                gettext("%s: Temp-file %s not removed\n"),
1884                                getprogname(),
1885                                temp_file_name->string_mb);
1886                 temp_file_name = NULL;
1887         }
1888 
1889         if (report_pwd) {
1890                 (void) fprintf(stderr,
1891                                gettext("Current working directory %s\n"),
1892                                get_current_path());
1893         }
1894         (void) fflush(stderr);
1895         exit_status = 1;
1896         exit(1);
1897 }
1898