d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Typedefs of pointers to structs are evil. Make Lst and LstNode typedef of

Browse Source 
the structs itself not of pointers to them. This will simplify constification.

Checked by: diff on the object files
This commit is contained in:
Hartmut Brandt 2004-12-07 13:49:13 +00:00
parent b82f920f8e
commit bf1ead0608
31 changed files with 230 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
usr.bin/make/arch.c
View File

@ -103,7 +103,7 @@ __FBSDID("$FreeBSD$");
#include "dir.h"
#include "config.h"
static Lst archives; /* Lst of archives we've already examined */
static Lst *archives; /* Lst of archives we've already examined */
typedef struct Arch {
char *name; /* Name of archive */
@ -174,7 +174,7 @@ ArchFree(void *ap)
*-----------------------------------------------------------------------
*/
ReturnStatus
Arch_ParseArchive(char **linePtr, Lst nodeLst, GNode *ctxt)
Arch_ParseArchive(char **linePtr, Lst *nodeLst, GNode *ctxt)
{
char *cp; /* Pointer into line */
GNode *gn; /* New node */
@ -336,7 +336,7 @@ Arch_ParseArchive(char **linePtr, Lst nodeLst, GNode *ctxt)
*/
free(buf);
} else if (Dir_HasWildcards(memName)) {
Lst members = Lst_Init();
Lst *members = Lst_Init();
char *member;
size_t sz = MAXPATHLEN;
size_t nsz;
@ -466,7 +466,7 @@ ArchStatMember(char *archive, char *member, Boolean hash)
int size; /* Size of archive member */
char *cp; /* Useful character pointer */
char magic[SARMAG];
LstNode ln; /* Lst member containing archive descriptor */
LstNode *ln; /* Lst member containing archive descriptor */
Arch *ar; /* Archive descriptor */
Hash_Entry *he; /* Entry containing member's description */
struct ar_hdr arh; /* archive-member header for reading archive */
@ -1016,7 +1016,7 @@ Arch_MTime(GNode *gn)
int
Arch_MemMTime(GNode *gn)
{
LstNode ln;
LstNode *ln;
GNode *pgn;
char *nameStart,
*nameEnd;
@ -1079,7 +1079,7 @@ Arch_MemMTime(GNode *gn)
*-----------------------------------------------------------------------
*/
void
Arch_FindLib(GNode *gn, Lst path)
Arch_FindLib(GNode *gn, Lst *path)
{
char *libName; /* file name for archive */
size_t sz;

4
usr.bin/make/compat.c
View File

@ -225,7 +225,7 @@ Compat_RunCommand(void *cmdp, void *gnp)
int status; /* Description of child's death */
int cpid; /* Child actually found */
ReturnStatus rstat; /* Status of fork */
LstNode cmdNode; /* Node where current command is located */
LstNode *cmdNode; /* Node where current command is located */
char **av; /* Argument vector for thing to exec */
int argc; /* Number of arguments in av or 0 if not
* dynamically allocated */
@ -679,7 +679,7 @@ CompatMake(void *gnp, void *pgnp)
*-----------------------------------------------------------------------
*/
void
Compat_Run(Lst targs)
Compat_Run(Lst *targs)
{
GNode *gn = NULL;/* Current root target */
int errors; /* Number of targets not remade due to errors */

40
usr.bin/make/dir.c
View File

@ -164,9 +164,9 @@ __FBSDID("$FreeBSD$");
* in a cache for when Dir_MTime was actually called.
*/
Lst dirSearchPath; /* main search path */
Lst *dirSearchPath; /* main search path */
static Lst openDirectories; /* the list of all open directories */
static Lst *openDirectories; /* the list of all open directories */
/*
* Variables for gathering statistics on the efficiency of the hashing
@ -229,7 +229,7 @@ Dir_Init(void)
void
Dir_InitDot(void)
{
LstNode ln;
LstNode *ln;
Dir_AddDir(openDirectories, ".");
if ((ln = Lst_Last(openDirectories)) == NULL)
@ -352,7 +352,7 @@ Dir_HasWildcards(const char *name)
*-----------------------------------------------------------------------
*/
static int
DirMatchFiles(const char *pattern, const Path *p, Lst expansions)
DirMatchFiles(const char *pattern, const Path *p, Lst *expansions)
{
Hash_Search search; /* Index into the directory's table */
Hash_Entry *entry; /* Current entry in the table */
@ -400,7 +400,7 @@ DirMatchFiles(const char *pattern, const Path *p, Lst expansions)
*-----------------------------------------------------------------------
*/
static void
DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions)
DirExpandCurly(const char *word, const char *brace, Lst *path, Lst *expansions)
{
const char *end; /* Character after the closing brace */
const char *cp; /* Current position in brace clause */
@ -504,9 +504,9 @@ DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions)
*-----------------------------------------------------------------------
*/
static void
DirExpandInt(const char *word, Lst path, Lst expansions)
DirExpandInt(const char *word, Lst *path, Lst *expansions)
{
LstNode ln; /* Current node */
LstNode *ln; /* Current node */
Path *p; /* Directory in the node */
if (Lst_Open(path) == SUCCESS) {
@ -556,7 +556,7 @@ DirPrintWord(void *word, void *dummy __unused)
*-----------------------------------------------------------------------
*/
void
Dir_Expand(char *word, Lst path, Lst expansions)
Dir_Expand(char *word, Lst *path, Lst *expansions)
{
char *cp;
@ -677,11 +677,11 @@ Dir_Expand(char *word, Lst path, Lst expansions)
*-----------------------------------------------------------------------
*/
char *
Dir_FindFile(char *name, Lst path)
Dir_FindFile(char *name, Lst *path)
{
char *p1; /* pointer into p->name */
char *p2; /* pointer into name */
LstNode ln; /* a list element */
LstNode *ln; /* a list element */
char *file; /* the current filename to check */
Path *p; /* current path member */
char *cp; /* final component of the name */
@ -1012,9 +1012,9 @@ Dir_MTime(GNode *gn)
*-----------------------------------------------------------------------
*/
void
Dir_AddDir(Lst path, char *name)
Dir_AddDir(Lst *path, char *name)
{
LstNode ln; /* node in case Path structure is found */
LstNode *ln; /* node in case Path structure is found */
Path *p; /* pointer to new Path structure */
DIR *d; /* for reading directory */
struct dirent *dp; /* entry in directory */
@ -1111,11 +1111,11 @@ Dir_CopyDir(void *p)
*-----------------------------------------------------------------------
*/
char *
Dir_MakeFlags(char *flag, Lst path)
Dir_MakeFlags(char *flag, Lst *path)
{
char *str; /* the string which will be returned */
char *tstr; /* the current directory preceded by 'flag' */
LstNode ln; /* the node of the current directory */
LstNode *ln; /* the node of the current directory */
Path *p; /* the structure describing the current directory */
str = estrdup("");
@ -1155,7 +1155,7 @@ Dir_Destroy(void *pp)
p->refCount -= 1;
if (p->refCount == 0) {
LstNode ln;
LstNode *ln;
ln = Lst_Member(openDirectories, p);
Lst_Remove(openDirectories, ln);
@ -1181,7 +1181,7 @@ Dir_Destroy(void *pp)
*-----------------------------------------------------------------------
*/
void
Dir_ClearPath(Lst path)
Dir_ClearPath(Lst *path)
{
Path *p;
@ -1207,9 +1207,9 @@ Dir_ClearPath(Lst path)
*-----------------------------------------------------------------------
*/
void
Dir_Concat(Lst path1, Lst path2)
Dir_Concat(Lst *path1, Lst *path2)
{
LstNode ln;
LstNode *ln;
Path *p;
for (ln = Lst_First(path2); ln != NULL; ln = Lst_Succ(ln)) {
@ -1225,7 +1225,7 @@ Dir_Concat(Lst path1, Lst path2)
void
Dir_PrintDirectories(void)
{
LstNode ln;
LstNode *ln;
Path *p;
printf("#*** Directory Cache:\n");
@ -1254,7 +1254,7 @@ DirPrintDir(void *p, void *dummy __unused)
}
void
Dir_PrintPath(Lst path)
Dir_PrintPath(Lst *path)
{
Lst_ForEach(path, DirPrintDir, (void *)NULL);

14
usr.bin/make/dir.h
View File

@ -58,15 +58,15 @@ void Dir_Init(void);
void Dir_InitDot(void);
void Dir_End(void);
Boolean Dir_HasWildcards(const char *);
void Dir_Expand(char *, Lst, Lst);
char *Dir_FindFile(char *, Lst);
void Dir_Expand(char *, Lst *, Lst *);
char *Dir_FindFile(char *, Lst *);
int Dir_MTime(GNode *);
void Dir_AddDir(Lst, char *);
char *Dir_MakeFlags(char *, Lst);
void Dir_ClearPath(Lst);
void Dir_Concat(Lst, Lst);
void Dir_AddDir(Lst *, char *);
char *Dir_MakeFlags(char *, Lst *);
void Dir_ClearPath(Lst *);
void Dir_Concat(Lst *, Lst *);
void Dir_PrintDirectories(void);
void Dir_PrintPath(Lst);
void Dir_PrintPath(Lst *);
void Dir_Destroy(void *);
void *Dir_CopyDir(void *);

4
usr.bin/make/for.c
View File

@ -72,7 +72,7 @@ __FBSDID("$FreeBSD$");
static int forLevel = 0; /* Nesting level */
static char *forVar; /* Iteration variable */
static Buffer forBuf; /* Commands in loop */
static Lst forLst; /* List of items */
static Lst *forLst; /* List of items */
/*
* State of a for loop.
@ -80,7 +80,7 @@ static Lst forLst; /* List of items */
typedef struct _For {
Buffer buf; /* Unexpanded buffer */
char* var; /* Index name */
Lst lst; /* List of variables */
Lst *lst; /* List of variables */
int lineno; /* Line # */
} For;

16
usr.bin/make/job.c
View File

@ -214,7 +214,7 @@ char *shellPath = NULL, /* full pathname of executable image */
static int maxJobs; /* The most children we can run at once */
STATIC int nJobs; /* The number of children currently running */
STATIC Lst jobs; /* The structures that describe them */
STATIC Lst *jobs; /* The structures that describe them */
STATIC Boolean jobFull; /* Flag to tell when the job table is full. It
* is set TRUE when (1) the total number of
* running jobs equals the maximum allowed */
@ -241,7 +241,7 @@ STATIC char *targFmt; /* Format string to use to head output from a
* been stopped somehow, the job is placed on the stoppedJobs queue to be run
* when the next job finishes.
*/
STATIC Lst stoppedJobs; /* Lst of Job structures describing
STATIC Lst *stoppedJobs; /* Lst of Job structures describing
* jobs that were stopped due to concurrency
* limits or externally */
@ -471,7 +471,7 @@ JobPrintCommand(void *cmdp, void *jobp)
char *cmdTemplate; /* Template to use when printing the
* command */
char *cmdStart; /* Start of expanded command */
LstNode cmdNode; /* Node for replacing the command */
LstNode *cmdNode; /* Node for replacing the command */
char *cmd = cmdp;
Job *job = jobp;
@ -1465,7 +1465,7 @@ JobStart(GNode *gn, int flags, Job *previous)
if ((job->flags&JOB_FIRST) && (Lst_Open(gn->commands) != SUCCESS)){
cmdsOK = FALSE;
} else {
LstNode ln = Lst_Next(gn->commands);
LstNode *ln = Lst_Next(gn->commands);
if ((ln == NULL) ||
JobPrintCommand(Lst_Datum(ln), job))
@ -1904,7 +1904,7 @@ Job_CatchChildren(Boolean block)
{
int pid; /* pid of dead child */
Job *job; /* job descriptor for dead child */
LstNode jnode; /* list element for finding job */
LstNode *jnode; /* list element for finding job */
int status; /* Exit/termination status */
/*
@ -1985,7 +1985,7 @@ Job_CatchOutput(int flag)
#else
struct timeval timeout;
fd_set readfds;
LstNode ln;
LstNode *ln;
Job *job;
#endif
@ -2615,7 +2615,7 @@ Job_ParseShell(char *line)
static void
JobInterrupt(int runINTERRUPT, int signo)
{
LstNode ln; /* element in job table */
LstNode *ln; /* element in job table */
Job *job = NULL; /* job descriptor in that element */
GNode *interrupt; /* the node describing the .INTERRUPT target */
@ -2736,7 +2736,7 @@ Job_Wait(void)
void
Job_AbortAll(void)
{
LstNode ln; /* element in job table */
LstNode *ln; /* element in job table */
Job *job; /* the job descriptor in that element */
int foo;

2
usr.bin/make/job.h
View File

@ -96,7 +96,7 @@ typedef struct Job {
char tfile[sizeof(TMPPAT)];
/* Temporary file to use for job */
GNode *node; /* The target the child is making */
LstNode tailCmds; /* The node of the first command to be
LstNode *tailCmds; /* The node of the first command to be
* saved when the job has been run */
FILE *cmdFILE; /* When creating the shell script, this is
* where the commands go */

44
usr.bin/make/lst.h
View File

@ -62,7 +62,7 @@ struct LstNode {
int flags:8; /* Node status flags */
void *datum; /* datum associated with this element */
};
typedef struct LstNode *LstNode;
typedef struct LstNode LstNode;
/*
* Flags required for synchronization
@ -77,19 +77,19 @@ typedef enum {
* The list itself
*/
struct Lst {
LstNode firstPtr; /* first node in list */
LstNode lastPtr; /* last node in list */
LstNode *firstPtr; /* first node in list */
LstNode *lastPtr; /* last node in list */
/*
* fields for sequential access
*/
LstWhere atEnd; /* Where in the list the last access was */
Boolean isOpen; /* true if list has been Lst_Open'ed */
LstNode curPtr; /* current node, if open. NULL if
LstNode *curPtr; /* current node, if open. NULL if
* *just* opened */
LstNode prevPtr; /* Previous node, if open. Used by
LstNode *prevPtr; /* Previous node, if open. Used by
* Lst_Remove */
};
typedef struct Lst *Lst;
typedef struct Lst Lst;
typedef int CompareProc(void *, void *);
typedef int DoProc(void *, void *);
@ -111,30 +111,30 @@ typedef void FreeProc(void *);
* Creation/destruction functions
*/
/* Create a new list */
Lst Lst_Init(void);
Lst *Lst_Init(void);
/* Duplicate an existing list */
Lst Lst_Duplicate(Lst, DuplicateProc *);
Lst *Lst_Duplicate(Lst *, DuplicateProc *);
/* Destroy an old one */
void Lst_Destroy(Lst, FreeProc *);
void Lst_Destroy(Lst *, FreeProc *);
/*
* Functions to modify a list
*/
/* Insert an element before another */
ReturnStatus Lst_Insert(Lst, LstNode, void *);
ReturnStatus Lst_Insert(Lst *, LstNode *, void *);
/* Insert an element after another */
ReturnStatus Lst_Append(Lst, LstNode, void *);
ReturnStatus Lst_Append(Lst *, LstNode *, void *);
/* Place an element at the front of a lst. */
#define Lst_AtFront(LST, D) (Lst_Insert((LST), Lst_First(LST), (D)))
/* Place an element at the end of a lst. */
#define Lst_AtEnd(LST, D) (Lst_Append((LST), Lst_Last(LST), (D)))
/* Remove an element */
ReturnStatus Lst_Remove(Lst, LstNode);
ReturnStatus Lst_Remove(Lst *, LstNode *);
/* Replace a node with a new value */
#define Lst_Replace(NODE, D) (((NODE) == NULL) ? FAILURE : \
(((NODE)->datum = (D)), SUCCESS))
/* Concatenate two lists */
ReturnStatus Lst_Concat(Lst, Lst, int);
ReturnStatus Lst_Concat(Lst *, Lst *, int);
/*
* Node-specific functions
@ -156,14 +156,14 @@ ReturnStatus Lst_Concat(Lst, Lst, int);
/* Find an element in a list */
#define Lst_Find(LST, D, FN) (Lst_FindFrom((LST), Lst_First(LST), (D), (FN)))
/* Find an element starting from somewhere */
LstNode Lst_FindFrom(Lst, LstNode, void *, CompareProc *);
LstNode *Lst_FindFrom(Lst *, LstNode *, void *, CompareProc *);
/*
* See if the given datum is on the list. Returns the LstNode containing
* the datum
*/
LstNode Lst_Member(Lst, void *);
LstNode *Lst_Member(Lst *, void *);
/* Apply a function to all elements of a lst */
void Lst_ForEach(Lst, DoProc *, void *);
void Lst_ForEach(Lst *, DoProc *, void *);
#define Lst_ForEach(LST, FN, D) (Lst_ForEachFrom((LST), Lst_First(LST), \
(FN), (D)))
/*
@ -171,20 +171,20 @@ void Lst_ForEach(Lst, DoProc *, void *);
* If the list is circular, the application will wrap around to the
* beginning of the list again.
*/
void Lst_ForEachFrom(Lst, LstNode, DoProc *, void *);
void Lst_ForEachFrom(Lst *, LstNode *, DoProc *, void *);
/*
* these functions are for dealing with a list as a table, of sorts.
* An idea of the "current element" is kept and used by all the functions
* between Lst_Open() and Lst_Close().
*/
/* Open the list */
ReturnStatus Lst_Open(Lst);
ReturnStatus Lst_Open(Lst *);
/* Next element please */
LstNode Lst_Next(Lst);
LstNode *Lst_Next(Lst *);
/* Done yet? */
Boolean Lst_IsAtEnd(Lst);
Boolean Lst_IsAtEnd(Lst *);
/* Finish table access */
void Lst_Close(Lst);
void Lst_Close(Lst *);
/*
* for using the list as a queue
@ -194,7 +194,7 @@ void Lst_Close(Lst);
? Lst_Append((LST), Lst_Last(LST), (D)) \
: FAILURE)
/* Remove an element from head of queue */
void * Lst_DeQueue(Lst);
void *Lst_DeQueue(Lst *);
/*
* LstValid (L) --

6
usr.bin/make/lst.lib/lstAppend.c
View File

@ -63,7 +63,7 @@ __FBSDID("$FreeBSD$");
* d said datum
*
* Side Effects:
* A new ListNode is created and linked in to the List. The lastPtr
* A new LstNode is created and linked in to the List. The lastPtr
* field of the List will be altered if ln is the last node in the
* list. lastPtr and firstPtr will alter if the list was empty and
* ln was NULL.
@ -71,9 +71,9 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
ReturnStatus
Lst_Append(Lst list, LstNode ln, void *d)
Lst_Append(Lst *list, LstNode *ln, void *d)
{
LstNode nLNode;
LstNode *nLNode;
if (Lst_Valid(list) && (ln == NULL && Lst_IsEmpty(list))) {
goto ok;

2
usr.bin/make/lst.lib/lstClose.c
View File

@ -70,7 +70,7 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
void
Lst_Close(Lst list)
Lst_Close(Lst *list)
{
if (Lst_Valid(list) == TRUE) {

10
usr.bin/make/lst.lib/lstConcat.c
View File

@ -73,12 +73,12 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
ReturnStatus
Lst_Concat(Lst list1, Lst list2, int flags)
Lst_Concat(Lst *list1, Lst *list2, int flags)
{
LstNode ln; /* original LstNode */
LstNode nln; /* new LstNode */
LstNode last; /* the last element in the list. Keeps
* bookkeeping until the end */
LstNode *ln; /* original LstNode */
LstNode *nln; /* new LstNode */
LstNode *last; /* the last element in the list. Keeps
* bookkeeping until the end */
if (!Lst_Valid(list1) || !Lst_Valid(list2)) {
return (FAILURE);

6
usr.bin/make/lst.lib/lstDeQueue.c
View File

@ -64,10 +64,10 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
void *
Lst_DeQueue(Lst l)
Lst_DeQueue(Lst *l)
{
void * rd;
LstNode tln;
void *rd;
LstNode *tln;
tln = Lst_First(l);
if (tln == NULL) {

6
usr.bin/make/lst.lib/lstDestroy.c
View File

@ -65,10 +65,10 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
void
Lst_Destroy(Lst list, FreeProc *freeProc)
Lst_Destroy(Lst *list, FreeProc *freeProc)
{
LstNode ln;
LstNode tln;
LstNode *ln;
LstNode *tln;
if (!Lst_Valid(list)) {
/*

8
usr.bin/make/lst.lib/lstDupl.c
View File

@ -67,11 +67,11 @@ __FBSDID("$FreeBSD$");
* A new list is created.
*-----------------------------------------------------------------------
*/
Lst
Lst_Duplicate(Lst list, DuplicateProc *copyProc)
Lst *
Lst_Duplicate(Lst *list, DuplicateProc *copyProc)
{
Lst nl;
LstNode ln;
Lst *nl;
LstNode *ln;
if (!Lst_Valid(list)) {
return (NULL);

6
usr.bin/make/lst.lib/lstFindFrom.c
View File

@ -64,10 +64,10 @@ __FBSDID("$FreeBSD$");
*
*-----------------------------------------------------------------------
*/
LstNode
Lst_FindFrom(Lst l, LstNode ln, void *d, CompareProc *cProc)
LstNode *
Lst_FindFrom(Lst *l, LstNode *ln, void *d, CompareProc *cProc)
{
LstNode tln;
LstNode *tln;
Boolean found = FALSE;
if (!Lst_Valid(l) || Lst_IsEmpty(l) || !Lst_NodeValid(ln, l)) {

4
usr.bin/make/lst.lib/lstForEachFrom.c
View File

@ -66,9 +66,9 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
void
Lst_ForEachFrom(Lst list, LstNode ln, DoProc *proc, void *d)
Lst_ForEachFrom(Lst *list, LstNode *ln, DoProc *proc, void *d)
{
LstNode next;
LstNode *next;
Boolean done;
int result;

4
usr.bin/make/lst.lib/lstInit.c
View File

@ -62,10 +62,10 @@ __FBSDID("$FreeBSD$");
*
*-----------------------------------------------------------------------
*/
Lst
Lst *
Lst_Init(void)
{
Lst nList;
Lst *nList;
nList = emalloc(sizeof(*nList));

4
usr.bin/make/lst.lib/lstInsert.c
View File

@ -69,9 +69,9 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
ReturnStatus
Lst_Insert(Lst list, LstNode ln, void *d)
Lst_Insert(Lst *list, LstNode *ln, void *d)
{
LstNode nLNode; /* new lnode for d */
LstNode *nLNode; /* new lnode for d */
/*
* check validity of arguments

2
usr.bin/make/lst.lib/lstIsAtEnd.c
View File

@ -73,7 +73,7 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
Boolean
Lst_IsAtEnd(Lst list)
Lst_IsAtEnd(Lst *list)
{
return (!Lst_Valid(list) || !list->isOpen ||

6
usr.bin/make/lst.lib/lstMember.c
View File

@ -49,10 +49,10 @@ __FBSDID("$FreeBSD$");
#include "make.h"
#include "lst.h"
LstNode
Lst_Member(Lst list, void *d)
LstNode *
Lst_Member(Lst *list, void *d)
{
LstNode lNode;
LstNode *lNode;
lNode = list->firstPtr;
if (lNode == NULL) {

6
usr.bin/make/lst.lib/lstNext.c
View File

@ -67,10 +67,10 @@ __FBSDID("$FreeBSD$");
*
*-----------------------------------------------------------------------
*/
LstNode
Lst_Next(Lst list)
LstNode *
Lst_Next(Lst *list)
{
LstNode tln;
LstNode *tln;
if ((Lst_Valid(list) == FALSE) || (list->isOpen == FALSE)) {
return (NULL);

2
usr.bin/make/lst.lib/lstOpen.c
View File

@ -69,7 +69,7 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
ReturnStatus
Lst_Open(Lst l)
Lst_Open(Lst *l)
{
if (Lst_Valid(l) == FALSE) {

2
usr.bin/make/lst.lib/lstRemove.c
View File

@ -65,7 +65,7 @@ __FBSDID("$FreeBSD$");
*-----------------------------------------------------------------------
*/
ReturnStatus
Lst_Remove(Lst list, LstNode ln)
Lst_Remove(Lst *list, LstNode *ln)
{
if (!Lst_Valid(list) || !Lst_NodeValid(ln, list)) {

20
usr.bin/make/main.c
View File

@ -93,15 +93,15 @@ __FBSDID("$FreeBSD$");
#define MAKEFLAGS ".MAKEFLAGS"
Lst create; /* Targets to be made */
Lst *create; /* Targets to be made */
time_t now; /* Time at start of make */
GNode *DEFAULT; /* .DEFAULT node */
Boolean allPrecious; /* .PRECIOUS given on line by itself */
static Boolean noBuiltins; /* -r flag */
static Lst makefiles; /* ordered list of makefiles to read */
static Lst *makefiles; /* ordered list of makefiles to read */
static Boolean expandVars; /* fully expand printed variables */
static Lst variables; /* list of variables to print */
static Lst *variables; /* list of variables to print */
int maxJobs; /* -j argument */
static Boolean forceJobs; /* -j argument given */
Boolean compatMake; /* -B argument */
@ -116,7 +116,7 @@ Boolean beSilent; /* -s flag */
Boolean beVerbose; /* -v flag */
Boolean oldVars; /* variable substitution style */
Boolean checkEnvFirst; /* -e flag */
Lst envFirstVars; /* (-E) vars to override from env */
Lst *envFirstVars; /* (-E) vars to override from env */
Boolean jobsRunning; /* TRUE if the jobs might be running */
static void MainParseArgs(int, char **);
@ -450,7 +450,7 @@ check_make_level(void)
int
main(int argc, char **argv)
{
Lst targs; /* target nodes to create -- passed to Make_Init */
Lst *targs; /* target nodes to create -- passed to Make_Init */
Boolean outOfDate = TRUE; /* FALSE if all targets up to date */
struct stat sa;
char *p, *p1, *path, *pathp;
@ -460,7 +460,7 @@ main(int argc, char **argv)
char *machine = getenv("MACHINE");
char *machine_arch = getenv("MACHINE_ARCH");
char *machine_cpu = getenv("MACHINE_CPU");
Lst sysMkPath; /* Path of sys.mk */
Lst *sysMkPath; /* Path of sys.mk */
char *cp = NULL, *start;
/* avoid faults on read-only strings */
static char syspath[] = _PATH_DEFSYSPATH;
@ -709,7 +709,7 @@ main(int argc, char **argv)
* will fill the thing in with the default or .MAIN target.
*/
if (!Lst_IsEmpty(create)) {
LstNode ln;
LstNode *ln;
for (ln = Lst_First(create); ln != NULL; ln = Lst_Succ(ln)) {
char *name = Lst_Datum(ln);
@ -744,7 +744,7 @@ main(int argc, char **argv)
* Makefile and makefile, in that order, if it wasn't.
*/
if (!noBuiltins) {
LstNode ln;
LstNode *ln;
sysMkPath = Lst_Init();
Dir_Expand(_PATH_DEFSYSMK, sysIncPath, sysMkPath);
@ -756,7 +756,7 @@ main(int argc, char **argv)
}
if (!Lst_IsEmpty(makefiles)) {
LstNode ln;
LstNode *ln;
ln = Lst_Find(makefiles, NULL, ReadMakefile);
if (ln != NULL)
@ -816,7 +816,7 @@ main(int argc, char **argv)
/* print the values of any variables requested by the user */
if (!Lst_IsEmpty(variables)) {
LstNode ln;
LstNode *ln;
for (ln = Lst_First(variables); ln != NULL;
ln = Lst_Succ(ln)) {

14
usr.bin/make/make.c
View File

@ -78,7 +78,7 @@ __FBSDID("$FreeBSD$");
#include "dir.h"
#include "job.h"
static Lst toBeMade; /* The current fringe of the graph. These
static Lst *toBeMade; /* The current fringe of the graph. These
* are nodes which await examination by
* MakeOODate. It is added to by
* Make_Update and subtracted from by
@ -264,7 +264,7 @@ static int
MakeAddChild(void *gnp, void *lp)
{
GNode *gn = gnp;
Lst l = lp;
Lst *l = lp;
if (!gn->make && !(gn->type & OP_USE)) {
Lst_EnQueue(l, gn);
@ -299,7 +299,7 @@ int
Make_HandleUse(GNode *cgn, GNode *pgn)
{
GNode *gn; /* A child of the .USE node */
LstNode ln; /* An element in the children list */
LstNode *ln; /* An element in the children list */
if (cgn->type & (OP_USE | OP_TRANSFORM)) {
if ((cgn->type & OP_USE) || Lst_IsEmpty(pgn->commands)) {
@ -376,7 +376,7 @@ Make_Update(GNode *cgn)
{
GNode *pgn; /* the parent node */
char *cname; /* the child's name */
LstNode ln; /* Element in parents and iParents lists */
LstNode *ln; /* Element in parents and iParents lists */
char *p1;
cname = Var_Value(TARGET, cgn, &p1);
@ -653,7 +653,7 @@ MakeStartJobs(void)
* have been.
*/
if (!Lst_IsEmpty(gn->preds)) {
LstNode ln;
LstNode *ln;
for (ln = Lst_First(gn->preds); ln != NULL; ln = Lst_Succ(ln)){
GNode *pgn = Lst_Datum(ln);
@ -777,10 +777,10 @@ MakePrintStatus(void *gnp, void *cyclep)
*-----------------------------------------------------------------------
*/
Boolean
Make_Run(Lst targs)
Make_Run(Lst *targs)
{
GNode *gn; /* a temporary pointer */
Lst examine; /* List of targets to examine */
Lst *examine; /* List of targets to examine */
int errors; /* Number of errors the Job module reports */
toBeMade = Lst_Init();

28
usr.bin/make/make.h
View File

@ -125,16 +125,16 @@ typedef struct GNode {
int cmtime; /* The modification time of its youngest
* child */
Lst iParents; /* Links to parents for which this is an
Lst *iParents; /* Links to parents for which this is an
* implied source, if any */
Lst cohorts; /* Other nodes for the :: operator */
Lst parents; /* Nodes that depend on this one */
Lst children; /* Nodes on which this one depends */
Lst successors; /* Nodes that must be made after this one */
Lst preds; /* Nodes that must be made before this one */
Lst *cohorts; /* Other nodes for the :: operator */
Lst *parents; /* Nodes that depend on this one */
Lst *children; /* Nodes on which this one depends */
Lst *successors;/* Nodes that must be made after this one */
Lst *preds; /* Nodes that must be made before this one */
Lst context; /* The local variables */
Lst commands; /* Creation commands */
Lst *context; /* The local variables */
Lst *commands; /* Creation commands */
struct _Suff *suffix; /* Suffix for the node (determined by
* Suff_FindDeps and opaque to everyone
@ -283,13 +283,13 @@ typedef struct IFile {
/*
* Global Variables
*/
extern Lst create; /* The list of target names specified on the
extern Lst *create; /* The list of target names specified on the
* command line. used to resolve #if
* make(...) statements */
extern Lst dirSearchPath; /* The list of directories to search when
extern Lst *dirSearchPath; /* The list of directories to search when
* looking for targets */
extern IFile curFile; /* current makefile */
extern Lst parseIncPath; /* The list of directories to search when
extern Lst *parseIncPath; /* The list of directories to search when
* looking for includes */
extern Boolean jobsRunning; /* True if jobs are running */
@ -314,7 +314,7 @@ extern Boolean queryFlag; /* TRUE if we aren't supposed to really make
extern Boolean checkEnvFirst; /* TRUE if environment should be searched for
* all variables before the global context */
extern Lst envFirstVars; /* List of specific variables for which the
extern Lst *envFirstVars; /* List of specific variables for which the
* environment should be searched before the
* global context */
@ -333,7 +333,7 @@ extern time_t now; /* The time at the start of this whole
extern Boolean oldVars; /* Do old-style variable substitution */
extern Lst sysIncPath; /* The system include path. */
extern Lst *sysIncPath; /* The system include path. */
/*
* debug control:
@ -377,6 +377,6 @@ Boolean Make_OODate(GNode *);
int Make_HandleUse(GNode *, GNode *);
void Make_Update(GNode *);
void Make_DoAllVar(GNode *);
Boolean Make_Run(Lst);
Boolean Make_Run(Lst *);
#endif /* _MAKE_H_ */

12
usr.bin/make/nonints.h
View File

@ -40,18 +40,18 @@
*/
/* arch.c */
ReturnStatus Arch_ParseArchive(char **, Lst, GNode *);
ReturnStatus Arch_ParseArchive(char **, Lst *, GNode *);
void Arch_Touch(GNode *);
void Arch_TouchLib(GNode *);
int Arch_MTime(GNode *);
int Arch_MemMTime(GNode *);
void Arch_FindLib(GNode *, Lst);
void Arch_FindLib(GNode *, Lst *);
Boolean Arch_LibOODate(GNode *);
void Arch_Init(void);
void Arch_End(void);
/* compat.c */
void Compat_Run(Lst);
void Compat_Run(Lst *);
int Compat_RunCommand(void *, void *);
/* cond.c */
@ -88,7 +88,7 @@ void Parse_File(char *, FILE *);
void Parse_Init(void);
void Parse_End(void);
void Parse_FromString(char *, int);
Lst Parse_MainName(void);
Lst *Parse_MainName(void);
/* str.c */
void str_init(void);
@ -105,7 +105,7 @@ Boolean Suff_IsTransform(char *);
GNode *Suff_AddTransform(char *);
int Suff_EndTransform(void *, void *);
void Suff_AddSuffix(char *);
Lst Suff_GetPath(char *);
Lst *Suff_GetPath(char *);
void Suff_DoPaths(void);
void Suff_AddInclude(char *);
void Suff_AddLib(char *);
@ -120,7 +120,7 @@ void Targ_Init(void);
void Targ_End(void);
GNode *Targ_NewGN(char *);
GNode *Targ_FindNode(char *, int);
Lst Targ_FindList(Lst, int);
Lst *Targ_FindList(Lst *, int);
Boolean Targ_Ignore(GNode *);
Boolean Targ_Silent(GNode *);
Boolean Targ_Precious(GNode *);

38
usr.bin/make/parse.c
View File

@ -101,8 +101,8 @@ __FBSDID("$FreeBSD$");
*/
#define CONTINUE 1
#define DONE 0
static Lst targets; /* targets we're working on */
static Lst targCmds; /* command lines for targets */
static Lst *targets; /* targets we're working on */
static Lst *targCmds; /* command lines for targets */
static Boolean inLine; /* true if currently in a dependency
* line or its commands */
static int fatals = 0;
@ -113,10 +113,10 @@ static GNode *mainNode; /* The main target to create. This is the
IFile curFile; /* current makefile */
static Lst includes; /* stack of IFiles generated by
static Lst *includes; /* stack of IFiles generated by
* #includes */
Lst parseIncPath; /* list of directories for "..." includes */
Lst sysIncPath; /* list of directories for <...> includes */
Lst *parseIncPath; /* list of directories for "..." includes */
Lst *sysIncPath; /* list of directories for <...> includes */
/*-
* specType contains the SPECial TYPE of the current target. It is
@ -212,7 +212,7 @@ static int ParseFindKeyword(char *);
static int ParseLinkSrc(void *, void *);
static int ParseDoOp(void *, void *);
static int ParseAddDep(void *, void *);
static void ParseDoSrc(int, char *, Lst);
static void ParseDoSrc(int, char *, Lst *);
static int ParseFindMain(void *, void *);
static int ParseAddDir(void *, void *);
static int ParseClearPath(void *, void *);
@ -376,8 +376,8 @@ ParseDoOp(void *gnp, void *opp)
* and the new instance is linked to all parents of the initial
* instance.
*/
GNode *cohort;
LstNode ln;
GNode *cohort;
LstNode *ln;
cohort = Targ_NewGN(gn->name);
/*
@ -464,7 +464,7 @@ ParseAddDep(void *pp, void *sp)
*---------------------------------------------------------------------
*/
static void
ParseDoSrc(int tOp, char *src, Lst allsrc)
ParseDoSrc(int tOp, char *src, Lst *allsrc)
{
GNode *gn = NULL;
@ -537,7 +537,7 @@ ParseDoSrc(int tOp, char *src, Lst allsrc)
}
if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
GNode *cohort;
LstNode ln;
LstNode *ln;
for (ln=Lst_First(gn->cohorts); ln != NULL; ln = Lst_Succ(ln)){
cohort = Lst_Datum(ln);
@ -670,14 +670,14 @@ ParseDoDependency (char *line)
GNode *gn; /* a general purpose temporary node */
int op; /* the operator on the line */
char savec; /* a place to save a character */
Lst paths; /* List of search paths to alter when parsing
Lst *paths; /* List of search paths to alter when parsing
* a list of .PATH targets */
int tOp; /* operator from special target */
Lst sources; /* list of archive source names after
Lst *sources; /* list of archive source names after
* expansion */
Lst curTargs; /* list of target names to be found and added
Lst *curTargs; /* list of target names to be found and added
* to the targets list */
Lst curSrcs; /* list of sources in order */
Lst *curSrcs; /* list of sources in order */
tOp = 0;
@ -870,7 +870,7 @@ ParseDoDependency (char *line)
* Call on the suffix module to give us a path to
* modify.
*/
Lst path;
Lst *path;
specType = ExPath;
path = Suff_GetPath(&line[5]);
@ -880,7 +880,7 @@ ParseDoDependency (char *line)
&line[5]);
return;
} else {
if (paths == (Lst)NULL) {
if (paths == NULL) {
paths = Lst_Init();
}
Lst_AtEnd(paths, path);
@ -900,7 +900,7 @@ ParseDoDependency (char *line)
* use Dir_Destroy in the destruction of the path as the
* Dir module could have added a directory to the path...
*/
Lst emptyPath = Lst_Init();
Lst *emptyPath = Lst_Init();
Dir_Expand(line, emptyPath, curTargs);
@ -2573,10 +2573,10 @@ Parse_End(void)
*
*-----------------------------------------------------------------------
*/
Lst
Lst *
Parse_MainName(void)
{
Lst listmain; /* result list */
Lst *listmain; /* result list */
listmain = Lst_Init();

120
usr.bin/make/suff.c
View File

@ -97,10 +97,10 @@ __FBSDID("$FreeBSD$");
#include "hash.h"
#include "dir.h"
static Lst sufflist; /* Lst of suffixes */
static Lst suffClean; /* Lst of suffixes to be cleaned */
static Lst srclist; /* Lst of sources */
static Lst transforms; /* Lst of transformation rules */
static Lst *sufflist; /* Lst of suffixes */
static Lst *suffClean; /* Lst of suffixes to be cleaned */
static Lst *srclist; /* Lst of sources */
static Lst *transforms; /* Lst of transformation rules */
static int sNum = 0; /* Counter for assigning suffix numbers */
@ -114,13 +114,13 @@ typedef struct _Suff {
#define SUFF_INCLUDE 0x01 /* One which is #include'd */
#define SUFF_LIBRARY 0x02 /* One which contains a library */
#define SUFF_NULL 0x04 /* The empty suffix */
Lst searchPath; /* The path along which files of this suffix
Lst *searchPath; /* The path along which files of this suffix
* may be found */
int sNum; /* The suffix number */
int refCount; /* Reference count of list membership */
Lst parents; /* Suffixes we have a transformation to */
Lst children; /* Suffixes we have a transformation from */
Lst ref; /* List of lists this suffix is referenced */
Lst *parents; /* Suffixes we have a transformation to */
Lst *children; /* Suffixes we have a transformation from */
Lst *ref; /* List of lists this suffix is referenced */
} Suff;
/*
@ -135,7 +135,7 @@ typedef struct _Src {
int children; /* Count of existing children (so we don't free
* this thing too early or never nuke it) */
#ifdef DEBUG_SRC
Lst cp; /* Debug; children list */
Lst *cp; /* Debug; children list */
#endif
} Src;
@ -144,7 +144,7 @@ typedef struct _Src {
* function...
*/
typedef struct {
Lst l;
Lst *l;
Src *s;
} LstSrc;
@ -160,20 +160,20 @@ static int SuffSuffHasNameP(void *, void *);
static int SuffSuffIsPrefix(void *, void *);
static int SuffGNHasNameP(void *, void *);
static void SuffFree(void *);
static void SuffInsert(Lst, Suff *);
static void SuffRemove(Lst, Suff *);
static void SuffInsert(Lst *, Suff *);
static void SuffRemove(Lst *, Suff *);
static Boolean SuffParseTransform(char *, Suff **, Suff **);
static int SuffRebuildGraph(void *, void *);
static int SuffAddSrc(void *, void *);
static int SuffRemoveSrc(Lst);
static void SuffAddLevel(Lst, Src *);
static Src *SuffFindThem(Lst, Lst);
static Src *SuffFindCmds(Src *, Lst);
static int SuffRemoveSrc(Lst *);
static void SuffAddLevel(Lst *, Src *);
static Src *SuffFindThem(Lst *, Lst *);
static Src *SuffFindCmds(Src *, Lst *);
static int SuffExpandChildren(void *, void *);
static Boolean SuffApplyTransform(GNode *, GNode *, Suff *, Suff *);
static void SuffFindDeps(GNode *, Lst);
static void SuffFindArchiveDeps(GNode *, Lst);
static void SuffFindNormalDeps(GNode *, Lst);
static void SuffFindDeps(GNode *, Lst *);
static void SuffFindArchiveDeps(GNode *, Lst *);
static void SuffFindNormalDeps(GNode *, Lst *);
static int SuffPrintName(void *, void *);
static int SuffPrintSuff(void *, void *);
static int SuffPrintTrans(void *, void *);
@ -363,9 +363,9 @@ SuffFree(void *sp)
*-----------------------------------------------------------------------
*/
static void
SuffRemove(Lst l, Suff *s)
SuffRemove(Lst *l, Suff *s)
{
LstNode ln = Lst_Member(l, s);
LstNode *ln = Lst_Member(l, s);
if (ln != NULL) {
Lst_Remove(l, ln);
@ -387,9 +387,9 @@ SuffRemove(Lst l, Suff *s)
*-----------------------------------------------------------------------
*/
static void
SuffInsert(Lst l, Suff *s)
SuffInsert(Lst *l, Suff *s)
{
LstNode ln; /* current element in l we're examining */
LstNode *ln; /* current element in l we're examining */
Suff *s2 = NULL; /* the suffix descriptor in this element */
if (Lst_Open(l) == FAILURE) {
@ -473,11 +473,11 @@ Suff_ClearSuffixes(void)
static Boolean
SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
{
LstNode srcLn; /* element in suffix list of trans source*/
LstNode *srcLn; /* element in suffix list of trans source*/
Suff *src; /* Source of transformation */
LstNode targLn; /* element in suffix list of trans target*/
LstNode *targLn; /* element in suffix list of trans target*/
char *str2; /* Extra pointer (maybe target suffix) */
LstNode singleLn; /* element in suffix list of any suffix
LstNode *singleLn; /* element in suffix list of any suffix
* that exactly matches str */
Suff *single = NULL;/* Source of possible transformation to
* null suffix */
@ -576,7 +576,7 @@ Suff_AddTransform(char *line)
GNode *gn; /* GNode of transformation rule */
Suff *s, /* source suffix */
*t; /* target suffix */
LstNode ln; /* Node for existing transformation */
LstNode *ln; /* Node for existing transformation */
ln = Lst_Find(transforms, line, SuffGNHasNameP);
if (ln == NULL) {
@ -698,7 +698,7 @@ SuffRebuildGraph(void *transformp, void *sp)
GNode *transform = transformp;
Suff *s = sp;
char *cp;
LstNode ln;
LstNode *ln;
Suff *s2 = NULL;
/*
@ -768,7 +768,7 @@ void
Suff_AddSuffix(char *str)
{
Suff *s; /* new suffix descriptor */
LstNode ln;
LstNode *ln;
ln = Lst_Find(sufflist, str, SuffSuffHasNameP);
if (ln == NULL) {
@ -807,10 +807,10 @@ Suff_AddSuffix(char *str)
* None
*-----------------------------------------------------------------------
*/
Lst
Lst *
Suff_GetPath(char *sname)
{
LstNode ln;
LstNode *ln;
Suff *s;
ln = Lst_Find(sufflist, sname, SuffSuffHasNameP);
@ -843,11 +843,11 @@ Suff_GetPath(char *sname)
void
Suff_DoPaths(void)
{
Suff *s;
LstNode ln;
char *ptr;
Lst inIncludes; /* Cumulative .INCLUDES path */
Lst inLibs; /* Cumulative .LIBS path */
Suff *s;
LstNode *ln;
char *ptr;
Lst *inIncludes; /* Cumulative .INCLUDES path */
Lst *inLibs; /* Cumulative .LIBS path */
if (Lst_Open(sufflist) == FAILURE) {
return;
@ -905,7 +905,7 @@ Suff_DoPaths(void)
void
Suff_AddInclude(char *sname)
{
LstNode ln;
LstNode *ln;
Suff *s;
ln = Lst_Find(sufflist, sname, SuffSuffHasNameP);
@ -934,7 +934,7 @@ Suff_AddInclude(char *sname)
void
Suff_AddLib(char *sname)
{
LstNode ln;
LstNode *ln;
Suff *s;
ln = Lst_Find(sufflist, sname, SuffSuffHasNameP);
@ -1028,7 +1028,7 @@ SuffAddSrc(void *sp, void *lsp)
*-----------------------------------------------------------------------
*/
static void
SuffAddLevel(Lst l, Src *targ)
SuffAddLevel(Lst *l, Src *targ)
{
LstSrc ls;
@ -1051,9 +1051,9 @@ SuffAddLevel(Lst l, Src *targ)
*----------------------------------------------------------------------
*/
static int
SuffRemoveSrc(Lst l)
SuffRemoveSrc(Lst *l)
{
LstNode ln;
LstNode *ln;
Src *s;
int t = 0;
@ -1075,7 +1075,7 @@ SuffRemoveSrc(Lst l)
free(s->pref);
else {
#ifdef DEBUG_SRC
LstNode ln = Lst_Member(s->parent->cp, s);
LstNode *ln = Lst_Member(s->parent->cp, s);
if (ln != NULL)
Lst_Remove(s->parent->cp, ln);
#endif
@ -1118,7 +1118,7 @@ SuffRemoveSrc(Lst l)
*-----------------------------------------------------------------------
*/
static Src *
SuffFindThem (Lst srcs, Lst slst)
SuffFindThem(Lst *srcs, Lst *slst)
{
Src *s; /* current Src */
Src *rs; /* returned Src */
@ -1180,9 +1180,9 @@ SuffFindThem (Lst srcs, Lst slst)
*-----------------------------------------------------------------------
*/
static Src *
SuffFindCmds (Src *targ, Lst slst)
SuffFindCmds (Src *targ, Lst *slst)
{
LstNode ln; /* General-purpose list node */
LstNode *ln; /* General-purpose list node */
GNode *t, /* Target GNode */
*s; /* Source GNode */
int prefLen;/* The length of the defined prefix */
@ -1272,8 +1272,8 @@ SuffExpandChildren(void *cgnp, void *pgnp)
GNode *cgn = cgnp;
GNode *pgn = pgnp;
GNode *gn; /* New source 8) */
LstNode prevLN; /* Node after which new source should be put */
LstNode ln; /* List element for old source */
LstNode *prevLN; /* Node after which new source should be put */
LstNode *ln; /* List element for old source */
char *cp; /* Expanded value */
/*
@ -1293,7 +1293,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
cp = Var_Subst(NULL, cgn->name, pgn, TRUE);
if (cp != NULL) {
Lst members = Lst_Init();
Lst *members = Lst_Init();
if (cgn->type & OP_ARCHV) {
/*
@ -1401,8 +1401,8 @@ SuffExpandChildren(void *cgnp, void *pgnp)
Lst_Remove(pgn->children, ln);
DEBUGF(SUFF, ("\n"));
} else if (Dir_HasWildcards(cgn->name)) {
Lst exp; /* List of expansions */
Lst path; /* Search path along which to expand */
Lst *exp; /* List of expansions */
Lst *path; /* Search path along which to expand */
/*
* Find a path along which to expand the word.
@ -1495,7 +1495,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
static Boolean
SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
{
LstNode ln; /* General node */
LstNode *ln; /* General node */
char *tname; /* Name of transformation rule */
GNode *gn; /* Node for same */
@ -1592,7 +1592,7 @@ SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
*-----------------------------------------------------------------------
*/
static void
SuffFindArchiveDeps(GNode *gn, Lst slst)
SuffFindArchiveDeps(GNode *gn, Lst *slst)
{
char *eoarch; /* End of archive portion */
char *eoname; /* End of member portion */
@ -1669,7 +1669,7 @@ SuffFindArchiveDeps(GNode *gn, Lst slst)
* through the entire list, we just look at suffixes to which the
* member's suffix may be transformed...
*/
LstNode ln;
LstNode *ln;
/*
* Use first matching suffix...
@ -1723,13 +1723,13 @@ SuffFindArchiveDeps(GNode *gn, Lst slst)
*-----------------------------------------------------------------------
*/
static void
SuffFindNormalDeps(GNode *gn, Lst slst)
SuffFindNormalDeps(GNode *gn, Lst *slst)
{
char *eoname; /* End of name */
char *sopref; /* Start of prefix */
LstNode ln; /* Next suffix node to check */
Lst srcs; /* List of sources at which to look */
Lst targs; /* List of targets to which things can be
LstNode *ln; /* Next suffix node to check */
Lst *srcs; /* List of sources at which to look */
Lst *targs; /* List of targets to which things can be
* transformed. They all have the same file,
* but different suff and pref fields */
Src *bottom; /* Start of found transformation path */
@ -2121,7 +2121,7 @@ Suff_FindDeps(GNode *gn)
static void
SuffFindDeps(GNode *gn, Lst slst)
SuffFindDeps(GNode *gn, Lst *slst)
{
if (gn->type & OP_DEPS_FOUND) {
@ -2146,7 +2146,7 @@ SuffFindDeps(GNode *gn, Lst slst)
* set the TARGET variable to the node's name in order to give it a
* value).
*/
LstNode ln;
LstNode *ln;
Suff *s;
ln = Lst_Find(sufflist, LIBSUFF, SuffSuffHasNameP);
@ -2192,7 +2192,7 @@ void
Suff_SetNull(char *name)
{
Suff *s;
LstNode ln;
LstNode *ln;
ln = Lst_Find(sufflist, name, SuffSuffHasNameP);
if (ln != NULL) {

12
usr.bin/make/targ.c
View File

@ -88,8 +88,8 @@ __FBSDID("$FreeBSD$");
#include "hash.h"
#include "dir.h"
static Lst allTargets; /* the list of all targets found so far */
static Lst allGNs; /* List of all the GNodes */
static Lst *allTargets; /* the list of all targets found so far */
static Lst *allGNs; /* List of all the GNodes */
static Hash_Table targets; /* a hash table of same */
#define HTSIZE 191 /* initial size of hash table */
@ -276,11 +276,11 @@ Targ_FindNode(char *name, int flags)
* an error message will be printed for each name which can't be found.
* -----------------------------------------------------------------------
*/
Lst
Targ_FindList(Lst names, int flags)
Lst *
Targ_FindList(Lst *names, int flags)
{
Lst nodes; /* result list */
LstNode ln; /* name list element */
Lst *nodes; /* result list */
LstNode *ln; /* name list element */
GNode *gn; /* node in tLn */
char *name;

6
usr.bin/make/var.c
View File

@ -124,7 +124,7 @@ static char varNoError[] = "";
GNode *VAR_GLOBAL; /* variables from the makefile */
GNode *VAR_CMD; /* variables defined on the command-line */
static Lst allVars; /* List of all variables */
static Lst *allVars; /* List of all variables */
#define FIND_CMD 0x1 /* look in VAR_CMD when searching */
#define FIND_GLOBAL 0x2 /* look in VAR_GLOBAL as well */
@ -207,7 +207,7 @@ static Var *
VarFind(char *name, GNode *ctxt, int flags)
{
Boolean localCheckEnvFirst;
LstNode var;
LstNode *var;
Var *v;
/*
@ -379,7 +379,7 @@ VarDelete(void *vp)
void
Var_Delete(char *name, GNode *ctxt)
{
LstNode ln;
LstNode *ln;
DEBUGF(VAR, ("%s:delete %s\n", ctxt->name, name));
ln = Lst_Find(ctxt->context, name, VarCmp);