dmake/dmake.c

   1 /* $RCSfile: dmake.c,v $
   2 -- $Revision: 1.13 $
   3 -- last change: $Author: kz $ $Date: 2008-03-05 18:28:04 $
   4 --
   5 -- SYNOPSIS
   6 --      The main program.
   7 --
   8 -- DESCRIPTION
   9 --
  10 --  dmake [-#dbug_string] [ options ]
  11 --          [ macro definitions ] [ target ... ]
  12 --
  13 --  This file contains the main command line parser for the
  14 --  make utility.  The valid flags recognized are as follows:
  15 --
  16 --  -f file         - use file as the makefile
  17 --  -C file     - duplicate console output to file (MSDOS only)
  18 --  -K file     - .KEEP_STATE file
  19 --  -#dbug_string   - dump out debugging info, see below
  20 --  -v[cdfimrtw]    - verbose, print what we are doing, as we do it
  21 --  -m[trae]    - measure timing information
  22 --
  23 --   options: (can be catenated, ie -irn == -i -r -n)
  24 --
  25 --  -A      - enable AUGMAKE special target mapping
  26 --  -B      - enable non-use of TABS to start recipe lines
  27 --  -c      - use non-standard comment scanning
  28 --      -d              - do not use directory cache
  29 --  -i              - ignore errors
  30 --  -n              - trace and print, do not execute commands
  31 --  -t              - touch, update dates without executing commands
  32 --  -T              - do not apply transitive closure on inference rules
  33 --  -r              - don't use internal rules
  34 --  -s              - do your work silently
  35 --  -S      - force Sequential make, overrides -P
  36 --  -q              - check if target is up to date.  Does not
  37 --            do anything.  Returns 0 if up to date, -1
  38 --            otherwise.
  39 --  -p              - print out a version of the makefile
  40 --  -P#     - set value of MAXPROCESS
  41 --  -E              - define environment strings as macros
  42 --  -e              - as -E but done after parsing makefile
  43 --  -u              - force unconditional update of target
  44 --  -k              - make all independent targets even if errors
  45 --  -V              - print out this make version number
  46 --  -M      - Microsoft make compatibility, (* disabled *)
  47 --  -h              - print out usage info
  48 --  -x      - export macro defs to environment
  49 --      -X              - ignore #! lines found in makefile
  50 --
  51 --  NOTE:  - #ddbug_string is only availabe for versions of dmake that
  52 --      have been compiled with -DDBUG switch on.  Not the case for
  53 --      distributed versions.  Any such versions must be linked
  54 --      together with a version of Fred Fish's debug code.
  55 --
  56 --  NOTE:  - in order to compile the code the include file stddef.h
  57 --      must be shipped with the bundled code.
  58 --
  59 -- AUTHOR
  60 --      Dennis Vadura, dvadura@dmake.wticorp.com
  61 --
  62 -- WWW
  63 --      http://dmake.wticorp.com/
  64 --
  65 -- COPYRIGHT
  66 --      Copyright (c) 1996,1997 by WTI Corp.  All rights reserved.
  67 --
  68 --      This program is NOT free software; you can redistribute it and/or
  69 --      modify it under the terms of the Software License Agreement Provided
  70 --      in the file <distribution-root>/readme/license.txt.
  71 --
  72 -- LOG
  73 --      Use cvs log to obtain detailed change logs.
  74 */
  75
  76 /* Set this flag to one, and the global variables in vextern.h will not
  77  * be defined as 'extern', instead they will be defined as global vars
  78  * when this module is compiled. */
  79 #define _DEFINE_GLOBALS_ 1
  80
  81 #include "extern.h" /* this includes config.h */
  82 #include "sysintf.h"
  83
  84 #ifndef MSDOS
  85 #define USAGE \
  86 "Usage:\n%s [-P#] [-{f|K} file] [-{w|W} target ...] [macro[!][[*][+][:]]=value ...]\n"
  87 #define USAGE2 \
  88 "%s [-v[cdfimrtw]] [-m[trae]] [-ABcdeEghiknpqrsStTuVxX] [target ...]\n"
  89 #else
  90 #define USAGE \
  91 "Usage:\n%s [-P#] [-{f|C|K} file] [-{w|W} target ...] [macro[!][[*][+][:]]=value ...]\n"
  92 #define USAGE2 \
  93 "%s [-v[cdfimrtw]] [-m[trae]] [-ABcdeEghiknpqrsStTuVxX] [target ...]\n"
  94 #endif
  95
  96 /* We don't use va_end at all, so define it out so that it doesn't produce
  97  * lots of "Value not used" warnings. */
  98 #ifdef va_end
  99 #undef va_end
 100 #endif
 101 #define va_end(expand_to_null)
 102
 103 /* Make certain that ARG macro is correctly defined. */
 104 #ifdef ARG
 105 #undef ARG
 106 #endif
 107 #define ARG(a,b) a b
 108
 109 static char *sccid = "Copyright (c) 1990,...,1997 by WTI Corp.";
 110 static char _warn  = TRUE;      /* warnings on by default */
 111
 112 static  void    _do_VPATH();
 113 static  void    _do_ReadEnvironment();
 114 #if !defined(__GNUC__) && !defined(__IBMC__)
 115 static  void    _do_f_flag ANSI((char, char *, char **));
 116 #else
 117 static  void    _do_f_flag ANSI((int, char *, char **));
 118 #endif
 119
 120 PUBLIC int
 121 main(argc, argv)
 122 int  argc;
 123 char **argv;
 124 {
 125 #ifdef MSDOS
 126    char*   std_fil_name = NIL(char);
 127 #endif
 128
 129    char*   fil_name = NIL(char);
 130    char*   state_name = NIL(char);
 131    char*   whatif = NIL(char);
 132    char*   cmdmacs;
 133    char*   targets;
 134    STRINGPTR cltarget = NIL(STRING); /* list of targets from command line. */
 135    STRINGPTR cltarget_first = NIL(STRING); /* Pointer to first element. */
 136    FILE*   mkfil;
 137    int     ex_val;
 138    int     m_export;
 139
 140    /* Uncomment the following line to pass commands to the DBUG engine
 141     * before the command line switches (-#..) are evaluated. */
 142    /*
 143    DB_PUSH("d,path");
 144     */
 145    DB_ENTER("main");
 146
 147    /* Initialize Global variables to their default values       */
 148    Prolog(argc, argv);
 149    /* Set internal macros to their initial values, some are changed
 150     * later again by Make_rules() that parses the values from ruletab.c. */
 151    Create_macro_vars();
 152    Catch_signals(Quit);
 153
 154    /* This macro is only defined for some OSs, see sysintf.c for details *
 155     * and NULL if undefined.                                             */
 156    Def_macro("ABSMAKECMD", AbsPname, M_PRECIOUS|M_NOEXPORT|M_EXPANDED );
 157
 158    Def_macro( "MAKECMD", Pname, M_PRECIOUS|M_NOEXPORT|M_EXPANDED );
 159    Pname = Basename(Pname);
 160
 161    DB_PROCESS(Pname);
 162    (void) setvbuf(stdout, NULL, _IOLBF, BUFSIZ); /* stdout line buffered */
 163
 164    Continue  = FALSE;
 165    Comment   = FALSE;
 166    Get_env   = FALSE;
 167    Force     = FALSE;
 168    Target    = FALSE;
 169    If_expand = FALSE;
 170    Listing   = FALSE;
 171    Readenv   = FALSE;
 172    Rules     = TRUE;
 173    Trace     = FALSE;
 174    Touch     = FALSE;
 175    Check     = FALSE;
 176    Microsoft = FALSE;
 177    Makemkf   = FALSE;
 178    UseWinpath= FALSE;
 179    No_exec   = FALSE;
 180    m_export  = FALSE;
 181    cmdmacs   = NIL(char);
 182    targets   = NIL(char);
 183    Is_exec_shell = FALSE;
 184    Shell_exec_target = NIL(CELL);
 185    stdout_redir = NIL(FILE);
 186
 187    /* Get fd for for @@-recipe silencing. */
 188    if( (zerofd = open(NULLDEV, O_WRONLY)) == -1 )
 189       Fatal( "Error opening %s !", NULLDEV );
 190
 191    Verbose     = V_NOFLAG;
 192    Measure     = M_NOFLAG;
 193    Transitive  = TRUE;
 194    Nest_level  = 0;
 195    Line_number = 0;
 196    Suppress_temp_file = FALSE;
 197    Skip_to_eof = FALSE;
 198
 199    while( --argc > 0 ) {
 200       register char *p;
 201       char *q;
 202
 203       if( *(p = *++argv) == '-' ) {
 204          if( p[1] == '\0' ) Fatal("Missing option letter");
 205
 206          /* copy options to Buffer for $(MFLAGS), strip 'f' and 'C'*/
 207          q = strchr(Buffer, '\0');
 208          while (*p != '\0') {
 209         char c = (*q++ = *p++);
 210             if( c == 'f' || c == 'C' ) q--;
 211      }
 212
 213      if( *(q-1) == '-' )
 214         q--;
 215      else
 216             *q++ = ' ';
 217
 218      *q = '\0';
 219
 220          for( p = *argv+1; *p; p++) switch (*p) {
 221         case 'f':
 222            _do_f_flag( 'f', *++argv, &fil_name ); argc--;
 223            break;
 224
 225 #if defined(MSDOS) && !defined(OS2)
 226         case 'C':
 227            _do_f_flag( 'C', *++argv, &std_fil_name ); argc--;
 228            Hook_std_writes( std_fil_name );
 229            break;
 230 #endif
 231
 232         case 'K':
 233            _do_f_flag( 'K', *++argv, &state_name ); argc--;
 234            Def_macro(".KEEP_STATE", state_name, M_EXPANDED|M_PRECIOUS);
 235            break;
 236
 237         case 'W':
 238         case 'w': {
 239            CELLPTR wif;
 240            _do_f_flag( 'w', *++argv, &whatif ); argc--;
 241            wif = Def_cell(whatif);
 242            wif->ce_attr |= A_WHATIF;
 243            whatif = NIL(char);
 244
 245            if ( *p == 'W')
 246           break;
 247         }
 248         /*FALLTHRU*/
 249
 250         case 'n':
 251            Trace = TRUE;
 252            break;
 253
 254         case 'k': Continue   = TRUE;  break;
 255         case 'c': Comment    = TRUE;  break;
 256         case 'p': Listing    = TRUE;  break;
 257         case 'r': Rules      = FALSE; break;
 258         case 't': Touch      = TRUE;  break;
 259         case 'q': Check      = TRUE;  break;
 260         case 'u': Force      = TRUE;  break;
 261         case 'x': m_export   = TRUE;  break;
 262         case 'X': No_exec    = TRUE;  break;
 263         case 'T': Transitive = FALSE; break;
 264         case 'e': Get_env    = 'e';   break;
 265         case 'E': Get_env    = 'E';   break;
 266
 267         case 'V': Version();  Quit(0);  break;
 268         case 'A': Def_macro("AUGMAKE", "y", M_EXPANDED); break;
 269         case 'B': Def_macro(".NOTABS", "y", M_EXPANDED); break;
 270         case 'i': Def_macro(".IGNORE", "y", M_EXPANDED); break;
 271         case 's': Def_macro(".SILENT", "y", M_EXPANDED); break;
 272         case 'S': Def_macro(".SEQUENTIAL", "y", M_EXPANDED); break;
 273         case 'g': Def_macro(".IGNOREGROUP","y", M_EXPANDED); break;
 274         case 'd': Def_macro(".DIRCACHE",NIL(char),M_EXPANDED); break;
 275
 276         case 'v':
 277            if( p[-1] != '-' ) Usage(TRUE);
 278            while( p[1] ) switch( *++p ) {
 279           case 'c': Verbose |= V_DIR_CACHE; break;
 280           case 'd': Verbose |= V_DIR_SET;   break;
 281           case 'f': Verbose |= V_FILE_IO;   break;
 282           case 'i': Verbose |= V_INFER;     break;
 283           case 'm': Verbose |= V_MAKE;      break;
 284                   case 'r': Verbose |= V_FORCEECHO; break;
 285           case 't': Verbose |= V_LEAVE_TMP; break;
 286                   case 'w': Verbose |= V_WARNALL;   break;
 287
 288           default: Usage(TRUE); break;
 289            }
 290            if( !Verbose ) Verbose = V_ALL;
 291                if( Verbose & V_FORCEECHO ) {
 292                  HASHPTR hp;
 293                  /* This cleans the .SILENT setting */
 294                  hp = Def_macro(".SILENT", "", M_EXPANDED);
 295                  /* This overrides the bitmask for further occurrences of
 296                   * .SILENT to "no bits allowed", see bit variables in the
 297                   * set_macro_value() definition in dag.c.
 298                   * The bitmask is already set by Create_macro_vars() in
 299                   * imacs.c and is overridden for the V_FORCEECHO case. */
 300                  hp->MV_MASK  = A_DEFAULT;
 301                }
 302            break;
 303
 304         case 'm':
 305            if( p[-1] != '-' ) Usage(TRUE);
 306            while( p[1] ) switch( *++p ) {
 307           case 't': Measure |= M_TARGET;    break;
 308           case 'r': Measure |= M_RECIPE;    break;
 309           case 'a': Measure |= M_ABSPATH;   break;
 310           case 'e': Measure |= M_SHELLESC;  break;
 311
 312           default: Usage(TRUE); break;
 313            }
 314            if( !Measure ) Measure = M_TARGET;
 315            break;
 316
 317         case 'P':
 318            if( p[1] ) {
 319           /* Only set MAXPROCESS if -S flag is *not* used. */
 320           if( !(Glob_attr & A_SEQ) ) {
 321              Def_macro( "MAXPROCESS", p+1, M_MULTI|M_EXPANDED );
 322           }
 323           p += strlen(p)-1;
 324            }
 325            else
 326           Fatal( "Missing number for -P flag" );
 327            break;
 328
 329 #ifdef DBUG
 330         case '#':
 331            DB_PUSH(p+1);
 332            p += strlen(p)-1;
 333            break;
 334 #endif
 335
 336         case 'h': Usage(FALSE); break;
 337         case 0:   break;    /* lone - */
 338         default:  Usage(TRUE);  break;
 339      }
 340       }
 341       else if( (q = strchr(p, '=')) != NIL(char) ) {
 342      cmdmacs = DmStrAdd( cmdmacs, DmStrDup2(p), TRUE );
 343      /* Macros defined on the command line are marked precious.
 344       * FIXME: The exception for += appears to be bogus. */
 345      Parse_macro( p, (q[-1]!='+')?M_PRECIOUS:M_DEFAULT );
 346       }
 347       else {
 348      /* Remember the targets from the command line. */
 349      register STRINGPTR nsp;
 350
 351      targets = DmStrAdd( targets, DmStrDup(p), TRUE );
 352
 353      TALLOC(nsp, 1, STRING);
 354      nsp->st_string = DmStrDup( p );
 355      nsp->st_next = NIL(STRING);
 356
 357      if(cltarget != NIL(STRING) )
 358         cltarget->st_next = nsp;
 359      else
 360         cltarget_first = nsp;
 361
 362      cltarget = nsp;
 363       }
 364    }
 365
 366    Def_macro( "MAKEMACROS",  cmdmacs, M_PRECIOUS|M_NOEXPORT );
 367    Def_macro( "MAKETARGETS", targets, M_PRECIOUS|M_NOEXPORT );
 368    if( cmdmacs != NIL(char) ) FREE(cmdmacs);
 369    if( targets != NIL(char) ) FREE(targets);
 370
 371    Def_macro( "MFLAGS", Buffer, M_PRECIOUS|M_NOEXPORT );
 372    Def_macro( "%", "$@", M_PRECIOUS|M_NOEXPORT );
 373
 374    if( *Buffer ) Def_macro( "MAKEFLAGS", Buffer+1, M_PRECIOUS|M_NOEXPORT );
 375
 376    _warn  = FALSE;  /* disable warnings for builtin rules */
 377    Target = TRUE;   /* make sure we don't mark any of the default rules as
 378              * potential targets. */
 379    Make_rules();    /* Parse the strings stored in Rule_tab. */
 380    _warn = TRUE;
 381
 382    /* If -r was not given find and parse startup-makefile. */
 383    if( Rules )
 384    {
 385      char *fname = NIL(char);
 386
 387      /* Search_file() also checks the environment variable. */
 388      if( (mkfil=Search_file("MAKESTARTUP", &fname)) != NIL(FILE) )
 389      {
 390        Parse(mkfil);
 391        Def_macro( "MAKESTARTUP", fname, M_EXPANDED|M_MULTI|M_FORCE );
 392      }
 393      else
 394        Fatal( "Configuration file `%s' not found", fname );
 395      if ( fname != NIL(char)) { FREE( fname ); fname = NIL(char); }
 396    }
 397
 398    /* Define the targets set on the command line now. */
 399    Target = FALSE;  /* Will be set to TRUE when the default targets are set. */
 400    for( cltarget = cltarget_first; cltarget != NIL(STRING); ) {
 401       CELLPTR cp;
 402       STRINGPTR nta = cltarget->st_next;
 403
 404       Add_prerequisite(Targets, cp = Def_cell(cltarget->st_string),
 405                FALSE, FALSE);
 406       cp->ce_flag |= F_TARGET;
 407       cp->ce_attr |= A_FRINGE;
 408       Target = TRUE;
 409
 410       FREE(cltarget->st_string);
 411       FREE(cltarget);
 412       cltarget = nta;
 413    }
 414
 415    if( Get_env == 'E' ) _do_ReadEnvironment();
 416
 417    /* Search for and parse user makefile. */
 418    if( fil_name != NIL(char) )
 419       mkfil = Openfile( fil_name, FALSE, TRUE );
 420    else {
 421       /* Search .MAKEFILES dependent list looking for a makefile.
 422        */
 423       register CELLPTR cp;
 424
 425       cp = Def_cell( ".MAKEFILES" );
 426       mkfil = TryFiles(cp->CE_PRQ);
 427    }
 428
 429    if( mkfil != NIL(FILE) ) {
 430       char *f = Filename();
 431       char *p;
 432
 433       if( strcmp(f, "stdin") == 0 ) f = "-";
 434       Def_macro( "MAKEFILE", p = DmStrAdd( "-f", f, FALSE ), M_PRECIOUS|M_NOEXPORT ); FREE(p);
 435       Parse( mkfil );
 436    }
 437    else if( !Rules )
 438       Fatal( "No `makefile' present" );
 439
 440    if( Nest_level     ) Fatal( "Missing .END for .IF" );
 441    if( Get_env == 'e' ) _do_ReadEnvironment();
 442
 443    _do_VPATH();                 /* kludge it up with .SOURCE    */
 444
 445    if( Listing ) Dump();        /* print out the structures     */
 446    if( Trace ) Glob_attr &= ~A_SILENT;  /* make sure we see the trace   */
 447
 448    if( !Target )
 449       Fatal( "No target" );
 450    else {
 451       Test_circle( Root, TRUE );
 452       Check_circle_dfa();
 453    }
 454
 455    if( m_export ) {
 456       int i;
 457
 458       for( i=0; i<HASH_TABLE_SIZE; ++i ) {
 459      HASHPTR hp = Macs[i];
 460
 461      while( hp ) {
 462         if( !(hp->ht_flag & M_NOEXPORT) && hp->ht_value != NIL(char) )
 463            if( Write_env_string(hp->ht_name, hp->ht_value) != 0 )
 464            Warning( "Could not export %s", hp->ht_name );
 465         hp = hp->ht_next;
 466      }
 467       }
 468    }
 469
 470    if( Buffer != NIL(char) ) {FREE( Buffer ); Buffer = NIL(char);}
 471    if( Trace ) Def_macro(".SEQUENTIAL", "y", M_EXPANDED);
 472
 473    ex_val = Make_targets();
 474
 475    Clear_signals();
 476
 477    /* Close fd for for @@-recipe silencing. */
 478    if( close(zerofd) )
 479       Fatal( "Error closing %s !", NULLDEV );
 480    Epilog(ex_val);      /* Does not return -- EVER */
 481    return 0;
 482 }
 483
 484
 485 static void
 486 _do_f_flag( flag, name, fname )
 487 char   flag;
 488 char  *name;
 489 char **fname;
 490 {
 491    if( *fname == NIL(char) ) {
 492       if( name != NIL(char) ) {
 493      *fname = name;
 494       } else
 495      Fatal("No file name for -%c", flag);
 496    } else
 497       Fatal("Only one `-%c file' allowed", flag);
 498 }
 499
 500
 501 static void
 502 _do_ReadEnvironment()
 503 {
 504    t_attr saveattr = Glob_attr;
 505
 506    Glob_attr |= A_SILENT;
 507    ReadEnvironment();
 508    Glob_attr = saveattr;
 509 }
 510
 511
 512 static void
 513 _do_VPATH()
 514 {
 515    HASHPTR hp;
 516    char    *_rl[2];
 517    extern char **Rule_tab;
 518
 519    hp = GET_MACRO("VPATH");
 520    if( hp == NIL(HASH) ) return;
 521
 522    _rl[0] = ".SOURCE :^ $(VPATH:s/:/ /)";
 523    _rl[1] = NIL(char);
 524
 525    Rule_tab = _rl;
 526    Parse( NIL(FILE) );
 527 }
 528
 529
 530 /*  The file table and pointer to the next FREE slot for use by both
 531     Openfile and Closefile.  Each open stacks the new file onto the open
 532     file stack, and a corresponding close will close the passed file, and
 533     return the next file on the stack.  The maximum number of nested
 534     include files is limited by the value of MAX_INC_DEPTH */
 535
 536 static struct {
 537    FILE         *file;      /* file pointer                 */
 538    char         *name;      /* name of file                 */
 539    int          numb;       /* line number                  */
 540 } ftab[ MAX_INC_DEPTH ];
 541
 542 static int next_file_slot = 0;
 543
 544 /* Set the proper macro value to reflect the depth of the .INCLUDE directives
 545  * and the name of the file we are reading.
 546  */
 547 static void
 548 _set_inc_depth()
 549 {
 550    char buf[10];
 551    sprintf( buf, "%d", next_file_slot );
 552    Def_macro( "INCDEPTH", buf, M_MULTI|M_NOEXPORT );
 553    Def_macro( "INCFILENAME",
 554               next_file_slot ? ftab[next_file_slot-1].name : "",
 555               M_MULTI|M_NOEXPORT|M_EXPANDED );
 556 }
 557
 558
 559 PUBLIC FILE *
 560 Openfile(name, mode, err)/*
 561 ===========================
 562    This routine opens a file for input or output depending on mode.
 563    If the file name is `-' then it returns standard input.
 564    The file is pushed onto the open file stack.  */
 565 char *name;
 566 int  mode;
 567 int  err;
 568 {
 569    FILE *fil;
 570
 571    DB_ENTER("Openfile");
 572
 573    if( name == NIL(char) || !*name ) {
 574       if( !err )
 575          DB_RETURN(NIL(FILE));
 576       else
 577          Fatal( "Openfile:  NIL filename" );
 578    }
 579
 580    if( next_file_slot == MAX_INC_DEPTH )
 581       Fatal( "Too many open files. Max nesting level is %d.", MAX_INC_DEPTH);
 582
 583    DB_PRINT( "io", ("Opening file [%s], in slot %d", name, next_file_slot) );
 584
 585    if( strcmp("-", name) == 0 ) {
 586       name = "stdin";
 587       fil = stdin;
 588    }
 589    else
 590       fil = fopen( name, mode ? "w":"r" );
 591
 592    if( Verbose & V_FILE_IO )
 593       printf( "%s:  Openning [%s] for %s", Pname, name, mode?"write":"read" );
 594
 595    if( fil == NIL(FILE) ) {
 596       if( Verbose & V_FILE_IO ) printf( " (fail)\n" );
 597       if( err )
 598          Fatal( mode ? "Cannot open file %s for write" : "File %s not found",
 599         name );
 600    }
 601    else {
 602       if( Verbose & V_FILE_IO ) printf( " (success)\n" );
 603       ftab[next_file_slot].file   = fil;
 604       ftab[next_file_slot].numb   = Line_number;
 605       ftab[next_file_slot++].name = DmStrDup(name);
 606       Line_number = 0;
 607       _set_inc_depth();
 608    }
 609
 610    DB_RETURN(fil);
 611 }
 612
 613
 614 PUBLIC FILE *
 615 Closefile()/*
 616 =============
 617    This routine is used to close the last file opened.  This forces make
 618    to open files in a last open first close fashion.  It returns the
 619    file pointer to the next file on the stack, and NULL if the stack is empty.*/
 620 {
 621    DB_ENTER("Closefile");
 622
 623    if( !next_file_slot )
 624       DB_RETURN( NIL(FILE) );
 625
 626    if( ftab[--next_file_slot].file != stdin ) {
 627       DB_PRINT( "io", ("Closing file in slot %d", next_file_slot) );
 628
 629       if( Verbose & V_FILE_IO )
 630      printf( "%s:  Closing [%s]\n", Pname, ftab[next_file_slot].name );
 631
 632       fclose( ftab[next_file_slot].file );
 633       FREE( ftab[next_file_slot].name );
 634    }
 635
 636    _set_inc_depth();
 637
 638    if( next_file_slot > 0 ) {
 639       Line_number = ftab[next_file_slot].numb;
 640       DB_RETURN( ftab[next_file_slot-1].file );
 641    }
 642    else
 643       Line_number = 0;
 644
 645    DB_RETURN( NIL(FILE) );
 646 }
 647
 648
 649 PUBLIC FILE *
 650 Search_file( macname, rname )
 651 char *macname;
 652 char **rname;
 653 {
 654    HASHPTR hp;
 655    FILE *fil = NIL(FILE);
 656    char *fname = NIL(char);
 657    char *ename = NIL(char);
 658
 659    /* order of precedence is:
 660     *
 661     *   MACNAME  from command line (precious is marked)
 662     *        ... via MACNAME:=filename definition.
 663     *   MACNAME  from environment
 664     *   MACNAME  from builtin rules (not precious)
 665     */
 666
 667    if( (hp = GET_MACRO(macname)) != NIL(HASH) ) {
 668      /* Only expand if needed. */
 669      if( hp->ht_flag & M_EXPANDED ) {
 670        ename = fname = DmStrDup(hp->ht_value);
 671      } else {
 672        ename = fname = Expand(hp->ht_value);
 673      }
 674
 675      if( hp->ht_flag & M_PRECIOUS ) fil = Openfile(fname, FALSE, FALSE);
 676    }
 677
 678    if( fil == NIL(FILE) ) {
 679      fname=Expand(Read_env_string(macname));
 680      if( (fil = Openfile(fname, FALSE, FALSE)) != NIL(FILE) ) FREE(ename);
 681    }
 682
 683    if( fil == NIL(FILE) && hp != NIL(HASH) ) {
 684      if ( fname != NIL(char) ) { FREE(fname); fname = NIL(char); }
 685      fil = Openfile(fname=ename, FALSE, FALSE);
 686    }
 687
 688    if( rname ) *rname = fname;
 689
 690    return(fil);
 691 }
 692
 693
 694 PUBLIC char *
 695 Filename()/*
 696 ============
 697    Return name of file on top of stack */
 698 {
 699    return( next_file_slot==0 ? NIL(char) : ftab[next_file_slot-1].name );
 700 }
 701
 702
 703 PUBLIC int
 704 Nestlevel()/*
 705 =============
 706    Return the file nesting level */
 707 {
 708    return( next_file_slot );
 709 }
 710
 711
 712 PUBLIC FILE *
 713 TryFiles(lp)/*
 714 ==============
 715    Try to open a makefile, try to make it if needed and return a
 716    filepointer to the first successful found or generated file.
 717    The function returns NIL(FILE) if nothing was found. */
 718 LINKPTR lp;
 719 {
 720    FILE *mkfil = NIL(FILE);
 721
 722    if( lp != NIL(LINK) ) {
 723       int s_n, s_t, s_q;
 724
 725       s_n = Trace;
 726       s_t = Touch;
 727       s_q = Check;
 728
 729       Trace = Touch = Check = FALSE;
 730       /* We are making a makefile. Wait for it. */
 731       Makemkf = Wait_for_completion = TRUE;
 732       mkfil = NIL(FILE);
 733
 734       for(;  lp != NIL(LINK) && mkfil == NIL(FILE); lp=lp->cl_next) {
 735      if( lp->cl_prq->ce_attr & A_FRINGE ) continue;
 736
 737      mkfil = Openfile( lp->cl_prq->CE_NAME, FALSE, FALSE );
 738
 739      /* Note that no error handling for failed Make() calls is possible
 740       * as expected errors (no rule to make the makefile) or unexpected
 741       * errors both return -1. */
 742      if( mkfil == NIL(FILE) && Make(lp->cl_prq, NIL(CELL)) != -1 ) {
 743         mkfil = Openfile( lp->cl_prq->CE_NAME, FALSE, FALSE );
 744         /* Remove flags that indicate that the target was already made.
 745          * This is also needed to avoid conflicts with the circular
 746          * dependency check in rulparse(), see issues 62118 and 81296
 747          * for details. */
 748         Unmake(lp->cl_prq);
 749      }
 750       }
 751
 752       Trace = s_n;
 753       Touch = s_t;
 754       Check = s_q;
 755       Makemkf = Wait_for_completion = FALSE;
 756    }
 757
 758    return(mkfil);
 759 }
 760
 761
 762 /*
 763 ** print error message from variable arg list
 764 */
 765
 766 static int errflg = TRUE;
 767 static int warnflg = FALSE;
 768
 769 static void
 770 errargs(fmt, args)
 771 char    *fmt;
 772 va_list  args;
 773 {
 774    int warn = _warn && warnflg && !(Glob_attr & A_SILENT);
 775
 776    if( errflg || warn ) {
 777       char *f = Filename();
 778
 779       fprintf( stderr, "%s:  ", Pname );
 780       if( f != NIL(char) ) fprintf(stderr, "%s:  line %d:  ", f, Line_number);
 781
 782       if( errflg )
 783          fprintf(stderr, "Error: -- ");
 784       else if( warn )
 785          fprintf(stderr, "Warning: -- ");
 786
 787       vfprintf( stderr, fmt, args );
 788       putc( '\n', stderr );
 789       if( errflg && !Continue ) Quit(0);
 790    }
 791 }
 792
 793
 794 /*
 795 ** Print error message and abort
 796 */
 797 PUBLIC void
 798 Fatal(ARG(char *,fmt), ARG(va_alist_type,va_alist))
 799 DARG(char *,fmt)
 800 DARG(va_alist_type,va_alist)
 801 {
 802    va_list args;
 803
 804    va_start(args, fmt);
 805    Continue = FALSE;
 806    errargs(fmt, args);
 807    va_end(args);
 808 }
 809
 810 /*
 811 ** error message and exit (unless -k)
 812 */
 813 PUBLIC void
 814 Error(ARG(char *,fmt), ARG(va_alist_type,va_alist))
 815 DARG(char *,fmt)
 816 DARG(va_alist_type,va_alist)
 817 {
 818    va_list args;
 819
 820    va_start(args, fmt);
 821    errargs(fmt, args);
 822    va_end(args);
 823 }
 824
 825
 826 /*
 827 ** non-fatal message
 828 */
 829 PUBLIC void
 830 Warning(ARG(char *,fmt), ARG(va_alist_type,va_alist))
 831 DARG(char *,fmt)
 832 DARG(va_alist_type,va_alist)
 833 {
 834    va_list args;
 835
 836    va_start(args, fmt);
 837    warnflg = TRUE;
 838    errflg = FALSE;
 839    errargs(fmt, args);
 840    errflg = TRUE;
 841    warnflg = FALSE;
 842    va_end(args);
 843 }
 844
 845
 846 PUBLIC void
 847 No_ram()
 848 {
 849    Fatal( "No more memory" );
 850 }
 851
 852
 853 PUBLIC void
 854 Usage( eflag )
 855 int eflag;
 856 {
 857    register char *p;
 858    char *fill;
 859
 860    fill = DmStrDup(Pname);
 861    for(p=fill; *p; p++) *p=' ';
 862
 863    if( eflag ) {
 864       fprintf(stderr, USAGE, Pname);
 865       fprintf(stderr, USAGE2, fill);
 866    }
 867    else {
 868    printf(USAGE, Pname);
 869    printf(USAGE2, fill);
 870    puts("    -P#        - set max number of child processes for parallel make");
 871    puts("    -f file    - use file as the makefile");
 872 #ifdef MSDOS
 873    puts("    -C [+]file - duplicate console output to file, ('+' => append)");
 874 #endif
 875    puts("    -K file    - use file as the .KEEP_STATE file");
 876    puts("    -w target  - show what you would do if 'target' were out of date");
 877    puts("    -W target  - rebuild pretending that 'target' is out of date");
 878    puts("    -v[cdfimrtw] - verbose, indicate what we are doing, (-v => -vcdfimrtw)");
 879    puts("                   c => dump directory cache info only" );
 880    puts("                   d => dump change of directory info only" );
 881    puts("                   f => dump file open/close info only" );
 882    puts("                   i => dump inference information only" );
 883    puts("                   m => dump make of target information only" );
 884    puts("                   r => Force output of recipe lines and warnings," );
 885    puts("                        overrides -s" );
 886    puts("                   t => keep temporary files when done" );
 887    puts("                   w => issue non-essential warnings\n" );
 888
 889    puts("    -m[trae] - Measure timing information, (-m => -mt)");
 890    puts("               t => display the start and end time of each target" );
 891    puts("               r => display the start and end time of each recipe" );
 892    puts("               a => display the target as an absolute path" );
 893    puts("               e => display the timing of shell escape macros\n" );
 894
 895    puts("Options: (can be catenated, ie -irn == -i -r -n)");
 896    puts("    -A   - enable AUGMAKE special target mapping");
 897    puts("    -B   - enable the use of spaces instead of tabs to start recipes");
 898    puts("    -c   - use non standard comment scanning");
 899    puts("    -d   - do not use directory cache");
 900    puts("    -E   - define environment strings as macros");
 901    puts("    -e   - same as -E but done after parsing makefile");
 902    puts("    -g   - disable the special meaning of [ ... ] for group recipes");
 903    puts("    -h   - print out usage info");
 904    puts("    -i   - ignore errors");
 905    puts("    -k   - make independent targets, even if errors");
 906    puts("    -n   - trace and print, do not execute commands");
 907    puts("    -p   - print out a version of the makefile");
 908    puts("    -q   - check if target is up to date.  Does not do");
 909    puts("           anything.  Returns 0 if up to date, 1 otherwise");
 910    puts("    -r   - don't use internal rules");
 911    puts("    -s   - do your work silently");
 912    puts("    -S   - disable parallel (force sequential) make, overrides -P");
 913    puts("    -t   - touch, update time stamps without executing commands");
 914    puts("    -T   - do not apply transitive closure on inference rules");
 915    puts("    -u   - force unconditional update of target");
 916    puts("    -V   - print out version number");
 917    puts("    -x   - export macro values to environment");
 918    puts("    -X   - ignore #! lines at start of makefile");
 919    }
 920    FREE(fill);
 921
 922    Quit(0);
 923 }
 924
 925
 926 PUBLIC void
 927 Version()
 928 {
 929    extern char **Rule_tab;
 930    char **p;
 931
 932    printf("%s - Version %s (%s)\n", Pname, VERSION, BUILDINFO);
 933    printf("%s\n\n", sccid);
 934
 935    puts("Default Configuration:");
 936    for (p=Rule_tab;  *p != NIL(char);  p++)
 937       printf("\t%s\n", *p);
 938
 939    printf("\n");
 940
 941 #if defined(HAVE_SPAWN_H) || defined(__CYGWIN__)
 942    /* Only systems that have spawn ar concerned whether spawn or fork/exec
 943     * are used. */
 944 #if ENABLE_SPAWN
 945       printf("Subprocesses are executed using: spawn.\n\n");
 946 #else
 947       printf("Subprocesses are executed using: fork/exec.\n\n");
 948 #endif
 949 #endif
 950
 951       printf("Please read the NEWS file for the latest release notes.\n");
 952 }