.EXPORTSAME, .NOEXPORT, -X and -x
SCCS-vsn: usr.bin/make/compat.c 5.3
SCCS-vsn: usr.bin/make/job.c 5.7
SCCS-vsn: usr.bin/make/main.c 5.8
SCCS-vsn: usr.bin/make/make.h 5.5
SCCS-vsn: usr.bin/make/nonints.h 5.3
SCCS-vsn: usr.bin/make/parse.c 5.5
SCCS-vsn: usr.bin/make/targ.c 5.4
-static char sccsid[] = "@(#)compat.c 5.2 (Berkeley) %G%";
+static char sccsid[] = "@(#)compat.c 5.3 (Berkeley) %G%";
#endif /* not lint */
/*-
#endif /* not lint */
/*-
- /*
- * If the job has not been marked unexportable, tell the Rmt module we've
- * got something for it...local is set TRUE if the job should be run
- * locally.
- */
- if (!(gn->type & OP_NOEXPORT)) {
- local = !Rmt_Begin(av[0], av, gn);
- } else {
- local = TRUE;
- }
/*
* Fork and execute the single command. If the fork fails, we abort.
/*
* Fork and execute the single command. If the fork fails, we abort.
numWritten = write (2, av[0], strlen (av[0]));
numWritten = write (2, ": not found\n", sizeof(": not found"));
} else {
numWritten = write (2, av[0], strlen (av[0]));
numWritten = write (2, ": not found\n", sizeof(": not found"));
} else {
- Rmt_Exec(av[0], av, FALSE);
+ (void)execv(av[0], av);
}
exit(1);
} else if (argc != 0) {
}
exit(1);
} else if (argc != 0) {
}
while ((stat = wait(&reason)) != cpid) {
}
while ((stat = wait(&reason)) != cpid) {
- if (!local) {
- Rmt_Done(id);
- }
-
-
if (stat > -1) {
if (WIFSTOPPED(reason)) {
status = reason.w_stopval; /* stopped */
if (stat > -1) {
if (WIFSTOPPED(reason)) {
status = reason.w_stopval; /* stopped */
-static char sccsid[] = "@(#)job.c 5.6 (Berkeley) %G%";
+static char sccsid[] = "@(#)job.c 5.7 (Berkeley) %G%";
#endif /* not lint */
/*-
#endif /* not lint */
/*-
static void JobRestart();
static int JobStart();
static void JobInterrupt();
static void JobRestart();
static int JobStart();
static void JobInterrupt();
/*-
*-----------------------------------------------------------------------
* JobCondPassSig --
/*-
*-----------------------------------------------------------------------
* JobCondPassSig --
signal(signo, JobPassSig);
}
signal(signo, JobPassSig);
}
/*-
*-----------------------------------------------------------------------
* JobCmpPid --
/*-
*-----------------------------------------------------------------------
* JobCmpPid --
{
return (pid - job->pid);
}
{
return (pid - job->pid);
}
/*-
*-----------------------------------------------------------------------
* JobPrintCommand --
/*-
*-----------------------------------------------------------------------
* JobPrintCommand --
/*-
*-----------------------------------------------------------------------
* JobSaveCommand --
/*-
*-----------------------------------------------------------------------
* JobSaveCommand --
(void)Lst_AtEnd (postCommands->commands, (ClientData)cmd);
return (0);
}
(void)Lst_AtEnd (postCommands->commands, (ClientData)cmd);
return (0);
}
/*-
*-----------------------------------------------------------------------
* JobFinish --
/*-
*-----------------------------------------------------------------------
* JobFinish --
/*-
*-----------------------------------------------------------------------
* Job_Touch --
/*-
*-----------------------------------------------------------------------
* Job_Touch --
/*-
*-----------------------------------------------------------------------
* Job_CheckCommands --
/*-
*-----------------------------------------------------------------------
* Job_CheckCommands --
JobDoOutput(job, FALSE);
}
#endif /* RMT_WILL_WATCH */
JobDoOutput(job, FALSE);
}
#endif /* RMT_WILL_WATCH */
/*-
*-----------------------------------------------------------------------
* JobExec --
/*-
*-----------------------------------------------------------------------
* JobExec --
(void) setpgrp(0, getpid());
#endif USE_PGRP
(void) setpgrp(0, getpid());
#endif USE_PGRP
- if (job->flags & JOB_REMOTE) {
- Rmt_Exec (shellPath, argv, FALSE);
- } else {
- (void) execv (shellPath, argv);
- }
-
+ (void) execv (shellPath, argv);
(void) write (2, "Could not execute shell\n",
sizeof ("Could not execute shell"));
_exit (1);
(void) write (2, "Could not execute shell\n",
sizeof ("Could not execute shell"));
_exit (1);
}
if (job->flags & JOB_REMOTE) {
}
if (job->flags & JOB_REMOTE) {
- job->rmtID = (char *)Rmt_LastID(job->pid);
+ job->rmtID = (char *)0;
/*-
*-----------------------------------------------------------------------
* JobMakeArgv --
/*-
*-----------------------------------------------------------------------
* JobMakeArgv --
}
argv[argc] = (char *)NULL;
}
}
argv[argc] = (char *)NULL;
}
/*-
*-----------------------------------------------------------------------
* JobRestart --
/*-
*-----------------------------------------------------------------------
* JobRestart --
- * Restart a job that stopped for some reason. If the job stopped
- * because it migrated home again, we tell the Rmt module to
- * find a new home for it and make it runnable if Rmt_ReExport
- * succeeded (if it didn't and the job may be run locally, we
- * simply resume it). If the job didn't run and can now, we run it.
+ * Restart a job that stopped for some reason.
if (DEBUG(JOB)) {
printf("Remigrating %x\n", job->pid);
}
if (DEBUG(JOB)) {
printf("Remigrating %x\n", job->pid);
}
- if (!Rmt_ReExport(job->pid)) {
- if (DEBUG(JOB)) {
- printf("Couldn't migrate...");
- }
- if (nLocal != maxLocal) {
+ if (nLocal != maxLocal) {
/*
* Job cannot be remigrated, but there's room on the local
* machine, so resume the job and note that another
/*
* Job cannot be remigrated, but there's room on the local
* machine, so resume the job and note that another
KILL(job->pid, SIGCONT);
nLocal +=1;
job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
KILL(job->pid, SIGCONT);
nLocal +=1;
job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
/*
* Job cannot be restarted. Mark the table as full and
* place the job back on the list of stopped jobs.
/*
* Job cannot be restarted. Mark the table as full and
* place the job back on the list of stopped jobs.
printf("Job queue is full.\n");
}
return;
printf("Job queue is full.\n");
}
return;
- }
- } else {
- /*
- * Clear out the remigrate and resume flags. If MIGRATE was set,
- * leave that around for JobFinish to see so it doesn't print out
- * that the job was continued.
- */
- job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
}
(void)Lst_AtEnd(jobs, (ClientData)job);
}
(void)Lst_AtEnd(jobs, (ClientData)job);
if (DEBUG(JOB)) {
printf("Restarting %s...", job->node->name);
}
if (DEBUG(JOB)) {
printf("Restarting %s...", job->node->name);
}
- if ((job->node->type&OP_NOEXPORT) ||
-#ifdef RMT_NO_EXEC
- !Rmt_Export(shellPath, argv, job)
-#else
- !Rmt_Begin(shellPath, argv, job->node)
-#endif
- )
- {
- if (((nLocal >= maxLocal) && ! (job->flags & JOB_SPECIAL)))
- {
+ if (((nLocal >= maxLocal) && ! (job->flags & JOB_SPECIAL))) {
/*
* Can't be exported and not allowed to run locally -- put it
* back on the hold queue and mark the table full
/*
* Can't be exported and not allowed to run locally -- put it
* back on the hold queue and mark the table full
printf("Job queue is full.\n");
}
return;
printf("Job queue is full.\n");
}
return;
/*
* Job may be run locally.
*/
/*
* Job may be run locally.
*/
printf("running locally\n");
}
job->flags &= ~JOB_REMOTE;
printf("running locally\n");
}
job->flags &= ~JOB_REMOTE;
- }
- } else {
- /*
- * Can be exported. Hooray!
- */
- if (DEBUG(JOB)) {
- printf("exporting\n");
- }
- job->flags |= JOB_REMOTE;
}
JobExec(job, argv);
} else {
}
JobExec(job, argv);
} else {
}
if (((job->flags & JOB_REMOTE) ||
(nLocal < maxLocal) ||
}
if (((job->flags & JOB_REMOTE) ||
(nLocal < maxLocal) ||
- (((job->flags & JOB_SPECIAL) ||
- (job->node->type & OP_NOEXPORT)) &&
+ (((job->flags & JOB_SPECIAL)) &&
(maxLocal == 0))) &&
(nJobs != maxJobs))
{
(maxLocal == 0))) &&
(nJobs != maxJobs))
{
/*-
*-----------------------------------------------------------------------
* JobStart --
/*-
*-----------------------------------------------------------------------
* JobStart --
- if (!(gn->type & OP_NOEXPORT)) {
-#ifdef RMT_NO_EXEC
- local = !Rmt_Export(shellPath, argv, job);
-#else
- local = !Rmt_Begin (shellPath, argv, gn);
-#endif /* RMT_NO_EXEC */
- if (!local) {
- job->flags |= JOB_REMOTE;
- }
- } else {
- local = TRUE;
- }
if (local && (((nLocal >= maxLocal) &&
!(job->flags & JOB_SPECIAL) &&
if (local && (((nLocal >= maxLocal) &&
!(job->flags & JOB_SPECIAL) &&
- (!(gn->type & OP_NOEXPORT) || (maxLocal != 0)))))
{
/*
* The job can only be run locally, but we've hit the limit of
{
/*
* The job can only be run locally, but we've hit the limit of
* finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
* may be run locally even when the local limit has been reached
* (e.g. when maxLocal == 0), though they will be exported if at
* finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
* may be run locally even when the local limit has been reached
* (e.g. when maxLocal == 0), though they will be exported if at
- * all possible. In addition, any target marked with .NOEXPORT will
- * be run locally if maxLocal is 0.
/*-
*-----------------------------------------------------------------------
* JobDoOutput --
/*-
*-----------------------------------------------------------------------
* JobDoOutput --
/*-
*-----------------------------------------------------------------------
* Job_CatchChildren --
/*-
*-----------------------------------------------------------------------
* Job_CatchChildren --
printf("Job queue is no longer full.\n");
}
jobFull = FALSE;
printf("Job queue is no longer full.\n");
}
jobFull = FALSE;
-
- if (job->flags & JOB_REMOTE) {
- Rmt_Done (job->rmtID);
- } else {
- nLocal -= 1;
- }
}
JobFinish (job, status);
}
}
}
JobFinish (job, status);
}
}
/*-
*-----------------------------------------------------------------------
* Job_CatchOutput --
/*-
*-----------------------------------------------------------------------
* Job_CatchOutput --
}
#endif /* RMT_WILL_WATCH */
}
}
#endif /* RMT_WILL_WATCH */
}
/*-
*-----------------------------------------------------------------------
* Job_Make --
/*-
*-----------------------------------------------------------------------
* Job_Make --
{
(void)JobStart (gn, 0, (Job *)NULL);
}
{
(void)JobStart (gn, 0, (Job *)NULL);
}
/*-
*-----------------------------------------------------------------------
* Job_Init --
/*-
*-----------------------------------------------------------------------
* Job_Init --
}
postCommands = Targ_FindNode (".END", TARG_CREATE);
}
}
postCommands = Targ_FindNode (".END", TARG_CREATE);
}
/*-
*-----------------------------------------------------------------------
* Job_Full --
/*-
*-----------------------------------------------------------------------
* Job_Full --
{
return (aborting || jobFull);
}
{
return (aborting || jobFull);
}
/*-
*-----------------------------------------------------------------------
* Job_Empty --
/*-
*-----------------------------------------------------------------------
* Job_Empty --
/*-
*-----------------------------------------------------------------------
* JobMatchShell --
/*-
*-----------------------------------------------------------------------
* JobMatchShell --
}
return (match == (Shell *) NULL ? sh : match);
}
}
return (match == (Shell *) NULL ? sh : match);
}
/*-
*-----------------------------------------------------------------------
* Job_ParseShell --
/*-
*-----------------------------------------------------------------------
* Job_ParseShell --
free (words);
return SUCCESS;
}
free (words);
return SUCCESS;
}
/*-
*-----------------------------------------------------------------------
* JobInterrupt --
/*-
*-----------------------------------------------------------------------
* JobInterrupt --
(void) unlink (tfile);
exit (0);
}
(void) unlink (tfile);
exit (0);
}
/*
*-----------------------------------------------------------------------
* Job_End --
/*
*-----------------------------------------------------------------------
* Job_End --
(void) unlink (tfile);
return(errors);
}
(void) unlink (tfile);
return(errors);
}
/*-
*-----------------------------------------------------------------------
* Job_Wait --
/*-
*-----------------------------------------------------------------------
* Job_Wait --
/*-
*-----------------------------------------------------------------------
* Job_AbortAll --
/*-
*-----------------------------------------------------------------------
* Job_AbortAll --
#endif /* not lint */
#ifndef lint
#endif /* not lint */
#ifndef lint
-static char sccsid[] = "@(#)main.c 5.7 (Berkeley) %G%";
+static char sccsid[] = "@(#)main.c 5.8 (Berkeley) %G%";
#endif /* not lint */
/*-
#endif /* not lint */
/*-
Boolean ignoreErrors; /* -i flag */
Boolean beSilent; /* -s flag */
Boolean sysVmake; /* -v flag */
Boolean ignoreErrors; /* -i flag */
Boolean beSilent; /* -s flag */
Boolean sysVmake; /* -v flag */
-Boolean oldVars; /* -V flag */
+Boolean oldVars; /* variable substitution style */
Boolean checkEnvFirst; /* -e flag */
Boolean checkEnvFirst; /* -e flag */
-static Boolean XFlag=FALSE; /* -X flag given */
-static Boolean xFlag=FALSE; /* -x flag given */
-Boolean noExport; /* Set TRUE if shouldn't export */
static Boolean jobsRunning; /* TRUE if the jobs might be running */
static Boolean ReadMakefile();
static Boolean jobsRunning; /* TRUE if the jobs might be running */
static Boolean ReadMakefile();
*/
static int initOptInd;
*/
static int initOptInd;
-#ifdef CAN_EXPORT
-#define OPTSTR "BCD:I:J:L:MPSVWXd:ef:iknp:qrstvxh"
-#else
-#define OPTSTR "BCD:I:J:L:MPSVWd:ef:iknp:qrstvh"
-#endif
-
static char *help[] = {
"-B Be as backwards-compatible with make as possible without\n\
being make.",
static char *help[] = {
"-B Be as backwards-compatible with make as possible without\n\
being make.",
"-M Be Make as closely as possible.",
"-P Don't use pipes to catch the output of jobs, use files.",
"-S Turn off the -k flag (see below).",
"-M Be Make as closely as possible.",
"-P Don't use pipes to catch the output of jobs, use files.",
"-S Turn off the -k flag (see below).",
-#ifndef POSIX
-"-V Use old-style variable substitution.",
-#endif
"-W Don't print warning messages.",
"-W Don't print warning messages.",
-#ifdef CAN_EXPORT
-"-X Turn off exporting of commands.",
-#endif
"-d<flags> Turn on debugging output.",
"-e Give environment variables precedence over those in the\n\
makefile(s).",
"-d<flags> Turn on debugging output.",
"-e Give environment variables precedence over those in the\n\
makefile(s).",
"-r Do not read the system makefile for pre-defined rules.",
"-s Don't print commands as they are executed.",
"-t Update targets by \"touching\" them (see touch(1)).",
"-r Do not read the system makefile for pre-defined rules.",
"-s Don't print commands as they are executed.",
"-t Update targets by \"touching\" them (see touch(1)).",
-"-v Be compatible with System V make. Implies -B, -V.",
-#ifdef CAN_EXPORT
-"-x Allow exportation of commands.",
-#endif
+"-v Be compatible with System V make. Implies -B.",
- while((c = getopt(argc, argv, OPTSTR)) != -1) {
+ while((c = getopt(argc, argv, "BCD:I:J:L:MPSWd:ef:iknp:qrstvh")) != -1) {
- backwards = oldVars = TRUE;
Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
break;
case 'C':
Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
break;
case 'C':
- oldVars = backwards = sysVmake = amMake = FALSE;
+ backwards = sysVmake = amMake = FALSE;
Var_Append(MAKEFLAGS, "-C", VAR_GLOBAL);
break;
case 'D':
Var_Append(MAKEFLAGS, "-C", VAR_GLOBAL);
break;
case 'D':
keepgoing = FALSE;
Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
break;
keepgoing = FALSE;
Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
break;
- case 'V':
- oldVars = TRUE;
- Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
- break;
case 'W':
noWarnings = TRUE;
Var_Append(MAKEFLAGS, "-W", VAR_GLOBAL);
break;
case 'W':
noWarnings = TRUE;
Var_Append(MAKEFLAGS, "-W", VAR_GLOBAL);
break;
- case 'X':
- XFlag = TRUE;
- Var_Append(MAKEFLAGS, "-X", VAR_GLOBAL);
- break;
case 'd':
{
char *modules = optarg;
case 'd':
{
char *modules = optarg;
Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
break;
case 'v':
Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
break;
case 'v':
- sysVmake = oldVars = backwards = TRUE;
+ sysVmake = backwards = TRUE;
Var_Append(MAKEFLAGS, "-v", VAR_GLOBAL);
break;
case 'h':
Var_Append(MAKEFLAGS, "-v", VAR_GLOBAL);
break;
case 'h':
if (amMake) {
backwards = TRUE;
}
if (amMake) {
backwards = TRUE;
}
- if (backwards) {
- oldVars = TRUE;
- }
/*
* See if the rest of the arguments are variable assignments and perform
/*
* See if the rest of the arguments are variable assignments and perform
if (strcmp (cp, "make") == 0) {
amMake = TRUE; /* Be like make */
backwards = TRUE; /* Do things the old-fashioned way */
if (strcmp (cp, "make") == 0) {
amMake = TRUE; /* Be like make */
backwards = TRUE; /* Do things the old-fashioned way */
- oldVars = TRUE; /* Same with variables */
} else if (strcmp(cp, "smake") == 0 || strcmp(cp, "vmake") == 0) {
} else if (strcmp(cp, "smake") == 0 || strcmp(cp, "vmake") == 0) {
- sysVmake = oldVars = backwards = TRUE;
+ sysVmake = backwards = TRUE;
} else {
amMake = FALSE;
backwards = FALSE; /* Do things MY way, not MAKE's */
} else {
amMake = FALSE;
backwards = FALSE; /* Do things MY way, not MAKE's */
- /*
- * Figure "noExport" out based on the current mode. Since exporting each
- * command in make mode is rather inefficient, we only export if the -x
- * flag was given. In regular mode though, we only refuse to export if
- * -X was given. In case the operative flag was given in the environment,
- * however, the opposite one may be given on the command line and cancel
- * the action.
- */
- if (amMake) {
- noExport = !xFlag || XFlag;
- } else {
- noExport = XFlag && !xFlag;
- }
-
Var_Append ("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL), VAR_GLOBAL);
/*
Var_Append ("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL), VAR_GLOBAL);
/*
/*
* Have now read the entire graph and need to make a list of targets to
* create. If none was given on the command line, we consult the parsing
/*
* Have now read the entire graph and need to make a list of targets to
* create. If none was given on the command line, we consult the parsing
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
- * @(#)make.h 5.4 (Berkeley) %G%
+ * @(#)make.h 5.5 (Berkeley) %G%
* state of the -n or -t flags */
#define OP_JOIN 0x00000400 /* Target is out-of-date only if any of its
* children was out-of-date */
* state of the -n or -t flags */
#define OP_JOIN 0x00000400 /* Target is out-of-date only if any of its
* children was out-of-date */
-#define OP_EXPORT 0x00000800 /* UNUSED: The creation of the target
- * should be sent somewhere else, if
- * possible. */
-#define OP_NOEXPORT 0x00001000 /* The creation should not be sent
- * elsewhere */
-#define OP_EXPORTSAME 0x00002000 /* Export only to machine with same
- * architecture */
#define OP_INVISIBLE 0x00004000 /* The node is invisible to its parents.
* I.e. it doesn't show up in the parents's
* local variables. */
#define OP_NOTMAIN 0x00008000 /* The node is exempt from normal 'main
* target' processing in parse.c */
#define OP_INVISIBLE 0x00004000 /* The node is invisible to its parents.
* I.e. it doesn't show up in the parents's
* local variables. */
#define OP_NOTMAIN 0x00008000 /* The node is exempt from normal 'main
* target' processing in parse.c */
-/*XXX*/
-#define OP_M68020 0x00010000 /* Command must be run on a 68020 */
/* Attributes applied by PMake */
#define OP_TRANSFORM 0x80000000 /* The node is a transformation rule */
#define OP_MEMBER 0x40000000 /* Target is a member of an archive */
/* Attributes applied by PMake */
#define OP_TRANSFORM 0x80000000 /* The node is a transformation rule */
#define OP_MEMBER 0x40000000 /* Target is a member of an archive */
* of-date */
extern Boolean noWarnings; /* TRUE if should not print warning messages */
* of-date */
extern Boolean noWarnings; /* TRUE if should not print warning messages */
-extern Boolean noExport; /* TRUE if should not export any jobs */
extern Boolean checkEnvFirst; /* TRUE if environment should be searched for
* variables before the global context */
extern Boolean checkEnvFirst; /* TRUE if environment should be searched for
* variables before the global context */
-#ifdef Sprite
-#define Str_FindSubstring(s1, s2) strstr(s1, s2)
-#endif /* Sprite */
-
-extern char *index();
-extern char *rindex();
extern char *malloc();
#endif _MAKE_H_
extern char *malloc();
#endif _MAKE_H_
void Make_Update ();
void Make_DoAllVar ();
Boolean Make_Run ();
void Make_Update ();
void Make_DoAllVar ();
Boolean Make_Run ();
-void Rmt_Init();
-void Rmt_AddServer ();
-Boolean Rmt_Begin ();
-void Rmt_Exec ();
-Boolean Rmt_ReExport();
-int Rmt_LastID();
-void Rmt_Done ();
void Job_Touch ();
Boolean Job_CheckCommands ();
void Job_CatchChildren ();
void Job_Touch ();
Boolean Job_CheckCommands ();
void Job_CatchChildren ();
void DieHorribly ();
void Finish ();
void Parse_Error ();
void DieHorribly ();
void Finish ();
void Parse_Error ();
-Boolean Parse_AnyExport();
Boolean Parse_IsVar ();
void Parse_DoVar ();
void Parse_AddIncludeDir ();
Boolean Parse_IsVar ();
void Parse_DoVar ();
void Parse_AddIncludeDir ();
int Targ_PrintCmd ();
char * Targ_FmtTime ();
void Targ_PrintType ();
int Targ_PrintCmd ();
char * Targ_FmtTime ();
void Targ_PrintType ();
-void Rmt_Init();
-void Rmt_AddServer ();
-Boolean Rmt_Begin ();
-Boolean Rmt_ReExport();
-void Rmt_Exec ();
-int Rmt_LastID();
-void Rmt_Done ();
char * Str_Concat ();
char ** Str_BreakString ();
void Str_FreeVec ();
char * Str_Concat ();
char ** Str_BreakString ();
void Str_FreeVec ();
-static char sccsid[] = "@(#)parse.c 5.4 (Berkeley) %G%";
+static char sccsid[] = "@(#)parse.c 5.5 (Berkeley) %G%";
#endif /* not lint */
/*-
#endif /* not lint */
/*-
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 */
-/*-
- * anyExport is used to trace if any target will need exportation. If none
- * does, then any .EXPORT target can be ignored and the process needn't
- * be slowed down by trying to connect to some load-balancing system.
- */
-static Boolean anyExport = FALSE;
-
/*-
* specType contains the SPECial TYPE of the current target. It is
* Not if the target is unspecial. If it *is* special, however, the children
/*-
* specType contains the SPECial TYPE of the current target. It is
* Not if the target is unspecial. If it *is* special, however, the children
Begin, /* .BEGIN */
Default, /* .DEFAULT */
End, /* .END */
Begin, /* .BEGIN */
Default, /* .DEFAULT */
End, /* .END */
Ignore, /* .IGNORE */
Includes, /* .INCLUDES */
Interrupt, /* .INTERRUPT */
Ignore, /* .IGNORE */
Includes, /* .INCLUDES */
Interrupt, /* .INTERRUPT */
MFlags, /* .MFLAGS or .MAKEFLAGS */
Main, /* .MAIN and we don't have anything user-specified to
* make */
MFlags, /* .MFLAGS or .MAKEFLAGS */
Main, /* .MAIN and we don't have anything user-specified to
* make */
- NoExport, /* .NOEXPORT */
Not, /* Not special */
NotParallel, /* .NOTPARALELL */
Null, /* .NULL */
Not, /* Not special */
NotParallel, /* .NOTPARALELL */
Null, /* .NULL */
{ ".DONTCARE", Attribute, OP_DONTCARE },
{ ".END", End, 0 },
{ ".EXEC", Attribute, OP_EXEC },
{ ".DONTCARE", Attribute, OP_DONTCARE },
{ ".END", End, 0 },
{ ".EXEC", Attribute, OP_EXEC },
-{ ".EXPORT", Export, OP_EXPORT },
-{ ".EXPORTSAME", Attribute, OP_EXPORTSAME },
{ ".IGNORE", Ignore, OP_IGNORE },
{ ".INCLUDES", Includes, 0 },
{ ".INTERRUPT", Interrupt, 0 },
{ ".INVISIBLE", Attribute, OP_INVISIBLE },
{ ".JOIN", Attribute, OP_JOIN },
{ ".LIBS", Libs, 0 },
{ ".IGNORE", Ignore, OP_IGNORE },
{ ".INCLUDES", Includes, 0 },
{ ".INTERRUPT", Interrupt, 0 },
{ ".INVISIBLE", Attribute, OP_INVISIBLE },
{ ".JOIN", Attribute, OP_JOIN },
{ ".LIBS", Libs, 0 },
-{ ".M68020", Attribute, OP_M68020 },
{ ".MAIN", Main, 0 },
{ ".MAKE", Attribute, OP_MAKE },
{ ".MAKEFLAGS", MFlags, 0 },
{ ".MFLAGS", MFlags, 0 },
{ ".MAIN", Main, 0 },
{ ".MAKE", Attribute, OP_MAKE },
{ ".MAKEFLAGS", MFlags, 0 },
{ ".MFLAGS", MFlags, 0 },
-{ ".NOEXPORT", NoExport, OP_NOEXPORT },
{ ".NOTMAIN", Attribute, OP_NOTMAIN },
{ ".NOTPARALLEL", NotParallel, 0 },
{ ".NULL", Null, 0 },
{ ".NOTMAIN", Attribute, OP_NOTMAIN },
{ ".NOTPARALLEL", NotParallel, 0 },
{ ".NULL", Null, 0 },
-/*-
- *-----------------------------------------------------------------------
- * Parse_AnyExport --
- * Return TRUE if any target was labeled for exportation.
- *
- * Results:
- * TRUE or FALSE...
- *
- * Side Effects:
- * None.
- *
- *-----------------------------------------------------------------------
- */
-Boolean
-Parse_AnyExport()
-{
- return (anyExport);
-}
-
/*-
*---------------------------------------------------------------------
* ParseLinkSrc --
/*-
*---------------------------------------------------------------------
* ParseLinkSrc --
}
if (op != 0) {
Lst_ForEach (targets, ParseDoOp, (ClientData)op);
}
if (op != 0) {
Lst_ForEach (targets, ParseDoOp, (ClientData)op);
- if (op == OP_EXPORT) {
- anyExport = TRUE;
- }
} else if (specType == Main) {
/*
* If we have noted the existence of a .MAIN, it means we need
} else if (specType == Main) {
/*
* If we have noted the existence of a .MAIN, it means we need
* Certain special targets have special semantics:
* .PATH Have to set the dirSearchPath
* variable too
* Certain special targets have special semantics:
* .PATH Have to set the dirSearchPath
* variable too
- * .EXPORT Doesn't really apply the
- * .EXPORT operator to its
- * sources, so we reset tOp.
* .MAIN Its sources are only used if
* nothing has been specified to
* create.
* .MAIN Its sources are only used if
* nothing has been specified to
* create.
}
(void)Lst_AtEnd(paths, (ClientData)dirSearchPath);
break;
}
(void)Lst_AtEnd(paths, (ClientData)dirSearchPath);
break;
- case Export:
- tOp = 0;
- break;
case Main:
if (!Lst_IsEmpty(create)) {
specType = Not;
case Main:
if (!Lst_IsEmpty(create)) {
specType = Not;
* a .IGNORE line ignores errors for all targets
* a .SILENT line creates silence when making all targets
* a .PATH removes all directories from the search path(s).
* a .IGNORE line ignores errors for all targets
* a .SILENT line creates silence when making all targets
* a .PATH removes all directories from the search path(s).
- * a .NOEXPORT turns off exportation for all jobs.
*/
if (!*line) {
switch (specType) {
*/
if (!*line) {
switch (specType) {
case Path:
Lst_ForEach(paths, ParseClearPath, (ClientData)NULL);
break;
case Path:
Lst_ForEach(paths, ParseClearPath, (ClientData)NULL);
break;
- case NoExport:
- noExport = TRUE;
- break;
}
} else if (specType == MFlags) {
/*
}
} else if (specType == MFlags) {
/*
*/
if ((specType == Suffixes) || (specType == Path) ||
(specType == Includes) || (specType == Libs) ||
*/
if ((specType == Suffixes) || (specType == Path) ||
(specType == Includes) || (specType == Libs) ||
- (specType == Export) || (specType == Null))
* files which are considered libraries and whose search path
* should be present in the .LIBS variable.
*
* files which are considered libraries and whose search path
* should be present in the .LIBS variable.
*
- * If it was .EXPORT, the source is the location of the export
- * server and is passed to the Rmt module as such.
- *
* If it was .NULL, the source is the suffix to use when a file
* has no valid suffix.
*/
* If it was .NULL, the source is the suffix to use when a file
* has no valid suffix.
*/
case Libs:
Suff_AddLib (line);
break;
case Libs:
Suff_AddLib (line);
break;
- case Export:
- Rmt_AddServer (line);
- break;
case Null:
Suff_SetNull (line);
break;
case Null:
Suff_SetNull (line);
break;
-static char sccsid[] = "@(#)targ.c 5.3 (Berkeley) %G%";
+static char sccsid[] = "@(#)targ.c 5.4 (Berkeley) %G%";
#endif /* not lint */
/*-
#endif /* not lint */
/*-
PRINTBIT(SILENT);
PRINTBIT(MAKE);
PRINTBIT(JOIN);
PRINTBIT(SILENT);
PRINTBIT(MAKE);
PRINTBIT(JOIN);
- PRINTBIT(EXPORT);
- PRINTBIT(NOEXPORT);
- PRINTBIT(EXPORTSAME);
PRINTBIT(INVISIBLE);
PRINTBIT(NOTMAIN);
PRINTDBIT(LIB);
PRINTBIT(INVISIBLE);
PRINTBIT(NOTMAIN);
PRINTDBIT(LIB);
/*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
case OP_MEMBER: if (DEBUG(TARG)) printf(".MEMBER "); break;
PRINTDBIT(ARCHV);
/*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
case OP_MEMBER: if (DEBUG(TARG)) printf(".MEMBER "); break;
PRINTDBIT(ARCHV);
projects / unix-history / commitdiff