diff options
| -rw-r--r-- | usr.bin/make/arch.c | 76 | ||||
| -rw-r--r-- | usr.bin/make/buf.c | 50 | ||||
| -rw-r--r-- | usr.bin/make/compat.c | 22 | ||||
| -rw-r--r-- | usr.bin/make/cond.c | 53 | ||||
| -rw-r--r-- | usr.bin/make/dir.c | 94 | ||||
| -rw-r--r-- | usr.bin/make/for.c | 9 | ||||
| -rw-r--r-- | usr.bin/make/hash.c | 43 | ||||
| -rw-r--r-- | usr.bin/make/job.c | 120 | ||||
| -rw-r--r-- | usr.bin/make/main.c | 56 | ||||
| -rw-r--r-- | usr.bin/make/make.c | 49 | ||||
| -rw-r--r-- | usr.bin/make/parse.c | 100 | ||||
| -rw-r--r-- | usr.bin/make/str.c | 34 | ||||
| -rw-r--r-- | usr.bin/make/suff.c | 144 | ||||
| -rw-r--r-- | usr.bin/make/targ.c | 64 | ||||
| -rw-r--r-- | usr.bin/make/var.c | 197 |
15 files changed, 340 insertions, 771 deletions
diff --git a/usr.bin/make/arch.c b/usr.bin/make/arch.c index 983dc42..063ad7a 100644 --- a/usr.bin/make/arch.c +++ b/usr.bin/make/arch.c @@ -136,8 +136,7 @@ static int ArchSVR4Entry(Arch *, char *, size_t, FILE *); *----------------------------------------------------------------------- */ static void -ArchFree(ap) - void * ap; +ArchFree(void *ap) { Arch *a = (Arch *) ap; Hash_Search search; @@ -162,7 +161,9 @@ ArchFree(ap) * Arch_ParseArchive -- * Parse the archive specification in the given line and find/create * the nodes for the specified archive members, placing their nodes - * on the given list. + * on the given list, given the pointer to the start of the + * specification, a Lst on which to place the nodes, and a context + * in which to expand variables. * * Results: * SUCCESS if it was a valid specification. The linePtr is updated @@ -175,10 +176,7 @@ ArchFree(ap) *----------------------------------------------------------------------- */ ReturnStatus -Arch_ParseArchive (linePtr, nodeLst, ctxt) - char **linePtr; /* Pointer to start of specification */ - Lst nodeLst; /* Lst on which to place the nodes */ - GNode *ctxt; /* Context in which to expand variables */ +Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt) { char *cp; /* Pointer into line */ GNode *gn; /* New node */ @@ -424,7 +422,8 @@ Arch_ParseArchive (linePtr, nodeLst, ctxt) *----------------------------------------------------------------------- * ArchFindArchive -- * See if the given archive is the one we are looking for. Called - * From ArchStatMember and ArchFindMember via Lst_Find. + * From ArchStatMember and ArchFindMember via Lst_Find with the + * current list element and the name we want. * * Results: * 0 if it is, non-zero if it isn't. @@ -435,9 +434,7 @@ Arch_ParseArchive (linePtr, nodeLst, ctxt) *----------------------------------------------------------------------- */ static int -ArchFindArchive (ar, archName) - void * ar; /* Current list element */ - void * archName; /* Name we want */ +ArchFindArchive (void *ar, void *archName) { return (strcmp ((char *) archName, ((Arch *) ar)->name)); } @@ -446,7 +443,8 @@ ArchFindArchive (ar, archName) *----------------------------------------------------------------------- * ArchStatMember -- * Locate a member of an archive, given the path of the archive and - * the path of the desired member. + * the path of the desired member, and a boolean representing whether + * or not the archive should be hashed (if not already hashed). * * Results: * A pointer to the current struct ar_hdr structure for the member. Note @@ -460,12 +458,7 @@ ArchFindArchive (ar, archName) *----------------------------------------------------------------------- */ static struct ar_hdr * -ArchStatMember (archive, member, hash) - char *archive; /* Path to the archive */ - char *member; /* Name of member. If it is a path, only the - * last component is used. */ - Boolean hash; /* TRUE if archive should be hashed if not - * already so. */ +ArchStatMember (char *archive, char *member, Boolean hash) { #define AR_MAX_NAME_LEN (sizeof(arh.ar_name)-1) FILE * arch; /* Stream to archive */ @@ -684,11 +677,7 @@ badarch: *----------------------------------------------------------------------- */ static int -ArchSVR4Entry(ar, name, size, arch) - Arch *ar; - char *name; - size_t size; - FILE *arch; +ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch) { #define ARLONGNAMES1 "//" #define ARLONGNAMES2 "/ARFILENAMES" @@ -760,7 +749,8 @@ ArchSVR4Entry(ar, name, size, arch) * ArchFindMember -- * Locate a member of an archive, given the path of the archive and * the path of the desired member. If the archive is to be modified, - * the mode should be "r+", if not, it should be "r". + * the mode should be "r+", if not, it should be "r". arhPtr is a + * poitner to the header structure to fill in. * * Results: * An FILE *, opened for reading and writing, positioned at the @@ -773,12 +763,7 @@ ArchSVR4Entry(ar, name, size, arch) *----------------------------------------------------------------------- */ static FILE * -ArchFindMember (archive, member, arhPtr, mode) - char *archive; /* Path to the archive */ - char *member; /* Name of member. If it is a path, only the - * last component is used. */ - struct ar_hdr *arhPtr; /* Pointer to header structure to be filled in */ - char *mode; /* The mode for opening the stream */ +ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode) { FILE * arch; /* Stream to archive */ int size; /* Size of archive member */ @@ -921,8 +906,7 @@ skip: *----------------------------------------------------------------------- */ void -Arch_Touch (gn) - GNode *gn; /* Node of member to touch */ +Arch_Touch (GNode *gn) { FILE * arch; /* Stream open to archive, positioned properly */ struct ar_hdr arh; /* Current header describing member */ @@ -957,8 +941,7 @@ Arch_Touch (gn) *----------------------------------------------------------------------- */ void -Arch_TouchLib (gn) - GNode *gn; /* The node of the library to touch */ +Arch_TouchLib (GNode *gn) { #ifdef RANLIBMAG FILE * arch; /* Stream open to archive */ @@ -981,7 +964,8 @@ Arch_TouchLib (gn) /*- *----------------------------------------------------------------------- * Arch_MTime -- - * Return the modification time of a member of an archive. + * Return the modification time of a member of an archive, given its + * name. * * Results: * The modification time (seconds). @@ -993,8 +977,7 @@ Arch_TouchLib (gn) *----------------------------------------------------------------------- */ int -Arch_MTime (gn) - GNode *gn; /* Node describing archive member */ +Arch_MTime(GNode *gn) { struct ar_hdr *arhPtr; /* Header of desired member */ int modTime; /* Modification time as an integer */ @@ -1031,8 +1014,7 @@ Arch_MTime (gn) *----------------------------------------------------------------------- */ int -Arch_MemMTime (gn) - GNode *gn; +Arch_MemMTime (GNode *gn) { LstNode ln; GNode *pgn; @@ -1079,7 +1061,7 @@ Arch_MemMTime (gn) /*- *----------------------------------------------------------------------- * Arch_FindLib -- - * Search for a library along the given search path. + * Search for a named library along the given search path. * * Results: * None. @@ -1097,9 +1079,7 @@ Arch_MemMTime (gn) *----------------------------------------------------------------------- */ void -Arch_FindLib (gn, path) - GNode *gn; /* Node of library to find */ - Lst path; /* Search path */ +Arch_FindLib (GNode *gn, Lst path) { char *libName; /* file name for archive */ size_t sz; @@ -1123,7 +1103,8 @@ Arch_FindLib (gn, path) *----------------------------------------------------------------------- * Arch_LibOODate -- * Decide if a node with the OP_LIB attribute is out-of-date. Called - * from Make_OODate to make its life easier. + * from Make_OODate to make its life easier, with the library's + * graph node. * * There are several ways for a library to be out-of-date that are * not available to ordinary files. In addition, there are ways @@ -1156,8 +1137,7 @@ Arch_FindLib (gn, path) *----------------------------------------------------------------------- */ Boolean -Arch_LibOODate (gn) - GNode *gn; /* The library's graph node */ +Arch_LibOODate (GNode *gn) { Boolean oodate; @@ -1210,7 +1190,7 @@ Arch_LibOODate (gn) *----------------------------------------------------------------------- */ void -Arch_Init () +Arch_Init (void) { archives = Lst_Init (FALSE); } @@ -1231,7 +1211,7 @@ Arch_Init () *----------------------------------------------------------------------- */ void -Arch_End () +Arch_End (void) { Lst_Destroy(archives, ArchFree); } diff --git a/usr.bin/make/buf.c b/usr.bin/make/buf.c index eb6b8cb..49523af 100644 --- a/usr.bin/make/buf.c +++ b/usr.bin/make/buf.c @@ -92,9 +92,7 @@ __FBSDID("$FreeBSD$"); *----------------------------------------------------------------------- */ void -Buf_OvAddByte (bp, byte) - Buffer bp; - int byte; +Buf_OvAddByte (Buffer bp, int byte) { bp->left = 0; BufExpand (bp, 1); @@ -122,10 +120,7 @@ Buf_OvAddByte (bp, byte) *----------------------------------------------------------------------- */ void -Buf_AddBytes (bp, numBytes, bytesPtr) - Buffer bp; - int numBytes; - const Byte *bytesPtr; +Buf_AddBytes (Buffer bp, int numBytes, const Byte *bytesPtr) { BufExpand (bp, numBytes); @@ -154,9 +149,7 @@ Buf_AddBytes (bp, numBytes, bytesPtr) *----------------------------------------------------------------------- */ void -Buf_UngetByte (bp, byte) - Buffer bp; - int byte; +Buf_UngetByte (Buffer bp, int byte) { if (bp->outPtr != bp->buffer) { @@ -204,10 +197,7 @@ Buf_UngetByte (bp, byte) *----------------------------------------------------------------------- */ void -Buf_UngetBytes (bp, numBytes, bytesPtr) - Buffer bp; - int numBytes; - Byte *bytesPtr; +Buf_UngetBytes (Buffer bp, int numBytes, Byte *bytesPtr) { if (bp->outPtr - bp->buffer >= numBytes) { @@ -249,8 +239,7 @@ Buf_UngetBytes (bp, numBytes, bytesPtr) *----------------------------------------------------------------------- */ int -Buf_GetByte (bp) - Buffer bp; +Buf_GetByte (Buffer bp) { int res; @@ -282,10 +271,7 @@ Buf_GetByte (bp) *----------------------------------------------------------------------- */ int -Buf_GetBytes (bp, numBytes, bytesPtr) - Buffer bp; - int numBytes; - Byte *bytesPtr; +Buf_GetBytes (Buffer bp, int numBytes, Byte *bytesPtr) { if (bp->inPtr - bp->outPtr < numBytes) { @@ -316,9 +302,7 @@ Buf_GetBytes (bp, numBytes, bytesPtr) *----------------------------------------------------------------------- */ Byte * -Buf_GetAll (bp, numBytesPtr) - Buffer bp; - int *numBytesPtr; +Buf_GetAll (Buffer bp, int *numBytesPtr) { if (numBytesPtr != (int *)NULL) { @@ -342,9 +326,7 @@ Buf_GetAll (bp, numBytesPtr) *----------------------------------------------------------------------- */ void -Buf_Discard (bp, numBytes) - Buffer bp; - int numBytes; +Buf_Discard (Buffer bp, int numBytes) { if (bp->inPtr - bp->outPtr <= numBytes) { @@ -371,8 +353,7 @@ Buf_Discard (bp, numBytes) *----------------------------------------------------------------------- */ int -Buf_Size (buf) - Buffer buf; +Buf_Size (Buffer buf) { return (buf->inPtr - buf->outPtr); } @@ -393,8 +374,7 @@ Buf_Size (buf) *----------------------------------------------------------------------- */ Buffer -Buf_Init (size) - int size; /* Initial size for the buffer */ +Buf_Init (int size) { Buffer bp; /* New Buffer */ @@ -414,7 +394,7 @@ Buf_Init (size) /*- *----------------------------------------------------------------------- * Buf_Destroy -- - * Nuke a buffer and all its resources. + * Destroy a buffer, and optionally free its data, too. * * Results: * None. @@ -425,9 +405,7 @@ Buf_Init (size) *----------------------------------------------------------------------- */ void -Buf_Destroy (buf, freeData) - Buffer buf; /* Buffer to destroy */ - Boolean freeData; /* TRUE if the data should be destroyed as well */ +Buf_Destroy (Buffer buf, Boolean freeData) { if (freeData) { @@ -451,9 +429,7 @@ Buf_Destroy (buf, freeData) *----------------------------------------------------------------------- */ void -Buf_ReplaceLastByte (buf, byte) - Buffer buf; /* buffer to augment */ - int byte; /* byte to be written */ +Buf_ReplaceLastByte (Buffer buf, int byte) { if (buf->inPtr == buf->outPtr) Buf_AddByte(buf, byte); diff --git a/usr.bin/make/compat.c b/usr.bin/make/compat.c index c329760..29e89a6 100644 --- a/usr.bin/make/compat.c +++ b/usr.bin/make/compat.c @@ -104,8 +104,7 @@ static char *sh_builtin[] = { *----------------------------------------------------------------------- */ static void -CompatInterrupt (signo) - int signo; +CompatInterrupt (int signo) { GNode *gn; @@ -149,8 +148,7 @@ CompatInterrupt (signo) *----------------------------------------------------------------------- */ static int -shellneed (cmd) - char *cmd; +shellneed (char *cmd) { char **av, **p; int ac; @@ -167,6 +165,7 @@ shellneed (cmd) * CompatRunCommand -- * Execute the next command for a target. If the command returns an * error, the node's made field is set to ERROR and creation stops. + * The node from which the command came is also given. * * Results: * 0 if the command succeeded, 1 if an error occurred. @@ -177,9 +176,7 @@ shellneed (cmd) *----------------------------------------------------------------------- */ static int -CompatRunCommand (cmdp, gnp) - void * cmdp; /* Command to execute */ - void * gnp; /* Node from which the command came */ +CompatRunCommand (void *cmdp, void *gnp) { char *cmdStart; /* Start of expanded command */ char *cp; @@ -399,7 +396,7 @@ CompatRunCommand (cmdp, gnp) /*- *----------------------------------------------------------------------- * CompatMake -- - * Make a target. + * Make a target, given the parent, to abort if necessary. * * Results: * 0 @@ -410,9 +407,7 @@ CompatRunCommand (cmdp, gnp) *----------------------------------------------------------------------- */ static int -CompatMake (gnp, pgnp) - void * gnp; /* The node to make */ - void * pgnp; /* Parent to abort if necessary */ +CompatMake (void *gnp, void *pgnp) { GNode *gn = (GNode *) gnp; GNode *pgn = (GNode *) pgnp; @@ -617,7 +612,7 @@ CompatMake (gnp, pgnp) /*- *----------------------------------------------------------------------- * Compat_Run -- - * Initialize this mode and start making. + * Start making again, given a list of target nodes. * * Results: * None. @@ -628,8 +623,7 @@ CompatMake (gnp, pgnp) *----------------------------------------------------------------------- */ void -Compat_Run(targs) - Lst targs; /* List of target nodes to re-create */ +Compat_Run(Lst targs) { char *cp; /* Pointer to string of shell meta-characters */ GNode *gn = NULL;/* Current root target */ diff --git a/usr.bin/make/cond.c b/usr.bin/make/cond.c index 029c48c..a6eb9a9 100644 --- a/usr.bin/make/cond.c +++ b/usr.bin/make/cond.c @@ -153,8 +153,7 @@ static Boolean skipLine = FALSE; /* Whether the parse module is skipping *----------------------------------------------------------------------- */ static void -CondPushBack (t) - Token t; /* Token to push back into the "stream" */ +CondPushBack (Token t) { condPushBack = t; } @@ -162,7 +161,8 @@ CondPushBack (t) /*- *----------------------------------------------------------------------- * CondGetArg -- - * Find the argument of a built-in function. + * Find the argument of a built-in function. parens is set to TRUE + * if the arguments are bounded by parens. * * Results: * The length of the argument and the address of the argument. @@ -174,11 +174,7 @@ CondPushBack (t) *----------------------------------------------------------------------- */ static int -CondGetArg (linePtr, argPtr, func, parens) - char **linePtr; - char **argPtr; - char *func; - Boolean parens; /* TRUE if arg should be bounded by parens */ +CondGetArg (char **linePtr, char **argPtr, char *func, Boolean parens) { char *cp; int argLen; @@ -276,9 +272,7 @@ CondGetArg (linePtr, argPtr, func, parens) *----------------------------------------------------------------------- */ static Boolean -CondDoDefined (argLen, arg) - int argLen; - char *arg; +CondDoDefined (int argLen, char *arg) { char savec = arg[argLen]; char *p1; @@ -310,9 +304,7 @@ CondDoDefined (argLen, arg) *----------------------------------------------------------------------- */ static int -CondStrMatch(string, pattern) - void * string; - void * pattern; +CondStrMatch(void *string, void *pattern) { return(!Str_Match((char *) string,(char *) pattern)); } @@ -331,9 +323,7 @@ CondStrMatch(string, pattern) *----------------------------------------------------------------------- */ static Boolean -CondDoMake (argLen, arg) - int argLen; - char *arg; +CondDoMake (int argLen, char *arg) { char savec = arg[argLen]; Boolean result; @@ -362,9 +352,7 @@ CondDoMake (argLen, arg) *----------------------------------------------------------------------- */ static Boolean -CondDoExists (argLen, arg) - int argLen; - char *arg; +CondDoExists (int argLen, char *arg) { char savec = arg[argLen]; Boolean result; @@ -396,9 +384,7 @@ CondDoExists (argLen, arg) *----------------------------------------------------------------------- */ static Boolean -CondDoTarget (argLen, arg) - int argLen; - char *arg; +CondDoTarget (int argLen, char *arg) { char savec = arg[argLen]; Boolean result; @@ -436,9 +422,7 @@ CondDoTarget (argLen, arg) *----------------------------------------------------------------------- */ static char * -CondCvtArg(str, value) - char *str; - double *value; +CondCvtArg(char *str, double *value) { if ((*str == '0') && (str[1] == 'x')) { long i; @@ -477,8 +461,7 @@ CondCvtArg(str, value) *----------------------------------------------------------------------- */ static Token -CondToken(doEval) - Boolean doEval; +CondToken(Boolean doEval) { Token t; @@ -913,8 +896,7 @@ error: *----------------------------------------------------------------------- */ static Token -CondT(doEval) - Boolean doEval; +CondT(Boolean doEval) { Token t; @@ -962,8 +944,7 @@ CondT(doEval) *----------------------------------------------------------------------- */ static Token -CondF(doEval) - Boolean doEval; +CondF(Boolean doEval) { Token l, o; @@ -1009,8 +990,7 @@ CondF(doEval) *----------------------------------------------------------------------- */ static Token -CondE(doEval) - Boolean doEval; +CondE(Boolean doEval) { Token l, o; @@ -1064,8 +1044,7 @@ CondE(doEval) *----------------------------------------------------------------------- */ int -Cond_Eval (line) - char *line; /* Line to parse */ +Cond_Eval (char *line) { struct If *ifp; Boolean isElse; @@ -1245,7 +1224,7 @@ Cond_Eval (line) *----------------------------------------------------------------------- */ void -Cond_End() +Cond_End(void) { if (condTop != MAXIF) { Parse_Error(PARSE_FATAL, "%d open conditional%s", MAXIF-condTop, diff --git a/usr.bin/make/dir.c b/usr.bin/make/dir.c index 8c63ee0..49a3cf9 100644 --- a/usr.bin/make/dir.c +++ b/usr.bin/make/dir.c @@ -209,7 +209,7 @@ static int DirPrintDir(void *, void *); *----------------------------------------------------------------------- */ void -Dir_Init () +Dir_Init (void) { dirSearchPath = Lst_Init (FALSE); openDirectories = Lst_Init (FALSE); @@ -246,7 +246,7 @@ Dir_Init () *----------------------------------------------------------------------- */ void -Dir_End() +Dir_End(void) { dot->refCount -= 1; Dir_Destroy((void *) dot); @@ -272,9 +272,7 @@ Dir_End() *----------------------------------------------------------------------- */ static int -DirFindName (p, dname) - void * p; /* Current name */ - void * dname; /* Desired name */ +DirFindName (void *p, void *dname) { return (strcmp (((Path *)p)->name, (char *) dname)); } @@ -282,7 +280,7 @@ DirFindName (p, dname) /*- *----------------------------------------------------------------------- * Dir_HasWildcards -- - * see if the given name has any wildcard characters in it + * See if the given name has any wildcard characters in it. * * Results: * returns TRUE if the word should be expanded, FALSE otherwise @@ -292,8 +290,7 @@ DirFindName (p, dname) *----------------------------------------------------------------------- */ Boolean -Dir_HasWildcards (name) - char *name; /* name to check */ +Dir_HasWildcards (char *name) { char *cp; int wild = 0, brace = 0, bracket = 0; @@ -343,10 +340,7 @@ Dir_HasWildcards (name) *----------------------------------------------------------------------- */ static int -DirMatchFiles (pattern, p, expansions) - char *pattern; /* Pattern to look for */ - Path *p; /* Directory to search */ - Lst expansions; /* Place to store the results */ +DirMatchFiles (char *pattern, Path *p, Lst expansions) { Hash_Search search; /* Index into the directory's table */ Hash_Entry *entry; /* Current entry in the table */ @@ -383,7 +377,10 @@ DirMatchFiles (pattern, p, expansions) * Expand curly braces like the C shell. Does this recursively. * Note the special case: if after the piece of the curly brace is * done there are no wildcard characters in the result, the result is - * placed on the list WITHOUT CHECKING FOR ITS EXISTENCE. + * placed on the list WITHOUT CHECKING FOR ITS EXISTENCE. The + * given arguments are the entire word to expand, the first curly + * brace in the word, the search path, and the list to store the + * expansions in. * * Results: * None. @@ -394,11 +391,7 @@ DirMatchFiles (pattern, p, expansions) *----------------------------------------------------------------------- */ static void -DirExpandCurly(word, brace, path, expansions) - char *word; /* Entire word to expand */ - char *brace; /* First curly brace in it */ - Lst path; /* Search path to use */ - Lst expansions; /* Place to store the expansions */ +DirExpandCurly(char *word, char *brace, Lst path, Lst expansions) { char *end; /* Character after the closing brace */ char *cp; /* Current position in brace clause */ @@ -496,7 +489,8 @@ DirExpandCurly(word, brace, path, expansions) * DirExpandInt -- * Internal expand routine. Passes through the directories in the * path one by one, calling DirMatchFiles for each. NOTE: This still - * doesn't handle patterns in directories... + * doesn't handle patterns in directories... Works given a word to + * expand, a path to look in, and a list to store expansions in. * * Results: * None. @@ -507,10 +501,7 @@ DirExpandCurly(word, brace, path, expansions) *----------------------------------------------------------------------- */ static void -DirExpandInt(word, path, expansions) - char *word; /* Word to expand */ - Lst path; /* Path on which to look */ - Lst expansions; /* Place to store the result */ +DirExpandInt(char *word, Lst path, Lst expansions) { LstNode ln; /* Current node */ Path *p; /* Directory in the node */ @@ -539,13 +530,11 @@ DirExpandInt(word, path, expansions) *----------------------------------------------------------------------- */ static int -DirPrintWord(word, dummy) - void * word; - void * dummy; +DirPrintWord(void *word, void *dummy __unused) { DEBUGF(DIR, ("%s ", (char *) word)); - return(dummy ? 0 : 0); + return (0); } /*- @@ -556,18 +545,14 @@ DirPrintWord(word, dummy) * * Results: * A list of words consisting of the files which exist along the search - * path matching the given pattern. + * path matching the given pattern is placed in expansions. * * Side Effects: * Directories may be opened. Who knows? *----------------------------------------------------------------------- */ void -Dir_Expand (word, path, expansions) - char *word; /* the word to expand */ - Lst path; /* the list of directories in which to find - * the resulting files */ - Lst expansions; /* the list on which to place the results */ +Dir_Expand (char *word, Lst path, Lst expansions) { char *cp; @@ -678,9 +663,7 @@ Dir_Expand (word, path, expansions) *----------------------------------------------------------------------- */ char * -Dir_FindFile (name, path) - char *name; /* the file to find */ - Lst path; /* the Lst of directories to search */ +Dir_FindFile (char *name, Lst path) { char *p1; /* pointer into p->name */ char *p2; /* pointer into name */ @@ -936,9 +919,7 @@ Dir_FindFile (name, path) *----------------------------------------------------------------------- */ int -Dir_MTime (gn) - GNode *gn; /* the file whose modification time is - * desired */ +Dir_MTime (GNode *gn) { char *fullName; /* the full pathname of name */ struct stat stb; /* buffer for finding the mod time */ @@ -1000,10 +981,7 @@ Dir_MTime (gn) *----------------------------------------------------------------------- */ void -Dir_AddDir (path, name) - Lst path; /* the path to which the directory should be - * added */ - char *name; /* the name of the directory to add */ +Dir_AddDir (Lst path, char *name) { LstNode ln; /* node in case Path structure is found */ Path *p; /* pointer to new Path structure */ @@ -1074,8 +1052,7 @@ Dir_AddDir (path, name) *----------------------------------------------------------------------- */ void * -Dir_CopyDir(p) - void * p; +Dir_CopyDir(void *p) { ((Path *) p)->refCount += 1; @@ -1100,9 +1077,7 @@ Dir_CopyDir(p) *----------------------------------------------------------------------- */ char * -Dir_MakeFlags (flag, path) - char *flag; /* flag which should precede each directory */ - Lst path; /* list of directories */ +Dir_MakeFlags (char *flag, Lst path) { char *str; /* the string which will be returned */ char *tstr; /* the current directory preceded by 'flag' */ @@ -1139,8 +1114,7 @@ Dir_MakeFlags (flag, path) *----------------------------------------------------------------------- */ void -Dir_Destroy (pp) - void * pp; /* The directory descriptor to nuke */ +Dir_Destroy (void *pp) { Path *p = (Path *) pp; p->refCount -= 1; @@ -1172,8 +1146,7 @@ Dir_Destroy (pp) *----------------------------------------------------------------------- */ void -Dir_ClearPath(path) - Lst path; /* Path to clear */ +Dir_ClearPath(Lst path) { Path *p; while (!Lst_IsEmpty(path)) { @@ -1198,9 +1171,7 @@ Dir_ClearPath(path) *----------------------------------------------------------------------- */ void -Dir_Concat(path1, path2) - Lst path1; /* Dest */ - Lst path2; /* Source */ +Dir_Concat(Lst path1, Lst path2) { LstNode ln; Path *p; @@ -1216,7 +1187,7 @@ Dir_Concat(path1, path2) /********** DEBUG INFO **********/ void -Dir_PrintDirectories() +Dir_PrintDirectories(void) { LstNode ln; Path *p; @@ -1236,17 +1207,16 @@ Dir_PrintDirectories() } } -static int DirPrintDir (p, dummy) - void * p; - void * dummy; +static int +DirPrintDir (void *p, void *dummy __unused) { printf ("%s ", ((Path *) p)->name); - return (dummy ? 0 : 0); + + return (0); } void -Dir_PrintPath (path) - Lst path; +Dir_PrintPath (Lst path) { Lst_ForEach (path, DirPrintDir, (void *)0); } diff --git a/usr.bin/make/for.c b/usr.bin/make/for.c index c152008..87890af 100644 --- a/usr.bin/make/for.c +++ b/usr.bin/make/for.c @@ -106,8 +106,7 @@ static int ForExec(void *, void *); *----------------------------------------------------------------------- */ int -For_Eval (line) - char *line; /* Line to parse */ +For_Eval (char *line) { char *ptr = line, *sub, *wrd; int level; /* Level at which to report errors. */ @@ -247,9 +246,7 @@ For_Eval (line) *----------------------------------------------------------------------- */ static int -ForExec(namep, argp) - void * namep; - void * argp; +ForExec(void *namep, void *argp) { char *name = (char *) namep; For *arg = (For *) argp; @@ -278,7 +275,7 @@ ForExec(namep, argp) *----------------------------------------------------------------------- */ void -For_Run() +For_Run(void) { For arg; diff --git a/usr.bin/make/hash.c b/usr.bin/make/hash.c index bc55c5d..7d2c64d 100644 --- a/usr.bin/make/hash.c +++ b/usr.bin/make/hash.c @@ -72,8 +72,11 @@ static void RebuildTable(Hash_Table *); *--------------------------------------------------------- * * Hash_InitTable -- + * + * Set up the hash table t with a given number of buckets, or a + * reasonable default if the number requested is less than or + * equal to zero. Hash tables will grow in size as needed. * - * This routine just sets up the hash table. * * Results: * None. @@ -85,13 +88,7 @@ static void RebuildTable(Hash_Table *); */ void -Hash_InitTable(t, numBuckets) - Hash_Table *t; /* Structure to use to hold table. */ - int numBuckets; /* How many buckets to create for starters. - * This number is rounded up to a power of - * two. If <= 0, a reasonable default is - * chosen. The table will grow in size later - * as needed. */ +Hash_InitTable(Hash_Table *t, int numBuckets) { int i; struct Hash_Entry **hp; @@ -132,8 +129,7 @@ Hash_InitTable(t, numBuckets) */ void -Hash_DeleteTable(t) - Hash_Table *t; +Hash_DeleteTable(Hash_Table *t) { struct Hash_Entry **hp, *h, *nexth = NULL; int i; @@ -172,9 +168,7 @@ Hash_DeleteTable(t) */ Hash_Entry * -Hash_FindEntry(t, key) - Hash_Table *t; /* Hash table to search. */ - char *key; /* A hash key. */ +Hash_FindEntry(Hash_Table *t, char *key) { Hash_Entry *e; unsigned h; @@ -209,14 +203,10 @@ Hash_FindEntry(t, key) */ Hash_Entry * -Hash_CreateEntry(t, key, newPtr) - Hash_Table *t; /* Hash table to search. */ - char *key; /* A hash key. */ - Boolean *newPtr; /* Filled in with TRUE if new entry created, - * FALSE otherwise. */ +Hash_CreateEntry(Hash_Table *t, char *key, Boolean *newPtr) { Hash_Entry *e; - unsigned h; + unsigned int h; char *p; int keylen; struct Hash_Entry **hp; @@ -276,9 +266,7 @@ Hash_CreateEntry(t, key, newPtr) */ void -Hash_DeleteEntry(t, e) - Hash_Table *t; - Hash_Entry *e; +Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e) { Hash_Entry **hp, *p; @@ -317,10 +305,7 @@ Hash_DeleteEntry(t, e) */ Hash_Entry * -Hash_EnumFirst(t, searchPtr) - Hash_Table *t; /* Table to be searched. */ - Hash_Search *searchPtr; /* Area in which to keep state - * about search.*/ +Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr) { searchPtr->tablePtr = t; searchPtr->nextIndex = 0; @@ -347,8 +332,7 @@ Hash_EnumFirst(t, searchPtr) */ Hash_Entry * -Hash_EnumNext(searchPtr) - Hash_Search *searchPtr; /* Area used to keep state about search. */ +Hash_EnumNext(Hash_Search *searchPtr) { Hash_Entry *e; Hash_Table *t = searchPtr->tablePtr; @@ -392,8 +376,7 @@ Hash_EnumNext(searchPtr) */ static void -RebuildTable(t) - Hash_Table *t; +RebuildTable(Hash_Table *t) { Hash_Entry *e, *next = NULL, **hp, **xp; int i, mask; diff --git a/usr.bin/make/job.c b/usr.bin/make/job.c index 7026b88..d83f8eb 100644 --- a/usr.bin/make/job.c +++ b/usr.bin/make/job.c @@ -342,9 +342,7 @@ static void JobRestartJobs(void); *----------------------------------------------------------------------- */ static int -JobCondPassSig(jobp, signop) - void * jobp; /* Job to biff */ - void * signop; /* Signal to send it */ +JobCondPassSig(void *jobp, void *signop) { Job *job = (Job *) jobp; int signo = *(int *) signop; @@ -380,8 +378,7 @@ JobCondPassSig(jobp, signop) *----------------------------------------------------------------------- */ static void -JobPassSig(signo) - int signo; /* The signal number we've received */ +JobPassSig(int signo) { sigset_t nmask, omask; struct sigaction act; @@ -450,9 +447,7 @@ JobPassSig(signo) *----------------------------------------------------------------------- */ static int -JobCmpPid(job, pid) - void * job; /* job to examine */ - void * pid; /* process id desired */ +JobCmpPid(void *job, void *pid) { return *(int *) pid - ((Job *) job)->pid; } @@ -472,9 +467,7 @@ JobCmpPid(job, pid) *----------------------------------------------------------------------- */ static int -JobCmpRmtID(job, rmtID) - void * job; /* job to examine */ - void * rmtID; /* remote id desired */ +JobCmpRmtID(void *job, void *rmtID) { return(*(int *) rmtID - *(int *) job->rmtID); } @@ -508,9 +501,7 @@ JobCmpRmtID(job, rmtID) *----------------------------------------------------------------------- */ static int -JobPrintCommand(cmdp, jobp) - void * cmdp; /* command string to print */ - void * jobp; /* job for which to print it */ +JobPrintCommand(void *cmdp, void *jobp) { Boolean noSpecials; /* true if we shouldn't worry about * inserting special commands into @@ -667,9 +658,7 @@ JobPrintCommand(cmdp, jobp) *----------------------------------------------------------------------- */ static int -JobSaveCommand(cmd, gn) - void * cmd; - void * gn; +JobSaveCommand(void *cmd, void *gn) { cmd = (void *) Var_Subst(NULL, (char *) cmd, (GNode *) gn, FALSE); (void) Lst_AtEnd(postCommands->commands, cmd); @@ -691,8 +680,7 @@ JobSaveCommand(cmd, gn) *----------------------------------------------------------------------- */ static void -JobClose(job) - Job *job; +JobClose(Job *job) { if (usePipes) { #ifdef RMT_WILL_WATCH @@ -736,9 +724,7 @@ JobClose(job) */ /*ARGSUSED*/ static void -JobFinish(job, status) - Job *job; /* job to finish */ - int *status; /* sub-why job went away */ +JobFinish(Job *job, int *status) { Boolean done; @@ -983,7 +969,7 @@ JobFinish(job, status) *----------------------------------------------------------------------- * Job_Touch -- * Touch the given target. Called by JobStart when the -t flag was - * given + * given. Prints messages unless told to be silent. * * Results: * None @@ -994,9 +980,7 @@ JobFinish(job, status) *----------------------------------------------------------------------- */ void -Job_Touch(gn, silent) - GNode *gn; /* the node of the file to touch */ - Boolean silent; /* TRUE if should not print messages */ +Job_Touch(GNode *gn, Boolean silent) { int streamID; /* ID of stream opened to do the touch */ struct utimbuf times; /* Times for utime() call */ @@ -1065,11 +1049,7 @@ Job_Touch(gn, silent) *----------------------------------------------------------------------- */ Boolean -Job_CheckCommands(gn, abortProc) - GNode *gn; /* The target whose commands need - * verifying */ - void (*abortProc)(const char *, ...); - /* Function to abort with message */ +Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...)) { if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) && (gn->type & OP_LIB) == 0) { @@ -1137,9 +1117,7 @@ Job_CheckCommands(gn, abortProc) */ /*ARGSUSED*/ static void -JobLocalInput(stream, job) - int stream; /* Stream that's ready (ignored) */ - Job *job; /* Job to which the stream belongs */ +JobLocalInput(int stream, Job *job) { JobDoOutput(job, FALSE); } @@ -1161,9 +1139,7 @@ JobLocalInput(stream, job) *----------------------------------------------------------------------- */ static void -JobExec(job, argv) - Job *job; /* Job to execute */ - char **argv; +JobExec(Job *job, char **argv) { int cpid; /* ID of new child */ @@ -1340,9 +1316,7 @@ jobExecFinish: *----------------------------------------------------------------------- */ static void -JobMakeArgv(job, argv) - Job *job; - char **argv; +JobMakeArgv(Job *job, char **argv) { int argc; static char args[10]; /* For merged arguments */ @@ -1396,8 +1370,7 @@ JobMakeArgv(job, argv) *----------------------------------------------------------------------- */ static void -JobRestart(job) - Job *job; /* Job to restart */ +JobRestart(Job *job) { #ifdef REMOTE int host; @@ -1615,12 +1588,7 @@ JobRestart(job) *----------------------------------------------------------------------- */ static int -JobStart(gn, flags, previous) - GNode *gn; /* target to create */ - int flags; /* flags for the job to override normal ones. - * e.g. JOB_SPECIAL or JOB_IGNDOTS */ - Job *previous; /* The previous Job structure for this node, - * if any. */ +JobStart(GNode *gn, int flags, Job *previous) { Job *job; /* new job descriptor */ char *argv[4]; /* Argument vector to shell */ @@ -1904,10 +1872,7 @@ JobStart(gn, flags, previous) } static char * -JobOutput(job, cp, endp, msg) - Job *job; - char *cp, *endp; - int msg; +JobOutput(Job *job, char *cp, char *endp, int msg) { char *ecp; @@ -1977,10 +1942,7 @@ JobOutput(job, cp, endp, msg) *----------------------------------------------------------------------- */ STATIC void -JobDoOutput(job, finish) - Job *job; /* the job whose output needs printing */ - Boolean finish; /* TRUE if this is the last time we'll be - * called for this job */ +JobDoOutput(Job *job, Boolean finish) { Boolean gotNL = FALSE; /* true if got a newline */ Boolean fbuf; /* true if our buffer filled up */ @@ -2171,8 +2133,7 @@ end_loop: *----------------------------------------------------------------------- */ void -Job_CatchChildren(block) - Boolean block; /* TRUE if should block on the wait. */ +Job_CatchChildren(Boolean block) { int pid; /* pid of dead child */ Job *job; /* job descriptor for dead child */ @@ -2243,7 +2204,7 @@ Job_CatchChildren(block) * ----------------------------------------------------------------------- */ void -Job_CatchOutput() +Job_CatchOutput(void) { int nfds; #ifdef USE_KQUEUE @@ -2346,8 +2307,7 @@ Job_CatchOutput() *----------------------------------------------------------------------- */ void -Job_Make(gn) - GNode *gn; +Job_Make(GNode *gn) { (void) JobStart(gn, 0, NULL); } @@ -2355,7 +2315,8 @@ Job_Make(gn) /*- *----------------------------------------------------------------------- * Job_Init -- - * Initialize the process module + * Initialize the process module, given a maximum number of jobs, and + * a maximum number of local jobs. * * Results: * none @@ -2365,11 +2326,7 @@ Job_Make(gn) *----------------------------------------------------------------------- */ void -Job_Init(maxproc, maxlocal) - int maxproc; /* the greatest number of jobs which may be - * running at one time */ - int maxlocal; /* the greatest number of local jobs which may - * be running at once. */ +Job_Init(int maxproc, int maxlocal) { GNode *begin; /* node for commands to do at the very start */ @@ -2491,7 +2448,7 @@ Job_Init(maxproc, maxlocal) *----------------------------------------------------------------------- */ Boolean -Job_Full() +Job_Full(void) { return(aborting || jobFull); } @@ -2513,7 +2470,7 @@ Job_Full() * ----------------------------------------------------------------------- */ Boolean -Job_Empty() +Job_Empty(void) { if (nJobs == 0) { if (!Lst_IsEmpty(stoppedJobs) && !aborting) { @@ -2546,8 +2503,7 @@ Job_Empty() *----------------------------------------------------------------------- */ static Shell * -JobMatchShell(name) - char *name; /* Final component of shell path */ +JobMatchShell(char *name) { Shell *sh; /* Pointer into shells table */ Shell *match; /* Longest-matching shell */ @@ -2618,8 +2574,7 @@ JobMatchShell(name) *----------------------------------------------------------------------- */ ReturnStatus -Job_ParseShell(line) - char *line; /* The shell spec */ +Job_ParseShell(char *line) { char **words; int wordCount; @@ -2747,10 +2702,7 @@ Job_ParseShell(line) *----------------------------------------------------------------------- */ static void -JobInterrupt(runINTERRUPT, signo) - int runINTERRUPT; /* Non-zero if commands for the .INTERRUPT - * target should be executed */ - int signo; /* signal received */ +JobInterrupt(int runINTERRUPT, int signo) { LstNode ln; /* element in job table */ Job *job = NULL; /* job descriptor in that element */ @@ -2873,7 +2825,7 @@ JobInterrupt(runINTERRUPT, signo) *----------------------------------------------------------------------- */ int -Job_Finish() +Job_Finish(void) { if (postCommands != NULL && !Lst_IsEmpty(postCommands->commands)) { if (errors) { @@ -2907,7 +2859,7 @@ Job_Finish() *----------------------------------------------------------------------- */ void -Job_Wait() +Job_Wait(void) { aborting = ABORT_WAIT; while (nJobs != 0) { @@ -2934,7 +2886,7 @@ Job_Wait() *----------------------------------------------------------------------- */ void -Job_AbortAll() +Job_AbortAll(void) { LstNode ln; /* element in job table */ Job *job; /* the job descriptor in that element */ @@ -2979,7 +2931,8 @@ Job_AbortAll() *----------------------------------------------------------------------- * JobFlagForMigration -- * Handle the eviction of a child. Called from RmtStatusChange. - * Flags the child as remigratable and then suspends it. + * Flags the child as remigratable and then suspends it. Takes + * the ID of the host we used, for matching children. * * Results: * none. @@ -2990,8 +2943,7 @@ Job_AbortAll() *----------------------------------------------------------------------- */ void -JobFlagForMigration(hostID) - int hostID; /* ID of host we used, for matching children. */ +JobFlagForMigration(int hostID) { Job *job; /* job descriptor for dead child */ LstNode jnode; /* list element for finding job */ @@ -3035,7 +2987,7 @@ JobFlagForMigration(hostID) *----------------------------------------------------------------------- */ static void -JobRestartJobs() +JobRestartJobs(void) { while (!jobFull && !Lst_IsEmpty(stoppedJobs)) { DEBUGF(JOB, ("Job queue is not full. Restarting a stopped job.\n")); diff --git a/usr.bin/make/main.c b/usr.bin/make/main.c index 88bf15e..3a9d30d 100644 --- a/usr.bin/make/main.c +++ b/usr.bin/make/main.c @@ -160,9 +160,7 @@ static char *objdir; /* where we chdir'ed to */ * given */ static void -MainParseArgs(argc, argv) - int argc; - char **argv; +MainParseArgs(int argc, char **argv) { char *p; int c; @@ -394,8 +392,7 @@ rearg: while((c = getopt(argc, argv, OPTFLAGS)) != -1) { * Only those that come from the various arguments. */ void -Main_ParseArgLine(line) - char *line; /* Line to fracture */ +Main_ParseArgLine(char *line) { char **argv; /* Manufactured argument vector */ int argc; /* Number of arguments in argv */ @@ -412,9 +409,7 @@ Main_ParseArgLine(line) } char * -chdir_verify_path(path, obpath) - char *path; - char *obpath; +chdir_verify_path(char *path, char *obpath) { struct stat sb; @@ -448,9 +443,7 @@ chdir_verify_path(path, obpath) * The program exits when done. Targets are created. etc. etc. etc. */ int -main(argc, argv) - int argc; - char **argv; +main(int argc, char **argv) { Lst targs; /* target nodes to create -- passed to Make_Init */ Boolean outOfDate = TRUE; /* FALSE if all targets up to date */ @@ -925,16 +918,16 @@ main(argc, argv) * lots */ static Boolean -ReadMakefile(p, q) - void *p; - void *q __unused; +ReadMakefile(void *p, void *q __unused) { - char *fname = p; /* makefile to read */ + char *fname; /* makefile to read */ FILE *stream; char *name, path[MAXPATHLEN]; char *MAKEFILE; int setMAKEFILE; + fname = p; + if (!strcmp(fname, "-")) { Parse_File("(stdin)", stdin); Var_Set("MAKEFILE", "", VAR_GLOBAL); @@ -1018,9 +1011,7 @@ found: * The string must be freed by the caller. */ char * -Cmd_Exec(cmd, error) - char *cmd; - char **error; +Cmd_Exec(char *cmd, char **error) { char *args[4]; /* Args for invoking the shell */ int fds[2]; /* Pipe streams */ @@ -1032,7 +1023,6 @@ Cmd_Exec(cmd, error) char *cp; int cc; - *error = NULL; /* @@ -1263,7 +1253,7 @@ Punt(const char *fmt, ...) * A big one... */ void -DieHorribly() +DieHorribly(void) { if (jobsRunning) Job_AbortAll(); @@ -1275,7 +1265,7 @@ DieHorribly() /* * Finish -- * Called when aborting due to errors in child shell to signal - * abnormal exit. + * abnormal exit, with the number of errors encountered in Make_Make. * * Results: * None @@ -1284,8 +1274,7 @@ DieHorribly() * The program exits */ void -Finish(errors) - int errors; /* number of errors encountered in Make_Make */ +Finish(int errors) { Fatal("%d error%s", errors, errors == 1 ? "" : "s"); } @@ -1295,8 +1284,7 @@ Finish(errors) * malloc, but die on error. */ void * -emalloc(len) - size_t len; +emalloc(size_t len) { void *p; @@ -1310,8 +1298,7 @@ emalloc(len) * strdup, but die on error. */ char * -estrdup(str) - const char *str; +estrdup(const char *str) { char *p; @@ -1325,9 +1312,7 @@ estrdup(str) * realloc, but die on error. */ void * -erealloc(ptr, size) - void *ptr; - size_t size; +erealloc(void *ptr, size_t size) { if ((ptr = realloc(ptr, size)) == NULL) enomem(); @@ -1339,7 +1324,7 @@ erealloc(ptr, size) * die when out of memory. */ void -enomem() +enomem(void) { err(2, NULL); } @@ -1349,8 +1334,7 @@ enomem() * Remove a file carefully, avoiding directories. */ int -eunlink(file) - const char *file; +eunlink(const char *file) { struct stat st; @@ -1369,7 +1353,7 @@ eunlink(file) * exit with usage message */ static void -usage() +usage(void) { (void)fprintf(stderr, "%s\n%s\n%s\n", "usage: make [-Beiknqrstv] [-D variable] [-d flags] [-E variable] [-f makefile]", @@ -1380,9 +1364,7 @@ usage() int -PrintAddr(a, b) - void * a; - void * b __unused; +PrintAddr(void *a, void *b __unused) { printf("%p ", a); return 0; diff --git a/usr.bin/make/make.c b/usr.bin/make/make.c index 4017f6c..653bd21 100644 --- a/usr.bin/make/make.c +++ b/usr.bin/make/make.c @@ -108,9 +108,7 @@ static int MakePrintStatus(void *, void *); *----------------------------------------------------------------------- */ int -Make_TimeStamp (pgn, cgn) - GNode *pgn; /* the current parent */ - GNode *cgn; /* the child we've just examined */ +Make_TimeStamp (GNode *pgn, GNode *cgn) { if (cgn->mtime > pgn->cmtime) { pgn->cmtime = cgn->mtime; @@ -119,9 +117,7 @@ Make_TimeStamp (pgn, cgn) } static int -MakeTimeStamp (pgn, cgn) - void * pgn; /* the current parent */ - void * cgn; /* the child we've just examined */ +MakeTimeStamp (void *pgn, void *cgn) { return Make_TimeStamp((GNode *) pgn, (GNode *) cgn); } @@ -145,8 +141,7 @@ MakeTimeStamp (pgn, cgn) *----------------------------------------------------------------------- */ Boolean -Make_OODate (gn) - GNode *gn; /* the node to check */ +Make_OODate (GNode *gn) { Boolean oodate; @@ -263,9 +258,7 @@ Make_OODate (gn) *----------------------------------------------------------------------- */ static int -MakeAddChild (gnp, lp) - void * gnp; /* the node to add */ - void * lp; /* the list to which to add it */ +MakeAddChild (void *gnp, void *lp) { GNode *gn = (GNode *) gnp; Lst l = (Lst) lp; @@ -300,9 +293,7 @@ MakeAddChild (gnp, lp) *----------------------------------------------------------------------- */ int -Make_HandleUse (cgn, pgn) - GNode *cgn; /* The .USE node */ - GNode *pgn; /* The target of the .USE node */ +Make_HandleUse (GNode *cgn, GNode *pgn) { GNode *gn; /* A child of the .USE node */ LstNode ln; /* An element in the children list */ @@ -345,9 +336,7 @@ Make_HandleUse (cgn, pgn) return (0); } static int -MakeHandleUse (pgn, cgn) - void * pgn; /* the current parent */ - void * cgn; /* the child we've just examined */ +MakeHandleUse (void *pgn, void *cgn) { return Make_HandleUse((GNode *) pgn, (GNode *) cgn); } @@ -378,8 +367,7 @@ MakeHandleUse (pgn, cgn) *----------------------------------------------------------------------- */ void -Make_Update (cgn) - GNode *cgn; /* the child node */ +Make_Update (GNode *cgn) { GNode *pgn; /* the parent node */ char *cname; /* the child's name */ @@ -540,10 +528,7 @@ Make_Update (cgn) *----------------------------------------------------------------------- */ static int -MakeAddAllSrc (cgnp, pgnp) - void * cgnp; /* The child to add */ - void * pgnp; /* The parent to whose ALLSRC variable it should be */ - /* added */ +MakeAddAllSrc (void *cgnp, void *pgnp) { GNode *cgn = (GNode *) cgnp; GNode *pgn = (GNode *) pgnp; @@ -613,8 +598,7 @@ MakeAddAllSrc (cgnp, pgnp) *----------------------------------------------------------------------- */ void -Make_DoAllVar (gn) - GNode *gn; +Make_DoAllVar (GNode *gn) { Lst_ForEach (gn->children, MakeAddAllSrc, (void *) gn); @@ -649,7 +633,7 @@ Make_DoAllVar (gn) *----------------------------------------------------------------------- */ static Boolean -MakeStartJobs () +MakeStartJobs (void) { GNode *gn; @@ -714,7 +698,9 @@ MakeStartJobs () * MakePrintStatus -- * Print the status of a top-level node, viz. it being up-to-date * already or not created due to an error in a lower level. - * Callback function for Make_Run via Lst_ForEach. + * Callback function for Make_Run via Lst_ForEach. If gn->unmade is + * nonzero and that is meant to imply a cycle in the graph, then + * cycle is TRUE. * * Results: * Always returns 0. @@ -725,11 +711,7 @@ MakeStartJobs () *----------------------------------------------------------------------- */ static int -MakePrintStatus(gnp, cyclep) - void * gnp; /* Node to examine */ - void * cyclep; /* True if gn->unmade being non-zero implies - * a cycle in the graph, not an error in an - * inferior */ +MakePrintStatus(void *gnp, void *cyclep) { GNode *gn = (GNode *) gnp; Boolean cycle = *(Boolean *) cyclep; @@ -786,8 +768,7 @@ MakePrintStatus(gnp, cyclep) *----------------------------------------------------------------------- */ Boolean -Make_Run (targs) - Lst targs; /* the initial list of targets */ +Make_Run (Lst targs) { GNode *gn; /* a temporary pointer */ Lst examine; /* List of targets to examine */ diff --git a/usr.bin/make/parse.c b/usr.bin/make/parse.c index 9375022..c19f679 100644 --- a/usr.bin/make/parse.c +++ b/usr.bin/make/parse.c @@ -266,8 +266,7 @@ static void ParseFinishLine(void); *---------------------------------------------------------------------- */ static int -ParseFindKeyword (str) - char *str; /* String to find */ +ParseFindKeyword (char *str) { int start, end, @@ -339,9 +338,7 @@ Parse_Error(int type, const char *fmt, ...) *--------------------------------------------------------------------- */ static int -ParseLinkSrc (pgnp, cgnp) - void * pgnp; /* The parent node */ - void * cgnp; /* The child node */ +ParseLinkSrc (void *pgnp, void *cgnp) { GNode *pgn = (GNode *) pgnp; GNode *cgn = (GNode *) cgnp; @@ -372,10 +369,7 @@ ParseLinkSrc (pgnp, cgnp) *--------------------------------------------------------------------- */ static int -ParseDoOp (gnp, opp) - void * gnp; /* The node to which the operator is to be - * applied */ - void * opp; /* The operator to apply */ +ParseDoOp (void *gnp, void *opp) { GNode *gn = (GNode *) gnp; int op = *(int *) opp; @@ -450,9 +444,7 @@ ParseDoOp (gnp, opp) *--------------------------------------------------------------------- */ static int -ParseAddDep(pp, sp) - void * pp; - void * sp; +ParseAddDep(void *pp, void *sp) { GNode *p = (GNode *) pp; GNode *s = (GNode *) sp; @@ -490,10 +482,7 @@ ParseAddDep(pp, sp) *--------------------------------------------------------------------- */ static void -ParseDoSrc (tOp, src, allsrc) - int tOp; /* operator (if any) from special targets */ - char *src; /* name of the source to handle */ - Lst allsrc; /* List of all sources to wait for */ +ParseDoSrc (int tOp, char *src, Lst allsrc) { GNode *gn = NULL; @@ -603,17 +592,15 @@ ParseDoSrc (tOp, src, allsrc) *----------------------------------------------------------------------- */ static int -ParseFindMain(gnp, dummy) - void * gnp; /* Node to examine */ - void * dummy; +ParseFindMain(void *gnp, void *dummy __unused) { GNode *gn = (GNode *) gnp; if ((gn->type & (OP_NOTMAIN|OP_USE|OP_EXEC|OP_TRANSFORM)) == 0) { mainNode = gn; Targ_SetMain(gn); - return (dummy ? 1 : 1); + return (1); } else { - return (dummy ? 0 : 0); + return (0); } } @@ -631,9 +618,7 @@ ParseFindMain(gnp, dummy) *----------------------------------------------------------------------- */ static int -ParseAddDir(path, name) - void * path; - void * name; +ParseAddDir(void *path, void *name) { Dir_AddDir((Lst) path, (char *) name); return(0); @@ -653,12 +638,10 @@ ParseAddDir(path, name) *----------------------------------------------------------------------- */ static int -ParseClearPath(path, dummy) - void * path; - void * dummy; +ParseClearPath(void *path, void *dummy __unused) { Dir_ClearPath((Lst) path); - return(dummy ? 0 : 0); + return (0); } /*- @@ -696,8 +679,7 @@ ParseClearPath(path, dummy) *--------------------------------------------------------------------- */ static void -ParseDoDependency (line) - char *line; /* the line to parse */ +ParseDoDependency (char *line) { char *cp; /* our current position */ GNode *gn; /* a general purpose temporary node */ @@ -1251,8 +1233,7 @@ ParseDoDependency (line) *--------------------------------------------------------------------- */ Boolean -Parse_IsVar (line) - char *line; /* the line to check */ +Parse_IsVar (char *line) { Boolean wasSpace = FALSE; /* set TRUE if found a space */ Boolean haveName = FALSE; /* Set TRUE if have a variable name */ @@ -1353,10 +1334,7 @@ Parse_IsVar (line) *--------------------------------------------------------------------- */ void -Parse_DoVar (line, ctxt) - char *line; /* a line guaranteed to be a variable - * assignment. This reduces error checks */ - GNode *ctxt; /* Context in which to do the assignment */ +Parse_DoVar (char *line, GNode *ctxt) { char *cp; /* pointer into line */ enum { @@ -1518,9 +1496,7 @@ Parse_DoVar (line, ctxt) * A new element is added to the commands list of the node. */ static int -ParseAddCmd(gnp, cmd) - void * gnp; /* the node to which the command is to be added */ - void * cmd; /* the command to add */ +ParseAddCmd(void *gnp, void *cmd) { GNode *gn = (GNode *) gnp; /* if target already supplied, ignore commands */ @@ -1550,8 +1526,7 @@ ParseAddCmd(gnp, cmd) *----------------------------------------------------------------------- */ static void -ParseHasCommands(gnp) - void * gnp; /* Node to examine */ +ParseHasCommands(void *gnp) { GNode *gn = (GNode *) gnp; if (!Lst_IsEmpty(gn->commands)) { @@ -1574,8 +1549,7 @@ ParseHasCommands(gnp) *----------------------------------------------------------------------- */ void -Parse_AddIncludeDir (dir) - char *dir; /* The name of the directory to add */ +Parse_AddIncludeDir (char *dir) { Dir_AddDir (parseIncPath, dir); } @@ -1591,8 +1565,7 @@ Parse_AddIncludeDir (dir) *--------------------------------------------------------------------- */ static void -ParseDoError(errmsg) - char *errmsg; /* error message */ +ParseDoError(char *errmsg) { if (!isspace((unsigned char) *errmsg)) { Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg); @@ -1628,8 +1601,7 @@ ParseDoError(errmsg) *--------------------------------------------------------------------- */ static void -ParseDoInclude (file) - char *file; /* file specification */ +ParseDoInclude (char *file) { char *fullname; /* full pathname of file */ IFile *oldFile; /* state associated with current file */ @@ -1806,8 +1778,7 @@ ParseDoInclude (file) *--------------------------------------------------------------------- */ void -Parse_FromString(str) - char *str; +Parse_FromString(char *str) { IFile *oldFile; /* state associated with this file */ @@ -1847,8 +1818,7 @@ Parse_FromString(str) *--------------------------------------------------------------------- */ static void -ParseTraditionalInclude (file) - char *file; /* file specification */ +ParseTraditionalInclude (char *file) { char *fullname; /* full pathname of file */ IFile *oldFile; /* state associated with current file */ @@ -1989,8 +1959,7 @@ ParseTraditionalInclude (file) *--------------------------------------------------------------------- */ static int -ParseEOF (opened) - int opened; +ParseEOF (int opened) { IFile *ifile; /* the state on the top of the includes stack */ @@ -2026,7 +1995,7 @@ ParseEOF (opened) *--------------------------------------------------------------------- */ static int -ParseReadc() +ParseReadc(void) { if (curFILE) return fgetc(curFILE); @@ -2049,8 +2018,7 @@ ParseReadc() *--------------------------------------------------------------------- */ static void -ParseUnreadc(c) - int c; +ParseUnreadc(int c) { if (curFILE) { ungetc(c, curFILE); @@ -2064,11 +2032,11 @@ ParseUnreadc(c) /* ParseSkipLine(): - * Grab the next line + * Grab the next line unless it begins with a dot (`.') and we're told to + * ignore such lines. */ static char * -ParseSkipLine(skip) - int skip; /* Skip lines that don't start with . */ +ParseSkipLine(int skip) { char *line; int c, lastc, lineLength = 0; @@ -2131,7 +2099,7 @@ ParseSkipLine(skip) *--------------------------------------------------------------------- */ static char * -ParseReadLine () +ParseReadLine (void) { Buffer buf; /* Buffer for current line */ int c; /* the current character */ @@ -2390,7 +2358,7 @@ test_char: *----------------------------------------------------------------------- */ static void -ParseFinishLine() +ParseFinishLine(void) { if (inLine) { Lst_ForEach(targets, Suff_EndTransform, (void *)NULL); @@ -2417,9 +2385,7 @@ ParseFinishLine() *--------------------------------------------------------------------- */ void -Parse_File(name, stream) - char *name; /* the name of the file being read */ - FILE * stream; /* Stream open to makefile to parse */ +Parse_File(char *name, FILE *stream) { char *cp, /* pointer into the line */ *line; /* the line we're working on */ @@ -2602,7 +2568,7 @@ Parse_File(name, stream) *--------------------------------------------------------------------- */ void -Parse_Init () +Parse_Init (void) { mainNode = NULL; parseIncPath = Lst_Init (FALSE); @@ -2612,7 +2578,7 @@ Parse_Init () } void -Parse_End() +Parse_End (void) { Lst_Destroy(targCmds, (void (*)(void *)) free); if (targets) @@ -2638,7 +2604,7 @@ Parse_End() *----------------------------------------------------------------------- */ Lst -Parse_MainName() +Parse_MainName(void) { Lst listmain; /* result list */ diff --git a/usr.bin/make/str.c b/usr.bin/make/str.c index 8ff10df..af5a239 100644 --- a/usr.bin/make/str.c +++ b/usr.bin/make/str.c @@ -52,7 +52,7 @@ static int argmax, curlen; * */ void -str_init() +str_init(void) { char *p1; argv = (char **)emalloc(((argmax = 50) + 1) * sizeof(char *)); @@ -66,7 +66,7 @@ str_init() * */ void -str_end() +str_end(void) { if (argv) { if (argv[0]) @@ -86,9 +86,7 @@ str_end() * the resulting string in allocated space. */ char * -str_concat(s1, s2, flags) - char *s1, *s2; - int flags; +str_concat(char *s1, char *s2, int flags) { int len1, len2; char *result; @@ -134,10 +132,7 @@ str_concat(s1, s2, flags) * the first word is always the value of the .MAKE variable. */ char ** -brk_string(str, store_argc, expand) - char *str; - int *store_argc; - Boolean expand; +brk_string(char *str, int *store_argc, Boolean expand) { int argc, ch; char inquote, *p, *start, *t; @@ -266,11 +261,11 @@ done: argv[argc] = (char *)NULL; * character-for-character basis with no wildcards or special characters. * * Side effects: None. + * + * XXX should be strstr(3). */ char * -Str_FindSubstring(string, substring) - char *string; /* String to search. */ - char *substring; /* Substring to find in string */ +Str_FindSubstring(char *string, char *substring) { char *a, *b; @@ -307,9 +302,7 @@ Str_FindSubstring(string, substring) * Side effects: None. */ int -Str_Match(string, pattern) - char *string; /* String */ - char *pattern; /* Pattern */ +Str_Match(char *string, char *pattern) { char c2; @@ -412,10 +405,7 @@ thisCharOK: ++pattern; *----------------------------------------------------------------------- */ char * -Str_SYSVMatch(word, pattern, len) - char *word; /* Word to examine */ - char *pattern; /* Pattern to examine against */ - int *len; /* Number of characters to substitute */ +Str_SYSVMatch(char *word, char *pattern, int *len) { char *p = pattern; char *w = word; @@ -478,11 +468,7 @@ Str_SYSVMatch(word, pattern, len) *----------------------------------------------------------------------- */ void -Str_SYSVSubst(buf, pat, src, len) - Buffer buf; - char *pat; - char *src; - int len; +Str_SYSVSubst(Buffer buf, char *pat, char *src, int len) { char *m; diff --git a/usr.bin/make/suff.c b/usr.bin/make/suff.c index 7cc1bbf..688f320 100644 --- a/usr.bin/make/suff.c +++ b/usr.bin/make/suff.c @@ -192,9 +192,7 @@ static int SuffPrintTrans(void *, void *); *----------------------------------------------------------------------- */ static char * -SuffStrIsPrefix (pref, str) - char *pref; /* possible prefix */ - char *str; /* string to check */ +SuffStrIsPrefix (char *pref, char *str) { while (*str && *pref == *str) { pref++; @@ -219,9 +217,7 @@ SuffStrIsPrefix (pref, str) *----------------------------------------------------------------------- */ static char * -SuffSuffIsSuffix (s, str) - Suff *s; /* possible suffix */ - char *str; /* string to examine */ +SuffSuffIsSuffix (Suff *s, char *str) { char *p1; /* Pointer into suffix name */ char *p2; /* Pointer into string being examined */ @@ -252,9 +248,7 @@ SuffSuffIsSuffix (s, str) *----------------------------------------------------------------------- */ static int -SuffSuffIsSuffixP(s, str) - void * s; - void * str; +SuffSuffIsSuffixP(void *s, void *str) { return(!SuffSuffIsSuffix((Suff *) s, (char *) str)); } @@ -273,9 +267,7 @@ SuffSuffIsSuffixP(s, str) *----------------------------------------------------------------------- */ static int -SuffSuffHasNameP (s, sname) - void * s; /* Suffix to check */ - void * sname; /* Desired name */ +SuffSuffHasNameP (void *s, void *sname) { return (strcmp ((char *) sname, ((Suff *) s)->name)); } @@ -296,9 +288,7 @@ SuffSuffHasNameP (s, sname) *----------------------------------------------------------------------- */ static int -SuffSuffIsPrefix (s, str) - void * s; /* suffix to compare */ - void * str; /* string to examine */ +SuffSuffIsPrefix (void *s, void *str) { return (SuffStrIsPrefix (((Suff *) s)->name, (char *) str) == NULL ? 1 : 0); } @@ -316,9 +306,7 @@ SuffSuffIsPrefix (s, str) *----------------------------------------------------------------------- */ static int -SuffGNHasNameP (gn, name) - void * gn; /* current node we're looking at */ - void * name; /* name we're looking for */ +SuffGNHasNameP (void *gn, void *name) { return (strcmp ((char *) name, ((GNode *) gn)->name)); } @@ -338,8 +326,7 @@ SuffGNHasNameP (gn, name) *----------------------------------------------------------------------- */ static void -SuffFree (sp) - void * sp; +SuffFree (void *sp) { Suff *s = (Suff *) sp; @@ -371,9 +358,7 @@ SuffFree (sp) *----------------------------------------------------------------------- */ static void -SuffRemove(l, s) - Lst l; - Suff *s; +SuffRemove(Lst l, Suff *s) { LstNode ln = Lst_Member(l, (void *)s); if (ln != NULL) { @@ -396,9 +381,7 @@ SuffRemove(l, s) *----------------------------------------------------------------------- */ static void -SuffInsert (l, s) - Lst l; /* the list where in s should be inserted */ - Suff *s; /* the suffix to insert */ +SuffInsert (Lst l, Suff *s) { LstNode ln; /* current element in l we're examining */ Suff *s2 = NULL; /* the suffix descriptor in this element */ @@ -451,7 +434,7 @@ SuffInsert (l, s) *----------------------------------------------------------------------- */ void -Suff_ClearSuffixes () +Suff_ClearSuffixes (void) { Lst_Concat (suffClean, sufflist, LST_CONCLINK); sufflist = Lst_Init(FALSE); @@ -481,10 +464,7 @@ Suff_ClearSuffixes () *----------------------------------------------------------------------- */ static Boolean -SuffParseTransform(str, srcPtr, targPtr) - char *str; /* String being parsed */ - Suff **srcPtr; /* Place to store source of trans. */ - Suff **targPtr; /* Place to store target of trans. */ +SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr) { LstNode srcLn; /* element in suffix list of trans source*/ Suff *src; /* Source of transformation */ @@ -562,8 +542,7 @@ SuffParseTransform(str, srcPtr, targPtr) *----------------------------------------------------------------------- */ Boolean -Suff_IsTransform (str) - char *str; /* string to check */ +Suff_IsTransform (char *str) { Suff *src, *targ; @@ -585,8 +564,7 @@ Suff_IsTransform (str) *----------------------------------------------------------------------- */ GNode * -Suff_AddTransform (line) - char *line; /* name of transformation to add */ +Suff_AddTransform (char *line) { GNode *gn; /* GNode of transformation rule */ Suff *s, /* source suffix */ @@ -648,9 +626,7 @@ Suff_AddTransform (line) *----------------------------------------------------------------------- */ int -Suff_EndTransform(gnp, dummy) - void * gnp; /* Node for transformation */ - void * dummy; /* Node for transformation */ +Suff_EndTransform(void *gnp, void *dummy __unused) { GNode *gn = (GNode *) gnp; @@ -682,7 +658,7 @@ Suff_EndTransform(gnp, dummy) DEBUGF(SUFF, ("transformation %s complete\n", gn->name)); } - return(dummy ? 0 : 0); + return (0); } /*- @@ -705,9 +681,7 @@ Suff_EndTransform(gnp, dummy) *----------------------------------------------------------------------- */ static int -SuffRebuildGraph(transformp, sp) - void * transformp; /* Transformation to test */ - void * sp; /* Suffix to rebuild */ +SuffRebuildGraph(void *transformp, void *sp) { GNode *transform = (GNode *) transformp; Suff *s = (Suff *) sp; @@ -779,8 +753,7 @@ SuffRebuildGraph(transformp, sp) *----------------------------------------------------------------------- */ void -Suff_AddSuffix (str) - char *str; /* the name of the suffix to add */ +Suff_AddSuffix (char *str) { Suff *s; /* new suffix descriptor */ LstNode ln; @@ -822,8 +795,7 @@ Suff_AddSuffix (str) *----------------------------------------------------------------------- */ Lst -Suff_GetPath (sname) - char *sname; +Suff_GetPath (char *sname) { LstNode ln; Suff *s; @@ -856,7 +828,7 @@ Suff_GetPath (sname) *----------------------------------------------------------------------- */ void -Suff_DoPaths() +Suff_DoPaths(void) { Suff *s; LstNode ln; @@ -918,8 +890,7 @@ Suff_DoPaths() *----------------------------------------------------------------------- */ void -Suff_AddInclude (sname) - char *sname; /* Name of suffix to mark */ +Suff_AddInclude (char *sname) { LstNode ln; Suff *s; @@ -948,8 +919,7 @@ Suff_AddInclude (sname) *----------------------------------------------------------------------- */ void -Suff_AddLib (sname) - char *sname; /* Name of suffix to mark */ +Suff_AddLib (char *sname) { LstNode ln; Suff *s; @@ -978,9 +948,7 @@ Suff_AddLib (sname) *----------------------------------------------------------------------- */ static int -SuffAddSrc (sp, lsp) - void * sp; /* suffix for which to create a Src structure */ - void * lsp; /* list and parent for the new Src */ +SuffAddSrc (void *sp, void *lsp) { Suff *s = (Suff *) sp; LstSrc *ls = (LstSrc *) lsp; @@ -1047,9 +1015,7 @@ SuffAddSrc (sp, lsp) *----------------------------------------------------------------------- */ static void -SuffAddLevel (l, targ) - Lst l; /* list to which to add the new level */ - Src *targ; /* Src structure to use as the parent */ +SuffAddLevel (Lst l, Src *targ) { LstSrc ls; @@ -1072,8 +1038,7 @@ SuffAddLevel (l, targ) *---------------------------------------------------------------------- */ static int -SuffRemoveSrc (l) - Lst l; +SuffRemoveSrc (Lst l) { LstNode ln; Src *s; @@ -1140,9 +1105,7 @@ SuffRemoveSrc (l) *----------------------------------------------------------------------- */ static Src * -SuffFindThem (srcs, slst) - Lst srcs; /* list of Src structures to search through */ - Lst slst; +SuffFindThem (Lst srcs, Lst slst) { Src *s; /* current Src */ Src *rs; /* returned Src */ @@ -1204,9 +1167,7 @@ SuffFindThem (srcs, slst) *----------------------------------------------------------------------- */ static Src * -SuffFindCmds (targ, slst) - Src *targ; /* Src structure to play with */ - Lst slst; +SuffFindCmds (Src *targ, Lst slst) { LstNode ln; /* General-purpose list node */ GNode *t, /* Target GNode */ @@ -1296,9 +1257,7 @@ SuffFindCmds (targ, slst) *----------------------------------------------------------------------- */ static int -SuffExpandChildren(cgnp, pgnp) - void * cgnp; /* Child to examine */ - void * pgnp; /* Parent node being processed */ +SuffExpandChildren(void *cgnp, void *pgnp) { GNode *cgn = (GNode *) cgnp; GNode *pgn = (GNode *) pgnp; @@ -1524,11 +1483,7 @@ SuffExpandChildren(cgnp, pgnp) *----------------------------------------------------------------------- */ static Boolean -SuffApplyTransform(tGn, sGn, t, s) - GNode *tGn; /* Target node */ - GNode *sGn; /* Source node */ - Suff *t; /* Target suffix */ - Suff *s; /* Source suffix */ +SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s) { LstNode ln; /* General node */ char *tname; /* Name of transformation rule */ @@ -1628,9 +1583,7 @@ SuffApplyTransform(tGn, sGn, t, s) *----------------------------------------------------------------------- */ static void -SuffFindArchiveDeps(gn, slst) - GNode *gn; /* Node for which to locate dependencies */ - Lst slst; +SuffFindArchiveDeps(GNode *gn, Lst slst) { char *eoarch; /* End of archive portion */ char *eoname; /* End of member portion */ @@ -1761,9 +1714,7 @@ SuffFindArchiveDeps(gn, slst) *----------------------------------------------------------------------- */ static void -SuffFindNormalDeps(gn, slst) - GNode *gn; /* Node for which to find sources */ - Lst slst; +SuffFindNormalDeps(GNode *gn, Lst slst) { char *eoname; /* End of name */ char *sopref; /* Start of prefix */ @@ -2153,8 +2104,7 @@ sfnd_return: */ void -Suff_FindDeps(gn) - GNode *gn; +Suff_FindDeps(GNode *gn) { SuffFindDeps(gn, srclist); @@ -2164,9 +2114,7 @@ Suff_FindDeps(gn) static void -SuffFindDeps (gn, slst) - GNode *gn; /* node we're dealing with */ - Lst slst; +SuffFindDeps (GNode *gn, Lst slst) { if (gn->type & OP_DEPS_FOUND) { /* @@ -2233,8 +2181,7 @@ SuffFindDeps (gn, slst) *----------------------------------------------------------------------- */ void -Suff_SetNull(name) - char *name; /* Name of null suffix */ +Suff_SetNull(char *name) { Suff *s; LstNode ln; @@ -2269,7 +2216,7 @@ Suff_SetNull(name) *----------------------------------------------------------------------- */ void -Suff_Init () +Suff_Init (void) { sufflist = Lst_Init (FALSE); suffClean = Lst_Init(FALSE); @@ -2312,7 +2259,7 @@ Suff_Init () */ void -Suff_End() +Suff_End(void) { Lst_Destroy(sufflist, SuffFree); Lst_Destroy(suffClean, SuffFree); @@ -2325,18 +2272,15 @@ Suff_End() /********************* DEBUGGING FUNCTIONS **********************/ -static int SuffPrintName(s, dummy) - void * s; - void * dummy; +static int +SuffPrintName(void *s, void *dummy __unused) { printf ("`%s' ", ((Suff *) s)->name); - return (dummy ? 0 : 0); + return (0); } static int -SuffPrintSuff (sp, dummy) - void * sp; - void * dummy; +SuffPrintSuff (void *sp, void *dummy __unused) { Suff *s = (Suff *) sp; int flags; @@ -2376,13 +2320,11 @@ SuffPrintSuff (sp, dummy) printf ("#\tSearch Path: "); Dir_PrintPath (s->searchPath); fputc ('\n', stdout); - return (dummy ? 0 : 0); + return (0); } static int -SuffPrintTrans (tp, dummy) - void * tp; - void * dummy; +SuffPrintTrans (void *tp, void *dummy __unused) { GNode *t = (GNode *) tp; @@ -2391,11 +2333,11 @@ SuffPrintTrans (tp, dummy) fputc ('\n', stdout); Lst_ForEach (t->commands, Targ_PrintCmd, (void *)0); fputc ('\n', stdout); - return(dummy ? 0 : 0); + return (0); } void -Suff_PrintAll() +Suff_PrintAll(void) { printf ("#*** Suffixes:\n"); Lst_ForEach (sufflist, SuffPrintSuff, (void *)0); diff --git a/usr.bin/make/targ.c b/usr.bin/make/targ.c index 851b7a9..2d0f1c3 100644 --- a/usr.bin/make/targ.c +++ b/usr.bin/make/targ.c @@ -112,7 +112,7 @@ static void TargFreeGN(void *); *----------------------------------------------------------------------- */ void -Targ_Init () +Targ_Init (void) { allTargets = Lst_Init (FALSE); Hash_InitTable (&targets, HTSIZE); @@ -131,7 +131,7 @@ Targ_Init () *----------------------------------------------------------------------- */ void -Targ_End () +Targ_End (void) { Lst_Destroy(allTargets, NOFREE); if (allGNs) @@ -153,8 +153,7 @@ Targ_End () *----------------------------------------------------------------------- */ GNode * -Targ_NewGN (name) - char *name; /* the name to stick in the new node */ +Targ_NewGN (char *name) { GNode *gn; @@ -202,8 +201,7 @@ Targ_NewGN (name) *----------------------------------------------------------------------- */ static void -TargFreeGN (gnp) - void * gnp; +TargFreeGN (void *gnp) { GNode *gn = (GNode *) gnp; @@ -238,10 +236,7 @@ TargFreeGN (gnp) *----------------------------------------------------------------------- */ GNode * -Targ_FindNode (name, flags) - char *name; /* the name to find */ - int flags; /* flags governing events when target not - * found */ +Targ_FindNode (char *name, int flags) { GNode *gn; /* node in that element */ Hash_Entry *he; /* New or used hash entry for node */ @@ -283,10 +278,7 @@ Targ_FindNode (name, flags) * ----------------------------------------------------------------------- */ Lst -Targ_FindList (names, flags) - Lst names; /* list of names to find */ - int flags; /* flags used if no node is found for a given - * name */ +Targ_FindList (Lst names, int flags) { Lst nodes; /* result list */ LstNode ln; /* name list element */ @@ -332,8 +324,7 @@ Targ_FindList (names, flags) *----------------------------------------------------------------------- */ Boolean -Targ_Ignore (gn) - GNode *gn; /* node to check for */ +Targ_Ignore (GNode *gn) { if (ignoreErrors || gn->type & OP_IGNORE) { return (TRUE); @@ -355,8 +346,7 @@ Targ_Ignore (gn) *----------------------------------------------------------------------- */ Boolean -Targ_Silent (gn) - GNode *gn; /* node to check for */ +Targ_Silent (GNode *gn) { if (beSilent || gn->type & OP_SILENT) { return (TRUE); @@ -378,8 +368,7 @@ Targ_Silent (gn) *----------------------------------------------------------------------- */ Boolean -Targ_Precious (gn) - GNode *gn; /* the node to check */ +Targ_Precious (GNode *gn) { if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) { return (TRUE); @@ -405,16 +394,13 @@ static GNode *mainTarg; /* the main target, as set by Targ_SetMain */ *----------------------------------------------------------------------- */ void -Targ_SetMain (gn) - GNode *gn; /* The main target we'll create */ +Targ_SetMain (GNode *gn) { mainTarg = gn; } static int -TargPrintName (gnp, ppath) - void * gnp; - void * ppath; +TargPrintName (void *gnp, void *ppath) { GNode *gn = (GNode *) gnp; printf ("%s ", gn->name); @@ -433,12 +419,10 @@ TargPrintName (gnp, ppath) int -Targ_PrintCmd (cmd, dummy) - void * cmd; - void * dummy; +Targ_PrintCmd (void *cmd, void *dummy __unused) { printf ("\t%s\n", (char *) cmd); - return (dummy ? 0 : 0); + return (0); } /*- @@ -456,8 +440,7 @@ Targ_PrintCmd (cmd, dummy) *----------------------------------------------------------------------- */ char * -Targ_FmtTime (modtime) - time_t modtime; +Targ_FmtTime (time_t modtime) { struct tm *parts; static char buf[128]; @@ -482,8 +465,7 @@ Targ_FmtTime (modtime) *----------------------------------------------------------------------- */ void -Targ_PrintType (type) - int type; +Targ_PrintType (int type) { int tbit; @@ -522,9 +504,7 @@ Targ_PrintType (type) *----------------------------------------------------------------------- */ static int -TargPrintNode (gnp, passp) - void * gnp; - void * passp; +TargPrintNode (void *gnp, void *passp) { GNode *gn = (GNode *) gnp; int pass = *(int *) passp; @@ -606,21 +586,19 @@ TargPrintNode (gnp, passp) *----------------------------------------------------------------------- */ static int -TargPrintOnlySrc(gnp, dummy) - void * gnp; - void * dummy; +TargPrintOnlySrc(void *gnp, void *dummy __unused) { GNode *gn = (GNode *) gnp; if (OP_NOP(gn->type)) printf("#\t%s [%s]\n", gn->name, gn->path ? gn->path : gn->name); - return (dummy ? 0 : 0); + return (0); } /*- *----------------------------------------------------------------------- * Targ_PrintGraph -- - * print the entire graph. heh heh + * Print the entire graph. * * Results: * none @@ -630,9 +608,7 @@ TargPrintOnlySrc(gnp, dummy) *----------------------------------------------------------------------- */ void -Targ_PrintGraph (pass) - int pass; /* Which pass this is. 1 => no processing - * 2 => processing done */ +Targ_PrintGraph (int pass) { printf("#*** Input graph:\n"); Lst_ForEach (allTargets, TargPrintNode, (void *)&pass); diff --git a/usr.bin/make/var.c b/usr.bin/make/var.c index 3587a70..3bd17ca 100644 --- a/usr.bin/make/var.c +++ b/usr.bin/make/var.c @@ -204,9 +204,7 @@ static int VarPrintVar(void *, void *); *----------------------------------------------------------------------- */ static int -VarCmp (v, name) - void * v; /* VAR structure to compare */ - void * name; /* name to look for */ +VarCmp (void *v, void *name) { return (strcmp ((char *) name, ((Var *) v)->name)); } @@ -224,9 +222,7 @@ VarCmp (v, name) *----------------------------------------------------------------------- */ static void -VarPossiblyExpand(name, ctxt) - char **name; - GNode *ctxt; +VarPossiblyExpand(char **name, GNode *ctxt) { if (strchr(*name, '$') != NULL) *name = Var_Subst(NULL, *name, ctxt, 0); @@ -240,6 +236,11 @@ VarPossiblyExpand(name, ctxt) * Find the given variable in the given context and any other contexts * indicated. * + * Flags: + * FIND_GLOBAL set means look in the VAR_GLOBAL context too + * FIND_CMD set means to look in the VAR_CMD context too + * FIND_ENV set means to look in the environment + * * Results: * A pointer to the structure describing the desired variable or * NULL if the variable does not exist. @@ -249,15 +250,7 @@ VarPossiblyExpand(name, ctxt) *----------------------------------------------------------------------- */ static Var * -VarFind (name, ctxt, flags) - char *name; /* name to find */ - GNode *ctxt; /* context in which to find it */ - int flags; /* FIND_GLOBAL set means to look in the - * VAR_GLOBAL context as well. - * FIND_CMD set means to look in the VAR_CMD - * context also. - * FIND_ENV set means to look in the - * environment */ +VarFind (char *name, GNode *ctxt, int flags) { Boolean localCheckEnvFirst; LstNode var; @@ -364,7 +357,7 @@ VarFind (name, ctxt, flags) /*- *----------------------------------------------------------------------- * VarAdd -- - * Add a new variable of name name and value val to the given context + * Add a new variable of name name and value val to the given context. * * Results: * None @@ -376,10 +369,7 @@ VarFind (name, ctxt, flags) *----------------------------------------------------------------------- */ static void -VarAdd (name, val, ctxt) - char *name; /* name of variable to add */ - char *val; /* value to set it to */ - GNode *ctxt; /* context in which to set it */ +VarAdd (char *name, char *val, GNode *ctxt) { Var *v; int len; @@ -413,8 +403,7 @@ VarAdd (name, val, ctxt) *----------------------------------------------------------------------- */ static void -VarDelete(vp) - void * vp; +VarDelete(void *vp) { Var *v = (Var *) vp; free(v->name); @@ -438,9 +427,7 @@ VarDelete(vp) *----------------------------------------------------------------------- */ void -Var_Delete(name, ctxt) - char *name; - GNode *ctxt; +Var_Delete(char *name, GNode *ctxt) { LstNode ln; @@ -479,10 +466,7 @@ Var_Delete(name, ctxt) *----------------------------------------------------------------------- */ void -Var_Set (name, val, ctxt) - char *name; /* name of variable to set */ - char *val; /* value to give to the variable */ - GNode *ctxt; /* context in which to set it */ +Var_Set (char *name, char *val, GNode *ctxt) { Var *v; @@ -534,10 +518,7 @@ Var_Set (name, val, ctxt) *----------------------------------------------------------------------- */ void -Var_Append (name, val, ctxt) - char *name; /* Name of variable to modify */ - char *val; /* String to append to it */ - GNode *ctxt; /* Context in which this should occur */ +Var_Append (char *name, char *val, GNode *ctxt) { Var *v; @@ -581,9 +562,7 @@ Var_Append (name, val, ctxt) *----------------------------------------------------------------------- */ Boolean -Var_Exists(name, ctxt) - char *name; /* Variable to find */ - GNode *ctxt; /* Context in which to start search */ +Var_Exists(char *name, GNode *ctxt) { Var *v; @@ -614,10 +593,7 @@ Var_Exists(name, ctxt) *----------------------------------------------------------------------- */ char * -Var_Value (name, ctxt, frp) - char *name; /* name to find */ - GNode *ctxt; /* context in which to search for it */ - char **frp; +Var_Value (char *name, GNode *ctxt, char **frp) { Var *v; @@ -654,12 +630,7 @@ Var_Value (name, ctxt, frp) *----------------------------------------------------------------------- */ static Boolean -VarHead (word, addSpace, buf, dummy) - char *word; /* Word to trim */ - Boolean addSpace; /* True if need to add a space to the buffer - * before sticking in the head */ - Buffer buf; /* Buffer in which to store it */ - void * dummy; +VarHead (char *word, Boolean addSpace, Buffer buf, void *dummy __unused) { char *slash; @@ -682,7 +653,7 @@ VarHead (word, addSpace, buf, dummy) Buf_AddByte(buf, (Byte)'.'); } } - return(dummy ? TRUE : TRUE); + return (TRUE); } /*- @@ -701,12 +672,7 @@ VarHead (word, addSpace, buf, dummy) *----------------------------------------------------------------------- */ static Boolean -VarTail (word, addSpace, buf, dummy) - char *word; /* Word to trim */ - Boolean addSpace; /* TRUE if need to stick a space in the - * buffer before adding the tail */ - Buffer buf; /* Buffer in which to store it */ - void * dummy; +VarTail (char *word, Boolean addSpace, Buffer buf, void *dummy __unused) { char *slash; @@ -722,7 +688,7 @@ VarTail (word, addSpace, buf, dummy) } else { Buf_AddBytes (buf, strlen(word), (Byte *)word); } - return (dummy ? TRUE : TRUE); + return (TRUE); } /*- @@ -740,12 +706,7 @@ VarTail (word, addSpace, buf, dummy) *----------------------------------------------------------------------- */ static Boolean -VarSuffix (word, addSpace, buf, dummy) - char *word; /* Word to trim */ - Boolean addSpace; /* TRUE if need to add a space before placing - * the suffix in the buffer */ - Buffer buf; /* Buffer in which to store it */ - void * dummy; +VarSuffix (char *word, Boolean addSpace, Buffer buf, void *dummy __unused) { char *dot; @@ -759,7 +720,7 @@ VarSuffix (word, addSpace, buf, dummy) dot[-1] = '.'; addSpace = TRUE; } - return (dummy ? addSpace : addSpace); + return (addSpace); } /*- @@ -778,12 +739,7 @@ VarSuffix (word, addSpace, buf, dummy) *----------------------------------------------------------------------- */ static Boolean -VarRoot (word, addSpace, buf, dummy) - char *word; /* Word to trim */ - Boolean addSpace; /* TRUE if need to add a space to the buffer - * before placing the root in it */ - Buffer buf; /* Buffer in which to store it */ - void * dummy; +VarRoot (char *word, Boolean addSpace, Buffer buf, void *dummy __unused) { char *dot; @@ -799,7 +755,7 @@ VarRoot (word, addSpace, buf, dummy) } else { Buf_AddBytes (buf, strlen(word), (Byte *)word); } - return (dummy ? TRUE : TRUE); + return (TRUE); } /*- @@ -807,6 +763,8 @@ VarRoot (word, addSpace, buf, dummy) * VarMatch -- * Place the word in the buffer if it matches the given pattern. * Callback function for VarModify to implement the :M modifier. + * A space will be added if requested. A pattern is supplied + * which the word must match. * * Results: * TRUE if a space should be placed in the buffer before the next @@ -818,13 +776,7 @@ VarRoot (word, addSpace, buf, dummy) *----------------------------------------------------------------------- */ static Boolean -VarMatch (word, addSpace, buf, pattern) - char *word; /* Word to examine */ - Boolean addSpace; /* TRUE if need to add a space to the - * buffer before adding the word, if it - * matches */ - Buffer buf; /* Buffer in which to store it */ - void * pattern; /* Pattern the word must match */ +VarMatch (char *word, Boolean addSpace, Buffer buf, void *pattern) { if (Str_Match(word, (char *) pattern)) { if (addSpace) { @@ -842,7 +794,7 @@ VarMatch (word, addSpace, buf, pattern) * VarSYSVMatch -- * Place the word in the buffer if it matches the given pattern. * Callback function for VarModify to implement the System V % - * modifiers. + * modifiers. A space is added if requested. * * Results: * TRUE if a space should be placed in the buffer before the next @@ -854,13 +806,7 @@ VarMatch (word, addSpace, buf, pattern) *----------------------------------------------------------------------- */ static Boolean -VarSYSVMatch (word, addSpace, buf, patp) - char *word; /* Word to examine */ - Boolean addSpace; /* TRUE if need to add a space to the - * buffer before adding the word, if it - * matches */ - Buffer buf; /* Buffer in which to store it */ - void * patp; /* Pattern the word must match */ +VarSYSVMatch (char *word, Boolean addSpace, Buffer buf, void *patp) { int len; char *ptr; @@ -885,7 +831,8 @@ VarSYSVMatch (word, addSpace, buf, patp) *----------------------------------------------------------------------- * VarNoMatch -- * Place the word in the buffer if it doesn't match the given pattern. - * Callback function for VarModify to implement the :N modifier. + * Callback function for VarModify to implement the :N modifier. A + * space is added if requested. * * Results: * TRUE if a space should be placed in the buffer before the next @@ -897,13 +844,7 @@ VarSYSVMatch (word, addSpace, buf, patp) *----------------------------------------------------------------------- */ static Boolean -VarNoMatch (word, addSpace, buf, pattern) - char *word; /* Word to examine */ - Boolean addSpace; /* TRUE if need to add a space to the - * buffer before adding the word, if it - * matches */ - Buffer buf; /* Buffer in which to store it */ - void * pattern; /* Pattern the word must match */ +VarNoMatch (char *word, Boolean addSpace, Buffer buf, void *pattern) { if (!Str_Match(word, (char *) pattern)) { if (addSpace) { @@ -920,7 +861,7 @@ VarNoMatch (word, addSpace, buf, pattern) *----------------------------------------------------------------------- * VarSubstitute -- * Perform a string-substitution on the given word, placing the - * result in the passed buffer. + * result in the passed buffer. A space is added if requested. * * Results: * TRUE if a space is needed before more characters are added. @@ -931,12 +872,7 @@ VarNoMatch (word, addSpace, buf, pattern) *----------------------------------------------------------------------- */ static Boolean -VarSubstitute (word, addSpace, buf, patternp) - char *word; /* Word to modify */ - Boolean addSpace; /* True if space should be added before - * other characters */ - Buffer buf; /* Buffer for result */ - void * patternp; /* Pattern for substitution */ +VarSubstitute (char *word, Boolean addSpace, Buffer buf, void *patternp) { int wordLen; /* Length of word */ char *cp; /* General pointer */ @@ -1098,10 +1034,7 @@ VarSubstitute (word, addSpace, buf, patternp) *----------------------------------------------------------------------- */ static void -VarREError(err, pat, str) - int err; - regex_t *pat; - const char *str; +VarREError(int err, regex_t *pat, const char *str) { char *errbuf; int errlen; @@ -1118,7 +1051,7 @@ VarREError(err, pat, str) *----------------------------------------------------------------------- * VarRESubstitute -- * Perform a regex substitution on the given word, placing the - * result in the passed buffer. + * result in the passed buffer. A space is added if requested. * * Results: * TRUE if a space is needed before more characters are added. @@ -1129,11 +1062,7 @@ VarREError(err, pat, str) *----------------------------------------------------------------------- */ static Boolean -VarRESubstitute(word, addSpace, buf, patternp) - char *word; - Boolean addSpace; - Buffer buf; - void * patternp; +VarRESubstitute(char *word, Boolean addSpace, Buffer buf, void *patternp) { VarREPattern *pat; int xrv; @@ -1261,11 +1190,8 @@ VarRESubstitute(word, addSpace, buf, patternp) *----------------------------------------------------------------------- */ static char * -VarModify (str, modProc, datum) - char *str; /* String whose words should be trimmed */ - /* Function to use to modify them */ - Boolean (*modProc)(char *, Boolean, Buffer, void *); - void * datum; /* Datum to pass it */ +VarModify (char *str, Boolean (*modProc)(char *, Boolean, Buffer, void *), + void *datum) { Buffer buf; /* Buffer for the new string */ Boolean addSpace; /* TRUE if need to add a space to the @@ -1311,14 +1237,8 @@ VarModify (str, modProc, datum) *----------------------------------------------------------------------- */ static char * -VarGetPattern(ctxt, err, tstr, delim, flags, length, pattern) - GNode *ctxt; - int err; - char **tstr; - int delim; - int *flags; - int *length; - VarPattern *pattern; +VarGetPattern(GNode *ctxt, int err, char **tstr, int delim, int *flags, + int *length, VarPattern *pattern) { char *cp; Buffer buf = Buf_Init(0); @@ -1431,8 +1351,7 @@ VarGetPattern(ctxt, err, tstr, delim, flags, length, pattern) *----------------------------------------------------------------------- */ static char * -VarQuote(str) - char *str; +VarQuote(char *str) { Buffer buf; @@ -1472,12 +1391,7 @@ VarQuote(str) *----------------------------------------------------------------------- */ char * -Var_Parse (str, ctxt, err, lengthPtr, freePtr) - char *str; /* The string to parse */ - GNode *ctxt; /* The context for the variable */ - Boolean err; /* TRUE if undefined variables are an error */ - int *lengthPtr; /* OUT: The length of the specification */ - Boolean *freePtr; /* OUT: TRUE if caller should free result */ +Var_Parse(char *str, GNode *ctxt, Boolean err, int *lengthPtr, Boolean *freePtr) { char *tstr; /* Pointer into str */ Var *v; /* Variable in invocation */ @@ -2327,11 +2241,7 @@ Var_Parse (str, ctxt, err, lengthPtr, freePtr) *----------------------------------------------------------------------- */ char * -Var_Subst (var, str, ctxt, undefErr) - char *var; /* Named variable || NULL for all */ - char *str; /* the string in which to substitute */ - GNode *ctxt; /* the context wherein to find variables */ - Boolean undefErr; /* TRUE if undefineds are an error */ +Var_Subst (char *var, char *str, GNode *ctxt, Boolean undefErr) { Buffer buf; /* Buffer for forming things */ char *val; /* Value to substitute for a variable */ @@ -2493,8 +2403,7 @@ Var_Subst (var, str, ctxt, undefErr) *----------------------------------------------------------------------- */ char * -Var_GetTail(file) - char *file; /* Filename to modify */ +Var_GetTail(char *file) { return(VarModify(file, VarTail, (void *)0)); } @@ -2515,8 +2424,7 @@ Var_GetTail(file) *----------------------------------------------------------------------- */ char * -Var_GetHead(file) - char *file; /* Filename to manipulate */ +Var_GetHead(char *file) { return(VarModify(file, VarHead, (void *)0)); } @@ -2534,7 +2442,7 @@ Var_GetHead(file) *----------------------------------------------------------------------- */ void -Var_Init () +Var_Init (void) { VAR_GLOBAL = Targ_NewGN ("Global"); VAR_CMD = Targ_NewGN ("Command"); @@ -2544,7 +2452,7 @@ Var_Init () void -Var_End () +Var_End (void) { Lst_Destroy(allVars, VarDelete); } @@ -2552,13 +2460,11 @@ Var_End () /****************** PRINT DEBUGGING INFO *****************/ static int -VarPrintVar (vp, dummy) - void * vp; - void * dummy; +VarPrintVar (void *vp, void *dummy __unused) { Var *v = (Var *) vp; printf ("%-16s = %s\n", v->name, (char *) Buf_GetAll(v->val, (int *)NULL)); - return (dummy ? 0 : 0); + return (0); } /*- @@ -2568,8 +2474,7 @@ VarPrintVar (vp, dummy) *----------------------------------------------------------------------- */ void -Var_Dump (ctxt) - GNode *ctxt; +Var_Dump (GNode *ctxt) { Lst_ForEach (ctxt->context, VarPrintVar, (void *) 0); } |
