kit

defn.c (21766B)

---

 #include "defn.h"
 
 #include <stdio.h>
 #include <string.h>
 
 static int set_err(char* err, size_t cap, const char* msg) {
   if (err && cap) snprintf(err, cap, "%s", msg);
   return BUILD_ERR;
 }
 
 static int slice_eq_cstr(KitSlice s, const char* c) {
   size_t n = c ? strlen(c) : 0u;
   return s.len == n && (n == 0u || memcmp(s.s, c, n) == 0);
 }
 
 static int token_valid(KitSlice s, size_t cap) {
   size_t i;
   if (s.len == 0u || s.len >= cap || !s.s) return 0;
   for (i = 0; i < s.len; ++i) {
     unsigned char c = (unsigned char)s.s[i];
     if (c == '\0' || c == '\n' || c == '\r' || c == ' ' || c == '\t')
       return 0;
   }
   return 1;
 }
 
 static int local_name_valid(KitSlice s) {
   size_t i;
   if (!token_valid(s, BUILD_TARGET_MAX)) return 0;
   for (i = 0; i < s.len; ++i) {
     if (s.s[i] == '/' || s.s[i] == ':' || s.s[i] == '\\') return 0;
   }
   return 1;
 }
 
 static int type_valid(KitSlice s) {
   size_t i;
   if (!token_valid(s, BUILD_KEY_MAX)) return 0;
   for (i = 0; i < s.len; ++i) {
     if (s.s[i] == '/' || s.s[i] == ':' || s.s[i] == '\\') return 0;
   }
   return 1;
 }
 
 static int package_valid(KitSlice s) {
   size_t i, start = 0;
   if (!s.s && s.len != 0u) return 0;
   if (s.len >= BUILD_PATH_MAX) return 0;
   if (s.len == 0u) return 1;
   if (s.s[0] == '/') return 0;
   for (i = 0; i <= s.len; ++i) {
     if (i == s.len || s.s[i] == '/') {
       size_t n = i - start;
       if (n == 0u) return 0;
       if (n == 1u && s.s[start] == '.') return 0;
       if (n == 2u && s.s[start] == '.' && s.s[start + 1u] == '.') return 0;
       start = i + 1u;
     } else if (s.s[i] == '\0' || s.s[i] == '\\' || s.s[i] == ':') {
       return 0;
     }
   }
   return 1;
 }
 
 static int rel_path_valid(KitSlice s, int allow_single_dot) {
   size_t i;
   size_t start = 0;
   if (!token_valid(s, BUILD_PATH_MAX)) return 0;
   if (allow_single_dot && s.len == 1u && s.s[0] == '.') return 1;
   if (s.s[0] == '/') return 0;
   for (i = 0; i <= s.len; ++i) {
     if (i == s.len || s.s[i] == '/') {
       size_t n = i - start;
       if (n == 0u) return 0;
       if (n == 1u && s.s[start] == '.') return 0;
       if (n == 2u && s.s[start] == '.' && s.s[start + 1u] == '.') return 0;
       start = i + 1u;
     } else if (s.s[i] == '\\' || s.s[i] == ':') {
       return 0;
     }
   }
   return 1;
 }
 
 static int recipe_path_valid(KitSlice s) {
   if (s.len > 2u && s.s[0] == '/' && s.s[1] == '/')
     return rel_path_valid((KitSlice){.s = s.s + 2u, .len = s.len - 2u}, 0);
   return rel_path_valid(s, 0);
 }
 
 static int pattern_valid(KitSlice s) {
   size_t i;
   if (!token_valid(s, BUILD_TARGET_MAX)) return 0;
   for (i = 0; i < s.len; ++i) {
     if (s.s[i] == '/' || s.s[i] == ':' || s.s[i] == '\\') return 0;
   }
   return 1;
 }
 
 static int next_line(const uint8_t* data, size_t len, size_t* pos,
                      KitSlice* line) {
   size_t start = *pos;
   size_t end = start;
   while (end < len && data[end] != '\n') ++end;
   if (end == len) return BUILD_ERR;
   line->data = data + start;
   line->len = end - start;
   *pos = end + 1u;
   return BUILD_OK;
 }
 
 static void copy_slice(char* dst, size_t cap, KitSlice s) {
   (void)cap;
   if (s.len) memcpy(dst, s.s, s.len);
   dst[s.len] = '\0';
 }
 
 static int cstr_slice_cmp(const char* a, KitSlice b) {
   size_t i = 0;
   for (;;) {
     int ac = a[i] ? (int)(unsigned char)a[i] : 0;
     int bc = i < b.len ? (int)(unsigned char)b.s[i] : 0;
     if (ac != bc) return ac < bc ? -1 : 1;
     if (!ac) return 0;
     ++i;
   }
 }
 
 static int parse_bool(KitSlice s, int* out) {
   if (slice_eq_cstr(s, "true")) {
     *out = 1;
     return BUILD_OK;
   }
   if (slice_eq_cstr(s, "false")) {
     *out = 0;
     return BUILD_OK;
   }
   return BUILD_ERR;
 }
 
 static int split_word(KitSlice line, KitSlice* key, KitSlice* rest) {
   size_t i = 0;
   while (i < line.len && line.s[i] != ' ' && line.s[i] != '\t') ++i;
   key->s = line.s;
   key->len = i;
   while (i < line.len && (line.s[i] == ' ' || line.s[i] == '\t')) ++i;
   rest->s = line.s + i;
   rest->len = line.len - i;
   return key->len != 0u ? BUILD_OK : BUILD_ERR;
 }
 
 static int parse_header(KitSlice line, KitSlice* kind, KitSlice* arg) {
   size_t i;
   if (line.len < 3u || line.s[0] != '[' || line.s[line.len - 1u] != ']')
     return BUILD_ERR;
   line.s++;
   line.len -= 2u;
   for (i = 0; i < line.len && line.s[i] != ' ' && line.s[i] != '\t'; ++i) {}
   kind->s = line.s;
   kind->len = i;
   while (i < line.len && (line.s[i] == ' ' || line.s[i] == '\t')) ++i;
   arg->s = line.s + i;
   arg->len = line.len - i;
   return kind->len != 0u ? BUILD_OK : BUILD_ERR;
 }
 
 static int line_is_header(KitSlice line) {
   return line.len >= 2u && line.s[0] == '[' && line.s[line.len - 1u] == ']';
 }
 
 static int glob_match(const char* pat, size_t pn, const char* text, size_t tn) {
   size_t pi = 0, ti = 0, star = (size_t)-1, mark = 0;
   while (ti < tn) {
     if (pi < pn && pat[pi] == '*') {
       star = pi++;
       mark = ti;
     } else if (pi < pn && (pat[pi] == '?' || pat[pi] == text[ti])) {
       ++pi;
       ++ti;
     } else if (star != (size_t)-1) {
       pi = star + 1u;
       ti = ++mark;
     } else {
       return 0;
     }
   }
   while (pi < pn && pat[pi] == '*') ++pi;
   return pi == pn;
 }
 
 int build_defn_parse(const uint8_t* data, size_t len, BuildDefn* out, char* err,
                      size_t errcap) {
   size_t pos = 0;
   KitSlice line;
   enum { ST_NONE, ST_TARGET, ST_DEFAULT, ST_RULE, ST_REDO } stanza = ST_NONE;
   BuildTargetDefn* cur_target = NULL;
   BuildDefaultDefn* cur_default = NULL;
   BuildRuleDefn* cur_rule = NULL;
 
   if (!data || !out) return set_err(err, errcap, "missing build definition");
   if ((out->cap_targets && !out->targets) ||
       (out->cap_defaults && !out->defaults) ||
       (out->cap_rules && !out->rules))
     return set_err(err, errcap, "missing build definition storage");
   out->bytes = data;
   out->len = len;
   out->version = 0;
   out->n_targets = 0;
   out->n_defaults = 0;
   out->n_rules = 0;
   memset(&out->redo, 0, sizeof out->redo);
   out->redo.walk_parents = 1;
 
   if (next_line(data, len, &pos, &line) != BUILD_OK)
     return set_err(err, errcap, "bad build definition magic/version");
   if (kit_slice_eq_cstr(line, "kit-build 1")) {
     out->version = 1;
   } else if (kit_slice_eq_cstr(line, "kit-build 2")) {
     out->version = 2;
   } else {
     return set_err(err, errcap, "bad build definition magic/version");
   }
 
   while (pos < len) {
     KitSlice key, rest, kind, arg;
     if (next_line(data, len, &pos, &line) != BUILD_OK)
       return set_err(err, errcap, "unterminated stanza");
     if (line.len == 0u) continue;
 
     if (line_is_header(line)) {
       if (parse_header(line, &kind, &arg) != BUILD_OK)
         return set_err(err, errcap, "bad stanza header");
       cur_target = NULL;
       cur_default = NULL;
       cur_rule = NULL;
       if (slice_eq_cstr(kind, "target")) {
         if (arg.len == 0u) return set_err(err, errcap, "missing target name");
         if (!local_name_valid(arg))
           return set_err(err, errcap, "invalid target name");
         if (out->n_targets > 0 &&
             cstr_slice_cmp(out->targets[out->n_targets - 1u].name, arg) >= 0)
           return set_err(err, errcap, "non-canonical target ordering");
         if (out->n_targets >= out->cap_targets)
           return set_err(err, errcap, "too many targets");
         cur_target = &out->targets[out->n_targets++];
         memset(cur_target, 0, sizeof *cur_target);
         copy_slice(cur_target->name, sizeof cur_target->name, arg);
         stanza = ST_TARGET;
       } else if (slice_eq_cstr(kind, "default")) {
         if (out->version < 2)
           return set_err(err, errcap, "default requires kit-build 2");
         if (arg.len == 0u) return set_err(err, errcap, "missing default type");
         if (!type_valid(arg)) return set_err(err, errcap, "invalid default type");
         if (out->n_defaults > 0 &&
             cstr_slice_cmp(out->defaults[out->n_defaults - 1u].type, arg) >= 0)
           return set_err(err, errcap, "non-canonical default ordering");
         if (out->n_defaults >= out->cap_defaults)
           return set_err(err, errcap, "too many defaults");
         cur_default = &out->defaults[out->n_defaults++];
         memset(cur_default, 0, sizeof *cur_default);
         copy_slice(cur_default->type, sizeof cur_default->type, arg);
         stanza = ST_DEFAULT;
       } else if (slice_eq_cstr(kind, "rule")) {
         if (out->version < 2)
           return set_err(err, errcap, "rule requires kit-build 2");
         if (arg.len == 0u) return set_err(err, errcap, "missing rule name");
         if (!type_valid(arg)) return set_err(err, errcap, "invalid rule name");
         if (out->n_rules > 0 &&
             cstr_slice_cmp(out->rules[out->n_rules - 1u].name, arg) >= 0)
           return set_err(err, errcap, "non-canonical rule ordering");
         if (out->n_rules >= out->cap_rules)
           return set_err(err, errcap, "too many rules");
         cur_rule = &out->rules[out->n_rules++];
         memset(cur_rule, 0, sizeof *cur_rule);
         copy_slice(cur_rule->name, sizeof cur_rule->name, arg);
         stanza = ST_RULE;
       } else if (slice_eq_cstr(kind, "redo-defaults")) {
         if (out->version < 2)
           return set_err(err, errcap, "redo-defaults requires kit-build 2");
         if (arg.len != 0u && !slice_eq_cstr(arg, "settings"))
           return set_err(err, errcap, "bad redo-defaults header");
         stanza = ST_REDO;
       } else {
         return set_err(err, errcap, "unknown stanza");
       }
       continue;
     }
 
     if (split_word(line, &key, &rest) != BUILD_OK)
       return set_err(err, errcap, "bad stanza line");
     if (stanza == ST_TARGET) {
       if (!cur_target) return set_err(err, errcap, "internal target state");
       if (slice_eq_cstr(key, "recipe")) {
         if (cur_target->has_recipe || !recipe_path_valid(rest))
           return set_err(err, errcap, "invalid recipe path");
         copy_slice(cur_target->recipe_path, sizeof cur_target->recipe_path,
                    rest);
         cur_target->has_recipe = 1;
       } else if (slice_eq_cstr(key, "type")) {
         if (cur_target->has_type || !type_valid(rest))
           return set_err(err, errcap, "invalid target type");
         copy_slice(cur_target->type, sizeof cur_target->type, rest);
         cur_target->has_type = 1;
       } else {
         return set_err(err, errcap, "unknown target field");
       }
     } else if (stanza == ST_DEFAULT) {
       if (!cur_default) return set_err(err, errcap, "internal default state");
       if (!slice_eq_cstr(key, "recipe") || cur_default->recipe_path[0] ||
           !recipe_path_valid(rest))
         return set_err(err, errcap, "invalid default field");
       copy_slice(cur_default->recipe_path, sizeof cur_default->recipe_path,
                  rest);
     } else if (stanza == ST_RULE) {
       if (!cur_rule) return set_err(err, errcap, "internal rule state");
       if (slice_eq_cstr(key, "match")) {
         if (cur_rule->match[0] || !pattern_valid(rest))
           return set_err(err, errcap, "invalid rule match");
         copy_slice(cur_rule->match, sizeof cur_rule->match, rest);
       } else if (slice_eq_cstr(key, "recipe")) {
         if (cur_rule->has_recipe || !recipe_path_valid(rest))
           return set_err(err, errcap, "invalid rule recipe");
         copy_slice(cur_rule->recipe_path, sizeof cur_rule->recipe_path, rest);
         cur_rule->has_recipe = 1;
       } else if (slice_eq_cstr(key, "type")) {
         if (cur_rule->has_type || !type_valid(rest))
           return set_err(err, errcap, "invalid rule type");
         copy_slice(cur_rule->type, sizeof cur_rule->type, rest);
         cur_rule->has_type = 1;
       } else {
         return set_err(err, errcap, "unknown rule field");
       }
     } else if (stanza == ST_REDO) {
       if (slice_eq_cstr(key, "enabled")) {
         if (parse_bool(rest, &out->redo.enabled) != BUILD_OK)
           return set_err(err, errcap, "invalid redo enabled");
       } else if (slice_eq_cstr(key, "walk-parents")) {
         if (parse_bool(rest, &out->redo.walk_parents) != BUILD_OK)
           return set_err(err, errcap, "invalid redo walk-parents");
       } else if (slice_eq_cstr(key, "search")) {
         KitSlice word;
         size_t start = 0, i;
         for (i = 0; i <= rest.len; ++i) {
           if (i == rest.len || rest.s[i] == ' ' || rest.s[i] == '\t') {
             if (i == start) {
               start = i + 1u;
               continue;
             }
             word.s = rest.s + start;
             word.len = i - start;
             if (!rel_path_valid(word, 1) ||
                 out->redo.n_search >=
                     sizeof out->redo.search / sizeof out->redo.search[0])
               return set_err(err, errcap, "invalid redo search");
             copy_slice(out->redo.search[out->redo.n_search],
                        sizeof out->redo.search[out->redo.n_search], word);
             ++out->redo.n_search;
             start = i + 1u;
           }
         }
       } else {
         return set_err(err, errcap, "unknown redo-defaults field");
       }
     } else {
       return set_err(err, errcap, "field outside stanza");
     }
   }
 
   for (pos = 0; pos < out->n_targets; ++pos) {
     if (!out->targets[pos].has_recipe && !out->targets[pos].has_type)
       return set_err(err, errcap, "target has no recipe or type");
   }
   for (pos = 0; pos < out->n_defaults; ++pos) {
     if (!out->defaults[pos].recipe_path[0])
       return set_err(err, errcap, "default has no recipe");
   }
   for (pos = 0; pos < out->n_rules; ++pos) {
     if (!out->rules[pos].match[0])
       return set_err(err, errcap, "rule has no match");
   }
   if (out->redo.enabled && out->redo.n_search == 0u) {
     snprintf(out->redo.search[out->redo.n_search++],
              sizeof out->redo.search[0], ".");
   }
   return BUILD_OK;
 }
 
 const BuildTargetDefn* build_defn_find(const BuildDefn* defn, KitSlice name) {
   size_t lo, hi;
   if (!defn || !local_name_valid(name)) return NULL;
   lo = 0;
   hi = defn->n_targets;
   while (lo < hi) {
     size_t mid = lo + (hi - lo) / 2u;
     int cmp = cstr_slice_cmp(defn->targets[mid].name, name);
     if (cmp == 0) return &defn->targets[mid];
     if (cmp < 0)
       lo = mid + 1u;
     else
       hi = mid;
   }
   return NULL;
 }
 
 const BuildDefaultDefn* build_defn_default_find(const BuildDefn* defn,
                                                 KitSlice type) {
   size_t lo, hi;
   if (!defn || !type_valid(type)) return NULL;
   lo = 0;
   hi = defn->n_defaults;
   while (lo < hi) {
     size_t mid = lo + (hi - lo) / 2u;
     int cmp = cstr_slice_cmp(defn->defaults[mid].type, type);
     if (cmp == 0) return &defn->defaults[mid];
     if (cmp < 0)
       lo = mid + 1u;
     else
       hi = mid;
   }
   return NULL;
 }
 
 const BuildRuleDefn* build_defn_rule_match(const BuildDefn* defn,
                                            KitSlice name, int* ambiguous) {
   const BuildRuleDefn* match = NULL;
   size_t i;
   if (ambiguous) *ambiguous = 0;
   if (!defn || !local_name_valid(name)) return NULL;
   for (i = 0; i < defn->n_rules; ++i) {
     const BuildRuleDefn* r = &defn->rules[i];
     if (!glob_match(r->match, strlen(r->match), name.s, name.len)) continue;
     if (match) {
       if (ambiguous) *ambiguous = 1;
       return NULL;
     }
     match = r;
   }
   return match;
 }
 
 static int last_component(KitSlice s, KitSlice* out) {
   size_t i = s.len;
   if (s.len == 0u) return BUILD_ERR;
   while (i > 0u && s.s[i - 1u] != '/') --i;
   out->s = s.s + i;
   out->len = s.len - i;
   return local_name_valid(*out) ? BUILD_OK : BUILD_ERR;
 }
 
 int build_target_canonicalize(KitSlice label, KitSlice current_repo,
                               KitSlice current_package,
                               char out[BUILD_TARGET_MAX], char* err,
                               size_t errcap) {
   KitSlice repo = current_repo;
   KitSlice pkg, local;
   char repo_buf[BUILD_KEY_MAX];
   size_t colon = (size_t)-1, i;
   if (!out || !label.s || label.len == 0u || !package_valid(current_package))
     return set_err(err, errcap, "invalid target label");
   if (repo.len && !token_valid(repo, BUILD_KEY_MAX))
     return set_err(err, errcap, "invalid target repo");
 
   if (label.s[0] == '@') {
     KitSlice explicit_repo;
     size_t slash = 1u;
     while (slash < label.len && label.s[slash] != '/') ++slash;
     if (slash <= 1u || slash + 1u >= label.len || label.s[slash + 1u] != '/')
       return set_err(err, errcap, "bad target label");
     explicit_repo.s = label.s + 1u;
     explicit_repo.len = slash - 1u;
     if (!token_valid(explicit_repo, BUILD_KEY_MAX))
       return set_err(err, errcap, "bad target repo");
     if (current_repo.len) {
       if (current_repo.len + explicit_repo.len + 2u > sizeof repo_buf)
         return set_err(err, errcap, "target repo too long");
       memcpy(repo_buf, current_repo.s, current_repo.len);
       repo_buf[current_repo.len] = '+';
       memcpy(repo_buf + current_repo.len + 1u, explicit_repo.s,
              explicit_repo.len);
       repo_buf[current_repo.len + 1u + explicit_repo.len] = '\0';
       repo = kit_slice_cstr(repo_buf);
     } else {
       repo = explicit_repo;
     }
     label.s += slash;
     label.len -= slash;
   }
 
   if (label.len >= 2u && label.s[0] == '/' && label.s[1] == '/') {
     KitSlice body = {.s = label.s + 2u, .len = label.len - 2u};
     for (i = 0; i < body.len; ++i) {
       if (body.s[i] == ':') {
         if (colon != (size_t)-1) return set_err(err, errcap, "bad target label");
         colon = i;
       }
     }
     if (colon == (size_t)-1) {
       pkg = body;
       if (!package_valid(pkg) || last_component(pkg, &local) != BUILD_OK)
         return set_err(err, errcap, "bad target label");
     } else {
       pkg.s = body.s;
       pkg.len = colon;
       local.s = body.s + colon + 1u;
       local.len = body.len - colon - 1u;
       if (!package_valid(pkg) || !local_name_valid(local))
         return set_err(err, errcap, "bad target label");
     }
   } else if (label.s[0] == ':') {
     pkg = current_package;
     local.s = label.s + 1u;
     local.len = label.len - 1u;
     if (!local_name_valid(local))
       return set_err(err, errcap, "bad target label");
   } else {
     pkg = current_package;
     local = label;
     if (!local_name_valid(local))
       return set_err(err, errcap, "bad target label");
   }
 
   if (repo.len) {
     if (repo.len + pkg.len + local.len + 5u > BUILD_TARGET_MAX)
       return set_err(err, errcap, "target label too long");
     out[0] = '@';
     memcpy(out + 1u, repo.s, repo.len);
     out[1u + repo.len] = '/';
     out[2u + repo.len] = '/';
     if (pkg.len) memcpy(out + 3u + repo.len, pkg.s, pkg.len);
     out[3u + repo.len + pkg.len] = ':';
     memcpy(out + 4u + repo.len + pkg.len, local.s, local.len);
     out[4u + repo.len + pkg.len + local.len] = '\0';
   } else if (pkg.len == 0u) {
     if (local.len + 4u > BUILD_TARGET_MAX)
       return set_err(err, errcap, "target label too long");
     out[0] = '/';
     out[1] = '/';
     out[2] = ':';
     memcpy(out + 3u, local.s, local.len);
     out[3u + local.len] = '\0';
   } else {
     if (pkg.len + local.len + 4u > BUILD_TARGET_MAX)
       return set_err(err, errcap, "target label too long");
     out[0] = '/';
     out[1] = '/';
     memcpy(out + 2u, pkg.s, pkg.len);
     out[2u + pkg.len] = ':';
     memcpy(out + 3u + pkg.len, local.s, local.len);
     out[3u + pkg.len + local.len] = '\0';
   }
   return BUILD_OK;
 }
 
 int build_target_split_repo(KitSlice canonical, char repo[BUILD_KEY_MAX],
                             char package[BUILD_PATH_MAX],
                             char local[BUILD_TARGET_MAX]) {
   KitSlice pkg, name;
   size_t i, colon = (size_t)-1, body_start = 0;
   if (!canonical.s || canonical.len < 4u)
     return BUILD_ERR;
   if (repo) repo[0] = '\0';
   if (canonical.s[0] == '@') {
     size_t slash = 1u;
     while (slash < canonical.len && canonical.s[slash] != '/') ++slash;
     if (slash <= 1u || slash + 1u >= canonical.len ||
         canonical.s[slash + 1u] != '/')
       return BUILD_ERR;
     if (repo) {
       KitSlice r = {.s = canonical.s + 1u, .len = slash - 1u};
       if (!token_valid(r, BUILD_KEY_MAX)) return BUILD_ERR;
       copy_slice(repo, BUILD_KEY_MAX, r);
     }
     body_start = slash;
   }
   if (canonical.len < body_start + 4u || canonical.s[body_start] != '/' ||
       canonical.s[body_start + 1u] != '/')
     return BUILD_ERR;
   for (i = body_start + 2u; i < canonical.len; ++i) {
     if (canonical.s[i] == ':') {
       colon = i;
       break;
     }
   }
   if (colon == (size_t)-1) return BUILD_ERR;
   pkg.s = canonical.s + body_start + 2u;
   pkg.len = colon - body_start - 2u;
   name.s = canonical.s + colon + 1u;
   name.len = canonical.len - colon - 1u;
   if (!package_valid(pkg) || !local_name_valid(name)) return BUILD_ERR;
   copy_slice(package, BUILD_PATH_MAX, pkg);
   copy_slice(local, BUILD_TARGET_MAX, name);
   return BUILD_OK;
 }
 
 int build_target_split(KitSlice canonical, char package[BUILD_PATH_MAX],
                        char local[BUILD_TARGET_MAX]) {
   return build_target_split_repo(canonical, NULL, package, local);
 }
 
 int build_recipe_path_resolve(KitSlice package, KitSlice recipe,
                               char out[BUILD_PATH_MAX]) {
   if (!out || !package_valid(package) || !recipe_path_valid(recipe))
     return BUILD_ERR;
   if (recipe.len > 2u && recipe.s[0] == '/' && recipe.s[1] == '/') {
     if (recipe.len - 2u + 1u > BUILD_PATH_MAX) return BUILD_ERR;
     memcpy(out, recipe.s + 2u, recipe.len - 2u);
     out[recipe.len - 2u] = '\0';
     return BUILD_OK;
   }
   if (package.len == 0u) {
     copy_slice(out, BUILD_PATH_MAX, recipe);
     return BUILD_OK;
   }
   if (package.len + 1u + recipe.len + 1u > BUILD_PATH_MAX) return BUILD_ERR;
   memcpy(out, package.s, package.len);
   out[package.len] = '/';
   memcpy(out + package.len + 1u, recipe.s, recipe.len);
   out[package.len + 1u + recipe.len] = '\0';
   return BUILD_OK;
 }