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  *      read.c
  28  *
  29  *      This file contains the makefile reader.
  30  */
  31 
  32 /*
  33  * Included files
  34  */
  35 #include <alloca.h>               /* alloca() */
  36 #include <errno.h>                /* errno */
  37 #include <fcntl.h>                /* fcntl() */
  38 #include <mk/defs.h>
  39 #include <mksh/macro.h>           /* expand_value(), expand_macro() */
  40 #include <mksh/misc.h>            /* getmem() */
  41 #include <mksh/read.h>            /* get_next_block_fn() */
  42 #include <sys/uio.h>              /* read() */
  43 #include <unistd.h>               /* read(), unlink() */
  44 #include <libintl.h>
  45 
  46 
  47 /*
  48  * typedefs & structs
  49  */
  50 
  51 /*
  52  * Static variables
  53  */
  54 
  55 static int line_started_with_space=0; // Used to diagnose spaces instead of tabs
  56 
  57 /*
  58  * File table of contents
  59  */
  60 static  void            parse_makefile(register Name true_makefile_name, register Source source);
  61 static  Source          push_macro_value(register Source bp, register wchar_t *buffer, int size, register Source source);
  62 extern  void            enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen);
  63 extern  Name            normalize_name(register wchar_t *name_string, register int length);
  64 
  65 /*
  66  *      read_simple_file(makefile_name, chase_path, doname_it,
  67  *               complain, must_exist, report_file, lock_makefile)
  68  *
  69  *      Make the makefile and setup to read it. Actually read it if it is stdio
  70  *
  71  *      Return value:
  72  *                              false if the read failed
  73  *
  74  *      Parameters:
  75  *              makefile_name   Name of the file to read
  76  *              chase_path      Use the makefile path when opening file
  77  *              doname_it       Call doname() to build the file first
  78  *              complain        Print message if doname/open fails
  79  *              must_exist      Generate fatal if file is missing
  80  *              report_file     Report file when running -P
  81  *              lock_makefile   Lock the makefile when reading
  82  *
  83  *      Static variables used:
  84  *
  85  *      Global variables used:
  86  *              do_not_exec_rule Is -n on?
  87  *              file_being_read Set to the name of the new file
  88  *              line_number     The number of the current makefile line
  89  *              makefiles_used  A list of all makefiles used, appended to
  90  */
  91 
  92 
  93 Boolean
  94 read_simple_file(register Name makefile_name, register Boolean chase_path, register Boolean doname_it, Boolean complain, Boolean must_exist, Boolean report_file, Boolean lock_makefile)
  95 {
  96         static short            max_include_depth;
  97         register Property       makefile = maybe_append_prop(makefile_name,
  98                                                              makefile_prop);
  99         Boolean                 forget_after_parse = false;
 100         static pathpt           makefile_path;
 101         register int            n;
 102         char                    *path;
 103         register Source         source = ALLOC(Source);
 104         Property                orig_makefile = makefile;
 105         Dependency              *dpp;
 106         Dependency              dp;
 107         register int            length;
 108         wchar_t                 *previous_file_being_read = file_being_read;
 109         int                     previous_line_number = line_number;
 110         wchar_t                 previous_current_makefile[MAXPATHLEN];
 111         Makefile_type           save_makefile_type;
 112         Name                    normalized_makefile_name;
 113         register wchar_t        *string_start;
 114         register wchar_t        *string_end;
 115 
 116 
 117 
 118         wchar_t * wcb = get_wstring(makefile_name->string_mb);
 119 
 120         if (max_include_depth++ >= 40) {
 121                 fatal(gettext("Too many nested include statements"));
 122         }
 123         if (makefile->body.makefile.contents != NULL) {
 124                 retmem(makefile->body.makefile.contents);
 125         }
 126         source->inp_buf =
 127           source->inp_buf_ptr =
 128             source->inp_buf_end = NULL;
 129         source->error_converting = false;
 130         makefile->body.makefile.contents = NULL;
 131         makefile->body.makefile.size = 0;
 132         if ((makefile_name->hash.length != 1) ||
 133             (wcb[0] != (int) hyphen_char)) {
 134                 if ((makefile->body.makefile.contents == NULL) &&
 135                     (doname_it)) {
 136                         if (makefile_path == NULL) {
 137                                 char *pfx = make_install_prefix();
 138                                 char *path;
 139 
 140                                 add_dir_to_path(".",
 141                                                 &makefile_path,
 142                                                 -1);
 143 
 144                                 // As regularly installed
 145                                 asprintf(&path, "%s/../share/lib/make", pfx);
 146                                 add_dir_to_path(path, &makefile_path, -1);
 147                                 free(path);
 148 
 149                                 // Tools build
 150                                 asprintf(&path, "%s/../../share/", pfx);
 151                                 add_dir_to_path(path, &makefile_path, -1);
 152                                 free(path);
 153                                     
 154                                 add_dir_to_path("/usr/share/lib/make",
 155                                                 &makefile_path,
 156                                                 -1);
 157                                 add_dir_to_path("/etc/default",
 158                                                 &makefile_path,
 159                                                 -1);
 160 
 161                                 free(pfx);
 162                         }
 163                         save_makefile_type = makefile_type;
 164                         makefile_type = reading_nothing;
 165                         if (doname(makefile_name, true, false) == build_dont_know) {
 166                                 /* Try normalized filename */
 167                                 string_start=get_wstring(makefile_name->string_mb);
 168                                 for (string_end=string_start+1; *string_end != L'\0'; string_end++);
 169                                 normalized_makefile_name=normalize_name(string_start, string_end - string_start);
 170                                 if ((strcmp(makefile_name->string_mb, normalized_makefile_name->string_mb) == 0) || 
 171                                         (doname(normalized_makefile_name, true, false) == build_dont_know)) {
 172                                         n = access_vroot(makefile_name->string_mb,
 173                                                  4,
 174                                                  chase_path ?
 175                                                  makefile_path : NULL,
 176                                                  VROOT_DEFAULT);
 177                                         if (n == 0) {
 178                                                 get_vroot_path((char **) NULL,
 179                                                        &path,
 180                                                        (char **) NULL);
 181                                                 if ((path[0] == (int) period_char) &&
 182                                                     (path[1] == (int) slash_char)) {
 183                                                         path += 2;
 184                                                 }
 185                                                 MBSTOWCS(wcs_buffer, path);
 186                                                 makefile_name = GETNAME(wcs_buffer,
 187                                                                 FIND_LENGTH);
 188                                         }
 189                                 }
 190                                 retmem(string_start);
 191                                 /* 
 192                                  * Commented out: retmem_mb(normalized_makefile_name->string_mb);
 193                                  * We have to return this memory, but it seems to trigger a bug
 194                                  * in dmake or in Sun C++ 5.7 compiler (it works ok if this code
 195                                  * is compiled using Sun C++ 5.6).
 196                                  */
 197                                 // retmem_mb(normalized_makefile_name->string_mb); 
 198                         }
 199                         makefile_type = save_makefile_type;
 200                 }
 201                 source->string.free_after_use = false;
 202                 source->previous = NULL;
 203                 source->already_expanded = false;
 204                 /* Lock the file for read, but not when -n. */
 205                 if (lock_makefile && 
 206                     !do_not_exec_rule) {
 207 
 208                          make_state_lockfile = getmem(strlen(make_state->string_mb) + strlen(".lock") + 1);
 209                          (void) sprintf(make_state_lockfile,
 210                                                 "%s.lock",
 211                                                 make_state->string_mb);
 212                         (void) file_lock(make_state->string_mb,
 213                                          make_state_lockfile,
 214                                          (int *) &make_state_locked,
 215                                          0);
 216                         if(!make_state_locked) {
 217                                 printf("-- NO LOCKING for read\n");
 218                                 retmem_mb(make_state_lockfile);
 219                                 make_state_lockfile = 0;
 220                                 return failed;
 221                         }
 222                 }
 223                 if (makefile->body.makefile.contents == NULL) {
 224                         save_makefile_type = makefile_type;
 225                         makefile_type = reading_nothing;
 226                         if ((doname_it) &&
 227                             (doname(makefile_name, true, false) == build_failed)) {
 228                                 if (complain) {
 229                                         (void) fprintf(stderr,
 230                                                        gettext("make: Couldn't make `%s'\n"),
 231                                                        makefile_name->string_mb);
 232                                 }
 233                                 max_include_depth--;
 234                                 makefile_type = save_makefile_type;
 235                                 return failed;
 236                         }
 237                         makefile_type = save_makefile_type;
 238                         //
 239                         // Before calling exists() make sure that we have the right timestamp
 240                         //
 241                         makefile_name->stat.time = file_no_time;
 242 
 243                         if (exists(makefile_name) == file_doesnt_exist) {
 244                                 if (complain ||
 245                                     (makefile_name->stat.stat_errno != ENOENT)) {
 246                                         if (must_exist) {
 247                                                 fatal(gettext("Can't find `%s': %s"),
 248                                                       makefile_name->string_mb,
 249                                                       errmsg(makefile_name->
 250                                                              stat.stat_errno));
 251                                         } else {
 252                                                 warning(gettext("Can't find `%s': %s"),
 253                                                         makefile_name->string_mb,
 254                                                         errmsg(makefile_name->
 255                                                                stat.stat_errno));
 256                                         }
 257                                 }
 258                                 max_include_depth--;
 259                                 if(make_state_locked && (make_state_lockfile != NULL)) {
 260                                         (void) unlink(make_state_lockfile);
 261                                         retmem_mb(make_state_lockfile);
 262                                         make_state_lockfile = NULL;
 263                                         make_state_locked = false;
 264                                 }
 265                                 retmem(wcb);
 266                                 retmem_mb((char *)source);
 267                                 return failed;
 268                         }
 269                         /*
 270                          * These values are the size and bytes of
 271                          * the MULTI-BYTE makefile.
 272                          */
 273                         orig_makefile->body.makefile.size =
 274                           makefile->body.makefile.size =
 275                             source->bytes_left_in_file =
 276                               makefile_name->stat.size;
 277                         if (report_file) {
 278                                 for (dpp = &makefiles_used;
 279                                      *dpp != NULL;
 280                                      dpp = &(*dpp)->next);
 281                                 dp = ALLOC(Dependency);
 282                                 dp->next = NULL;
 283                                 dp->name = makefile_name;
 284                                 dp->automatic = false;
 285                                 dp->stale = false;
 286                                 dp->built = false;
 287                                 *dpp = dp;
 288                         }
 289                         source->fd = open_vroot(makefile_name->string_mb,
 290                                                 O_RDONLY,
 291                                                 0,
 292                                                 NULL,
 293                                                 VROOT_DEFAULT);
 294                         if (source->fd < 0) {
 295                                 if (complain || (errno != ENOENT)) {
 296                                         if (must_exist) {
 297                                                 fatal(gettext("Can't open `%s': %s"),
 298                                                       makefile_name->string_mb,
 299                                                       errmsg(errno));
 300                                         } else {
 301                                                 warning(gettext("Can't open `%s': %s"),
 302                                                         makefile_name->string_mb,
 303                                                         errmsg(errno));
 304                                         }
 305                                 }
 306                                 max_include_depth--;
 307                                 return failed;
 308                         }
 309                         (void) fcntl(source->fd, F_SETFD, 1);
 310                         orig_makefile->body.makefile.contents =
 311                           makefile->body.makefile.contents =
 312                             source->string.text.p =
 313                               source->string.buffer.start =
 314                                 ALLOC_WC((int) (makefile_name->stat.size + 2));
 315                         if (makefile_type == reading_cpp_file) {
 316                                 forget_after_parse = true;
 317                         }
 318                         source->string.text.end = source->string.text.p;
 319                         source->string.buffer.end =
 320                           source->string.text.p + makefile_name->stat.size;
 321                 } else {
 322                         /* Do we ever reach here? */
 323                         source->fd = -1;
 324                         source->string.text.p =
 325                           source->string.buffer.start =
 326                             makefile->body.makefile.contents;
 327                         source->string.text.end =
 328                           source->string.buffer.end =
 329                             source->string.text.p + makefile->body.makefile.size;
 330                         source->bytes_left_in_file =
 331                           makefile->body.makefile.size;
 332                 }
 333                 file_being_read = wcb;
 334         } else {
 335                 char            *stdin_text_p;
 336                 char            *stdin_text_end;
 337                 char            *stdin_buffer_start;
 338                 char            *stdin_buffer_end;
 339                 char            *p_mb;
 340                 int             num_mb_chars;
 341                 size_t          num_wc_chars;
 342 
 343                 MBSTOWCS(wcs_buffer, "Standard in");
 344                 makefile_name = GETNAME(wcs_buffer, FIND_LENGTH);
 345                 /*
 346                  * Memory to read standard in, then convert it
 347                  * to wide char strings.
 348                  */
 349                 stdin_buffer_start =
 350                   stdin_text_p = getmem(length = 1024);
 351                 stdin_buffer_end = stdin_text_p + length;
 352                 MBSTOWCS(wcs_buffer, "standard input");
 353                 file_being_read = (wchar_t *) wsdup(wcs_buffer);
 354                 line_number = 0;
 355                 while ((n = read(fileno(stdin),
 356                                  stdin_text_p,
 357                                  length)) > 0) {
 358                         length -= n;
 359                         stdin_text_p += n;
 360                         if (length == 0) {
 361                                 p_mb = getmem(length = 1024 +
 362                                               (stdin_buffer_end -
 363                                                stdin_buffer_start));
 364                                 (void) strncpy(p_mb,
 365                                                stdin_buffer_start,
 366                                                (stdin_buffer_end -
 367                                                 stdin_buffer_start));
 368                                 retmem_mb(stdin_buffer_start);
 369                                 stdin_text_p = p_mb +
 370                                   (stdin_buffer_end - stdin_buffer_start);
 371                                 stdin_buffer_start = p_mb;
 372                                 stdin_buffer_end =
 373                                   stdin_buffer_start + length;
 374                                 length = 1024;
 375                         }
 376                 }
 377                 if (n < 0) {
 378                         fatal(gettext("Error reading standard input: %s"),
 379                               errmsg(errno));
 380                 }
 381                 stdin_text_p = stdin_buffer_start;
 382                 stdin_text_end = stdin_buffer_end - length;
 383                 num_mb_chars = stdin_text_end - stdin_text_p;
 384 
 385                 /*
 386                  * Now, convert the sequence of multibyte chars into
 387                  * a sequence of corresponding wide character codes.
 388                  */
 389                 source->string.free_after_use = false;
 390                 source->previous = NULL;
 391                 source->bytes_left_in_file = 0;
 392                 source->fd = -1;
 393                 source->already_expanded = false;
 394                 source->string.buffer.start =
 395                   source->string.text.p = ALLOC_WC(num_mb_chars + 1);
 396                 source->string.buffer.end =
 397                     source->string.text.p + num_mb_chars;
 398                 num_wc_chars = mbstowcs(source->string.text.p,
 399                                         stdin_text_p,
 400                                         num_mb_chars);
 401                 if ((int) num_wc_chars >= 0) {
 402                         source->string.text.end =
 403                           source->string.text.p + num_wc_chars;
 404                 }
 405                 (void) retmem_mb(stdin_text_p);
 406         }
 407         line_number = 1;
 408         if (trace_reader) {
 409                 (void) printf(gettext(">>>>>>>>>>>>>>>> Reading makefile %s\n"),
 410                               makefile_name->string_mb);
 411         }
 412         parse_makefile(makefile_name, source);
 413         if (trace_reader) {
 414                 (void) printf(gettext(">>>>>>>>>>>>>>>> End of makefile %s\n"),
 415                               makefile_name->string_mb);
 416         }
 417         if(file_being_read) {
 418                 retmem(file_being_read);
 419         }
 420         file_being_read = previous_file_being_read;
 421         line_number = previous_line_number;
 422         makefile_type = reading_nothing;
 423         max_include_depth--;
 424         if (make_state_locked) {
 425                 /* Unlock .make.state. */
 426                 unlink(make_state_lockfile);
 427                 make_state_locked = false;
 428                 retmem_mb(make_state_lockfile);
 429         }
 430         if (forget_after_parse) {
 431                 retmem(makefile->body.makefile.contents);
 432                 makefile->body.makefile.contents = NULL;
 433         }
 434         retmem_mb((char *)source);
 435         return succeeded;
 436 }
 437 
 438 /*
 439  *      parse_makefile(true_makefile_name, source)
 440  *
 441  *      Strings are read from Sources.
 442  *      When macros are found, their values are represented by a
 443  *      Source that is pushed on a stack. At end of string
 444  *      (that is returned from GET_CHAR() as 0), the block is popped.
 445  *
 446  *      Parameters:
 447  *              true_makefile_name      The name of makefile we are parsing
 448  *              source                  The source block to read from
 449  *
 450  *      Global variables used:
 451  *              do_not_exec_rule Is -n on?
 452  *              line_number     The number of the current makefile line
 453  *              makefile_type   What kind of makefile are we reading?
 454  *              empty_name      The Name ""
 455  */
 456 static void
 457 parse_makefile(register Name true_makefile_name, register Source source)
 458 {
 459 /*
 460         char                    mb_buffer[MB_LEN_MAX];
 461  */
 462         register wchar_t        *source_p;
 463         register wchar_t        *source_end;
 464         register wchar_t        *string_start;
 465         wchar_t                 *string_end;
 466         register Boolean        macro_seen_in_string;
 467         Boolean                 append;
 468         String_rec              name_string;
 469         wchar_t                 name_buffer[STRING_BUFFER_LENGTH];
 470         register int            distance;
 471         register int            paren_count;
 472         int                     brace_count;
 473         int                     char_number;
 474         Cmd_line                command;
 475         Cmd_line                command_tail;
 476         Name                    macro_value;
 477 
 478         Name_vector_rec         target;
 479         Name_vector_rec         depes;
 480         Name_vector_rec         extra_name_vector;
 481         Name_vector             current_names;
 482         Name_vector             extra_names = &extra_name_vector;
 483         Name_vector             nvp;
 484         Boolean                 target_group_seen;
 485 
 486         register Reader_state   state;
 487         register Reader_state   on_eoln_state;
 488         register Separator      separator;
 489 
 490         wchar_t                 buffer[4 * STRING_BUFFER_LENGTH];
 491         Source                  extrap;
 492 
 493         Boolean                 save_do_not_exec_rule = do_not_exec_rule;
 494         Name                    makefile_name;
 495 
 496         static Name             sh_name;
 497         static Name             shell_name;
 498         int                     i;
 499 
 500         static wchar_t          include_space[10];
 501         static wchar_t          include_tab[10];
 502         int                     tmp_bytes_left_in_string;
 503         Boolean                 tmp_maybe_include = false;
 504         int                     emptycount = 0;
 505         Boolean                 first_target;
 506 
 507         String_rec              include_name;
 508         wchar_t                 include_buffer[STRING_BUFFER_LENGTH];
 509 
 510         target.next = depes.next = NULL;
 511         /* Move some values from their struct to register declared locals */
 512         CACHE_SOURCE(0);
 513 
 514  start_new_line:
 515         /*
 516          * Read whitespace on old line. Leave pointer on first char on
 517          * next line.
 518          */
 519         first_target = true;
 520         on_eoln_state = exit_state;
 521 /*
 522         for (WCTOMB(mb_buffer, GET_CHAR());
 523              1;
 524              source_p++, WCTOMB(mb_buffer, GET_CHAR()))
 525                 switch (mb_buffer[0]) {
 526  */
 527         for (char_number=0; 1; source_p++,char_number++) switch (GET_CHAR()) {
 528         case nul_char:
 529                 /* End of this string. Pop it and return to the previous one */
 530                 GET_NEXT_BLOCK(source);
 531                 source_p--;
 532                 if (source == NULL) {
 533                         GOTO_STATE(on_eoln_state);
 534                 }
 535                 break;
 536         case newline_char:
 537         end_of_line:
 538                 source_p++;
 539                 if (source->fd >= 0) {
 540                         line_number++;
 541                 }
 542                 switch (GET_CHAR()) {
 543                 case nul_char:
 544                         GET_NEXT_BLOCK(source);
 545                         if (source == NULL) {
 546                                 GOTO_STATE(on_eoln_state);
 547                         }
 548                         /* Go back to the top of this loop */
 549                         goto start_new_line;
 550                 case newline_char:
 551                 case numbersign_char:
 552                 case dollar_char:
 553                 case space_char:
 554                 case tab_char:
 555                         /*
 556                          * Go back to the top of this loop since the
 557                          * new line does not start with a regular char.
 558                          */
 559                         goto start_new_line;
 560                 default:
 561                         /* We found the first proper char on the new line */
 562                         goto start_new_line_no_skip;
 563                 }
 564         case space_char:
 565                 if (char_number == 0)
 566                         line_started_with_space=line_number;
 567         case tab_char:
 568                 /* Whitespace. Just keep going in this loop */
 569                 break;
 570         case numbersign_char:
 571                 /* Comment. Skip over it */
 572                 for (; 1; source_p++) {
 573                         switch (GET_CHAR()) {
 574                         case nul_char:
 575                                 GET_NEXT_BLOCK_NOCHK(source);
 576                                 if (source == NULL) {
 577                                         GOTO_STATE(on_eoln_state);
 578                                 }
 579                                 if (source->error_converting) {
 580                                 // Illegal byte sequence - skip its first byte
 581                                         source->inp_buf_ptr++;
 582                                 }
 583                                 source_p--;
 584                                 break;
 585                         case backslash_char:
 586                                 /* Comments can be continued */
 587                                 if (*++source_p == (int) nul_char) {
 588                                         GET_NEXT_BLOCK_NOCHK(source);
 589                                         if (source == NULL) {
 590                                                 GOTO_STATE(on_eoln_state);
 591                                         }
 592                                         if (source->error_converting) {
 593                                         // Illegal byte sequence - skip its first byte
 594                                                 source->inp_buf_ptr++;
 595                                                 source_p--;
 596                                                 break;
 597                                         }
 598                                 }
 599                                 if(*source_p == (int) newline_char) {
 600                                         if (source->fd >= 0) {
 601                                                 line_number++;
 602                                         }
 603                                 }
 604                                 break;
 605                         case newline_char:
 606                                 /*
 607                                  * After we skip the comment we go to
 608                                  * the end of line handler since end of
 609                                  * line terminates comments.
 610                                  */
 611                                 goto end_of_line;
 612                         }
 613                 }
 614         case dollar_char:
 615                 /* Macro reference */
 616                 if (source->already_expanded) {
 617                         /*
 618                          * If we are reading from the expansion of a
 619                          * macro we already expanded everything enough.
 620                          */
 621                         goto start_new_line_no_skip;
 622                 }
 623                 /*
 624                  * Expand the value and push the Source on the stack of
 625                  * things being read.
 626                  */
 627                 source_p++;
 628                 UNCACHE_SOURCE();
 629                 {
 630                         Source t = (Source) alloca((int) sizeof (Source_rec));
 631                         source = push_macro_value(t,
 632                                                   buffer,
 633                                                   sizeof buffer,
 634                                                   source);
 635                 }
 636                 CACHE_SOURCE(1);
 637                 break;
 638         default:
 639                 /* We found the first proper char on the new line */
 640                 goto start_new_line_no_skip;
 641         }
 642 
 643         /*
 644          * We found the first normal char (one that starts an identifier)
 645          * on the newline.
 646          */
 647 start_new_line_no_skip:
 648         /* Inspect that first char to see if it maybe is special anyway */
 649         switch (GET_CHAR()) {
 650         case nul_char:
 651                 GET_NEXT_BLOCK(source);
 652                 if (source == NULL) {
 653                         GOTO_STATE(on_eoln_state);
 654                 }
 655                 goto start_new_line_no_skip;
 656         case newline_char:
 657                 /* Just in case */
 658                 goto start_new_line;
 659         case exclam_char:
 660                 /* Evaluate the line before it is read */
 661                 string_start = source_p + 1;
 662                 macro_seen_in_string = false;
 663                 /* Stuff the line in a string so we can eval it. */
 664                 for (; 1; source_p++) {
 665                         switch (GET_CHAR()) {
 666                         case newline_char:
 667                                 goto eoln_1;
 668                         case nul_char:
 669                                 if (source->fd > 0) {
 670                                         if (!macro_seen_in_string) {
 671                                                 macro_seen_in_string = true;
 672                                                 INIT_STRING_FROM_STACK(
 673                                                       name_string, name_buffer);
 674                                         }
 675                                         append_string(string_start,
 676                                                       &name_string,
 677                                                       source_p - string_start);
 678                                         GET_NEXT_BLOCK(source);
 679                                         string_start = source_p;
 680                                         source_p--;
 681                                         break;
 682                                 }
 683                         eoln_1:
 684                                 if (!macro_seen_in_string) {
 685                                         INIT_STRING_FROM_STACK(name_string,
 686                                                                name_buffer);
 687                                 }
 688                                 append_string(string_start,
 689                                               &name_string,
 690                                               source_p - string_start);
 691                                 extrap = (Source)
 692                                   alloca((int) sizeof (Source_rec));
 693                                 extrap->string.buffer.start = NULL;
 694                                 extrap->inp_buf =
 695                                   extrap->inp_buf_ptr =
 696                                     extrap->inp_buf_end = NULL;
 697                                 extrap->error_converting = false;
 698                                 if (*source_p == (int) nul_char) {
 699                                         source_p++;
 700                                 }
 701                                 /* Eval the macro */
 702                                 expand_value(GETNAME(name_string.buffer.start,
 703                                                      FIND_LENGTH),
 704                                              &extrap->string,
 705                                              false);
 706                                 if (name_string.free_after_use) {
 707                                         retmem(name_string.buffer.start);
 708                                 }
 709                                 UNCACHE_SOURCE();
 710                                 extrap->string.text.p =
 711                                   extrap->string.buffer.start;
 712                                 extrap->fd = -1;
 713                                 /* And push the value */
 714                                 extrap->previous = source;
 715                                 source = extrap;
 716                                 CACHE_SOURCE(0);
 717                                 goto line_evald;
 718                         }
 719                 }
 720         default:
 721                 goto line_evald;
 722         }
 723 
 724         /* We now have a line we can start reading */
 725  line_evald:
 726         if (source == NULL) {
 727                 GOTO_STATE(exit_state);
 728         }
 729         /* Check if this is an include command */
 730         if ((makefile_type == reading_makefile) &&
 731             !source->already_expanded) {
 732             if (include_space[0] == (int) nul_char) {
 733                 MBSTOWCS(include_space, "include ");
 734                 MBSTOWCS(include_tab, "include\t");
 735             }
 736             if ((IS_WEQUALN(source_p, include_space, 8)) ||
 737                 (IS_WEQUALN(source_p, include_tab, 8))) {
 738                 source_p += 7;
 739                 if (iswspace(*source_p)) {
 740                         Makefile_type save_makefile_type;
 741                         wchar_t         *name_start;
 742                         int             name_length;
 743 
 744                         /*
 745                          * Yes, this is an include.
 746                          * Skip spaces to get to the filename.
 747                          */
 748                         while (iswspace(*source_p) ||
 749                                (*source_p == (int) nul_char)) {
 750                                 switch (GET_CHAR()) {
 751                                 case nul_char:
 752                                         GET_NEXT_BLOCK(source);
 753                                         if (source == NULL) {
 754                                                 GOTO_STATE(on_eoln_state);
 755                                         }
 756                                         break;
 757 
 758                                 default:
 759                                         source_p++;
 760                                         break;
 761                                 }
 762                         }
 763 
 764                         string_start = source_p;
 765                         /* Find the end of the filename */
 766                         macro_seen_in_string = false;
 767                         while (!iswspace(*source_p) ||
 768                                (*source_p == (int) nul_char)) {
 769                                 switch (GET_CHAR()) {
 770                                 case nul_char:
 771                                         if (!macro_seen_in_string) {
 772                                                 INIT_STRING_FROM_STACK(name_string,
 773                                                                        name_buffer);
 774                                         }
 775                                         append_string(string_start,
 776                                                       &name_string,
 777                                                       source_p - string_start);
 778                                         macro_seen_in_string = true;
 779                                         GET_NEXT_BLOCK(source);
 780                                         string_start = source_p;
 781                                         if (source == NULL) {
 782                                                 GOTO_STATE(on_eoln_state);
 783                                         }
 784                                         break;
 785 
 786                                 default:
 787                                         source_p++;
 788                                         break;
 789                                 }
 790                         }
 791 
 792                         source->string.text.p = source_p;
 793                         if (macro_seen_in_string) {
 794                                 append_string(string_start,
 795                                               &name_string,
 796                                               source_p - string_start);
 797                                 name_start = name_string.buffer.start;
 798                                 name_length = name_string.text.p - name_start;
 799                         } else {
 800                                 name_start = string_start;
 801                                 name_length = source_p - string_start;
 802                         }
 803 
 804                         /* Strip "./" from the head of the name */
 805                         if ((name_start[0] == (int) period_char) &&
 806                            (name_start[1] == (int) slash_char)) {
 807                                 name_start += 2;
 808                                 name_length -= 2;
 809                         }
 810                         /* if include file name is surrounded by double quotes */
 811                         if ((name_start[0] == (int) doublequote_char) &&
 812                             (name_start[name_length - 1] == (int) doublequote_char)) {
 813                                 name_start += 1;
 814                                 name_length -= 2;
 815 
 816                                 /* if name does not begin with a slash char */
 817                                 if (name_start[0] != (int) slash_char) {
 818                                         if ((name_start[0] == (int) period_char) &&
 819                                             (name_start[1] == (int) slash_char)) {
 820                                                 name_start += 2;
 821                                                 name_length -= 2;
 822                                         }
 823 
 824                                         INIT_STRING_FROM_STACK(include_name, include_buffer);
 825                                         APPEND_NAME(true_makefile_name,
 826                                                       &include_name,
 827                                                       true_makefile_name->hash.length);
 828 
 829                                         wchar_t *slash = wsrchr(include_name.buffer.start, (int) slash_char);
 830                                         if (slash != NULL) {
 831                                                 include_name.text.p = slash + 1;
 832                                                 append_string(name_start,
 833                                                               &include_name,
 834                                                               name_length);
 835 
 836                                                 name_start = include_name.buffer.start;
 837                                                 name_length = include_name.text.p - name_start; 
 838                                         }
 839                                 }
 840                         }
 841 
 842                         /* Even when we run -n we want to create makefiles */
 843                         do_not_exec_rule = false;
 844                         makefile_name = GETNAME(name_start, name_length);
 845                         if (makefile_name->dollar) {
 846                                 String_rec      destination;
 847                                 wchar_t         buffer[STRING_BUFFER_LENGTH];
 848                                 wchar_t         *p;
 849                                 wchar_t         *q;
 850 
 851                                 INIT_STRING_FROM_STACK(destination, buffer);
 852                                 expand_value(makefile_name,
 853                                              &destination,
 854                                              false);
 855                                 for (p = destination.buffer.start;
 856                                      (*p != (int) nul_char) && iswspace(*p);
 857                                      p++);
 858                                 for (q = p;
 859                                      (*q != (int) nul_char) && !iswspace(*q);
 860                                      q++);
 861                                 makefile_name = GETNAME(p, q-p);
 862                                 if (destination.free_after_use) {
 863                                         retmem(destination.buffer.start);
 864                                 }
 865                         }
 866                         source_p++;
 867                         UNCACHE_SOURCE();
 868                         /* Read the file */
 869                         save_makefile_type = makefile_type;
 870                         if (read_simple_file(makefile_name,
 871                                              true,
 872                                              true,
 873                                              true,
 874                                              false,
 875                                              true,
 876                                              false) == failed) {
 877                                 fatal_reader(gettext("Read of include file `%s' failed"),
 878                                              makefile_name->string_mb);
 879                         }
 880                         makefile_type = save_makefile_type;
 881                         do_not_exec_rule = save_do_not_exec_rule;
 882                         CACHE_SOURCE(0);
 883                         goto start_new_line;
 884                 } else {
 885                         source_p -= 7;
 886                 }
 887             } else {
 888                 /* Check if the word include was split across 8K boundary. */
 889                 
 890                 tmp_bytes_left_in_string = source->string.text.end - source_p;
 891                 if (tmp_bytes_left_in_string < 8) {
 892                         tmp_maybe_include = false;
 893                         if (IS_WEQUALN(source_p,
 894                                        include_space,
 895                                        tmp_bytes_left_in_string)) {
 896                                 tmp_maybe_include = true;
 897                         }
 898                         if (tmp_maybe_include) {
 899                                 GET_NEXT_BLOCK(source);
 900                                 tmp_maybe_include = false;
 901                                 goto line_evald;
 902                         }
 903                 }
 904             }
 905         }
 906 
 907         /* Reset the status in preparation for the new line */
 908         for (nvp = &target; nvp != NULL; nvp = nvp->next) {
 909                 nvp->used = 0;
 910         }
 911         for (nvp = &depes; nvp != NULL; nvp = nvp->next) {
 912                 nvp->used = 0;
 913         }
 914         target_group_seen = false;
 915         command = command_tail = NULL;
 916         macro_value = NULL;
 917         append = false;
 918         current_names = &target;
 919         SET_STATE(scan_name_state);
 920         on_eoln_state = illegal_eoln_state;
 921         separator = none_seen;
 922 
 923         /* The state machine starts here */
 924  enter_state:
 925         while (1) switch (state) {
 926 
 927 /****************************************************************
 928  *      Scan name state
 929  */
 930 case scan_name_state:
 931         /* Scan an identifier. We skip over chars until we find a break char */
 932         /* First skip white space. */
 933         for (; 1; source_p++) switch (GET_CHAR()) {
 934         case nul_char:
 935                 GET_NEXT_BLOCK(source);
 936                 source_p--;
 937                 if (source == NULL) {
 938                         GOTO_STATE(on_eoln_state);
 939                 }
 940                 break;
 941         case newline_char:
 942                 /* We found the end of the line. */
 943                 /* Do postprocessing or return error */
 944                 source_p++;
 945                 if (source->fd >= 0) {
 946                         line_number++;
 947                 }
 948                 GOTO_STATE(on_eoln_state);
 949         case backslash_char:
 950                 /* Continuation */
 951                 if (*++source_p == (int) nul_char) {
 952                         GET_NEXT_BLOCK(source);
 953                         if (source == NULL) {
 954                                 GOTO_STATE(on_eoln_state);
 955                         }
 956                 }
 957                 if (*source_p == (int) newline_char) {
 958                         if (source->fd >= 0) {
 959                                 line_number++;
 960                         }
 961                 } else {
 962                         source_p--;
 963                 }
 964                 break;
 965         case tab_char:
 966         case space_char:
 967                 /* Whitespace is skipped */
 968                 break;
 969         case numbersign_char:
 970                 /* Comment. Skip over it */
 971                 for (; 1; source_p++) {
 972                         switch (GET_CHAR()) {
 973                         case nul_char:
 974                                 GET_NEXT_BLOCK_NOCHK(source);
 975                                 if (source == NULL) {
 976                                         GOTO_STATE(on_eoln_state);
 977                                 }
 978                                 if (source->error_converting) {
 979                                 // Illegal byte sequence - skip its first byte
 980                                         source->inp_buf_ptr++;
 981                                 }
 982                                 source_p--;
 983                                 break;
 984                         case backslash_char:
 985                                 if (*++source_p == (int) nul_char) {
 986                                         GET_NEXT_BLOCK_NOCHK(source);
 987                                         if (source == NULL) {
 988                                                 GOTO_STATE(on_eoln_state);
 989                                         }
 990                                         if (source->error_converting) {
 991                                         // Illegal byte sequence - skip its first byte
 992                                                 source->inp_buf_ptr++;
 993                                                 source_p--;
 994                                                 break;
 995                                         }
 996                                 }
 997                                 if(*source_p == (int) newline_char) {
 998                                         if (source->fd >= 0) {
 999                                                 line_number++;
1000                                         }
1001                                 }
1002                                 break;
1003                         case newline_char:
1004                                 source_p++;
1005                                 if (source->fd >= 0) {
1006                                         line_number++;
1007                                 }
1008                                 GOTO_STATE(on_eoln_state);
1009                         }
1010                 }
1011         case dollar_char:
1012                 /* Macro reference. Expand and push value */
1013                 if (source->already_expanded) {
1014                         goto scan_name;
1015                 }
1016                 source_p++;
1017                 UNCACHE_SOURCE();
1018                 {
1019                         Source t = (Source) alloca((int) sizeof (Source_rec));
1020                         source = push_macro_value(t,
1021                                                   buffer,
1022                                                   sizeof buffer,
1023                                                   source);
1024                 }
1025                 CACHE_SOURCE(1);
1026                 break;
1027         default:
1028                 /* End of white space */
1029                 goto scan_name;
1030         }
1031 
1032         /* First proper identifier character */
1033  scan_name:
1034 
1035         string_start = source_p;
1036         paren_count = brace_count = 0;
1037         macro_seen_in_string = false;
1038         resume_name_scan:
1039         for (; 1; source_p++) {
1040                 switch (GET_CHAR()) {
1041                 case nul_char:
1042                         /* Save what we have seen so far of the identifier */
1043                         if (source_p != string_start) {
1044                                 if (!macro_seen_in_string) {
1045                                         INIT_STRING_FROM_STACK(name_string,
1046                                                                name_buffer);
1047                                 }
1048                                 append_string(string_start,
1049                                               &name_string,
1050                                               source_p - string_start);
1051                                 macro_seen_in_string = true;
1052                         }
1053                         /* Get more text to read */
1054                         GET_NEXT_BLOCK(source);
1055                         string_start = source_p;
1056                         source_p--;
1057                         if (source == NULL) {
1058                                 GOTO_STATE(on_eoln_state);
1059                         }
1060                         break;
1061                 case newline_char:
1062                         if (paren_count > 0) {
1063                                 fatal_reader(gettext("Unmatched `(' on line"));
1064                         }
1065                         if (brace_count > 0) {
1066                                 fatal_reader(gettext("Unmatched `{' on line"));
1067                         }
1068                         source_p++;
1069                         /* Enter name */
1070                         current_names = enter_name(&name_string,
1071                                                    macro_seen_in_string,
1072                                                    string_start,
1073                                                    source_p - 1,
1074                                                    current_names,
1075                                                    &extra_names,
1076                                                    &target_group_seen);
1077                         first_target = false;
1078                         if (extra_names == NULL) {
1079                                 extra_names = (Name_vector)
1080                                   alloca((int) sizeof (Name_vector_rec));
1081                         }
1082                         /* Do postprocessing or return error */
1083                         if (source->fd >= 0) {
1084                                 line_number++;
1085                         }
1086                         GOTO_STATE(on_eoln_state);
1087                 case backslash_char:
1088                         /* Check if this is a quoting backslash */
1089                         if (!macro_seen_in_string) {
1090                                 INIT_STRING_FROM_STACK(name_string,
1091                                                        name_buffer);
1092                                 macro_seen_in_string = true;
1093                         }
1094                         append_string(string_start,
1095                                       &name_string,
1096                                       source_p - string_start);
1097                         if (*++source_p == (int) nul_char) {
1098                                 GET_NEXT_BLOCK(source);
1099                                 if (source == NULL) {
1100                                         GOTO_STATE(on_eoln_state);
1101                                 }
1102                         }
1103                         if (*source_p == (int) newline_char) {
1104                                 if (source->fd >= 0) {
1105                                         line_number++;
1106                                 }
1107                                 *source_p = (int) space_char;
1108                                 string_start = source_p;
1109                                 goto resume_name_scan;
1110                         } else {
1111                                 string_start = source_p;
1112                                 break;
1113                         }
1114                         break;
1115                 case numbersign_char:
1116                         if (paren_count + brace_count > 0) {
1117                                 break;
1118                         }
1119                         fatal_reader(gettext("Unexpected comment seen"));
1120                 case dollar_char:
1121                         if (source->already_expanded) {
1122                                 break;
1123                         }
1124                         /* Save the identifier so far */
1125                         if (source_p != string_start) {
1126                                 if (!macro_seen_in_string) {
1127                                         INIT_STRING_FROM_STACK(name_string,
1128                                                                name_buffer);
1129                                 }
1130                                 append_string(string_start,
1131                                               &name_string,
1132                                               source_p - string_start);
1133                                 macro_seen_in_string = true;
1134                         }
1135                         /* Eval and push the macro */
1136                         source_p++;
1137                         UNCACHE_SOURCE();
1138                         {
1139                                 Source t =
1140                                   (Source) alloca((int) sizeof (Source_rec));
1141                                 source = push_macro_value(t,
1142                                                           buffer,
1143                                                           sizeof buffer,
1144                                                           source);
1145                         }
1146                         CACHE_SOURCE(1);
1147                         string_start = source_p + 1;
1148                         break;
1149                 case parenleft_char:
1150                         paren_count++;
1151                         break;
1152                 case parenright_char:
1153                         if (--paren_count < 0) {
1154                                 fatal_reader(gettext("Unmatched `)' on line"));
1155                         }
1156                         break;
1157                 case braceleft_char:
1158                         brace_count++;
1159                         break;
1160                 case braceright_char:
1161                         if (--brace_count < 0) {
1162                                 fatal_reader(gettext("Unmatched `}' on line"));
1163                         }
1164                         break;
1165                 case ampersand_char:
1166                 case greater_char:
1167                 case bar_char:
1168                         if (paren_count + brace_count == 0) {
1169                                 source_p++;
1170                         }
1171                         /* Fall into */
1172                 case tab_char:
1173                 case space_char:
1174                         if (paren_count + brace_count > 0) {
1175                                 break;
1176                         }
1177                         current_names = enter_name(&name_string,
1178                                                    macro_seen_in_string,
1179                                                    string_start,
1180                                                    source_p,
1181                                                    current_names,
1182                                                    &extra_names,
1183                                                    &target_group_seen);
1184                         first_target = false;
1185                         if (extra_names == NULL) {
1186                                 extra_names = (Name_vector)
1187                                   alloca((int) sizeof (Name_vector_rec));
1188                         }
1189                         goto enter_state;
1190                 case colon_char:
1191                         if (paren_count + brace_count > 0) {
1192                                 break;
1193                         }
1194                         if (separator == conditional_seen) {
1195                                 break;
1196                         }
1197 /** POSIX **/
1198 #if 0
1199                         if(posix) {
1200                           emptycount = 0;
1201                         }
1202 #endif
1203 /** END POSIX **/
1204                         /* End of the target list. We now start reading */
1205                         /* dependencies or a conditional assignment */
1206                         if (separator != none_seen) {
1207                                 fatal_reader(gettext("Extra `:', `::', or `:=' on dependency line"));
1208                         }
1209                         /* Enter the last target */
1210                         if ((string_start != source_p) ||
1211                             macro_seen_in_string) {
1212                                 current_names =
1213                                   enter_name(&name_string,
1214                                              macro_seen_in_string,
1215                                              string_start,
1216                                              source_p,
1217                                              current_names,
1218                                              &extra_names,
1219                                              &target_group_seen);
1220                                 first_target = false;
1221                                 if (extra_names == NULL) {
1222                                         extra_names = (Name_vector)
1223                                           alloca((int)
1224                                                  sizeof (Name_vector_rec));
1225                                 }
1226                         }
1227                         /* Check if it is ":" "::" or ":=" */
1228                 scan_colon_label:
1229                         switch (*++source_p) {
1230                         case nul_char:
1231                                 GET_NEXT_BLOCK(source);
1232                                 source_p--;
1233                                 if (source == NULL) {
1234                                         GOTO_STATE(enter_dependencies_state);
1235                                 }
1236                                 goto scan_colon_label;
1237                         case equal_char:
1238                                 if(svr4) {
1239                                   fatal_reader(gettext("syntax error"));
1240                                 }
1241                                 separator = conditional_seen;
1242                                 source_p++;
1243                                 current_names = &depes;
1244                                 GOTO_STATE(scan_name_state);
1245                         case colon_char:
1246                                 separator = two_colon;
1247                                 source_p++;
1248                                 break;
1249                         default:
1250                                 separator = one_colon;
1251                         }
1252                         current_names = &depes;
1253                         on_eoln_state = enter_dependencies_state;
1254                         GOTO_STATE(scan_name_state);
1255                 case semicolon_char:
1256                         if (paren_count + brace_count > 0) {
1257                                 break;
1258                         }
1259                         /* End of reading names. Start reading the rule */
1260                         if ((separator != one_colon) &&
1261                             (separator != two_colon)) {
1262                                 fatal_reader(gettext("Unexpected command seen"));
1263                         }
1264                         /* Enter the last dependency */
1265                         if ((string_start != source_p) ||
1266                             macro_seen_in_string) {
1267                                 current_names =
1268                                   enter_name(&name_string,
1269                                              macro_seen_in_string,
1270                                              string_start,
1271                                              source_p,
1272                                              current_names,
1273                                              &extra_names,
1274                                              &target_group_seen);
1275                                 first_target = false;
1276                                 if (extra_names == NULL) {
1277                                         extra_names = (Name_vector)
1278                                           alloca((int)
1279                                                  sizeof (Name_vector_rec));
1280                                 }
1281                         }
1282                         source_p++;
1283                         /* Make sure to enter a rule even if the is */
1284                         /* no text here */
1285                         command = command_tail = ALLOC(Cmd_line);
1286                         command->next = NULL;
1287                         command->command_line = empty_name;
1288                         command->make_refd = false;
1289                         command->ignore_command_dependency = false;
1290                         command->assign = false;
1291                         command->ignore_error = false;
1292                         command->silent = false;
1293 
1294                         GOTO_STATE(scan_command_state);
1295                 case plus_char:
1296                         /*
1297                         ** following code drops the target separator plus char if it starts
1298                         ** a line.
1299                         */ 
1300                         if(first_target && !macro_seen_in_string &&
1301                                         source_p == string_start) {
1302                                 for (; 1; source_p++)
1303                                 switch (GET_CHAR()) {
1304                                 case nul_char:
1305                                         if (source_p != string_start) {
1306                                                 if (!macro_seen_in_string) {
1307                                                         INIT_STRING_FROM_STACK(name_string,
1308                                                                                name_buffer);
1309                                                 }
1310                                                 append_string(string_start,
1311                                                               &name_string,
1312                                                               source_p - string_start);
1313                                                 macro_seen_in_string = true;
1314                                         }
1315                                         GET_NEXT_BLOCK(source);
1316                                         string_start = source_p;
1317                                         source_p--;
1318                                         if (source == NULL) {
1319                                                 GOTO_STATE(on_eoln_state);
1320                                         }
1321                                         break;
1322                                 case plus_char:
1323                                         source_p++;
1324                                         while (*source_p == (int) nul_char) {
1325                                                 if (source_p != string_start) {
1326                                                         if (!macro_seen_in_string) {
1327                                                                 INIT_STRING_FROM_STACK(name_string,
1328                                                                                name_buffer);
1329                                                         }
1330                                                         append_string(string_start,
1331                                                                       &name_string,
1332                                                                       source_p - string_start);
1333                                                         macro_seen_in_string = true;
1334                                                 }
1335                                                 GET_NEXT_BLOCK(source);
1336                                                 string_start = source_p;
1337                                                 if (source == NULL) {
1338                                                         GOTO_STATE(on_eoln_state);
1339                                                 }
1340                                         }
1341                                         if (*source_p == (int) tab_char ||
1342                                                         *source_p == (int) space_char) {
1343                                                 macro_seen_in_string = false;
1344                                                 string_start = source_p + 1;
1345                                         } else {
1346                                                 goto resume_name_scan;
1347                                         }
1348                                         break;
1349                                 case tab_char:
1350                                 case space_char:
1351                                         string_start = source_p + 1;
1352                                         break;
1353                                 default:
1354                                         goto resume_name_scan;
1355                                 }
1356                         }
1357                         if (paren_count + brace_count > 0) {
1358                                 break;
1359                         }
1360                         /* We found "+=" construct */
1361                         if (source_p != string_start) {
1362                                 /* "+" is not a break char. */
1363                                 /* Ignore it if it is part of an identifier */
1364                                 source_p++;
1365                                 goto resume_name_scan;
1366                         }
1367                         /* Make sure the "+" is followed by a "=" */
1368                 scan_append:
1369                         switch (*++source_p) {
1370                         case nul_char:
1371                                 if (!macro_seen_in_string) {
1372                                         INIT_STRING_FROM_STACK(name_string,
1373                                                                name_buffer);
1374                                 }
1375                                 append_string(string_start,
1376                                               &name_string,
1377                                               source_p - string_start);
1378                                 GET_NEXT_BLOCK(source);
1379                                 source_p--;
1380                                 string_start = source_p;
1381                                 if (source == NULL) {
1382                                         GOTO_STATE(illegal_eoln_state);
1383                                 }
1384                                 goto scan_append;
1385                         case equal_char:
1386                                 if(!svr4) {
1387                                   append = true;
1388                                 } else {
1389                                   fatal_reader(gettext("Must be a separator on rules"));
1390                                 }
1391                                 break;
1392                         default:
1393                                 /* The "+" just starts a regular name. */
1394                                 /* Start reading that name */
1395                                 goto resume_name_scan;
1396                         }
1397                         /* Fall into */
1398                 case equal_char:
1399                         if (paren_count + brace_count > 0) {
1400                                 break;
1401                         }
1402                         /* We found macro assignment. */
1403                         /* Check if it is legal and if it is appending */
1404                         switch (separator) {
1405                         case none_seen:
1406                                 separator = equal_seen;
1407                                 on_eoln_state = enter_equal_state;
1408                                 break;
1409                         case conditional_seen:
1410                                 on_eoln_state = enter_conditional_state;
1411                                 break;
1412                         default:
1413                                 /* Reader must special check for "MACRO:sh=" */
1414                                 /* notation */
1415                                 if (sh_name == NULL) {
1416                                         MBSTOWCS(wcs_buffer, "sh");
1417                                         sh_name = GETNAME(wcs_buffer, FIND_LENGTH);
1418                                         MBSTOWCS(wcs_buffer, "shell");
1419                                         shell_name = GETNAME(wcs_buffer, FIND_LENGTH);
1420                                 }
1421 
1422                                 if (!macro_seen_in_string) {
1423                                         INIT_STRING_FROM_STACK(name_string,
1424                                                        name_buffer);
1425                                 }
1426                                 append_string(string_start,
1427                                               &name_string,
1428                                               source_p - string_start
1429                                 );
1430 
1431                                 if ( (((target.used == 1) &&
1432                                      (depes.used == 1) &&
1433                                      (depes.names[0] == sh_name)) ||
1434                                     ((target.used == 1) &&
1435                                      (depes.used == 0) &&
1436                                      (separator == one_colon) &&
1437                                      (GETNAME(name_string.buffer.start,FIND_LENGTH) == sh_name))) &&
1438                                     (!svr4)) {
1439                                         String_rec      macro_name;
1440                                         wchar_t         buffer[100];
1441 
1442                                         INIT_STRING_FROM_STACK(macro_name,
1443                                                                buffer);
1444                                         APPEND_NAME(target.names[0],
1445                                                       &macro_name,
1446                                                       FIND_LENGTH);
1447                                         append_char((int) colon_char,
1448                                                     &macro_name);
1449                                         APPEND_NAME(sh_name,
1450                                                       &macro_name,
1451                                                       FIND_LENGTH);
1452                                         target.names[0] =
1453                                           GETNAME(macro_name.buffer.start,
1454                                                   FIND_LENGTH);
1455                                         separator = equal_seen;
1456                                         on_eoln_state = enter_equal_state;
1457                                         break;
1458                                 } else if ( (((target.used == 1) &&
1459                                             (depes.used == 1) &&
1460                                             (depes.names[0] == shell_name)) ||
1461                                            ((target.used == 1) &&
1462                                             (depes.used == 0) &&
1463                                             (separator == one_colon) &&
1464                                             (GETNAME(name_string.buffer.start,FIND_LENGTH) == shell_name))) &&
1465                                            (!svr4)) {
1466                                         String_rec      macro_name;
1467                                         wchar_t         buffer[100];
1468 
1469                                         INIT_STRING_FROM_STACK(macro_name,
1470                                                                buffer);
1471                                         APPEND_NAME(target.names[0],
1472                                                       &macro_name,
1473                                                       FIND_LENGTH);
1474                                         append_char((int) colon_char,
1475                                                     &macro_name);
1476                                         APPEND_NAME(shell_name,
1477                                                       &macro_name,
1478                                                       FIND_LENGTH);
1479                                         target.names[0] =
1480                                           GETNAME(macro_name.buffer.start,
1481                                                   FIND_LENGTH);
1482                                         separator = equal_seen;
1483                                         on_eoln_state = enter_equal_state;
1484                                         break;
1485                                 } 
1486                                 if(svr4) {
1487                                   fatal_reader(gettext("syntax error"));
1488                                 }
1489                                 else {
1490                                   fatal_reader(gettext("Macro assignment on dependency line"));
1491                                 }
1492                         }
1493                         if (append) {
1494                                 source_p--;
1495                         }
1496                         /* Enter the macro name */
1497                         if ((string_start != source_p) ||
1498                             macro_seen_in_string) {
1499                                 current_names =
1500                                   enter_name(&name_string,
1501                                              macro_seen_in_string,
1502                                              string_start,
1503                                              source_p,
1504                                              current_names,
1505                                              &extra_names,
1506                                              &target_group_seen);
1507                                 first_target = false;
1508                                 if (extra_names == NULL) {
1509                                         extra_names = (Name_vector)
1510                                           alloca((int)
1511                                                  sizeof (Name_vector_rec));
1512                                 }
1513                         }
1514                         if (append) {
1515                                 source_p++;
1516                         }
1517                         macro_value = NULL;
1518                         source_p++;
1519                         distance = 0;
1520                         /* Skip whitespace to the start of the value */
1521                         macro_seen_in_string = false;
1522                         for (; 1; source_p++) {
1523                                 switch (GET_CHAR()) {
1524                                 case nul_char:
1525                                         GET_NEXT_BLOCK(source);
1526                                         source_p--;
1527                                         if (source == NULL) {
1528                                                 GOTO_STATE(on_eoln_state);
1529                                         }
1530                                         break;
1531                                 case backslash_char:
1532                                         if (*++source_p == (int) nul_char) {
1533                                                 GET_NEXT_BLOCK(source);
1534                                                 if (source == NULL) {
1535                                                         GOTO_STATE(on_eoln_state);
1536                                                 }
1537                                         }
1538                                         if (*source_p != (int) newline_char) {
1539                                                 if (!macro_seen_in_string) {
1540                                                         macro_seen_in_string =
1541                                                           true;
1542                                                         INIT_STRING_FROM_STACK(name_string,
1543                                                                                name_buffer);
1544                                                 }
1545                                                 append_char((int)
1546                                                             backslash_char,
1547                                                             &name_string);
1548                                                 append_char(*source_p,
1549                                                             &name_string);
1550                                                 string_start = source_p+1;
1551                                                 goto macro_value_start;
1552                                         } else {
1553                                             if (source->fd >= 0) {
1554                                                 line_number++;
1555                                             }
1556                                         }
1557                                         break;
1558                                 case newline_char:
1559                                 case numbersign_char:
1560                                         string_start = source_p;
1561                                         goto macro_value_end;
1562                                 case tab_char:
1563                                 case space_char:
1564                                         break;
1565                                 default:
1566                                         string_start = source_p;
1567                                         goto macro_value_start;
1568                                 }
1569                         }
1570                 macro_value_start:
1571                         /* Find the end of the value */
1572                         for (; 1; source_p++) {
1573                                 if (distance != 0) {
1574                                         *source_p = *(source_p + distance);
1575                                 }
1576                                 switch (GET_CHAR()) {
1577                                 case nul_char:
1578                                         if (!macro_seen_in_string) {
1579                                                 macro_seen_in_string = true;
1580                                                 INIT_STRING_FROM_STACK(name_string,
1581                                                                        name_buffer);
1582                                         }
1583                                         append_string(string_start,
1584                                                       &name_string,
1585                                                       source_p - string_start);
1586                                         GET_NEXT_BLOCK(source);
1587                                         string_start = source_p;
1588                                         source_p--;
1589                                         if (source == NULL) {
1590                                                 GOTO_STATE(on_eoln_state);
1591                                         }
1592                                         break;
1593                                 case backslash_char:
1594                                         source_p++;
1595                                         if (distance != 0) {
1596                                                 *source_p =
1597                                                   *(source_p + distance);
1598                                         }
1599                                         if (*source_p == (int) nul_char) {
1600                                                 if (!macro_seen_in_string) {
1601                                                         macro_seen_in_string =
1602                                                           true;
1603                                                         INIT_STRING_FROM_STACK(name_string,
1604                                                                                name_buffer);
1605                                                 }
1606 
1607 /*  BID_1225561 */
1608                                                 *(source_p - 1) = (int) space_char;
1609                                                 append_string(string_start,
1610                                                               &name_string,
1611                                                               source_p -
1612                                                               string_start - 1);
1613                                                 GET_NEXT_BLOCK(source);
1614                                                 string_start = source_p;
1615                                                 if (source == NULL) {
1616                                                         GOTO_STATE(on_eoln_state);
1617                                                 }
1618                                                 if (distance != 0) {
1619                                                         *source_p =
1620                                                           *(source_p +
1621                                                             distance);
1622                                                 }
1623                                                 if (*source_p == (int) newline_char) {
1624                                                         append_char((int) space_char, &name_string);
1625                                                 } else {
1626                                                         append_char((int) backslash_char, &name_string);
1627                                                 }
1628 /****************/
1629                                         }
1630                                         if (*source_p == (int) newline_char) {
1631                                                 source_p--;
1632                                                 line_number++;
1633                                                 distance++;
1634                                                 *source_p = (int) space_char;
1635                                                 while ((*(source_p +
1636                                                           distance + 1) ==
1637                                                         (int) tab_char) ||
1638                                                        (*(source_p +
1639                                                           distance + 1) ==
1640                                                         (int) space_char)) {
1641                                                         distance++;
1642                                                 }
1643                                         }
1644                                         break;
1645                                 case newline_char:
1646                                 case numbersign_char:
1647                                         goto macro_value_end;
1648                                 }
1649                         }
1650                 macro_value_end:
1651                         /* Complete the value in the string */
1652                         if (!macro_seen_in_string) {
1653                                 macro_seen_in_string = true;
1654                                 INIT_STRING_FROM_STACK(name_string,
1655                                                        name_buffer);
1656                         }
1657                         append_string(string_start,
1658                                       &name_string,
1659                                       source_p - string_start);
1660                         if (name_string.buffer.start != name_string.text.p) {
1661                                         macro_value =
1662                                           GETNAME(name_string.buffer.start,
1663                                                   FIND_LENGTH);
1664                                 }
1665                         if (name_string.free_after_use) {
1666                                 retmem(name_string.buffer.start);
1667                         }
1668                         for (; distance > 0; distance--) {
1669                                 *source_p++ = (int) space_char;
1670                         }
1671                         GOTO_STATE(on_eoln_state);
1672                 }
1673         }
1674 
1675 /****************************************************************
1676  *      enter dependencies state
1677  */
1678  case enter_dependencies_state:
1679  enter_dependencies_label:
1680 /* Expects pointer on first non whitespace char after last dependency. (On */
1681 /* next line.) We end up here after having read a "targets : dependencies" */
1682 /* line. The state checks if there is a rule to read and if so dispatches */
1683 /* to scan_command_state scan_command_state reads one rule line and the */
1684 /* returns here */
1685 
1686         /* First check if the first char on the next line is special */
1687         switch (GET_CHAR()) {
1688         case nul_char:
1689                 GET_NEXT_BLOCK(source);
1690                 if (source == NULL) {
1691                         break;
1692                 }
1693                 goto enter_dependencies_label;
1694         case exclam_char:
1695                 /* The line should be evaluate before it is read */
1696                 macro_seen_in_string = false;
1697                 string_start = source_p + 1;
1698                 for (; 1; source_p++) {
1699                         switch (GET_CHAR()) {
1700                         case newline_char:
1701                                 goto eoln_2;
1702                         case nul_char:
1703                                 if (source->fd > 0) {
1704                                         if (!macro_seen_in_string) {
1705                                                 macro_seen_in_string = true;
1706                                                 INIT_STRING_FROM_STACK(name_string,
1707                                                                        name_buffer);
1708                                         }
1709                                         append_string(string_start,
1710                                                       &name_string,
1711                                                       source_p - string_start);
1712                                         GET_NEXT_BLOCK(source);
1713                                         string_start = source_p;
1714                                         source_p--;
1715                                         break;
1716                                 }
1717                         eoln_2:
1718                                 if (!macro_seen_in_string) {
1719                                         INIT_STRING_FROM_STACK(name_string,
1720                                                                name_buffer);
1721                                 }
1722                                 append_string(string_start,
1723                                               &name_string,
1724                                               source_p - string_start);
1725                                 extrap = (Source)
1726                                   alloca((int) sizeof (Source_rec));
1727                                 extrap->string.buffer.start = NULL;
1728                                 extrap->inp_buf =
1729                                   extrap->inp_buf_ptr =
1730                                     extrap->inp_buf_end = NULL;
1731                                 extrap->error_converting = false;
1732                                 expand_value(GETNAME(name_string.buffer.start,
1733                                                      FIND_LENGTH),
1734                                              &extrap->string,
1735                                              false);
1736                                 if (name_string.free_after_use) {
1737                                         retmem(name_string.buffer.start);
1738                                 }
1739                                 UNCACHE_SOURCE();
1740                                 extrap->string.text.p =
1741                                   extrap->string.buffer.start;
1742                                 extrap->fd = -1;
1743                                 extrap->previous = source;
1744                                 source = extrap;
1745                                 CACHE_SOURCE(0);
1746                                 goto enter_dependencies_label;
1747                         }
1748                 }
1749         case dollar_char:
1750                 if (source->already_expanded) {
1751                         break;
1752                 }
1753                 source_p++;
1754                 UNCACHE_SOURCE();
1755                 {
1756                         Source t = (Source) alloca((int) sizeof (Source_rec));
1757                         source = push_macro_value(t,
1758                                                   buffer,
1759                                                   sizeof buffer,
1760                                                   source);
1761                 }
1762                 CACHE_SOURCE(0);
1763                 goto enter_dependencies_label;
1764         case numbersign_char:
1765                 if (makefile_type != reading_makefile) {
1766                         source_p++;
1767                         GOTO_STATE(scan_command_state);
1768                 }
1769                 for (; 1; source_p++) {
1770                         switch (GET_CHAR()) {
1771                         case nul_char:
1772                                 GET_NEXT_BLOCK_NOCHK(source);
1773                                 if (source == NULL) {
1774                                         GOTO_STATE(on_eoln_state);
1775                                 }
1776                                 if (source->error_converting) {
1777                                 // Illegal byte sequence - skip its first byte
1778                                         source->inp_buf_ptr++;
1779                                 }
1780                                 source_p--;
1781                                 break;
1782                         case backslash_char:
1783                                 if (*++source_p == (int) nul_char) {
1784                                         GET_NEXT_BLOCK_NOCHK(source);
1785                                         if (source == NULL) {
1786                                                 GOTO_STATE(on_eoln_state);
1787                                         }
1788                                         if (source->error_converting) {
1789                                         // Illegal byte sequence - skip its first byte
1790                                                 source->inp_buf_ptr++;
1791                                                 source_p--;
1792                                                 break;
1793                                         }
1794                                 }
1795                                 if(*source_p == (int) newline_char) {
1796                                         if (source->fd >= 0) {
1797                                                 line_number++;
1798                                         }
1799                                 }
1800                                 break;
1801                         case newline_char:
1802                                 source_p++;
1803                                 if (source->fd >= 0) {
1804                                         line_number++;
1805                                 }
1806                                 goto enter_dependencies_label;
1807                         }
1808                 }
1809 
1810         case tab_char:
1811                 GOTO_STATE(scan_command_state);
1812         }
1813 
1814         /* We read all the command lines for the target/dependency line. */
1815         /* Enter the stuff */
1816         enter_target_groups_and_dependencies( &target, &depes, command, 
1817                                              separator, target_group_seen);
1818 
1819         goto start_new_line;
1820 
1821 /****************************************************************
1822  *      scan command state
1823  */
1824 case scan_command_state:
1825         /* We need to read one rule line. Do that and return to */
1826         /* the enter dependencies state */
1827         string_start = source_p;
1828         macro_seen_in_string = false;
1829         for (; 1; source_p++) {
1830                 switch (GET_CHAR()) {
1831                 case backslash_char:
1832                         if (!macro_seen_in_string) {
1833                                 INIT_STRING_FROM_STACK(name_string,
1834                                                        name_buffer);
1835                         }
1836                         append_string(string_start,
1837                                       &name_string,
1838                                       source_p - string_start);
1839                         macro_seen_in_string = true;
1840                         if (*++source_p == (int) nul_char) {
1841                                 GET_NEXT_BLOCK(source);
1842                                 if (source == NULL) {
1843                                         string_start = source_p;
1844                                         goto command_newline;
1845                                 }
1846                         }
1847                         append_char((int) backslash_char, &name_string);
1848                         append_char(*source_p, &name_string);
1849                         if (*source_p == (int) newline_char) {
1850                                 if (source->fd >= 0) {
1851                                         line_number++;
1852                                 }
1853                                 if (*++source_p == (int) nul_char) {
1854                                         GET_NEXT_BLOCK(source);
1855                                         if (source == NULL) {
1856                                                 string_start = source_p;
1857                                                 goto command_newline;
1858                                         }
1859                                 }
1860                                 if (*source_p == (int) tab_char) {
1861                                         source_p++;
1862                                 }
1863                         } else {
1864                                 if (*++source_p == (int) nul_char) {
1865                                         GET_NEXT_BLOCK(source);
1866                                         if (source == NULL) {
1867                                                 string_start = source_p;
1868                                                 goto command_newline;
1869                                         }
1870                                 }
1871                         }
1872                         string_start = source_p;
1873                         if ((*source_p == (int) newline_char) ||
1874                             (*source_p == (int) backslash_char) ||
1875                             (*source_p == (int) nul_char)) {
1876                                 source_p--;
1877                         }
1878                         break;
1879                 case newline_char:
1880                 command_newline:
1881                         if ((string_start != source_p) ||
1882                             macro_seen_in_string) {
1883                                 if (macro_seen_in_string) {
1884                                         append_string(string_start,
1885                                                       &name_string,
1886                                                       source_p - string_start);
1887                                         string_start =
1888                                           name_string.buffer.start;
1889                                         string_end = name_string.text.p;
1890                                 } else {
1891                                         string_end = source_p;
1892                                 }
1893                                 while ((*string_start != (int) newline_char) &&
1894                                        iswspace(*string_start)){
1895                                         string_start++;
1896                                 }
1897                                 if ((string_end > string_start) ||
1898                                     (makefile_type == reading_statefile)) {
1899                                         if (command_tail == NULL) {
1900                                                 command =
1901                                                   command_tail =
1902                                                     ALLOC(Cmd_line);
1903                                         } else {
1904                                                 command_tail->next =
1905                                                   ALLOC(Cmd_line);
1906                                                 command_tail =
1907                                                   command_tail->next;
1908                                         }
1909                                         command_tail->next = NULL;
1910                                         command_tail->make_refd = false;
1911                                         command_tail->ignore_command_dependency = false;
1912                                         command_tail->assign = false;
1913                                         command_tail->ignore_error = false;
1914                                         command_tail->silent = false;
1915                                         command_tail->command_line =
1916                                           GETNAME(string_start,
1917                                                   string_end - string_start);
1918                                         if (macro_seen_in_string &&
1919                                             name_string.free_after_use) {
1920                                                 retmem(name_string.
1921                                                        buffer.start);
1922                                         }
1923                                 }
1924                         }
1925                         do {
1926                                 if ((source != NULL) && (source->fd >= 0)) {
1927                                         line_number++;
1928                                 }
1929                                 if ((source != NULL) &&
1930                                     (*++source_p == (int) nul_char)) {
1931                                         GET_NEXT_BLOCK(source);
1932                                         if (source == NULL) {
1933                                                 GOTO_STATE(on_eoln_state);
1934                                         }
1935                                 }
1936                         } while (*source_p == (int) newline_char);
1937 
1938                         GOTO_STATE(enter_dependencies_state);
1939                 case nul_char:
1940                         if (!macro_seen_in_string) {
1941                                 INIT_STRING_FROM_STACK(name_string,
1942                                                        name_buffer);
1943                         }
1944                         append_string(string_start,
1945                                       &name_string,
1946                                       source_p - string_start);
1947                         macro_seen_in_string = true;
1948                         GET_NEXT_BLOCK(source);
1949                         string_start = source_p;
1950                         source_p--;
1951                         if (source == NULL) {
1952                                 GOTO_STATE(enter_dependencies_state);
1953                         }
1954                         break;
1955                 }
1956         }
1957 
1958 /****************************************************************
1959  *      enter equal state
1960  */
1961 case enter_equal_state:
1962         if (target.used != 1) {
1963                 GOTO_STATE(poorly_formed_macro_state);
1964         }
1965         enter_equal(target.names[0], macro_value, append);
1966         goto start_new_line;
1967 
1968 /****************************************************************
1969  *      enter conditional state
1970  */
1971 case enter_conditional_state:
1972         if (depes.used != 1) {
1973                 GOTO_STATE(poorly_formed_macro_state);
1974         }
1975         for (nvp = &target; nvp != NULL; nvp = nvp->next) {
1976                 for (i = 0; i < nvp->used; i++) {
1977                         enter_conditional(nvp->names[i],
1978                                           depes.names[0],
1979                                           macro_value,
1980                                           append);
1981                 }
1982         }
1983         goto start_new_line;
1984 
1985 /****************************************************************
1986  *      Error states
1987  */
1988 case illegal_bytes_state:
1989         fatal_reader(gettext("Invalid byte sequence"));
1990 case illegal_eoln_state:
1991         if (line_number > 1) {
1992                 if (line_started_with_space == (line_number - 1)) {
1993                         line_number--;
1994                         fatal_reader(gettext("Unexpected end of line seen\n\t*** missing separator (did you mean TAB instead of 8 spaces?)"));
1995                 }
1996         }
1997         fatal_reader(gettext("Unexpected end of line seen"));
1998 case poorly_formed_macro_state:
1999         fatal_reader(gettext("Badly formed macro assignment"));
2000 case exit_state:
2001         return;
2002 default:
2003         fatal_reader(gettext("Internal error. Unknown reader state"));
2004 }
2005 }
2006 
2007 /*
2008  *      push_macro_value(bp, buffer, size, source)
2009  *
2010  *      Macro and function that evaluates one macro
2011  *      and makes the reader read from the value of it
2012  *
2013  *      Return value:
2014  *                              The source block to read the macro from
2015  *
2016  *      Parameters:
2017  *              bp              The new source block to fill in
2018  *              buffer          Buffer to read from
2019  *              size            size of the buffer
2020  *              source          The old source block
2021  *
2022  *      Global variables used:
2023  */
2024 static Source
2025 push_macro_value(register Source bp, register wchar_t *buffer, int size, register Source source)
2026 {
2027         bp->string.buffer.start = bp->string.text.p = buffer;
2028         bp->string.text.end = NULL;
2029         bp->string.buffer.end = buffer + (size/SIZEOFWCHAR_T);
2030         bp->string.free_after_use = false;
2031         bp->inp_buf =
2032           bp->inp_buf_ptr =
2033             bp->inp_buf_end = NULL;
2034         bp->error_converting = false;
2035         expand_macro(source, &bp->string, (wchar_t *) NULL, false);
2036         bp->string.text.p = bp->string.buffer.start;
2037 
2038         /* 4209588: 'make' doesn't understand a macro with whitespaces in the head as target.
2039          * strip whitespace from the begining of the macro value
2040          */
2041         while (iswspace(*bp->string.text.p)) {
2042                 bp->string.text.p++;
2043         }
2044 
2045         bp->fd = -1;
2046         bp->already_expanded = true;
2047         bp->previous = source;
2048         return bp;
2049 }
2050 
2051 /*
2052  *      enter_target_groups_and_dependencies(target, depes, command, separator,
2053  *                                           target_group_seen)
2054  *
2055  *      Parameters:
2056  *              target          Structure that shows the target(s) on the line
2057  *                              we are currently parsing. This can looks like
2058  *                              target1 .. targetN : dependencies
2059  *                                                      commands
2060  *                              or
2061  *                              target1 + .. + targetN : dependencies
2062  *                                                       commands
2063  *              depes           Dependencies
2064  *              command         Points to the command(s) to be executed for 
2065  *                              this target.
2066  *              separator       : or :: or :=
2067  *              target_group_seen       Set if we have target1 + .. + targetN
2068  *              
2069  *              
2070  *      After reading the command lines for a target, this routine 
2071  *      is called to setup the dependencies and the commands for it.
2072  *      If the target is a % pattern or part of a target group, then 
2073  *      the appropriate routines are called.
2074  */
2075         
2076 void
2077 enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen)
2078 {
2079         int                     i;
2080         Boolean                 reset= true;
2081         Chain                   target_group_member;
2082         Percent                 percent_ptr;
2083 
2084         for (; target != NULL; target = target->next) {
2085                 for (i = 0; i < target->used; i++) {
2086                         if (target->names[i] != NULL) {
2087                                 if (target_group_seen) {
2088                                         target_group_member =
2089                                           find_target_groups(target, i, reset);
2090                                         if(target_group_member == NULL) {
2091                                                 fatal_reader(gettext("Unexpected '+' on dependency line"));
2092                                         }
2093                                 }
2094                                 reset = false;
2095 
2096                                 /* If we saw it in the makefile it must be
2097                                  * a file */
2098                                 target->names[i]->stat.is_file = true;
2099                                 /* Make sure that we use dependencies 
2100                                  * entered for makefiles */
2101                                 target->names[i]->state = build_dont_know;
2102 
2103                                 /* If the target is special we delegate 
2104                                  * the processing */
2105                                 if (target->names[i]->special_reader 
2106                                     != no_special) {
2107                                         special_reader(target->names[i], 
2108                                                        depes, 
2109                                                        command);
2110                                 }       
2111                                 /* Check if this is a "a%b : x%y" type rule */
2112                                 else if (target->names[i]->percent) {
2113                                         percent_ptr = 
2114                                           enter_percent(target->names[i], 
2115                                                         target->target_group[i], 
2116                                                         depes, command);
2117                                         if (target_group_seen) {
2118                                                 target_group_member->percent_member =
2119                                                   percent_ptr;
2120                                         }
2121                                 } else if (target->names[i]->dollar) {
2122                                         enter_dyntarget(target->names[i]);
2123                                         enter_dependencies
2124                                           (target->names[i],
2125                                            target->target_group[i],
2126                                            depes,       
2127                                            command,
2128                                            separator);
2129                                 } else {
2130                                         if (target_group_seen) {
2131                                                 target_group_member->percent_member =
2132                                                   NULL;
2133                                         }
2134                                 
2135                                         enter_dependencies
2136                                           (target->names[i],
2137                                            target->target_group[i],
2138                                            depes,       
2139                                            command,
2140                                            separator);
2141                                 }
2142                         }
2143                 }
2144         }
2145 }
2146                                      
2147