Annotation of src/usr.bin/make/targ.c, Revision 1.1
1.1 ! deraadt 1: /* $NetBSD: targ.c,v 1.5 1995/06/14 15:20:08 christos Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
! 5: * Copyright (c) 1988, 1989 by Adam de Boor
! 6: * Copyright (c) 1989 by Berkeley Softworks
! 7: * All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to Berkeley by
! 10: * Adam de Boor.
! 11: *
! 12: * Redistribution and use in source and binary forms, with or without
! 13: * modification, are permitted provided that the following conditions
! 14: * are met:
! 15: * 1. Redistributions of source code must retain the above copyright
! 16: * notice, this list of conditions and the following disclaimer.
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in the
! 19: * documentation and/or other materials provided with the distribution.
! 20: * 3. All advertising materials mentioning features or use of this software
! 21: * must display the following acknowledgement:
! 22: * This product includes software developed by the University of
! 23: * California, Berkeley and its contributors.
! 24: * 4. Neither the name of the University nor the names of its contributors
! 25: * may be used to endorse or promote products derived from this software
! 26: * without specific prior written permission.
! 27: *
! 28: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 29: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 30: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 31: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 32: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 33: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 34: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 35: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 36: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 37: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 38: * SUCH DAMAGE.
! 39: */
! 40:
! 41: #ifndef lint
! 42: /* from: static char sccsid[] = "@(#)targ.c 5.9 (Berkeley) 3/1/91"; */
! 43: static char *rcsid = "$Id: targ.c,v 1.5 1995/06/14 15:20:08 christos Exp $";
! 44: #endif /* not lint */
! 45:
! 46: /*-
! 47: * targ.c --
! 48: * Functions for maintaining the Lst allTargets. Target nodes are
! 49: * kept in two structures: a Lst, maintained by the list library, and a
! 50: * hash table, maintained by the hash library.
! 51: *
! 52: * Interface:
! 53: * Targ_Init Initialization procedure.
! 54: *
! 55: * Targ_End Cleanup the module
! 56: *
! 57: * Targ_NewGN Create a new GNode for the passed target
! 58: * (string). The node is *not* placed in the
! 59: * hash table, though all its fields are
! 60: * initialized.
! 61: *
! 62: * Targ_FindNode Find the node for a given target, creating
! 63: * and storing it if it doesn't exist and the
! 64: * flags are right (TARG_CREATE)
! 65: *
! 66: * Targ_FindList Given a list of names, find nodes for all
! 67: * of them. If a name doesn't exist and the
! 68: * TARG_NOCREATE flag was given, an error message
! 69: * is printed. Else, if a name doesn't exist,
! 70: * its node is created.
! 71: *
! 72: * Targ_Ignore Return TRUE if errors should be ignored when
! 73: * creating the given target.
! 74: *
! 75: * Targ_Silent Return TRUE if we should be silent when
! 76: * creating the given target.
! 77: *
! 78: * Targ_Precious Return TRUE if the target is precious and
! 79: * should not be removed if we are interrupted.
! 80: *
! 81: * Debugging:
! 82: * Targ_PrintGraph Print out the entire graphm all variables
! 83: * and statistics for the directory cache. Should
! 84: * print something for suffixes, too, but...
! 85: */
! 86:
! 87: #include <stdio.h>
! 88: #include <time.h>
! 89: #include "make.h"
! 90: #include "hash.h"
! 91: #include "dir.h"
! 92:
! 93: static Lst allTargets; /* the list of all targets found so far */
! 94: static Lst allGNs; /* List of all the GNodes */
! 95: static Hash_Table targets; /* a hash table of same */
! 96:
! 97: #define HTSIZE 191 /* initial size of hash table */
! 98:
! 99: static int TargPrintOnlySrc __P((ClientData, ClientData));
! 100: static int TargPrintName __P((ClientData, ClientData));
! 101: static int TargPrintNode __P((ClientData, ClientData));
! 102: static void TargFreeGN __P((ClientData));
! 103:
! 104: /*-
! 105: *-----------------------------------------------------------------------
! 106: * Targ_Init --
! 107: * Initialize this module
! 108: *
! 109: * Results:
! 110: * None
! 111: *
! 112: * Side Effects:
! 113: * The allTargets list and the targets hash table are initialized
! 114: *-----------------------------------------------------------------------
! 115: */
! 116: void
! 117: Targ_Init ()
! 118: {
! 119: allTargets = Lst_Init (FALSE);
! 120: Hash_InitTable (&targets, HTSIZE);
! 121: }
! 122:
! 123: /*-
! 124: *-----------------------------------------------------------------------
! 125: * Targ_End --
! 126: * Finalize this module
! 127: *
! 128: * Results:
! 129: * None
! 130: *
! 131: * Side Effects:
! 132: * All lists and gnodes are cleared
! 133: *-----------------------------------------------------------------------
! 134: */
! 135: void
! 136: Targ_End ()
! 137: {
! 138: Lst_Destroy(allTargets, NOFREE);
! 139: if (allGNs)
! 140: Lst_Destroy(allGNs, TargFreeGN);
! 141: Hash_DeleteTable(&targets);
! 142: }
! 143:
! 144: /*-
! 145: *-----------------------------------------------------------------------
! 146: * Targ_NewGN --
! 147: * Create and initialize a new graph node
! 148: *
! 149: * Results:
! 150: * An initialized graph node with the name field filled with a copy
! 151: * of the passed name
! 152: *
! 153: * Side Effects:
! 154: * The gnode is added to the list of all gnodes.
! 155: *-----------------------------------------------------------------------
! 156: */
! 157: GNode *
! 158: Targ_NewGN (name)
! 159: char *name; /* the name to stick in the new node */
! 160: {
! 161: register GNode *gn;
! 162:
! 163: gn = (GNode *) emalloc (sizeof (GNode));
! 164: gn->name = strdup (name);
! 165: gn->path = (char *) 0;
! 166: if (name[0] == '-' && name[1] == 'l') {
! 167: gn->type = OP_LIB;
! 168: } else {
! 169: gn->type = 0;
! 170: }
! 171: gn->unmade = 0;
! 172: gn->make = FALSE;
! 173: gn->made = UNMADE;
! 174: gn->childMade = FALSE;
! 175: gn->mtime = gn->cmtime = 0;
! 176: gn->iParents = Lst_Init (FALSE);
! 177: gn->cohorts = Lst_Init (FALSE);
! 178: gn->parents = Lst_Init (FALSE);
! 179: gn->children = Lst_Init (FALSE);
! 180: gn->successors = Lst_Init (FALSE);
! 181: gn->preds = Lst_Init (FALSE);
! 182: gn->context = Lst_Init (FALSE);
! 183: gn->commands = Lst_Init (FALSE);
! 184: gn->suffix = NULL;
! 185:
! 186: if (allGNs == NULL)
! 187: allGNs = Lst_Init(FALSE);
! 188: Lst_AtEnd(allGNs, (ClientData) gn);
! 189:
! 190: return (gn);
! 191: }
! 192:
! 193: /*-
! 194: *-----------------------------------------------------------------------
! 195: * TargFreeGN --
! 196: * Destroy a GNode
! 197: *
! 198: * Results:
! 199: * None.
! 200: *
! 201: * Side Effects:
! 202: * None.
! 203: *-----------------------------------------------------------------------
! 204: */
! 205: static void
! 206: TargFreeGN (gnp)
! 207: ClientData gnp;
! 208: {
! 209: GNode *gn = (GNode *) gnp;
! 210:
! 211:
! 212: free(gn->name);
! 213: if (gn->path)
! 214: free(gn->path);
! 215:
! 216: Lst_Destroy(gn->iParents, NOFREE);
! 217: Lst_Destroy(gn->cohorts, NOFREE);
! 218: Lst_Destroy(gn->parents, NOFREE);
! 219: Lst_Destroy(gn->children, NOFREE);
! 220: Lst_Destroy(gn->successors, NOFREE);
! 221: Lst_Destroy(gn->preds, NOFREE);
! 222: Lst_Destroy(gn->context, NOFREE);
! 223: Lst_Destroy(gn->commands, NOFREE);
! 224: free((Address)gn);
! 225: }
! 226:
! 227:
! 228: /*-
! 229: *-----------------------------------------------------------------------
! 230: * Targ_FindNode --
! 231: * Find a node in the list using the given name for matching
! 232: *
! 233: * Results:
! 234: * The node in the list if it was. If it wasn't, return NILGNODE of
! 235: * flags was TARG_NOCREATE or the newly created and initialized node
! 236: * if it was TARG_CREATE
! 237: *
! 238: * Side Effects:
! 239: * Sometimes a node is created and added to the list
! 240: *-----------------------------------------------------------------------
! 241: */
! 242: GNode *
! 243: Targ_FindNode (name, flags)
! 244: char *name; /* the name to find */
! 245: int flags; /* flags governing events when target not
! 246: * found */
! 247: {
! 248: GNode *gn; /* node in that element */
! 249: Hash_Entry *he; /* New or used hash entry for node */
! 250: Boolean isNew; /* Set TRUE if Hash_CreateEntry had to create */
! 251: /* an entry for the node */
! 252:
! 253:
! 254: if (flags & TARG_CREATE) {
! 255: he = Hash_CreateEntry (&targets, name, &isNew);
! 256: if (isNew) {
! 257: gn = Targ_NewGN (name);
! 258: Hash_SetValue (he, gn);
! 259: (void) Lst_AtEnd (allTargets, (ClientData)gn);
! 260: }
! 261: } else {
! 262: he = Hash_FindEntry (&targets, name);
! 263: }
! 264:
! 265: if (he == (Hash_Entry *) NULL) {
! 266: return (NILGNODE);
! 267: } else {
! 268: return ((GNode *) Hash_GetValue (he));
! 269: }
! 270: }
! 271:
! 272: /*-
! 273: *-----------------------------------------------------------------------
! 274: * Targ_FindList --
! 275: * Make a complete list of GNodes from the given list of names
! 276: *
! 277: * Results:
! 278: * A complete list of graph nodes corresponding to all instances of all
! 279: * the names in names.
! 280: *
! 281: * Side Effects:
! 282: * If flags is TARG_CREATE, nodes will be created for all names in
! 283: * names which do not yet have graph nodes. If flags is TARG_NOCREATE,
! 284: * an error message will be printed for each name which can't be found.
! 285: * -----------------------------------------------------------------------
! 286: */
! 287: Lst
! 288: Targ_FindList (names, flags)
! 289: Lst names; /* list of names to find */
! 290: int flags; /* flags used if no node is found for a given
! 291: * name */
! 292: {
! 293: Lst nodes; /* result list */
! 294: register LstNode ln; /* name list element */
! 295: register GNode *gn; /* node in tLn */
! 296: char *name;
! 297:
! 298: nodes = Lst_Init (FALSE);
! 299:
! 300: if (Lst_Open (names) == FAILURE) {
! 301: return (nodes);
! 302: }
! 303: while ((ln = Lst_Next (names)) != NILLNODE) {
! 304: name = (char *)Lst_Datum(ln);
! 305: gn = Targ_FindNode (name, flags);
! 306: if (gn != NILGNODE) {
! 307: /*
! 308: * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
! 309: * are added to the list in the order in which they were
! 310: * encountered in the makefile.
! 311: */
! 312: (void) Lst_AtEnd (nodes, (ClientData)gn);
! 313: if (gn->type & OP_DOUBLEDEP) {
! 314: (void)Lst_Concat (nodes, gn->cohorts, LST_CONCNEW);
! 315: }
! 316: } else if (flags == TARG_NOCREATE) {
! 317: Error ("\"%s\" -- target unknown.", name);
! 318: }
! 319: }
! 320: Lst_Close (names);
! 321: return (nodes);
! 322: }
! 323:
! 324: /*-
! 325: *-----------------------------------------------------------------------
! 326: * Targ_Ignore --
! 327: * Return true if should ignore errors when creating gn
! 328: *
! 329: * Results:
! 330: * TRUE if should ignore errors
! 331: *
! 332: * Side Effects:
! 333: * None
! 334: *-----------------------------------------------------------------------
! 335: */
! 336: Boolean
! 337: Targ_Ignore (gn)
! 338: GNode *gn; /* node to check for */
! 339: {
! 340: if (ignoreErrors || gn->type & OP_IGNORE) {
! 341: return (TRUE);
! 342: } else {
! 343: return (FALSE);
! 344: }
! 345: }
! 346:
! 347: /*-
! 348: *-----------------------------------------------------------------------
! 349: * Targ_Silent --
! 350: * Return true if be silent when creating gn
! 351: *
! 352: * Results:
! 353: * TRUE if should be silent
! 354: *
! 355: * Side Effects:
! 356: * None
! 357: *-----------------------------------------------------------------------
! 358: */
! 359: Boolean
! 360: Targ_Silent (gn)
! 361: GNode *gn; /* node to check for */
! 362: {
! 363: if (beSilent || gn->type & OP_SILENT) {
! 364: return (TRUE);
! 365: } else {
! 366: return (FALSE);
! 367: }
! 368: }
! 369:
! 370: /*-
! 371: *-----------------------------------------------------------------------
! 372: * Targ_Precious --
! 373: * See if the given target is precious
! 374: *
! 375: * Results:
! 376: * TRUE if it is precious. FALSE otherwise
! 377: *
! 378: * Side Effects:
! 379: * None
! 380: *-----------------------------------------------------------------------
! 381: */
! 382: Boolean
! 383: Targ_Precious (gn)
! 384: GNode *gn; /* the node to check */
! 385: {
! 386: if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
! 387: return (TRUE);
! 388: } else {
! 389: return (FALSE);
! 390: }
! 391: }
! 392:
! 393: /******************* DEBUG INFO PRINTING ****************/
! 394:
! 395: static GNode *mainTarg; /* the main target, as set by Targ_SetMain */
! 396: /*-
! 397: *-----------------------------------------------------------------------
! 398: * Targ_SetMain --
! 399: * Set our idea of the main target we'll be creating. Used for
! 400: * debugging output.
! 401: *
! 402: * Results:
! 403: * None.
! 404: *
! 405: * Side Effects:
! 406: * "mainTarg" is set to the main target's node.
! 407: *-----------------------------------------------------------------------
! 408: */
! 409: void
! 410: Targ_SetMain (gn)
! 411: GNode *gn; /* The main target we'll create */
! 412: {
! 413: mainTarg = gn;
! 414: }
! 415:
! 416: static int
! 417: TargPrintName (gnp, ppath)
! 418: ClientData gnp;
! 419: ClientData ppath;
! 420: {
! 421: GNode *gn = (GNode *) gnp;
! 422: printf ("%s ", gn->name);
! 423: #ifdef notdef
! 424: if (ppath) {
! 425: if (gn->path) {
! 426: printf ("[%s] ", gn->path);
! 427: }
! 428: if (gn == mainTarg) {
! 429: printf ("(MAIN NAME) ");
! 430: }
! 431: }
! 432: #endif /* notdef */
! 433: return (ppath ? 0 : 0);
! 434: }
! 435:
! 436:
! 437: int
! 438: Targ_PrintCmd (cmd, dummy)
! 439: ClientData cmd;
! 440: ClientData dummy;
! 441: {
! 442: printf ("\t%s\n", (char *) cmd);
! 443: return (dummy ? 0 : 0);
! 444: }
! 445:
! 446: /*-
! 447: *-----------------------------------------------------------------------
! 448: * Targ_FmtTime --
! 449: * Format a modification time in some reasonable way and return it.
! 450: *
! 451: * Results:
! 452: * The time reformatted.
! 453: *
! 454: * Side Effects:
! 455: * The time is placed in a static area, so it is overwritten
! 456: * with each call.
! 457: *
! 458: *-----------------------------------------------------------------------
! 459: */
! 460: char *
! 461: Targ_FmtTime (time)
! 462: time_t time;
! 463: {
! 464: struct tm *parts;
! 465: static char buf[40];
! 466: static char *months[] = {
! 467: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
! 468: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
! 469: };
! 470:
! 471: parts = localtime(&time);
! 472:
! 473: sprintf (buf, "%d:%02d:%02d %s %d, 19%d",
! 474: parts->tm_hour, parts->tm_min, parts->tm_sec,
! 475: months[parts->tm_mon], parts->tm_mday, parts->tm_year);
! 476: return(buf);
! 477: }
! 478:
! 479: /*-
! 480: *-----------------------------------------------------------------------
! 481: * Targ_PrintType --
! 482: * Print out a type field giving only those attributes the user can
! 483: * set.
! 484: *
! 485: * Results:
! 486: *
! 487: * Side Effects:
! 488: *
! 489: *-----------------------------------------------------------------------
! 490: */
! 491: void
! 492: Targ_PrintType (type)
! 493: register int type;
! 494: {
! 495: register int tbit;
! 496:
! 497: #ifdef __STDC__
! 498: #define PRINTBIT(attr) case CONCAT(OP_,attr): printf("." #attr " "); break
! 499: #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG)) printf("." #attr " "); break
! 500: #else
! 501: #define PRINTBIT(attr) case CONCAT(OP_,attr): printf(".attr "); break
! 502: #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG)) printf(".attr "); break
! 503: #endif /* __STDC__ */
! 504:
! 505: type &= ~OP_OPMASK;
! 506:
! 507: while (type) {
! 508: tbit = 1 << (ffs(type) - 1);
! 509: type &= ~tbit;
! 510:
! 511: switch(tbit) {
! 512: PRINTBIT(OPTIONAL);
! 513: PRINTBIT(USE);
! 514: PRINTBIT(EXEC);
! 515: PRINTBIT(IGNORE);
! 516: PRINTBIT(PRECIOUS);
! 517: PRINTBIT(SILENT);
! 518: PRINTBIT(MAKE);
! 519: PRINTBIT(JOIN);
! 520: PRINTBIT(INVISIBLE);
! 521: PRINTBIT(NOTMAIN);
! 522: PRINTDBIT(LIB);
! 523: /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
! 524: case OP_MEMBER: if (DEBUG(TARG)) printf(".MEMBER "); break;
! 525: PRINTDBIT(ARCHV);
! 526: }
! 527: }
! 528: }
! 529:
! 530: /*-
! 531: *-----------------------------------------------------------------------
! 532: * TargPrintNode --
! 533: * print the contents of a node
! 534: *-----------------------------------------------------------------------
! 535: */
! 536: static int
! 537: TargPrintNode (gnp, passp)
! 538: ClientData gnp;
! 539: ClientData passp;
! 540: {
! 541: GNode *gn = (GNode *) gnp;
! 542: int pass = *(int *) passp;
! 543: if (!OP_NOP(gn->type)) {
! 544: printf("#\n");
! 545: if (gn == mainTarg) {
! 546: printf("# *** MAIN TARGET ***\n");
! 547: }
! 548: if (pass == 2) {
! 549: if (gn->unmade) {
! 550: printf("# %d unmade children\n", gn->unmade);
! 551: } else {
! 552: printf("# No unmade children\n");
! 553: }
! 554: if (! (gn->type & (OP_JOIN|OP_USE|OP_EXEC))) {
! 555: if (gn->mtime != 0) {
! 556: printf("# last modified %s: %s\n",
! 557: Targ_FmtTime(gn->mtime),
! 558: (gn->made == UNMADE ? "unmade" :
! 559: (gn->made == MADE ? "made" :
! 560: (gn->made == UPTODATE ? "up-to-date" :
! 561: "error when made"))));
! 562: } else if (gn->made != UNMADE) {
! 563: printf("# non-existent (maybe): %s\n",
! 564: (gn->made == MADE ? "made" :
! 565: (gn->made == UPTODATE ? "up-to-date" :
! 566: (gn->made == ERROR ? "error when made" :
! 567: "aborted"))));
! 568: } else {
! 569: printf("# unmade\n");
! 570: }
! 571: }
! 572: if (!Lst_IsEmpty (gn->iParents)) {
! 573: printf("# implicit parents: ");
! 574: Lst_ForEach (gn->iParents, TargPrintName, (ClientData)0);
! 575: fputc ('\n', stdout);
! 576: }
! 577: }
! 578: if (!Lst_IsEmpty (gn->parents)) {
! 579: printf("# parents: ");
! 580: Lst_ForEach (gn->parents, TargPrintName, (ClientData)0);
! 581: fputc ('\n', stdout);
! 582: }
! 583:
! 584: printf("%-16s", gn->name);
! 585: switch (gn->type & OP_OPMASK) {
! 586: case OP_DEPENDS:
! 587: printf(": "); break;
! 588: case OP_FORCE:
! 589: printf("! "); break;
! 590: case OP_DOUBLEDEP:
! 591: printf(":: "); break;
! 592: }
! 593: Targ_PrintType (gn->type);
! 594: Lst_ForEach (gn->children, TargPrintName, (ClientData)0);
! 595: fputc ('\n', stdout);
! 596: Lst_ForEach (gn->commands, Targ_PrintCmd, (ClientData)0);
! 597: printf("\n\n");
! 598: if (gn->type & OP_DOUBLEDEP) {
! 599: Lst_ForEach (gn->cohorts, TargPrintNode, (ClientData)&pass);
! 600: }
! 601: }
! 602: return (0);
! 603: }
! 604:
! 605: /*-
! 606: *-----------------------------------------------------------------------
! 607: * TargPrintOnlySrc --
! 608: * Print only those targets that are just a source.
! 609: *
! 610: * Results:
! 611: * 0.
! 612: *
! 613: * Side Effects:
! 614: * The name of each file is printed preceeded by #\t
! 615: *
! 616: *-----------------------------------------------------------------------
! 617: */
! 618: static int
! 619: TargPrintOnlySrc(gnp, dummy)
! 620: ClientData gnp;
! 621: ClientData dummy;
! 622: {
! 623: GNode *gn = (GNode *) gnp;
! 624: if (OP_NOP(gn->type))
! 625: printf("#\t%s [%s]\n", gn->name, gn->path ? gn->path : gn->name);
! 626:
! 627: return (dummy ? 0 : 0);
! 628: }
! 629:
! 630: /*-
! 631: *-----------------------------------------------------------------------
! 632: * Targ_PrintGraph --
! 633: * print the entire graph. heh heh
! 634: *
! 635: * Results:
! 636: * none
! 637: *
! 638: * Side Effects:
! 639: * lots o' output
! 640: *-----------------------------------------------------------------------
! 641: */
! 642: void
! 643: Targ_PrintGraph (pass)
! 644: int pass; /* Which pass this is. 1 => no processing
! 645: * 2 => processing done */
! 646: {
! 647: printf("#*** Input graph:\n");
! 648: Lst_ForEach (allTargets, TargPrintNode, (ClientData)&pass);
! 649: printf("\n\n");
! 650: printf("#\n# Files that are only sources:\n");
! 651: Lst_ForEach (allTargets, TargPrintOnlySrc, (ClientData) 0);
! 652: printf("#*** Global Variables:\n");
! 653: Var_Dump (VAR_GLOBAL);
! 654: printf("#*** Command-line Variables:\n");
! 655: Var_Dump (VAR_CMD);
! 656: printf("\n");
! 657: Dir_PrintDirectories();
! 658: printf("\n");
! 659: Suff_PrintAll();
! 660: }
![[BACK]](/icons/back.gif){kind=icon}
Return to targ.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / make