kit

input.c (30410B)

---

 /*
  * Parse a makefile and build the target/rule/macro graph. Ported from pdpmake
  * input.c. The read path no longer uses FILE*: a MakeSource iterates either an
  * in-memory makefile buffer or the built-in rules generator; included makefiles
  * are read through KitContext.file_io; `!=` / $(shell) run through host->capture.
  *
  * v1 limitation: shell-glob wildcards in prerequisites/targets are not expanded
  * (pdpmake used <glob.h>). Names are taken literally, with backslash escapes
  * removed, which matches the non-wildcard path exactly. Part of the
  * src/api/make.c amalgamation.
  */
 #include "make.h"
 
 #define mk_find_colon(p) strchr((p), ':')
 
 /* Defined below; used by mk_expand_macros for the $(shell ...) function. */
 static char* mk_run_command(MakeCtx* mc, const char* cmd);
 
 /*
  * Return a pointer to the next blank-delimited word or NULL if none are left.
  */
 static char* mk_gettok(char** ptr) {
   char* p;
 
   while (isblank((unsigned char)**ptr)) /* Skip blanks. */
     (*ptr)++;
 
   if (**ptr == '\0') /* Nothing after blanks. */
     return NULL;
 
   p = *ptr; /* Word starts here. */
 
   while (**ptr != '\0' && !isblank((unsigned char)**ptr))
     (*ptr)++; /* Find end of word. */
 
   if (**ptr != '\0') *(*ptr)++ = '\0';
 
   return p;
 }
 
 /*
  * Skip over (possibly adjacent or nested) macro expansions.
  */
 static char* mk_skip_macro(const char* s) {
   while (*s && s[0] == '$') {
     if (s[1] == '(' || s[1] == '{') {
       char end = *++s == '(' ? ')' : '}';
       while (*s && *s != end) s = mk_skip_macro(s + 1);
       if (*s == end) ++s;
     } else if (s[1] != '\0') {
       s += 2;
     } else {
       break;
     }
   }
   return (char*)s;
 }
 
 /*
  * Process each whitespace-separated word: replace paths with their directory or
  * filename part, and replace prefixes/suffixes. Returns an arena string, or
  * NULL if the input is unmodified.
  */
 static char* mk_modify_words(MakeCtx* mc, const char* val, int modifier,
                              size_t lenf, size_t lenr, const char* find_pref,
                              const char* repl_pref, const char* find_suff,
                              const char* repl_suff) {
   char *s, *copy, *word, *sep, *newword, *buf = NULL;
   size_t find_pref_len = 0, find_suff_len = 0;
 
   if (!modifier && lenf == 0 && lenr == 0) return buf;
 
   if (find_pref) {
     find_pref_len = strlen(find_pref);
     find_suff_len = lenf - find_pref_len - 1;
   }
 
   s = copy = mk_strdup(mc, val);
   while ((word = mk_gettok(&s)) != NULL) {
     newword = NULL;
     if (modifier) {
       sep = strrchr(word, '/');
       if (modifier == 'D') {
         if (!sep) {
           word[0] = '.';
           sep = word + 1;
         } else if (sep == word) {
           sep = word + 1;
         }
         *sep = '\0';
       } else if (/* modifier == 'F' && */ sep) {
         word = sep + 1;
       }
     }
     if (find_pref != NULL || lenf != 0 || lenr != 0) {
       size_t lenw = strlen(word);
       /* Pattern macro expansions: <prefix>%<suffix>, e.g. src/%.c. */
       if (find_pref != NULL && lenw + 1 >= lenf) {
         if (strncmp(word, find_pref, find_pref_len) == 0 &&
             strcmp(word + lenw - find_suff_len, find_suff) == 0) {
           if (!repl_suff) {
             word = newword = mk_strdup(mc, repl_pref);
           } else {
             word[lenw - find_suff_len] = '\0';
             word = newword =
                 mk_concat3(mc, repl_pref, word + find_pref_len, repl_suff);
           }
         }
       } else if (lenw >= lenf && strcmp(word + lenw - lenf, find_suff) == 0) {
         word[lenw - lenf] = '\0';
         word = newword = mk_concat3(mc, word, repl_suff, "");
       }
     }
     buf = mk_appendword(mc, buf, word);
   }
   return buf;
 }
 
 /*
  * Return a pointer to the next instance of a character, skipping over macro
  * expansions so ':' and '=' inside $(VAR:.s1=.s2) aren't seen as separators.
  */
 static char* mk_find_char(const char* str, int c) {
   const char* s;
 
   for (s = mk_skip_macro(str); *s; s = mk_skip_macro(s + 1)) {
     if (*s == c) return (char*)s;
   }
   return NULL;
 }
 
 /*
  * Recursively expand any macros in str to an arena string.
  */
 static char* mk_expand_macros(MakeCtx* mc, const char* str, int except_dollar) {
   char *exp, *newexp, *s, *t, *p, *q, *name;
   char *find, *replace, *modified;
   char *expval, *expfind, *find_suff, *repl_suff;
   char *find_pref = NULL, *repl_pref = NULL;
   size_t lenf, lenr;
   char modifier;
   struct macro* mp;
 
   exp = mk_strdup(mc, str);
   for (t = exp; *t; t++) {
     if (*t == '$') {
       if (t[1] == '\0') {
         break;
       }
       if (t[1] == '$' && except_dollar) {
         t++;
         continue;
       }
       /* Need to expand a macro. Find its extent (s to t inclusive) and copy. */
       s = t;
       t++;
       if (*t == '{' || *t == '(') {
         t = mk_find_char(t, *t == '{' ? '}' : ')');
         if (t == NULL) mk_error(mc, "unterminated variable '%s'", s);
         name = mk_strndup(mc, s + 2, t - s - 2);
       } else {
         name = mk_alloc(mc, 2);
         name[0] = *t;
         name[1] = '\0';
       }
 
       modified = NULL;
       /* $(shell command): a non-POSIX function; run it and substitute its
        * stdout. Detected before the ':'/'=' parsing below, which would
        * otherwise mangle a command containing those characters. */
       if (!mc->posix && strncmp(name, "shell", 5) == 0 &&
           isblank((unsigned char)name[5])) {
         char* scmd = mk_expand_macros(mc, name + 6, FALSE);
         modified = mk_run_command(mc, scmd);
         goto mk_expanded;
       }
 
       /* Only do suffix replacement or pattern macro expansion if both ':' and
        * '=' are found, plus a '%' for the latter. */
       expfind = NULL;
       find_suff = repl_suff = NULL;
       lenf = lenr = 0;
       if ((find = mk_find_char(name, ':'))) {
         *find++ = '\0';
         expfind = mk_expand_macros(mc, find, FALSE);
         if ((replace = mk_find_char(expfind, '='))) {
           *replace++ = '\0';
           lenf = strlen(expfind);
           if (!POSIX_2017 && (find_suff = strchr(expfind, '%'))) {
             find_pref = expfind;
             repl_pref = replace;
             *find_suff++ = '\0';
             if ((repl_suff = strchr(replace, '%'))) *repl_suff++ = '\0';
           } else {
             if (mc->posix && !(mc->pragma & P_EMPTY_SUFFIX) && lenf == 0)
               mk_error(mc, "empty suffix%s",
                        ": allow with pragma empty_suffix");
             find_suff = expfind;
             repl_suff = replace;
             lenr = strlen(repl_suff);
           }
         }
       }
 
       p = q = name;
       /* If not in POSIX mode expand macros in the name. */
       if (!POSIX_2017) {
         char* expname = mk_expand_macros(mc, name, FALSE);
         name = expname;
       } else
         /* Skip over nested expansions in name. */
         do {
           *q++ = *p;
         } while ((p = mk_skip_macro(p + 1)) && *p);
 
       /* The internal macros support 'D' and 'F' modifiers. */
       modifier = '\0';
       switch (name[0]) {
         case '^':
         case '+':
           if (POSIX_2017) break;
           /* fall through */
         case '@':
         case '%':
         case '?':
         case '<':
         case '*':
           if ((name[1] == 'D' || name[1] == 'F') && name[2] == '\0') {
             modifier = name[1];
             name[1] = '\0';
           }
           break;
       }
 
       modified = NULL;
       if ((mp = mk_getmp(mc, name))) {
         /* Recursive expansion. */
         if (mp->m_flag) mk_error(mc, "recursive macro %s", name);
         /* Note if we've expanded $(MAKE). */
         if (strcmp(name, "MAKE") == 0) mc->opts |= OPT_make;
         mp->m_flag = TRUE;
         /* Immediate-expansion macros aren't recursively expanded. */
         if (mp->m_immediate)
           expval = mk_strdup(mc, mp->m_val);
         else
           expval = mk_expand_macros(mc, mp->m_val, FALSE);
         mp->m_flag = FALSE;
         modified = mk_modify_words(mc, expval, modifier, lenf, lenr, find_pref,
                                    repl_pref, find_suff, repl_suff);
         if (!modified) modified = expval;
       }
 
     mk_expanded:
       if (modified && *modified) {
         /* Text replaced by the expansion is s to t inclusive. */
         *s = '\0';
         newexp = mk_concat3(mc, exp, modified, t + 1);
         t = newexp + (s - exp) + strlen(modified) - 1;
         exp = newexp;
       } else {
         /* Macro wasn't expanded or expanded to nothing. Close the gap. */
         q = t + 1;
         t = s - 1;
         while ((*s++ = *q++)) continue;
       }
     }
   }
   return exp;
 }
 
 /*
  * Process a non-command line: strip comment, join escaped newlines.
  */
 static void mk_process_line(MakeCtx* mc, char* s) {
   char* t;
 
   /* Strip comment. In non-POSIX mode don't treat '#' inside a macro expansion
    * as a comment, nor a backslash-escaped '#'. */
   if (!mc->posix) {
     char* u = s;
     while ((t = mk_find_char(u, '#')) && t > u && t[-1] == '\\') {
       for (u = t; *u; ++u) u[-1] = u[0];
       *u = '\0';
       u = t;
     }
   } else
     t = strchr(s, '#');
   if (t) *t = '\0';
 
   /* Replace escaped newline + leading whitespace on the next line with a single
    * space. Stop at a non-escaped newline. */
   for (t = s; *s && *s != '\n';) {
     if (s[0] == '\\' && s[1] == '\n') {
       s += 2;
       while (isspace((unsigned char)*s)) ++s;
       *t++ = ' ';
     } else {
       *t++ = *s++;
     }
   }
   *t = '\0';
 }
 
 enum { MK_INITIAL = 0, MK_SKIP_LINE = 1 << 0, MK_EXPECT_ELSE = 1 << 1,
        MK_GOT_MATCH = 1 << 2 };
 
 /*
  * Extract strings following ifeq/ifneq and compare them. Return -1 on error.
  */
 static int mk_compare_strings(MakeCtx* mc, char* arg1) {
   char *arg2, *end, term, *t1, *t2;
   int ret;
 
   if (arg1[0] == '(')
     term = ',';
   else if (arg1[0] == '"' || arg1[0] == '\'')
     term = arg1[0];
   else
     return -1;
 
   arg2 = mk_find_char(++arg1, term);
   if (arg2 == NULL) return -1;
   *arg2++ = '\0';
 
   if (term == ',') {
     term = ')';
   } else {
     while (isspace((unsigned char)arg2[0])) arg2++;
     if (arg2[0] == '"' || arg2[0] == '\'')
       term = arg2[0];
     else
       return -1;
     ++arg2;
   }
 
   end = mk_find_char(arg2, term);
   if (end == NULL) return -1;
   *end++ = '\0';
 
   if (mk_gettok(&end) != NULL) mk_warning(mc, "unexpected text");
 
   t1 = mk_expand_macros(mc, arg1, FALSE);
   t2 = mk_expand_macros(mc, arg2, FALSE);
   ret = strcmp(t1, t2) == 0;
   return ret;
 }
 
 /*
  * Process conditional directives; return TRUE if the current line is skipped.
  */
 static int mk_skip_line(MakeCtx* mc, const char* str1) {
   char *copy, *q, *token;
   bool new_level = TRUE;
   int ret = mc->cstate[mc->clevel] & MK_SKIP_LINE;
 
   q = copy = mk_strdup(mc, str1);
   mk_process_line(mc, copy);
   if ((token = mk_gettok(&q)) != NULL) {
     if (strcmp(token, "endif") == 0) {
       if (mk_gettok(&q) != NULL) mk_error_unexpected(mc, "text");
       if (mc->clevel == 0) mk_error_unexpected(mc, token);
       --mc->clevel;
       ret = TRUE;
       goto end;
     } else if (strcmp(token, "else") == 0) {
       if (!(mc->cstate[mc->clevel] & MK_EXPECT_ELSE))
         mk_error_unexpected(mc, token);
 
       if ((mc->cstate[mc->clevel] & MK_GOT_MATCH))
         mc->cstate[mc->clevel] |= MK_SKIP_LINE;
       else
         mc->cstate[mc->clevel] &= ~MK_SKIP_LINE;
 
       token = mk_gettok(&q);
       if (token == NULL) {
         mc->cstate[mc->clevel] &= ~MK_EXPECT_ELSE;
         ret = TRUE;
         goto end;
       } else {
         new_level = FALSE;
       }
     }
 
     if (strcmp(token, "ifdef") == 0 || strcmp(token, "ifndef") == 0 ||
         strcmp(token, "ifeq") == 0 || strcmp(token, "ifneq") == 0) {
       int match;
 
       if (token[2] == 'd' || token[3] == 'd') {
         char* name = mk_gettok(&q);
         if (name != NULL && mk_gettok(&q) == NULL) {
           char* t = mk_expand_macros(mc, name, FALSE);
           struct macro* mp = mk_getmp(mc, t);
           match = mp != NULL && mp->m_val[0] != '\0';
         } else {
           match = -1;
         }
       } else {
         match = mk_compare_strings(mc, q);
       }
 
       if (match >= 0) {
         if (new_level) {
           if (mc->clevel == MK_IF_MAX) mk_error(mc, "nesting too deep");
           ++mc->clevel;
           mc->cstate[mc->clevel] = MK_EXPECT_ELSE | MK_SKIP_LINE;
           if ((mc->cstate[mc->clevel - 1] & MK_SKIP_LINE))
             mc->cstate[mc->clevel] |= MK_GOT_MATCH;
         }
 
         if (!(mc->cstate[mc->clevel] & MK_GOT_MATCH)) {
           if (token[2] == 'n') match = !match;
           if (match) {
             mc->cstate[mc->clevel] &= ~MK_SKIP_LINE;
             mc->cstate[mc->clevel] |= MK_GOT_MATCH;
           }
         }
       } else {
         mk_error(mc, "invalid condition");
       }
       ret = TRUE;
     } else if (!new_level) {
       mk_error(mc, "missing conditional");
     }
   }
 end:
   return ret;
 }
 
 /*
  * fgets-style reader over a MakeSource: the built-in rules (data == NULL) or an
  * in-memory makefile buffer.
  */
 static char* mk_src_fgets(MakeCtx* mc, char* s, int size, MakeSource* src) {
   int i = 0;
 
   if (src->data == NULL) return mk_getrules(mc, s, size);
   if (src->pos >= src->len) return NULL;
   while (i < size - 1 && src->pos < src->len) {
     char c = (char)src->data[src->pos++];
     s[i++] = c;
     if (c == '\n') break;
   }
   s[i] = '\0';
   return i ? s : NULL;
 }
 
 /*
  * Read a newline-terminated logical line into an arena string. Backslash-escaped
  * newlines don't terminate it; comment lines are skipped. Return NULL on EOF.
  */
 static char* mk_readline(MakeCtx* mc, MakeSource* src, int want_command) {
   char *p, *str = NULL;
   int pos = 0;
   int len = 0;
 
   for (;;) {
     if (len - pos > 1 && mk_src_fgets(mc, str + pos, len - pos, src) == NULL) {
       if (pos) return str;
       return NULL; /* EOF */
     }
 
     if (len - pos < 2 || (p = strchr(str + pos, '\n')) == NULL) {
       int oldlen = len;
       if (len) pos = len - 1;
       len += 256;
       str = mk_realloc(mc, str, (size_t)oldlen, (size_t)len);
       continue;
     }
     mc->lineno++;
 
     if (p != str && p[-1] == '\r') {
       p[-1] = '\n';
       *p-- = '\0';
     }
 
     if (p != str && p[-1] == '\\') {
       pos = p - str + 1;
       continue;
     }
     mc->dispno = mc->lineno;
 
     if (mc->posix || !mk_skip_line(mc, str)) {
       if (want_command && *str == '\t') return str;
 
       p = str;
       while (isblank((unsigned char)*p)) p++;
 
       if (*p != '\n' && (mc->posix ? *str != '#' : *p != '#')) return str;
     }
 
     pos = 0;
   }
 }
 
 /*
  * Return the suffix name if the argument is a known suffix, else NULL.
  */
 static const char* mk_is_suffix(MakeCtx* mc, const char* s) {
   struct name* np;
   struct rule* rp;
   struct depend* dp;
 
   np = mk_newname(mc, ".SUFFIXES");
   for (rp = np->n_rule; rp; rp = rp->r_next) {
     for (dp = rp->r_dep; dp; dp = dp->d_next) {
       if (strcmp(s, dp->d_name->n_name) == 0) return dp->d_name->n_name;
     }
   }
   return NULL;
 }
 
 /*
  * Return TRUE if s is formed by concatenating two known suffixes.
  */
 static int mk_is_inference_target(MakeCtx* mc, const char* s) {
   struct name* np;
   struct rule *rp1, *rp2;
   struct depend *dp1, *dp2;
 
   np = mk_newname(mc, ".SUFFIXES");
   for (rp1 = np->n_rule; rp1; rp1 = rp1->r_next) {
     for (dp1 = rp1->r_dep; dp1; dp1 = dp1->d_next) {
       const char* suff1 = dp1->d_name->n_name;
       size_t len = strlen(suff1);
 
       if (strncmp(s, suff1, len) == 0) {
         for (rp2 = np->n_rule; rp2; rp2 = rp2->r_next) {
           for (dp2 = rp2->r_dep; dp2; dp2 = dp2->d_next) {
             const char* suff2 = dp2->d_name->n_name;
             if (strcmp(s + len, suff2) == 0) return TRUE;
           }
         }
       }
     }
   }
   return FALSE;
 }
 
 enum {
   T_NORMAL = 0,
   T_SPECIAL = (1 << 0),
   T_INFERENCE = (1 << 1),
   T_NOPREREQ = (1 << 2),
   T_COMMAND = (1 << 3),
 };
 
 /*
  * Determine if s is a special target and return flags describing it.
  */
 static int mk_target_type(MakeCtx* mc, char* s) {
   int ret;
   static const char* s_name[] = {
       ".DEFAULT", ".POSIX",   ".IGNORE",      ".PRECIOUS",
       ".SILENT",  ".SUFFIXES", ".PHONY",       ".NOTPARALLEL",
       ".WAIT",    ".PRAGMA",
   };
   static const uint8_t s_type[] = {
       T_SPECIAL | T_NOPREREQ | T_COMMAND,
       T_SPECIAL | T_NOPREREQ,
       T_SPECIAL,
       T_SPECIAL,
       T_SPECIAL,
       T_SPECIAL,
       T_SPECIAL,
       T_SPECIAL | T_NOPREREQ,
       T_SPECIAL | T_NOPREREQ,
       T_SPECIAL,
   };
 
   for (ret = 0; (size_t)ret < sizeof(s_name) / sizeof(s_name[0]); ret++)
     if (strcmp(s_name[ret], s) == 0) return s_type[ret];
 
   ret = T_NORMAL;
   if (!mc->posix) {
     if (mk_is_suffix(mc, s) || mk_is_inference_target(mc, s))
       ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
   } else {
     /* In POSIX inference rule targets must contain one or two dots. */
     char* sfx = mk_suffix(s);
     if (*s == '.' && mk_is_suffix(mc, sfx)) {
       if (s == sfx) {
         ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
       } else {
         *sfx = '\0';
         if (mk_is_suffix(mc, s)) ret = T_INFERENCE | T_NOPREREQ | T_COMMAND;
         *sfx = '.';
       }
     }
   }
   return ret;
 }
 
 static int mk_ends_with_bracket(const char* s) {
   const char* t = strrchr(s, ')');
   return t && t[1] == '\0';
 }
 
 /*
  * Process a command line: strip POSIX comments, collapse escaped newlines.
  */
 static char* mk_process_command(MakeCtx* mc, char* s) {
   char *t, *u;
   int len;
   char* outside;
 
   if (!(mc->pragma & P_COMMAND_COMMENT) && mc->posix) {
     /* POSIX strips comments from command lines. */
     t = strchr(s, '#');
     if (t) {
       *t = '\0';
       mk_warning(mc,
                  "comment in command removed: keep with pragma command_comment");
     }
   }
 
   len = (int)strlen(s) + 1;
   outside = mk_alloc(mc, (size_t)len);
   memset(outside, 0, (size_t)len);
   for (t = mk_skip_macro(s); *t; t = mk_skip_macro(t + 1)) outside[t - s] = 1;
 
   /* Process escaped newlines. Stop at first non-escaped newline. */
   for (t = u = s; *u && *u != '\n';) {
     if (u[0] == '\\' && u[1] == '\n') {
       if (POSIX_2017 || outside[u - s]) {
         /* Outside macro: remove tab following escaped newline. */
         *t++ = *u++;
         *t++ = *u++;
         u += (*u == '\t');
       } else {
         /* Inside macro: replace escaped newline + leading whitespace with a
          * single space. */
         u += 2;
         while (isspace((unsigned char)*u)) ++u;
         *t++ = ' ';
       }
     } else {
       *t++ = *u++;
     }
   }
   *t = '\0';
   return s;
 }
 
 /*
  * Run a command and capture its stdout for `!=` / $(shell). Returns an arena
  * string or NULL.
  */
 static char* mk_run_command(MakeCtx* mc, const char* cmd) {
   uint8_t* out = NULL;
   size_t out_len = 0;
   int status = 0;
   char* val;
   char* s;
   size_t len;
   const KitExec* ex = mc->host->exec;
   KitExecProc* proc = NULL;
   KitSlice av[3];
   KitExecOpts eo;
 
   av[0] = kit_slice_cstr(mc->shell);
   av[1] = KIT_SLICE_LIT("-c");
   av[2] = kit_slice_cstr(cmd);
   memset(&eo, 0, sizeof eo);
   eo.argv = av;
   eo.argc = 3;
   eo.env = mc->env;
   eo.nenv = mc->nenv;
   eo.cwd = mc->root ? kit_slice_cstr(mc->root) : KIT_SLICE_NULL;
   eo.search_path = 1;
   eo.capture_stdout = 1;
   if (ex->spawn(ex->user, &eo, &proc) != 0) return NULL;
   /* Like pdpmake's run_command, use the captured output regardless of status. */
   (void)ex->wait(ex->user, proc, &status, &out, &out_len);
   if (out == NULL || out_len == 0) {
     if (out) mc->ctx->heap->free(mc->ctx->heap, out, out_len);
     return NULL;
   }
 
   val = mk_alloc(mc, out_len + 1);
   memcpy(val, out, out_len);
   val[out_len] = '\0';
   len = out_len;
   mc->ctx->heap->free(mc->ctx->heap, out, out_len);
 
   /* Strip leading whitespace in POSIX mode. */
   if (mc->posix) {
     s = val;
     while (isspace((unsigned char)*s)) {
       ++s;
       --len;
     }
     if (len == 0) return NULL;
     memmove(val, s, len + 1);
   }
 
   /* Remove one trailing newline (BSD compatibility); others become spaces. */
   if (val[len - 1] == '\n') val[len - 1] = '\0';
   for (s = val; *s; ++s) {
     if (*s == '\n') *s = ' ';
   }
   return val;
 }
 
 /*
  * Remove backslash escapes from a name (the non-wildcard path of pdpmake's
  * wildcard()); v1 does not expand shell globs.
  */
 static void mk_deglob(char* p) {
   char* s;
   for (s = p; *p; ++p) {
     if (*p == '\\' && p[1] != '\0') continue;
     *s++ = *p;
   }
   *s = '\0';
 }
 
 /*
  * Determine if a line is a target rule with an inline command; return a pointer
  * to the semicolon separator if so, else NULL.
  */
 static char* mk_inline_command(char* line) {
   char* p = mk_find_char(line, ':');
   if (p) p = strchr(p, ';');
   return p;
 }
 
 /*
  * Parse input from a makefile source and construct the tree structure.
  */
 static void mk_input(MakeCtx* mc, MakeSource* src, int ilevel) {
   char *p, *q, *s, *a, *str, *expanded, *copy;
   char *str1, *str2;
   struct name* np;
   struct depend* dp;
   struct cmd* cp;
   int startno, count;
   bool semicolon_cmd, seen_inference;
   uint8_t old_clevel = mc->clevel;
   bool dbl;
   char* lib = NULL;
   int nfile, i;
   char** files;
   bool minus;
 
   mc->lineno = 0;
   str1 = mk_readline(mc, src, FALSE);
   while (str1) {
     str2 = NULL;
 
     /* Take a copy before non-command processing in case this is a rule with an
      * inline command (target: prereq; command). */
     copy = mk_strdup(mc, str1);
     mk_process_line(mc, str1);
     str = str1;
 
     /* Check for an include line. */
     if (!mc->posix)
       while (isblank((unsigned char)*str)) ++str;
     minus = !POSIX_2017 && *str == '-';
     p = str + minus;
     if (strncmp(p, "include", 7) == 0 && isblank((unsigned char)p[7])) {
       const char* old_makefile = mc->makefile;
       int old_lineno = mc->lineno;
 
       if (ilevel > 16) mk_error(mc, "too many includes");
 
       count = 0;
       q = expanded = mk_expand_macros(mc, p + 7, FALSE);
       while ((p = mk_gettok(&q)) != NULL) {
         KitFileData ifd;
 
         ++count;
         if (!POSIX_2017) {
           /* Try to create the include file or bring it up-to-date. */
           mc->opts |= OPT_include;
           mk_make(mc, mk_newname(mc, p), 1);
           mc->opts &= ~OPT_include;
         }
         ifd.data = NULL;
         ifd.size = 0;
         ifd.token = NULL;
         if (!mc->ctx->file_io ||
             mc->ctx->file_io->read_all(mc->ctx->file_io->user, mk_path(mc, p),
                                        &ifd) != KIT_OK) {
           if (!minus) mk_error(mc, "can't open include file '%s'", p);
         } else {
           MakeSource subsrc = {(const char*)ifd.data, ifd.size, 0};
           mc->makefile = p;
           mk_input(mc, &subsrc, ilevel + 1);
           if (mc->ctx->file_io->release)
             mc->ctx->file_io->release(mc->ctx->file_io->user, &ifd);
           mc->makefile = old_makefile;
           mc->lineno = old_lineno;
         }
         if (POSIX_2017) break;
       }
       if (POSIX_2017) {
         if (p == NULL || mk_gettok(&q)) mk_error(mc, "one include file per line");
       } else if (count == 0) {
         if (mc->posix) mk_error(mc, "no include file");
       }
       goto end_loop;
     }
 
     /* Check for a macro definition. */
     str = str1;
     if (POSIX_2017 && *str == '\t') mk_error(mc, "command not allowed here");
     if (mk_find_char(str, '=') != NULL) {
       int level = (useenv || src->data == NULL) ? 4 : 3;
       char* copy2 = mk_strdup(mc, str);
       char* newq = NULL;
       char eq = '\0';
       q = mk_find_char(copy2, '='); /* q can't be NULL */
 
       if (q - 1 > copy2) {
         switch (q[-1]) {
           case ':':
             /* '::=' and ':::=' are from POSIX 2024. */
             if (!POSIX_2017 && q - 2 > copy2 && q[-2] == ':') {
               if (q - 3 > copy2 && q[-3] == ':') {
                 eq = 'B'; /* BSD-style ':=' */
                 q[-3] = '\0';
               } else {
                 eq = ':'; /* GNU-style ':=' */
                 q[-2] = '\0';
               }
               break;
             }
             /* ':=' is a non-POSIX extension. */
             if (mc->posix) break;
             goto set_eq;
           case '+':
           case '?':
           case '!':
             /* '+=', '?=' and '!=' are from POSIX 2024. */
             if (POSIX_2017) break;
           set_eq:
             eq = q[-1];
             q[-1] = '\0';
             break;
         }
       }
       *q++ = '\0'; /* Separate name and value. */
       while (isblank((unsigned char)*q)) q++;
       if ((p = strrchr(q, '\n')) != NULL) *p = '\0';
 
       /* Expand LHS of the assignment. */
       p = expanded = mk_expand_macros(mc, copy2, FALSE);
       if ((a = mk_gettok(&p)) == NULL) mk_error(mc, "invalid macro assignment");
 
       /* If the expanded LHS contains ':' and ';' it might be a target rule. */
       if ((s = strchr(a, ':')) != NULL && strchr(s, ';') != NULL) {
         goto try_target;
       }
 
       if (mk_gettok(&p)) mk_error(mc, "invalid macro assignment");
 
       if (eq == ':') {
         /* GNU-style ':='. Expand RHS; immediate-expansion macro. */
         q = newq = mk_expand_macros(mc, q, FALSE);
         level |= M_IMMEDIATE;
       } else if (eq == 'B') {
         /* BSD-style ':='. Expand RHS but not '$$'; delayed-expansion. */
         q = newq = mk_expand_macros(mc, q, TRUE);
       } else if (eq == '?' && mk_getmp(mc, a) != NULL) {
         goto end_loop; /* Skip; macro already set. */
       } else if (eq == '+') {
         /* Append to current value. */
         struct macro* mp = mk_getmp(mc, a);
         char* rhs;
         newq = mp && mp->m_val[0] ? mk_strdup(mc, mp->m_val) : NULL;
         if (mp && mp->m_immediate) {
           rhs = mk_expand_macros(mc, q, FALSE);
           level |= M_IMMEDIATE;
         } else {
           rhs = q;
         }
         newq = mk_appendword(mc, newq, rhs);
         q = newq;
       } else if (eq == '!') {
         char* cmd = mk_expand_macros(mc, q, FALSE);
         q = newq = mk_run_command(mc, cmd);
       }
       mk_setmacro(mc, a, q, level);
       (void)newq;
       goto end_loop;
     }
 
     /* If we get here it must be a target rule. */
   try_target:
     if (*str == '\t') /* Command without target. */
       mk_error(mc, "command not allowed here");
     p = expanded = mk_expand_macros(mc, str, FALSE);
 
     /* Look for colon separator. */
     q = mk_find_colon(p);
     if (q == NULL) mk_error(mc, "expected separator");
 
     *q++ = '\0'; /* Separate targets and prerequisites. */
 
     /* Double colon. */
     dbl = !mc->posix && *q == ':';
     if (dbl) q++;
 
     /* Look for semicolon separator. */
     cp = NULL;
     s = strchr(q, ';');
     if (s) {
       /* Retrieve command from the original or expanded copy of the line. */
       char* copy3 = mk_expand_macros(mc, copy, FALSE);
       if ((p = mk_inline_command(copy)) || (p = mk_inline_command(copy3)))
         cp = mk_newcmd(mc, mk_process_command(mc, p + 1), cp);
       *s = '\0';
     }
     semicolon_cmd = cp != NULL && cp->c_cmd[0] != '\0';
 
     /* Create list of prerequisites. */
     dp = NULL;
     while (((p = mk_gettok(&q)) != NULL)) {
       char* newp = NULL;
 
       if (!mc->posix) {
         /* Allow prerequisites of form library(member1 member2). */
         if (!lib) {
           s = strchr(p, '(');
           if (s && !mk_ends_with_bracket(s) && strchr(q, ')')) {
             lib = p;
             if (s[1] != '\0') {
               p = newp = mk_concat3(mc, lib, ")", "");
               s[1] = '\0';
             } else {
               continue;
             }
           }
         } else if (mk_ends_with_bracket(p)) {
           if (*p != ')') p = newp = mk_concat3(mc, lib, p, "");
           lib = NULL;
           if (newp == NULL) continue;
         } else {
           p = newp = mk_concat3(mc, lib, p, ")");
         }
       }
 
       /* v1: names are literal (no glob); strip backslash escapes. */
       nfile = 1;
       files = &p;
       if (!mc->posix) mk_deglob(p);
       for (i = 0; i < nfile; ++i) {
         if (!POSIX_2017 && strcmp(files[i], ".WAIT") == 0) continue;
         np = mk_newname(mc, files[i]);
         dp = mk_newdep(mc, np, dp);
       }
     }
     lib = NULL;
 
     /* Create list of commands. */
     startno = mc->dispno;
     while ((str2 = mk_readline(mc, src, TRUE)) && *str2 == '\t') {
       cp = mk_newcmd(mc, mk_process_command(mc, str2), cp);
     }
     mc->dispno = startno;
 
     /* Create target names and attach the rule to them. */
     q = expanded;
     count = 0;
     seen_inference = FALSE;
     while ((p = mk_gettok(&q)) != NULL) {
       nfile = 1;
       files = &p;
       if (!mc->posix) mk_deglob(p);
       for (i = 0; i < nfile; ++i)
 #define p files[i]
       {
         int ttype = mk_target_type(mc, p);
 
         np = mk_newname(mc, p);
         if (ttype != T_NORMAL) {
           /* Enforce prerequisites/commands. */
           if ((ttype & T_NOPREREQ) && dp) mk_error_not_allowed(mc,
                                                                "prerequisites",
                                                                p);
           if ((ttype & T_INFERENCE)) {
             if (semicolon_cmd) mk_error_in_inference_rule(mc, "'; command'");
             seen_inference = TRUE;
           }
           if ((ttype & T_COMMAND) && !cp &&
               !((ttype & T_INFERENCE) && !semicolon_cmd))
             mk_error(mc, "commands required for %s", p);
           if (!(ttype & T_COMMAND) && cp) mk_error_not_allowed(mc, "commands",
                                                                p);
 
           if ((ttype & T_INFERENCE)) {
             np->n_flag |= N_INFERENCE;
           } else if (strcmp(p, ".DEFAULT") == 0) {
             np->n_flag |= N_SPECIAL | N_INFERENCE;
           } else {
             np->n_flag |= N_SPECIAL;
           }
         } else if (!mc->firstname) {
           mc->firstname = np;
         }
         mk_addrule(mc, np, dp, cp, dbl);
         count++;
       }
 #undef p
     }
     if (seen_inference && count != 1)
       mk_error_in_inference_rule(mc, "multiple targets");
 
     /* Prerequisites/commands are unused if there were no targets. */
     if (count == 0) {
       (void)dp;
       (void)cp;
     }
 
   end_loop:
     mc->dispno = mc->lineno;
     str1 = str2 ? str2 : mk_readline(mc, src, FALSE);
     (void)copy;
     (void)expanded;
     if (!mc->seen_first && src->data) {
       if (mk_findname(mc, ".POSIX")) {
         /* The first non-comment line defined .POSIX. */
         mc->posix = TRUE;
       }
       mc->seen_first = TRUE;
     }
   }
   /* Conditionals aren't allowed to span files. */
   if (mc->clevel != old_clevel) mk_error(mc, "invalid conditional");
 }