- Convert negative logic, so code is easyer to read.
[dragonfly.git] / usr.bin / make / compat.c
1 /*
2  * Copyright (c) 1988, 1989, 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1988, 1989 by Adam de Boor
5  * Copyright (c) 1989 by Berkeley Softworks
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Adam de Boor.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  * @(#)compat.c 8.2 (Berkeley) 3/19/94
40  * $FreeBSD: src/usr.bin/make/compat.c,v 1.16.2.2 2000/07/01 12:24:21 ps Exp $
41  * $DragonFly: src/usr.bin/make/Attic/compat.c,v 1.26 2005/01/31 08:30:51 okumoto Exp $
42  */
43
44 /*-
45  * compat.c --
46  *      The routines in this file implement the full-compatibility
47  *      mode of PMake. Most of the special functionality of PMake
48  *      is available in this mode. Things not supported:
49  *          - different shells.
50  *          - friendly variable substitution.
51  *
52  * Interface:
53  *      Compat_Run          Initialize things for this module and recreate
54  *                          thems as need creatin'
55  */
56
57 #include <sys/types.h>
58 #include <sys/wait.h>
59 #include <ctype.h>
60 #include <errno.h>
61 #include <signal.h>
62 #include <stdlib.h>
63 #include <string.h>
64 #include <unistd.h>
65
66 #include "buf.h"
67 #include "compat.h"
68 #include "config.h"
69 #include "dir.h"
70 #include "globals.h"
71 #include "GNode.h"
72 #include "job.h"
73 #include "make.h"
74 #include "str.h"
75 #include "suff.h"
76 #include "targ.h"
77 #include "util.h"
78 #include "var.h"
79
80 /*
81  * The following array is used to make a fast determination of which
82  * characters are interpreted specially by the shell.  If a command
83  * contains any of these characters, it is executed by the shell, not
84  * directly by us.
85  */
86
87 static char         meta[256];
88
89 static GNode        *curTarg = NULL;
90 static GNode        *ENDNode;
91 static sig_atomic_t interrupted;
92
93 static void CompatInterrupt(int);
94 static int CompatMake(void *, void *);
95 static int shellneed(char *);
96
97 static void
98 CompatInit(void)
99 {
100     const char  *cp;    /* Pointer to string of shell meta-characters */
101
102     for (cp = "#=|^(){};&<>*?[]:$`\\\n"; *cp != '\0'; cp++) {
103         meta[(unsigned char)*cp] = 1;
104     }
105     /*
106      * The null character serves as a sentinel in the string.
107      */
108     meta[0] = 1;
109 }
110
111 /*
112  * Interrupt handler - set flag and defer handling to the main code
113  */
114 static void
115 CompatCatchSig(int signo)
116 {
117
118         interrupted = signo;
119 }
120
121 /*-
122  *-----------------------------------------------------------------------
123  * CompatInterrupt --
124  *      Interrupt the creation of the current target and remove it if
125  *      it ain't precious.
126  *
127  * Results:
128  *      None.
129  *
130  * Side Effects:
131  *      The target is removed and the process exits. If .INTERRUPT exists,
132  *      its commands are run first WITH INTERRUPTS IGNORED..
133  *
134  *-----------------------------------------------------------------------
135  */
136 static void
137 CompatInterrupt(int signo)
138 {
139     GNode   *gn;
140     sigset_t nmask, omask;
141
142     sigemptyset(&nmask);
143     sigaddset(&nmask, SIGINT);
144     sigaddset(&nmask, SIGTERM);
145     sigaddset(&nmask, SIGHUP);
146     sigaddset(&nmask, SIGQUIT);
147     sigprocmask(SIG_SETMASK, &nmask, &omask);
148
149     /* prevent recursion in evaluation of .INTERRUPT */
150     interrupted = 0;
151
152     if ((curTarg != NULL) && !Targ_Precious(curTarg)) {
153         char      *p1;
154         char      *file = Var_Value(TARGET, curTarg, &p1);
155
156         if (!noExecute && eunlink(file) != -1) {
157             printf("*** %s removed\n", file);
158         }
159         free(p1);
160     }
161
162     /*
163      * Run .INTERRUPT only if hit with interrupt signal
164      */
165     if (signo == SIGINT) {
166         gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
167         if (gn != NULL) {
168             Lst_ForEach(&gn->commands, Compat_RunCommand, (void *)gn);
169         }
170     }
171
172     sigprocmask(SIG_SETMASK, &omask, NULL);
173
174     if (signo == SIGQUIT)
175         exit(signo);
176     signal(signo, SIG_DFL);
177     kill(getpid(), signo);
178 }
179
180 /*-
181  *-----------------------------------------------------------------------
182  * shellneed --
183  *
184  * Results:
185  *      Returns 1 if a specified line must be executed by the shell,
186  *      and 0 if it can be run via execve.
187  *
188  * Side Effects:
189  *      None.
190  *
191  *-----------------------------------------------------------------------
192  */
193 static int
194 shellneed(char *cmd)
195 {
196         static const char *sh_builtin[] = {
197                 "alias", "cd", "eval", "exec",
198                 "exit", "read", "set", "ulimit",
199                 "unalias", "umask", "unset", "wait",
200                 ":", NULL
201         };
202         char            **av;
203         const char      **p;
204         int             ac;
205
206         av = brk_string(cmd, &ac, TRUE);
207         for (p = sh_builtin; *p != 0; p++)
208                 if (strcmp(av[1], *p) == 0)
209                         return (1);
210         return (0);
211 }
212
213 /*-
214  *-----------------------------------------------------------------------
215  * Compat_RunCommand --
216  *      Execute the next command for a target. If the command returns an
217  *      error, the node's made field is set to ERROR and creation stops.
218  *      The node from which the command came is also given.
219  *
220  * Results:
221  *      0 if the command succeeded, 1 if an error occurred.
222  *
223  * Side Effects:
224  *      The node's 'made' field may be set to ERROR.
225  *
226  *-----------------------------------------------------------------------
227  */
228 int
229 Compat_RunCommand(void *cmdp, void *gnp)
230 {
231     char        *cmdStart;      /* Start of expanded command */
232     char        *cp;
233     Boolean     silent;         /* Don't print command */
234     Boolean     doit;           /* Execute even in -n */
235     Boolean     errCheck;       /* Check errors */
236     int         reason;         /* Reason for child's death */
237     int         status;         /* Description of child's death */
238     int         cpid;           /* Child actually found */
239     ReturnStatus        rstat;  /* Status of fork */
240     LstNode     *cmdNode;       /* Node where current command is located */
241     char        **av;           /* Argument vector for thing to exec */
242     int         internal;       /* Various values.. */
243     char        *cmd = cmdp;
244     GNode       *gn = gnp;
245     Buffer      *buf;
246
247     /*
248      * Avoid clobbered variable warnings by forcing the compiler
249      * to ``unregister'' variables
250      */
251 #if __GNUC__
252     (void) &av;
253     (void) &errCheck;
254 #endif
255     silent = gn->type & OP_SILENT;
256     errCheck = !(gn->type & OP_IGNORE);
257     doit = FALSE;
258
259     cmdNode = Lst_Member(&gn->commands, cmd);
260
261     buf = Var_Subst(NULL, cmd, gn, FALSE);
262     cmdStart = Buf_GetAll(buf, NULL);
263     Buf_Destroy(buf, FALSE);
264
265     /*
266      * brk_string will return an argv with a NULL in av[0], thus causing
267      * execvp to choke and die horribly. Besides, how can we execute a null
268      * command? In any case, we warn the user that the command expanded to
269      * nothing (is this the right thing to do?).
270      */
271
272     if (*cmdStart == '\0') {
273         free(cmdStart);
274         Error("%s expands to empty string", cmd);
275         return (0);
276     } else {
277         cmd = cmdStart;
278     }
279     Lst_Replace(cmdNode, cmdStart);
280
281     if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
282         Lst_AtEnd(&ENDNode->commands, cmdStart);
283         return (0);
284     } else if (strcmp(cmdStart, "...") == 0) {
285         gn->type |= OP_SAVE_CMDS;
286         return (0);
287     }
288
289     while ((*cmd == '@') || (*cmd == '-') || (*cmd == '+')) {
290         switch (*cmd) {
291
292           case '@':
293             silent = DEBUG(LOUD) ? FALSE : TRUE;
294             break;
295
296           case '-':
297             errCheck = FALSE;
298             break;
299
300           case '+':
301             doit = TRUE;
302             if (!meta[0])               /* we came here from jobs */
303                 CompatInit();
304             break;
305         }
306         cmd++;
307     }
308
309     while (isspace((unsigned char)*cmd))
310         cmd++;
311
312     /*
313      * Search for meta characters in the command. If there are no meta
314      * characters, there's no need to execute a shell to execute the
315      * command.
316      */
317     for (cp = cmd; !meta[(unsigned char)*cp]; cp++) {
318         continue;
319     }
320
321     /*
322      * Print the command before echoing if we're not supposed to be quiet for
323      * this one. We also print the command if -n given, but not if '+'.
324      */
325     if (!silent || (noExecute && !doit)) {
326         printf("%s\n", cmd);
327         fflush(stdout);
328     }
329
330     /*
331      * If we're not supposed to execute any commands, this is as far as
332      * we go...
333      */
334     if (!doit && noExecute) {
335         return (0);
336     }
337
338     if (*cp != '\0') {
339         /*
340          * If *cp isn't the null character, we hit a "meta" character and
341          * need to pass the command off to the shell. We give the shell the
342          * -e flag as well as -c if it's supposed to exit when it hits an
343          * error.
344          */
345         static char     *shargv[4];
346
347         shargv[0] = shellPath;
348         shargv[1] = (errCheck ? "-ec" : "-c");
349         shargv[2] = cmd;
350         shargv[3] = NULL;
351         av = shargv;
352     } else if ((internal = shellneed(cmd))) {
353         /*
354          * This command must be passed by the shell for other reasons..
355          * or.. possibly not at all.
356          */
357         static char     *shargv[4];
358
359         shargv[0] = shellPath;
360         shargv[1] = (errCheck ? "-ec" : "-c");
361         shargv[2] = cmd;
362         shargv[3] = NULL;
363         av = shargv;
364     } else {
365         int     argc;   /* Number of arguments in av */
366         /*
367          * No meta-characters, so no need to exec a shell. Break the command
368          * into words to form an argument vector we can execute.
369          * brk_string sticks our name in av[0], so we have to
370          * skip over it...
371          */
372         av = brk_string(cmd, &argc, TRUE);
373         av += 1;
374     }
375
376     /*
377      * Fork and execute the single command. If the fork fails, we abort.
378      */
379     cpid = vfork();
380     if (cpid < 0) {
381         Fatal("Could not fork");
382     }
383     if (cpid == 0) {
384         execvp(av[0], av);
385         write(STDERR_FILENO, av[0], strlen(av[0]));
386         write(STDERR_FILENO, ":", 1);
387         write(STDERR_FILENO, strerror(errno), strlen(strerror(errno)));
388         write(STDERR_FILENO, "\n", 1);
389         _exit(1);
390     }
391
392     /*
393      * we need to print out the command associated with this Gnode in
394      * Targ_PrintCmd from Targ_PrintGraph when debugging at level g2,
395      * in main(), Fatal() and DieHorribly(), therefore do not free it
396      * when debugging.
397      */
398     if (!DEBUG(GRAPH2)) {
399         free(cmdStart);
400         Lst_Replace(cmdNode, cmdp);
401     }
402
403     /*
404      * The child is off and running. Now all we can do is wait...
405      */
406     while (1) {
407
408         while ((rstat = wait(&reason)) != cpid) {
409             if (interrupted || (rstat == -1 && errno != EINTR)) {
410                     break;
411             }
412         }
413         if (interrupted)
414             CompatInterrupt(interrupted);
415
416         if (rstat > -1) {
417             if (WIFSTOPPED(reason)) {
418                 status = WSTOPSIG(reason);              /* stopped */
419             } else if (WIFEXITED(reason)) {
420                 status = WEXITSTATUS(reason);           /* exited */
421                 if (status != 0) {
422                     printf("*** Error code %d", status);
423                 }
424             } else {
425                 status = WTERMSIG(reason);              /* signaled */
426                 printf("*** Signal %d", status);
427             }
428
429
430             if (!WIFEXITED(reason) || (status != 0)) {
431                 if (errCheck) {
432                     gn->made = ERROR;
433                     if (keepgoing) {
434                         /*
435                          * Abort the current target, but let others
436                          * continue.
437                          */
438                         printf(" (continuing)\n");
439                     }
440                 } else {
441                     /*
442                      * Continue executing commands for this target.
443                      * If we return 0, this will happen...
444                      */
445                     printf(" (ignored)\n");
446                     status = 0;
447                 }
448             }
449             break;
450         } else {
451             Fatal("error in wait: %d", rstat);
452             /*NOTREACHED*/
453         }
454     }
455
456     return (status);
457 }
458
459 /*-
460  *-----------------------------------------------------------------------
461  * CompatMake --
462  *      Make a target, given the parent, to abort if necessary.
463  *
464  * Results:
465  *      0
466  *
467  * Side Effects:
468  *      If an error is detected and not being ignored, the process exits.
469  *
470  *-----------------------------------------------------------------------
471  */
472 static int
473 CompatMake(void *gnp, void *pgnp)
474 {
475     GNode *gn = gnp;
476     GNode *pgn = pgnp;
477
478     if (gn->type & OP_USE) {
479         Make_HandleUse(gn, pgn);
480     } else if (gn->made == UNMADE) {
481         /*
482          * First mark ourselves to be made, then apply whatever transformations
483          * the suffix module thinks are necessary. Once that's done, we can
484          * descend and make all our children. If any of them has an error
485          * but the -k flag was given, our 'make' field will be set FALSE again.
486          * This is our signal to not attempt to do anything but abort our
487          * parent as well.
488          */
489         gn->make = TRUE;
490         gn->made = BEINGMADE;
491         Suff_FindDeps(gn);
492         Lst_ForEach(&gn->children, CompatMake, gn);
493         if (!gn->make) {
494             gn->made = ABORTED;
495             pgn->make = FALSE;
496             return (0);
497         }
498
499         if (Lst_Member(&gn->iParents, pgn) != NULL) {
500             char *p1;
501             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
502             free(p1);
503         }
504
505         /*
506          * All the children were made ok. Now cmtime contains the modification
507          * time of the newest child, we need to find out if we exist and when
508          * we were modified last. The criteria for datedness are defined by the
509          * Make_OODate function.
510          */
511         DEBUGF(MAKE, ("Examining %s...", gn->name));
512         if (!Make_OODate(gn)) {
513             gn->made = UPTODATE;
514             DEBUGF(MAKE, ("up-to-date.\n"));
515             return (0);
516         } else {
517             DEBUGF(MAKE, ("out-of-date.\n"));
518         }
519
520         /*
521          * If the user is just seeing if something is out-of-date, exit now
522          * to tell him/her "yes".
523          */
524         if (queryFlag) {
525             exit(1);
526         }
527
528         /*
529          * We need to be re-made. We also have to make sure we've got a $?
530          * variable. To be nice, we also define the $> variable using
531          * Make_DoAllVar().
532          */
533         Make_DoAllVar(gn);
534
535         /*
536          * Alter our type to tell if errors should be ignored or things
537          * should not be printed so Compat_RunCommand knows what to do.
538          */
539         if (Targ_Ignore(gn)) {
540             gn->type |= OP_IGNORE;
541         }
542         if (Targ_Silent(gn)) {
543             gn->type |= OP_SILENT;
544         }
545
546         if (Job_CheckCommands(gn, Fatal)) {
547             /*
548              * Our commands are ok, but we still have to worry about the -t
549              * flag...
550              */
551             if (!touchFlag) {
552                 curTarg = gn;
553                 Lst_ForEach(&gn->commands, Compat_RunCommand, (void *)gn);
554                 curTarg = NULL;
555             } else {
556                 Job_Touch(gn, gn->type & OP_SILENT);
557             }
558         } else {
559             gn->made = ERROR;
560         }
561
562         if (gn->made != ERROR) {
563             /*
564              * If the node was made successfully, mark it so, update
565              * its modification time and timestamp all its parents. Note
566              * that for .ZEROTIME targets, the timestamping isn't done.
567              * This is to keep its state from affecting that of its parent.
568              */
569             gn->made = MADE;
570 #ifndef RECHECK
571             /*
572              * We can't re-stat the thing, but we can at least take care of
573              * rules where a target depends on a source that actually creates
574              * the target, but only if it has changed, e.g.
575              *
576              * parse.h : parse.o
577              *
578              * parse.o : parse.y
579              *          yacc -d parse.y
580              *          cc -c y.tab.c
581              *          mv y.tab.o parse.o
582              *          cmp -s y.tab.h parse.h || mv y.tab.h parse.h
583              *
584              * In this case, if the definitions produced by yacc haven't
585              * changed from before, parse.h won't have been updated and
586              * gn->mtime will reflect the current modification time for
587              * parse.h. This is something of a kludge, I admit, but it's a
588              * useful one..
589              *
590              * XXX: People like to use a rule like
591              *
592              * FRC:
593              *
594              * To force things that depend on FRC to be made, so we have to
595              * check for gn->children being empty as well...
596              */
597             if (!Lst_IsEmpty(&gn->commands) || Lst_IsEmpty(&gn->children)) {
598                 gn->mtime = now;
599             }
600 #else
601             /*
602              * This is what Make does and it's actually a good thing, as it
603              * allows rules like
604              *
605              *  cmp -s y.tab.h parse.h || cp y.tab.h parse.h
606              *
607              * to function as intended. Unfortunately, thanks to the stateless
608              * nature of NFS (and the speed of this program), there are times
609              * when the modification time of a file created on a remote
610              * machine will not be modified before the stat() implied by
611              * the Dir_MTime occurs, thus leading us to believe that the file
612              * is unchanged, wreaking havoc with files that depend on this one.
613              *
614              * I have decided it is better to make too much than to make too
615              * little, so this stuff is commented out unless you're sure it's
616              * ok.
617              * -- ardeb 1/12/88
618              */
619             if (noExecute || Dir_MTime(gn) == 0) {
620                 gn->mtime = now;
621             }
622             if (gn->cmtime > gn->mtime)
623                 gn->mtime = gn->cmtime;
624             DEBUGF(MAKE, ("update time: %s\n", Targ_FmtTime(gn->mtime)));
625 #endif
626             if (!(gn->type & OP_EXEC)) {
627                 pgn->childMade = TRUE;
628                 Make_TimeStamp(pgn, gn);
629             }
630         } else if (keepgoing) {
631             pgn->make = FALSE;
632         } else {
633             char *p1;
634
635             printf("\n\nStop in %s.\n", Var_Value(".CURDIR", gn, &p1));
636             free(p1);
637             exit(1);
638         }
639     } else if (gn->made == ERROR) {
640         /*
641          * Already had an error when making this beastie. Tell the parent
642          * to abort.
643          */
644         pgn->make = FALSE;
645     } else {
646         if (Lst_Member(&gn->iParents, pgn) != NULL) {
647             char *p1;
648             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
649             free(p1);
650         }
651         switch(gn->made) {
652             case BEINGMADE:
653                 Error("Graph cycles through %s\n", gn->name);
654                 gn->made = ERROR;
655                 pgn->make = FALSE;
656                 break;
657             case MADE:
658                 if ((gn->type & OP_EXEC) == 0) {
659                     pgn->childMade = TRUE;
660                     Make_TimeStamp(pgn, gn);
661                 }
662                 break;
663             case UPTODATE:
664                 if ((gn->type & OP_EXEC) == 0) {
665                     Make_TimeStamp(pgn, gn);
666                 }
667                 break;
668             default:
669                 break;
670         }
671     }
672
673     return (0);
674 }
675
676 /*-
677  *-----------------------------------------------------------------------
678  * Compat_Run --
679  *      Start making again, given a list of target nodes.
680  *
681  * Results:
682  *      None.
683  *
684  * Side Effects:
685  *      Guess what?
686  *
687  *-----------------------------------------------------------------------
688  */
689 void
690 Compat_Run(Lst *targs)
691 {
692     GNode         *gn = NULL;/* Current root target */
693     int           errors;   /* Number of targets not remade due to errors */
694
695     CompatInit();
696     Shell_Init();               /* Set up shell. */
697
698     if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
699         signal(SIGINT, CompatCatchSig);
700     }
701     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
702         signal(SIGTERM, CompatCatchSig);
703     }
704     if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
705         signal(SIGHUP, CompatCatchSig);
706     }
707     if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
708         signal(SIGQUIT, CompatCatchSig);
709     }
710
711     ENDNode = Targ_FindNode(".END", TARG_CREATE);
712     /*
713      * If the user has defined a .BEGIN target, execute the commands attached
714      * to it.
715      */
716     if (!queryFlag) {
717         gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
718         if (gn != NULL) {
719             Lst_ForEach(&gn->commands, Compat_RunCommand, gn);
720             if (gn->made == ERROR) {
721                 printf("\n\nStop.\n");
722                 exit(1);
723             }
724         }
725     }
726
727     /*
728      * For each entry in the list of targets to create, call CompatMake on
729      * it to create the thing. CompatMake will leave the 'made' field of gn
730      * in one of several states:
731      *      UPTODATE        gn was already up-to-date
732      *      MADE            gn was recreated successfully
733      *      ERROR           An error occurred while gn was being created
734      *      ABORTED         gn was not remade because one of its inferiors
735      *                      could not be made due to errors.
736      */
737     errors = 0;
738     while (!Lst_IsEmpty(targs)) {
739         gn = Lst_DeQueue(targs);
740         CompatMake(gn, gn);
741
742         if (gn->made == UPTODATE) {
743             printf("`%s' is up to date.\n", gn->name);
744         } else if (gn->made == ABORTED) {
745             printf("`%s' not remade because of errors.\n", gn->name);
746             errors += 1;
747         }
748     }
749
750     /*
751      * If the user has defined a .END target, run its commands.
752      */
753     if (errors == 0) {
754         Lst_ForEach(&ENDNode->commands, Compat_RunCommand, gn);
755     }
756 }