This change imports the ports collection from the former porttix and srctix repositories and converts them to port(5) files with metadata pointing to the upstream release tarballs with patches checked into this repository. Ports are now developed and versioned along with the operating system and are automatically built per the PACKAGES environment variable. The patches are licensed under the same license as the relevant ports. Tix has gained support for the new port(5) format. tix-port(8) is the new high level ports build even point that handles downloading pstream releases into the new mirror cache directory, applying the patches, building the port with the lower-level tix-build(8), and finally installing the binary package. The new tix-vars(8) program parses port(5) files and the new tix-rmdiff(8) program produces input for tix-rmpatch(8). The old doc/ directory is discontinued in favor of manual pages documenting the new ports system. The obsolete porttix-create(8) and srctix-create(8) programs are removed.
1256 lines
38 KiB
C
1256 lines
38 KiB
C
/*
|
|
* Copyright (c) 2013, 2014, 2015, 2016, 2020, 2022 Jonas 'Sortie' Termansen.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* tix-build.c
|
|
* Compile a source tix into a tix suitable for installation.
|
|
*/
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <dirent.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <signal.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "util.h"
|
|
|
|
struct buildvar
|
|
{
|
|
const char* variable;
|
|
const char* value;
|
|
bool program;
|
|
};
|
|
|
|
static struct buildvar buildvars[] =
|
|
{
|
|
{ "AR", "ar", true },
|
|
{ "AS", "as", true },
|
|
{ "CC", "gcc", true },
|
|
{ "CFLAGS", "-Os", false },
|
|
{ "CPP", "gcc -E", true },
|
|
{ "CPP", "", false },
|
|
{ "CXXFILT", "c++filt", true },
|
|
{ "CXX", "g++", true },
|
|
{ "CXXFLAGS", "-Os", false },
|
|
{ "LD", "ld", true },
|
|
{ "LDFLAGS", "", false },
|
|
{ "NM", "nm", true },
|
|
{ "OBJCOPY", "objcopy", true },
|
|
{ "OBJDUMP", "objdump", true },
|
|
{ "PKG_CONFIG", "pkg-config", true },
|
|
{ "RANLIB", "ranlib", true },
|
|
{ "READELF", "readelf", true },
|
|
{ "STRIP", "strip", true },
|
|
};
|
|
|
|
#define BUILDVARS_LENGTH (sizeof(buildvars) / sizeof(buildvars[0]))
|
|
|
|
enum build_step
|
|
{
|
|
BUILD_STEP_NO_SUCH_STEP,
|
|
BUILD_STEP_START,
|
|
BUILD_STEP_PRE_CLEAN,
|
|
BUILD_STEP_CONFIGURE,
|
|
BUILD_STEP_BUILD,
|
|
BUILD_STEP_INSTALL,
|
|
BUILD_STEP_POST_INSTALL,
|
|
BUILD_STEP_POST_CLEAN,
|
|
BUILD_STEP_PACKAGE,
|
|
BUILD_STEP_END,
|
|
};
|
|
|
|
static bool should_do_build_step(enum build_step step,
|
|
enum build_step start,
|
|
enum build_step end)
|
|
{
|
|
return start <= step && step <= end;
|
|
}
|
|
|
|
#define SHOULD_DO_BUILD_STEP(step, minfo) \
|
|
should_do_build_step((step), (minfo)->start_step, (minfo)->end_step)
|
|
|
|
static enum build_step step_of_step_name(const char* step_name)
|
|
{
|
|
if ( !strcmp(step_name, "start") )
|
|
return BUILD_STEP_START;
|
|
if ( !strcmp(step_name, "clean") )
|
|
return BUILD_STEP_PRE_CLEAN;
|
|
if ( !strcmp(step_name, "pre-clean") )
|
|
return BUILD_STEP_PRE_CLEAN;
|
|
if ( !strcmp(step_name, "configure") )
|
|
return BUILD_STEP_CONFIGURE;
|
|
if ( !strcmp(step_name, "build") )
|
|
return BUILD_STEP_BUILD;
|
|
if ( !strcmp(step_name, "install") )
|
|
return BUILD_STEP_INSTALL;
|
|
if ( !strcmp(step_name, "post-install") )
|
|
return BUILD_STEP_POST_INSTALL;
|
|
if ( !strcmp(step_name, "post-clean") )
|
|
return BUILD_STEP_POST_CLEAN;
|
|
if ( !strcmp(step_name, "package") )
|
|
return BUILD_STEP_PACKAGE;
|
|
if ( !strcmp(step_name, "end") )
|
|
return BUILD_STEP_END;
|
|
return BUILD_STEP_NO_SUCH_STEP;
|
|
}
|
|
|
|
struct metainfo
|
|
{
|
|
char* build;
|
|
char* build_dir;
|
|
char* destination;
|
|
int generation;
|
|
char* host;
|
|
char* make;
|
|
char* makeflags;
|
|
char* package_dir;
|
|
char* package_info_path;
|
|
char* package_name;
|
|
char* prefix;
|
|
char* exec_prefix;
|
|
char* sysroot;
|
|
char* tar;
|
|
char* target;
|
|
char* tmp;
|
|
string_array_t package_info;
|
|
enum build_step start_step;
|
|
enum build_step end_step;
|
|
bool bootstrapping;
|
|
bool cross;
|
|
// TODO: After releasing Sortix 1.1, remove tixbuildinfo support.
|
|
bool tixbuildinfo;
|
|
};
|
|
|
|
static const char* metainfo_get_def(const struct metainfo* minfo,
|
|
const char* key,
|
|
const char* old_key,
|
|
const char* def)
|
|
{
|
|
return dictionary_get_def((string_array_t*) &minfo->package_info,
|
|
!minfo->tixbuildinfo ? key : old_key, def);
|
|
}
|
|
|
|
static const char* metainfo_get(const struct metainfo* minfo,
|
|
const char* key,
|
|
const char* old_key)
|
|
{
|
|
return metainfo_get_def(minfo, key, old_key, NULL);
|
|
}
|
|
|
|
static const char* metainfo_verify(struct metainfo* minfo,
|
|
const char* key,
|
|
const char* old_key)
|
|
{
|
|
const char* ret = metainfo_get(minfo, key, old_key);
|
|
if ( !ret )
|
|
errx(1, "error: `%s': no `%s' variable declared",
|
|
minfo->package_info_path, !minfo->tixbuildinfo ? key : old_key);
|
|
return ret;
|
|
}
|
|
|
|
static bool has_in_path(const char* program)
|
|
{
|
|
pid_t child_pid = fork();
|
|
if ( child_pid < 0 )
|
|
err(1, "fork: which %s", program);
|
|
if ( child_pid )
|
|
{
|
|
int exitstatus;
|
|
waitpid(child_pid, &exitstatus, 0);
|
|
return WIFEXITED(exitstatus) && WEXITSTATUS(exitstatus) == 0;
|
|
}
|
|
close(0);
|
|
close(1);
|
|
close(2);
|
|
if ( open("/dev/null", O_RDONLY) != 0 ||
|
|
open("/dev/null", O_WRONLY) != 1 ||
|
|
open("/dev/null", O_WRONLY) != 2 )
|
|
{
|
|
warn("/dev/null");
|
|
_exit(1);
|
|
}
|
|
const char* argv[] = { "which", program, NULL };
|
|
execvp(argv[0], (char**) argv);
|
|
_exit(1);
|
|
}
|
|
|
|
static void emit_compiler_wrapper_invocation(FILE* wrapper,
|
|
struct metainfo* minfo,
|
|
const char* name)
|
|
{
|
|
fprintf(wrapper, "%s", name);
|
|
if ( minfo->sysroot )
|
|
fprintf(wrapper, " --sysroot=\"$SYSROOT\"");
|
|
fprintf(wrapper, " \"$@\"");
|
|
}
|
|
|
|
static void emit_compiler_sysroot_wrapper(struct metainfo* minfo,
|
|
const char* bindir,
|
|
const char* name)
|
|
{
|
|
if ( !has_in_path(name) )
|
|
return;
|
|
char* wrapper_path = join_paths(bindir, name);
|
|
if ( !wrapper_path )
|
|
err(1, "malloc");
|
|
FILE* wrapper = fopen(wrapper_path, "w");
|
|
if ( !wrapper )
|
|
err(1, "`%s'", wrapper_path);
|
|
fprintf(wrapper, "#!/bin/sh\n");
|
|
fprint_shell_variable_assignment(wrapper, "PATH", getenv("PATH"));
|
|
if ( minfo->sysroot )
|
|
fprint_shell_variable_assignment(wrapper, "SYSROOT", minfo->sysroot);
|
|
fprintf(wrapper, "exec ");
|
|
emit_compiler_wrapper_invocation(wrapper, minfo, name);
|
|
fprintf(wrapper, "\n");
|
|
fflush(wrapper);
|
|
fchmod_plus_x(fileno(wrapper));
|
|
if ( ferror(wrapper) || fflush(wrapper) == EOF )
|
|
err(1, "%s", wrapper_path);
|
|
fclose(wrapper);
|
|
free(wrapper_path);
|
|
}
|
|
|
|
static void emit_compiler_sysroot_cross_wrapper(struct metainfo* minfo,
|
|
const char* bindir,
|
|
const char* name)
|
|
{
|
|
char* cross_name = print_string("%s-%s", minfo->host, name);
|
|
if ( !cross_name )
|
|
err(1, "malloc");
|
|
emit_compiler_sysroot_wrapper(minfo, bindir, cross_name);
|
|
free(cross_name);
|
|
}
|
|
|
|
static void emit_pkg_config_wrapper(struct metainfo* minfo, const char* bindir)
|
|
{
|
|
// Create a pkg-config script for the build system.
|
|
char* pkg_config_for_build_path = join_paths(bindir, "pkg-config");
|
|
if ( !pkg_config_for_build_path )
|
|
err(1, "malloc");
|
|
FILE* pkg_config_for_build = fopen(pkg_config_for_build_path, "w");
|
|
if ( !pkg_config_for_build )
|
|
err(1, "`%s'", pkg_config_for_build_path);
|
|
fprintf(pkg_config_for_build, "#!/bin/sh\n");
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PATH", getenv("PATH"));
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG", getenv("PKG_CONFIG"));
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_FOR_BUILD", getenv("PKG_CONFIG_FOR_BUILD"));
|
|
if ( getenv("PKG_CONFIG_PATH_FOR_BUILD") )
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_PATH", getenv("PKG_CONFIG_PATH_FOR_BUILD"));
|
|
else
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_PATH", getenv("PKG_CONFIG_PATH"));
|
|
if ( getenv("PKG_CONFIG_SYSROOT_DIR_FOR_BUILD") )
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_SYSROOT_DIR",
|
|
getenv("PKG_CONFIG_SYSROOT_DIR_FOR_BUILD"));
|
|
else
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_SYSROOT_DIR", getenv("PKG_CONFIG_SYSROOT_DIR"));
|
|
if ( getenv("PKG_CONFIG_LIBDIR_FOR_BUILD") )
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_LIBDIR", getenv("PKG_CONFIG_LIBDIR_FOR_BUILD"));
|
|
else
|
|
fprint_shell_variable_assignment(pkg_config_for_build,
|
|
"PKG_CONFIG_LIBDIR", getenv("PKG_CONFIG_LIBDIR"));
|
|
fprintf(pkg_config_for_build,
|
|
"exec ${PKG_CONFIG_FOR_BUILD:-${PKG_CONFIG:-pkg-config}} \"$@\"\n");
|
|
if ( ferror(pkg_config_for_build) || fflush(pkg_config_for_build) == EOF )
|
|
err(1, "%s", pkg_config_for_build_path);
|
|
fchmod_plus_x(fileno(pkg_config_for_build));
|
|
fclose(pkg_config_for_build);
|
|
free(pkg_config_for_build_path);
|
|
|
|
// Create a pkg-config script for the host system.
|
|
char* var_pkg_config_libdir =
|
|
print_string("%s%s/lib/pkgconfig",
|
|
minfo->sysroot ? minfo->sysroot : "", minfo->exec_prefix);
|
|
if ( !var_pkg_config_libdir )
|
|
err(1, "malloc");
|
|
char* var_pkg_config_path = strdup(var_pkg_config_libdir);
|
|
if ( !var_pkg_config_path )
|
|
err(1, "malloc");
|
|
char* pkg_config_name = print_string("%s-pkg-config", minfo->host);
|
|
if ( !pkg_config_name )
|
|
err(1, "malloc");
|
|
char* pkg_config_path = join_paths(bindir, pkg_config_name);
|
|
if ( !pkg_config_path )
|
|
err(1, "malloc");
|
|
FILE* pkg_config = fopen(pkg_config_path, "w");
|
|
if ( !pkg_config )
|
|
err(1, "`%s'", pkg_config_path);
|
|
fprintf(pkg_config, "#!/bin/sh\n");
|
|
fprint_shell_variable_assignment(pkg_config, "PATH", getenv("PATH"));
|
|
fprint_shell_variable_assignment(pkg_config,
|
|
"PKG_CONFIG", getenv("PKG_CONFIG"));
|
|
fprint_shell_variable_assignment(pkg_config,
|
|
"PKG_CONFIG_PATH", var_pkg_config_path);
|
|
fprint_shell_variable_assignment(pkg_config,
|
|
"PKG_CONFIG_SYSROOT_DIR", minfo->sysroot);
|
|
fprint_shell_variable_assignment(pkg_config,
|
|
"PKG_CONFIG_LIBDIR", var_pkg_config_libdir);
|
|
// Pass --static as Sortix only static links at the moment.
|
|
fprintf(pkg_config, "exec ${PKG_CONFIG:-%s} --static \"$@\"\n",
|
|
has_in_path(pkg_config_name) ? pkg_config_name : "pkg-config");
|
|
fflush(pkg_config);
|
|
if ( ferror(pkg_config) || fflush(pkg_config) == EOF )
|
|
err(1, "%s", pkg_config_path);
|
|
fchmod_plus_x(fileno(pkg_config));
|
|
fclose(pkg_config);
|
|
free(pkg_config_path);
|
|
free(var_pkg_config_libdir);
|
|
free(var_pkg_config_path);
|
|
}
|
|
|
|
static void append_to_path(const char* directory)
|
|
{
|
|
const char* path = getenv("PATH");
|
|
if ( path && path[0] )
|
|
{
|
|
char* new_path = print_string("%s:%s", directory, path);
|
|
if ( !new_path )
|
|
err(1, "malloc");
|
|
if ( setenv("PATH", new_path, 1) < 0 )
|
|
err(1, "setenv");
|
|
free(new_path);
|
|
}
|
|
else if ( setenv("PATH", directory, 1) < 0 )
|
|
err(1, "setenv");
|
|
}
|
|
|
|
static void EmitWrappers(struct metainfo* minfo)
|
|
{
|
|
if ( !minfo->cross )
|
|
return;
|
|
|
|
char* bindir = join_paths(tmp_root, "bin");
|
|
if ( mkdir(bindir, 0777) < 0 )
|
|
err(1, "mkdir: %s", bindir);
|
|
|
|
emit_pkg_config_wrapper(minfo, bindir);
|
|
emit_compiler_sysroot_cross_wrapper(minfo, bindir, "cc");
|
|
emit_compiler_sysroot_cross_wrapper(minfo, bindir, "gcc");
|
|
emit_compiler_sysroot_cross_wrapper(minfo, bindir, "c++");
|
|
emit_compiler_sysroot_cross_wrapper(minfo, bindir, "g++");
|
|
emit_compiler_sysroot_cross_wrapper(minfo, bindir, "ld");
|
|
|
|
append_to_path(bindir);
|
|
|
|
free(bindir);
|
|
}
|
|
|
|
static void SetNeedVariableBuildTool(struct metainfo* minfo,
|
|
const char* variable,
|
|
const char* value)
|
|
{
|
|
const char* needed_vars =
|
|
metainfo_get_def(minfo, "MAKE_NEEDED_VARS", "pkg.make.needed-vars",
|
|
"true");
|
|
char* key = minfo->tixbuildinfo ?
|
|
print_string("pkg.make.needed-vars.%s", variable) :
|
|
print_string("MAKE_NEEDED_VARS_%s", variable);
|
|
if ( !key )
|
|
err(1, "malloc");
|
|
const char* needed_var = metainfo_get_def(minfo, key, key, needed_vars);
|
|
free(key);
|
|
if ( !parse_boolean(needed_var) )
|
|
return;
|
|
if ( setenv(variable, value, 1) < 0 )
|
|
err(1, "setenv");
|
|
}
|
|
|
|
static void SetNeedVariableCrossTool(struct metainfo* minfo,
|
|
const char* variable,
|
|
const char* value)
|
|
{
|
|
if ( !minfo->cross )
|
|
SetNeedVariableBuildTool(minfo, variable, value);
|
|
else
|
|
{
|
|
char* newvalue = print_string("%s-%s", minfo->host, value);
|
|
if ( !newvalue )
|
|
err(1, "malloc");
|
|
SetNeedVariableBuildTool(minfo, variable, newvalue);
|
|
free(newvalue);
|
|
}
|
|
}
|
|
|
|
static void SetNeededVariables(struct metainfo* minfo)
|
|
{
|
|
if ( minfo->bootstrapping )
|
|
{
|
|
for ( size_t i = 0; i < BUILDVARS_LENGTH; i++ )
|
|
unsetenv(buildvars[i].variable);
|
|
for ( size_t i = 0; i < BUILDVARS_LENGTH; i++ )
|
|
{
|
|
char* for_build =
|
|
print_string("%s_FOR_BUILD", buildvars[i].variable);
|
|
if ( !for_build )
|
|
err(1, "malloc");
|
|
const char* value = getenv(for_build);
|
|
if ( value && setenv(buildvars[i].variable, value, 1) < 0 )
|
|
err(1, "setenv");
|
|
free(for_build);
|
|
}
|
|
return;
|
|
}
|
|
|
|
for ( size_t i = 0; i < BUILDVARS_LENGTH; i++ )
|
|
{
|
|
if ( !buildvars[i].program && !getenv(buildvars[i].variable) )
|
|
continue;
|
|
char* for_build = print_string("%s_FOR_BUILD", buildvars[i].variable);
|
|
if ( !for_build )
|
|
err(1, "malloc");
|
|
SetNeedVariableBuildTool(minfo, for_build, buildvars[i].value);
|
|
free(for_build);
|
|
}
|
|
for ( size_t i = 0; i < BUILDVARS_LENGTH; i++ )
|
|
if ( buildvars[i].program )
|
|
SetNeedVariableCrossTool(minfo, buildvars[i].variable,
|
|
buildvars[i].value);
|
|
}
|
|
|
|
static void Configure(struct metainfo* minfo)
|
|
{
|
|
if ( !fork_and_wait_or_recovery() )
|
|
return;
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
const char* configure_raw =
|
|
metainfo_get_def(minfo, "CONFIGURE", "pkg.configure.cmd",
|
|
"./configure");
|
|
char* configure;
|
|
if ( strcmp(minfo->build_dir, minfo->package_dir) == 0 )
|
|
configure = strdup(configure_raw);
|
|
else
|
|
configure = join_paths(minfo->package_dir, configure_raw);
|
|
if ( !configure )
|
|
err(1, "malloc");
|
|
const char* conf_extra_args =
|
|
metainfo_get_def(minfo, "CONFIGURE_ARGS", "pkg.configure.args", "");
|
|
const char* conf_extra_vars =
|
|
metainfo_get_def(minfo, "CONFIGURE_VARS", "pkg.configure.vars", "");
|
|
bool with_sysroot =
|
|
parse_boolean(metainfo_get_def(minfo,
|
|
"CONFIGURE_WITH_SYSROOT", "pkg.configure.with-sysroot", "false"));
|
|
// TODO: I am unclear if this issue still affects gcc, I might have
|
|
// forgotten to set pkg.configure.with-sysroot-ld-bug=true there.
|
|
const char* with_sysroot_ld_bug_default = "false";
|
|
if ( !strcmp(minfo->package_name, "gcc") )
|
|
with_sysroot_ld_bug_default = "true";
|
|
bool with_sysroot_ld_bug =
|
|
parse_boolean(metainfo_get_def(minfo, "CONFIGURE_WITH_SYSROOT_LD_BUG",
|
|
"pkg.configure.with-sysroot-ld-bug", with_sysroot_ld_bug_default ));
|
|
bool with_build_sysroot =
|
|
parse_boolean(metainfo_get_def(minfo, "CONFIGURE_WITH_BUILD_SYSROOT",
|
|
"pkg.configure.with-build-sysroot", "false"));
|
|
if ( chdir(minfo->build_dir) != 0 )
|
|
err(1, "chdir: `%s'", minfo->build_dir);
|
|
if ( subdir && chdir(subdir) != 0 )
|
|
err(1, "chdir: `%s/%s'", minfo->build_dir, subdir);
|
|
SetNeededVariables(minfo);
|
|
string_array_t env_vars = string_array_make();
|
|
string_array_append_token_string(&env_vars, conf_extra_vars);
|
|
for ( size_t i = 0; i < env_vars.length; i++ )
|
|
{
|
|
char* key = env_vars.strings[i];
|
|
assert(key);
|
|
char* assignment = strchr((char*) key, '=');
|
|
if ( !assignment )
|
|
{
|
|
if ( !strncmp(key, "unset ", strlen("unset ")) )
|
|
unsetenv(key + strlen("unset "));
|
|
continue;
|
|
}
|
|
*assignment = '\0';
|
|
char* value = assignment+1;
|
|
setenv(key, value, 1);
|
|
}
|
|
const char* fixed_cmd_argv[] =
|
|
{
|
|
configure,
|
|
print_string("--prefix=%s", minfo->prefix),
|
|
print_string("--exec-prefix=%s", minfo->exec_prefix),
|
|
print_string("--build=%s", minfo->build),
|
|
minfo->bootstrapping ? NULL :
|
|
print_string("--host=%s", minfo->host),
|
|
print_string("--target=%s", minfo->target),
|
|
NULL
|
|
};
|
|
string_array_t args = string_array_make();
|
|
for ( size_t i = 0; fixed_cmd_argv[i]; i++ )
|
|
string_array_append(&args, fixed_cmd_argv[i]);
|
|
if ( minfo->sysroot && with_build_sysroot )
|
|
{
|
|
string_array_append(&args, print_string("--with-build-sysroot=%s",
|
|
minfo->sysroot));
|
|
if ( minfo->sysroot && with_sysroot )
|
|
{
|
|
// TODO: Binutils has a bug where the empty string means that
|
|
// sysroot support is disabled and ld --sysroot won't work
|
|
// so set it to / here for compatibility.
|
|
// TODO: GCC has a bug where it doesn't use the
|
|
// --with-build-sysroot value when --with-sysroot= when
|
|
// locating standard library headers.
|
|
if ( with_sysroot_ld_bug )
|
|
string_array_append(&args, "--with-sysroot=/");
|
|
else
|
|
string_array_append(&args, "--with-sysroot=");
|
|
}
|
|
}
|
|
else if ( minfo->sysroot && with_sysroot )
|
|
{
|
|
string_array_append(&args, print_string("--with-sysroot=%s",
|
|
minfo->sysroot));
|
|
}
|
|
string_array_append_token_string(&args, conf_extra_args);
|
|
string_array_append(&args, NULL);
|
|
recovery_execvp(args.strings[0], (char* const*) args.strings);
|
|
err(127, "`%s'", args.strings[0]);
|
|
}
|
|
|
|
static bool TestDirty(struct metainfo* minfo,
|
|
const char* subdir,
|
|
const char* candidate)
|
|
{
|
|
if ( !subdir )
|
|
subdir = ".";
|
|
char* path;
|
|
if ( asprintf(&path, "%s/%s/%s", minfo->build_dir, subdir, candidate) < 0 )
|
|
err(1, "asprintf");
|
|
bool result = access(path, F_OK) == 0;
|
|
free(path);
|
|
return result;
|
|
}
|
|
|
|
static bool IsDirty(struct metainfo* minfo)
|
|
{
|
|
const char* dirty_file = metainfo_get(minfo, "DIRTY_FILE", "pkg.dirty-file");
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
if ( dirty_file )
|
|
return TestDirty(minfo, subdir, dirty_file);
|
|
return TestDirty(minfo, subdir, "config.log") ||
|
|
TestDirty(minfo, subdir, "Makefile") ||
|
|
TestDirty(minfo, subdir, "makefile");
|
|
}
|
|
|
|
static void Make(struct metainfo* minfo,
|
|
const char* make_target,
|
|
const char* destdir,
|
|
bool die_on_error,
|
|
const char* subdir)
|
|
{
|
|
if ( !(die_on_error ?
|
|
fork_and_wait_or_recovery() :
|
|
fork_and_wait_or_death_def(false)) )
|
|
return;
|
|
|
|
char* make = strdup(minfo->make);
|
|
const char* override_make = metainfo_get(minfo, "MAKE", "pkg.make.cmd");
|
|
const char* make_extra_args =
|
|
metainfo_get_def(minfo, "MAKE_ARGS", "pkg.make.args", "");
|
|
const char* make_extra_vars =
|
|
metainfo_get_def(minfo, "MAKE_VARS", "pkg.make.vars", "");
|
|
if ( override_make )
|
|
{
|
|
free(make);
|
|
make = strdup(override_make);
|
|
}
|
|
SetNeededVariables(minfo);
|
|
if ( chdir(minfo->build_dir) != 0 )
|
|
err(1, "chdir: `%s'", minfo->build_dir);
|
|
if ( subdir && chdir(subdir) != 0 )
|
|
err(1, "chdir: `%s/%s'", minfo->build_dir, subdir);
|
|
if ( !minfo->bootstrapping && destdir )
|
|
setenv("DESTDIR", destdir, 1);
|
|
setenv("BUILD", minfo->build, 1);
|
|
setenv("HOST", minfo->host, 1);
|
|
setenv("TARGET", minfo->target, 1);
|
|
if ( minfo->prefix )
|
|
setenv("PREFIX", minfo->prefix, 1);
|
|
else
|
|
unsetenv("PREFIX");
|
|
if ( minfo->exec_prefix )
|
|
setenv("EXEC_PREFIX", minfo->exec_prefix, 1);
|
|
else
|
|
unsetenv("EXEC_PREFIX");
|
|
if ( minfo->makeflags )
|
|
setenv("MAKEFLAGS", minfo->makeflags, 1);
|
|
setenv("MAKE", minfo->make, 1);
|
|
string_array_t env_vars = string_array_make();
|
|
string_array_append_token_string(&env_vars, make_extra_vars);
|
|
for ( size_t i = 0; i < env_vars.length; i++ )
|
|
{
|
|
char* key = env_vars.strings[i];
|
|
assert(key);
|
|
char* assignment = strchr((char*) key, '=');
|
|
if ( !assignment )
|
|
{
|
|
if ( !strncmp(key, "unset ", strlen("unset ")) )
|
|
unsetenv(key + strlen("unset "));
|
|
continue;
|
|
}
|
|
*assignment = '\0';
|
|
char* value = assignment+1;
|
|
setenv(key, value, 1);
|
|
}
|
|
const char* fixed_cmd_argv[] = { make, NULL };
|
|
string_array_t args = string_array_make();
|
|
for ( size_t i = 0; fixed_cmd_argv[i]; i++ )
|
|
string_array_append(&args, fixed_cmd_argv[i]);
|
|
string_array_append_token_string(&args, make_target);
|
|
string_array_append_token_string(&args, make_extra_args);
|
|
if ( !die_on_error )
|
|
string_array_append(&args, "-k");
|
|
string_array_append(&args, NULL);
|
|
if ( die_on_error )
|
|
recovery_execvp(args.strings[0], (char* const*) args.strings);
|
|
else
|
|
execvp(args.strings[0], (char* const*) args.strings);
|
|
err(127, "`%s'", args.strings[0]);
|
|
}
|
|
|
|
static void Clean(struct metainfo* minfo)
|
|
{
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
const char* build_system =
|
|
metainfo_get_def(minfo, "BUILD_SYSTEM", "pkg.build-system", "none");
|
|
const char* default_clean_target =
|
|
!strcmp(build_system, "configure") ? "distclean" : "clean";
|
|
const char* clean_target =
|
|
metainfo_get_def(minfo, "MAKE_CLEAN_TARGET", "pkg.make.clean-target",
|
|
default_clean_target);
|
|
const char* ignore_clean_failure_var =
|
|
metainfo_get_def(minfo, "MAKE_IGNORE_CLEAN_FAILURE",
|
|
"pkg.make.ignore-clean-failure", "true");
|
|
bool ignore_clean_failure = parse_boolean(ignore_clean_failure_var);
|
|
|
|
Make(minfo, clean_target, NULL, !ignore_clean_failure, subdir);
|
|
}
|
|
|
|
static void Build(struct metainfo* minfo)
|
|
{
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
const char* build_target =
|
|
metainfo_get_def(minfo, "MAKE_BUILD_TARGET", "pkg.make.build-target",
|
|
"all");
|
|
|
|
Make(minfo, build_target, NULL, true, subdir);
|
|
}
|
|
|
|
static void CreateDestination(void)
|
|
{
|
|
char* tardir_rel = join_paths(tmp_root, "tix");
|
|
char* destdir_rel = join_paths(tardir_rel, "data");
|
|
char* tixdir_rel = join_paths(tardir_rel, "tix");
|
|
|
|
if ( mkdir(tardir_rel, 0777) < 0 )
|
|
err(1, "mkdir: %s", tardir_rel);
|
|
if ( mkdir(destdir_rel, 0755) != 0 )
|
|
err(1, "mkdir: `%s'", destdir_rel);
|
|
if ( mkdir(tixdir_rel, 0755) != 0 )
|
|
err(1, "mkdir: `%s'", tixdir_rel);
|
|
|
|
free(tardir_rel);
|
|
free(destdir_rel);
|
|
free(tixdir_rel);
|
|
}
|
|
|
|
static void Install(struct metainfo* minfo)
|
|
{
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
const char* install_target =
|
|
metainfo_get_def(minfo, "MAKE_INSTALL_TARGET",
|
|
"pkg.make.install-target", "install");
|
|
char* tardir_rel = join_paths(tmp_root, "tix");
|
|
char* destdir_rel = join_paths(tardir_rel, "data");
|
|
char* destdir = realpath(destdir_rel, NULL);
|
|
if ( !destdir )
|
|
err(1, "realpath: %s", destdir_rel);
|
|
|
|
Make(minfo, install_target, destdir, true, subdir);
|
|
|
|
free(tardir_rel);
|
|
free(destdir_rel);
|
|
free(destdir);
|
|
}
|
|
|
|
static void PostInstall(struct metainfo* minfo)
|
|
{
|
|
const char* post_install_cmd =
|
|
metainfo_get(minfo, "POST_INSTALL", "pkg.post-install.cmd");
|
|
if ( !post_install_cmd )
|
|
return;
|
|
|
|
if ( !fork_and_wait_or_recovery() )
|
|
return;
|
|
|
|
const char* subdir = metainfo_get(minfo, "SUBDIR", "pkg.subdir");
|
|
char* tardir_rel = join_paths(tmp_root, "tix");
|
|
char* destdir_rel = join_paths(tardir_rel, "data");
|
|
char* destdir = realpath(destdir_rel, NULL);
|
|
if ( !destdir )
|
|
err(1, "realpath: %s", destdir_rel);
|
|
|
|
SetNeededVariables(minfo);
|
|
if ( chdir(minfo->package_dir) != 0 )
|
|
err(1, "chdir: `%s'", minfo->package_dir);
|
|
if ( subdir && chdir(subdir) != 0 )
|
|
err(1, "chdir: `%s/%s'", minfo->build_dir, subdir);
|
|
setenv("TIX_BUILD_DIR", minfo->build_dir, 1);
|
|
setenv("TIX_SOURCE_DIR", minfo->package_dir, 1);
|
|
setenv("TIX_INSTALL_DIR", destdir, 1);
|
|
if ( minfo->sysroot )
|
|
setenv("TIX_SYSROOT", minfo->sysroot, 1);
|
|
else
|
|
unsetenv("TIX_SYSROOT");
|
|
setenv("BUILD", minfo->build, 1);
|
|
setenv("HOST", minfo->host, 1);
|
|
setenv("TARGET", minfo->target, 1);
|
|
if ( minfo->prefix )
|
|
setenv("PREFIX", minfo->prefix, 1);
|
|
else
|
|
unsetenv("PREFIX");
|
|
if ( minfo->exec_prefix )
|
|
setenv("EXEC_PREFIX", minfo->exec_prefix, 1);
|
|
else
|
|
unsetenv("EXEC_PREFIX");
|
|
const char* cmd_argv[] =
|
|
{
|
|
post_install_cmd,
|
|
NULL
|
|
};
|
|
recovery_execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
err(127, "%s", cmd_argv[0]);
|
|
}
|
|
|
|
static void TixInfo(struct metainfo* minfo)
|
|
{
|
|
char* tardir_rel = join_paths(tmp_root, "tix");
|
|
if ( !tardir_rel )
|
|
err(1, "malloc");
|
|
char* tixinfo_rel = join_paths(tardir_rel, "tix/tixinfo");
|
|
if ( !tixinfo_rel )
|
|
err(1, "malloc");
|
|
const char* alias = metainfo_get(minfo, "ALIAS_OF", "pkg.alias-of");
|
|
const char* runtime_deps =
|
|
metainfo_get(minfo, "RUNTIME_DEPS", "pkg.runtime-deps");
|
|
bool location_independent =
|
|
parse_boolean(metainfo_get_def(minfo,
|
|
"LOCATION_INDEPENDENT", "pkg.location-independent", "false"));
|
|
|
|
FILE* tixinfo_fp = fopen(tixinfo_rel, "w");
|
|
if ( !tixinfo_fp )
|
|
err(1, "`%s'", tixinfo_rel);
|
|
|
|
fprintf(tixinfo_fp, "tix.version=1\n");
|
|
fprintf(tixinfo_fp, "tix.class=tix\n");
|
|
fprintf(tixinfo_fp, "tix.platform=%s\n", minfo->host);
|
|
fprintf(tixinfo_fp, "pkg.name=%s\n", minfo->package_name);
|
|
if ( alias )
|
|
fprintf(tixinfo_fp, "pkg.alias-of=%s\n", alias);
|
|
else
|
|
{
|
|
if ( runtime_deps )
|
|
fprintf(tixinfo_fp, "pkg.runtime-deps=%s\n", runtime_deps);
|
|
if ( location_independent )
|
|
fprintf(tixinfo_fp, "pkg.location-independent=true\n");
|
|
else
|
|
fprintf(tixinfo_fp, "pkg.prefix=%s\n", minfo->prefix);
|
|
}
|
|
|
|
if ( ferror(tixinfo_fp) || fflush(tixinfo_fp) == EOF )
|
|
err(1, "write: `%s'", tixinfo_rel);
|
|
|
|
fclose(tixinfo_fp);
|
|
free(tardir_rel);
|
|
free(tixinfo_rel);
|
|
}
|
|
|
|
static void Package(struct metainfo* minfo)
|
|
{
|
|
if ( !fork_and_wait_or_recovery() )
|
|
return;
|
|
|
|
char* tardir_rel = join_paths(tmp_root, "tix");
|
|
if ( !tardir_rel )
|
|
err(1, "malloc");
|
|
char* package_tix = print_string("%s/%s.tix.tar.xz",
|
|
minfo->destination, minfo->package_name);
|
|
if ( !package_tix )
|
|
err(1, "malloc");
|
|
printf("Creating `%s'...\n", package_tix);
|
|
|
|
const char* cmd_argv[] =
|
|
{
|
|
minfo->tar,
|
|
"-C", tardir_rel,
|
|
"--remove-files",
|
|
"--create",
|
|
"--xz",
|
|
"--numeric-owner",
|
|
"--owner=0",
|
|
"--group=0",
|
|
"--file", package_tix,
|
|
"tix",
|
|
"data",
|
|
NULL
|
|
};
|
|
recovery_execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
err(127, "%s", cmd_argv[0]);
|
|
}
|
|
|
|
static void Compile(struct metainfo* minfo)
|
|
{
|
|
// Detect which build system we are interfacing with.
|
|
const char* build_system =
|
|
metainfo_get(minfo, "BUILD_SYSTEM", "pkg.build-system");
|
|
if ( !build_system )
|
|
errx(1, "%s: pkg.build-system was not found", minfo->package_info_path);
|
|
|
|
// Determine whether need to do an out-of-directory build.
|
|
const char* use_build_dir_var =
|
|
metainfo_get_def(minfo, "CONFIGURE_USE_BUILD_DIRECTORY",
|
|
"pkg.configure.use-build-directory", "false");
|
|
bool use_build_dir = parse_boolean(use_build_dir_var);
|
|
if ( use_build_dir )
|
|
{
|
|
const char* build_rel =
|
|
minfo->bootstrapping ? "build-bootstrap" : "build";
|
|
minfo->build_dir = join_paths(tmp_root, build_rel);
|
|
if ( !minfo->build_dir )
|
|
err(1, "malloc");
|
|
if ( mkdir(minfo->build_dir, 0777) < 0 )
|
|
err(1, "mkdir %s", minfo->build_dir);
|
|
}
|
|
else
|
|
minfo->build_dir = strdup(minfo->package_dir);
|
|
|
|
// Reset the build directory if needed.
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_PRE_CLEAN, minfo) &&
|
|
!use_build_dir &&
|
|
IsDirty(minfo) )
|
|
Clean(minfo);
|
|
|
|
// Configure the build directory if needed.
|
|
if ( strcmp(build_system, "configure") == 0 &&
|
|
SHOULD_DO_BUILD_STEP(BUILD_STEP_CONFIGURE, minfo) )
|
|
Configure(minfo);
|
|
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_BUILD, minfo) )
|
|
Build(minfo);
|
|
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_INSTALL, minfo) )
|
|
Install(minfo);
|
|
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_POST_INSTALL, minfo) )
|
|
PostInstall(minfo);
|
|
|
|
// Clean the build directory after the successful build.
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_POST_CLEAN, minfo) )
|
|
Clean(minfo);
|
|
}
|
|
|
|
static void Bootstrap(struct metainfo* minfo)
|
|
{
|
|
struct metainfo newinfo = { 0 };
|
|
|
|
newinfo.build = minfo->build;
|
|
newinfo.build_dir = NULL;
|
|
newinfo.destination = NULL;
|
|
newinfo.generation = minfo->generation;
|
|
newinfo.host = minfo->build;
|
|
newinfo.make = minfo->make;
|
|
newinfo.makeflags = minfo->makeflags;
|
|
newinfo.package_dir = minfo->package_dir;
|
|
newinfo.package_info_path = minfo->package_info_path;
|
|
newinfo.package_name = minfo->package_name;
|
|
newinfo.prefix = join_paths(tmp_root, "bootstrap");
|
|
if ( !newinfo.prefix )
|
|
err(1, "malloc");
|
|
if ( mkdir(newinfo.prefix, 0777) < 0 )
|
|
err(1, "mkdir: %s", newinfo.prefix);
|
|
newinfo.exec_prefix = newinfo.prefix;
|
|
newinfo.sysroot = NULL;
|
|
newinfo.tar = minfo->tar;
|
|
newinfo.target = minfo->host;
|
|
newinfo.tmp = minfo->tmp;
|
|
const char* bootstrap_prefix =
|
|
minfo->tixbuildinfo ? "bootstrap." : "BOOTSTRAP_";
|
|
for ( size_t i = 0; i < minfo->package_info.length; i++ )
|
|
{
|
|
const char* string = minfo->package_info.strings[i];
|
|
if ( minfo->tixbuildinfo ?
|
|
!strncmp(string, "pkg.", strlen("pkg.")) :
|
|
strncmp(string, bootstrap_prefix, strlen(bootstrap_prefix)) != 0 )
|
|
continue;
|
|
if ( !strncmp(string, bootstrap_prefix, strlen(bootstrap_prefix)) )
|
|
{
|
|
const char* rest = string + strlen(bootstrap_prefix);
|
|
char* newstring = minfo->tixbuildinfo ?
|
|
print_string("pkg.%s", rest) :
|
|
strdup(rest);
|
|
if ( !newstring )
|
|
err(1, "malloc");
|
|
if ( !string_array_append(&newinfo.package_info, newstring) )
|
|
err(1, "malloc");
|
|
free(newstring);
|
|
}
|
|
else
|
|
{
|
|
if ( !string_array_append(&newinfo.package_info, string) )
|
|
err(1, "malloc");
|
|
}
|
|
}
|
|
newinfo.start_step = BUILD_STEP_PRE_CLEAN;
|
|
newinfo.end_step = BUILD_STEP_POST_CLEAN;
|
|
newinfo.bootstrapping = true;
|
|
newinfo.cross = false;
|
|
|
|
Compile(&newinfo);
|
|
|
|
char* bindir = join_paths(newinfo.prefix, "bin");
|
|
if ( !bindir )
|
|
err(1, "malloc");
|
|
if ( access(bindir, F_OK) == 0 )
|
|
append_to_path(bindir);
|
|
free(bindir);
|
|
|
|
char* sbindir = join_paths(newinfo.prefix, "sbin");
|
|
if ( !sbindir )
|
|
err(1, "malloc");
|
|
if ( access(sbindir, F_OK) == 0 )
|
|
append_to_path(sbindir);
|
|
free(sbindir);
|
|
|
|
string_array_reset(&newinfo.package_info);
|
|
free(newinfo.prefix);
|
|
}
|
|
|
|
static void BuildPackage(struct metainfo* minfo)
|
|
{
|
|
// Whether this is just an alias for another package.
|
|
const char* alias = metainfo_get(minfo, "ALIAS_OF", "pkg.alias-of");
|
|
|
|
// Determine if the package is location independent.
|
|
bool location_independent =
|
|
parse_boolean(metainfo_get_def(minfo, "LOCATION_INDEPENDENT",
|
|
"pkg.location-independent", "false"));
|
|
if ( !alias && !location_independent && !minfo->prefix )
|
|
errx(1, "error: %s is not location independent and you need to "
|
|
"specify the intended destination prefix using --prefix",
|
|
minfo->package_name);
|
|
|
|
CreateDestination();
|
|
|
|
// Possibly build a native version of the package to aid cross-compilation.
|
|
// This is an anti-feature needed for broken packages that don't properly
|
|
// handle this case entirely themselves. There's a few packages that need
|
|
// the exact same version around natively in order to cross-compile.
|
|
const char* use_bootstrap_var =
|
|
metainfo_get_def(minfo, "USE_BOOTSTRAP", "pkg.use-bootstrap", "false");
|
|
bool use_bootstrap = parse_boolean(use_bootstrap_var);
|
|
if ( !alias && use_bootstrap && strcmp(minfo->build, minfo->host) != 0 &&
|
|
SHOULD_DO_BUILD_STEP(BUILD_STEP_CONFIGURE, minfo) )
|
|
Bootstrap(minfo);
|
|
|
|
EmitWrappers(minfo);
|
|
|
|
if ( !alias )
|
|
Compile(minfo);
|
|
|
|
if ( SHOULD_DO_BUILD_STEP(BUILD_STEP_PACKAGE, minfo) )
|
|
{
|
|
TixInfo(minfo);
|
|
Package(minfo);
|
|
}
|
|
}
|
|
|
|
static void VerifySourceTixInformation(struct metainfo* minfo)
|
|
{
|
|
if ( minfo->tixbuildinfo )
|
|
{
|
|
const char* pipath = minfo->package_info_path;
|
|
string_array_t* pinfo = &minfo->package_info;
|
|
const char* tix_version =
|
|
VerifyInfoVariable(pinfo, "tix.version", pipath);
|
|
if ( atoi(tix_version) != 1 )
|
|
errx(1, "error: `%s': tix version `%s' not supported", pipath,
|
|
tix_version);
|
|
const char* tix_class = VerifyInfoVariable(pinfo, "tix.class", pipath);
|
|
if ( !strcmp(tix_class, "tix") )
|
|
errx(1, "error: `%s': this object is a binary tix and is already "
|
|
"compiled.\n", pipath);
|
|
if ( strcmp(tix_class, "srctix") )
|
|
errx(1, "error: `%s': tix class `%s' is not `srctix': this object "
|
|
"is not suitable for compilation.", pipath, tix_class);
|
|
}
|
|
metainfo_verify(minfo, "NAME", "pkg.name");
|
|
if ( !metainfo_get(minfo, "ALIAS_OF", "pkg.alias-of") )
|
|
metainfo_verify(minfo, "BUILD_SYSTEM", "pkg.build-system");
|
|
}
|
|
|
|
// TODO: The MAKEFLAGS variable is actually not in the same format as the token
|
|
// string language. It appears that GNU make doesn't escape " characters,
|
|
// but instead consider them normal characters. This should work as
|
|
// expected, though, as long as the MAKEFLAGS variable doesn't contain any
|
|
// quote characters.
|
|
static void PurifyMakeflags(void)
|
|
{
|
|
const char* makeflags_environment = getenv("MAKEFLAGS");
|
|
if ( !makeflags_environment )
|
|
return;
|
|
string_array_t makeflags = string_array_make();
|
|
string_array_append_token_string(&makeflags, makeflags_environment);
|
|
// Discard all the environmental variables in MAKEFLAGS.
|
|
for ( size_t i = 0; i < makeflags.length; i++ )
|
|
{
|
|
char* flag = makeflags.strings[i];
|
|
assert(flag);
|
|
if ( flag[0] == '-' )
|
|
continue;
|
|
if ( !strchr(flag, '=') )
|
|
continue;
|
|
free(flag);
|
|
for ( size_t n = i + 1; n < makeflags.length; n++ )
|
|
makeflags.strings[n-1] = makeflags.strings[n];
|
|
makeflags.length--;
|
|
i--;
|
|
}
|
|
char* new_makeflags_environment = token_string_of_string_array(&makeflags);
|
|
assert(new_makeflags_environment);
|
|
setenv("MAKEFLAGS", new_makeflags_environment, 1);
|
|
free(new_makeflags_environment);
|
|
string_array_reset(&makeflags);
|
|
}
|
|
|
|
static char* FindPortFile(char* package_dir)
|
|
{
|
|
char* path = print_string("%s.port", package_dir);
|
|
if ( !path )
|
|
err(1, "malloc");
|
|
if ( !access(path, F_OK) )
|
|
return path;
|
|
free(path);
|
|
path = join_paths(package_dir, "tix.port");
|
|
if ( !path )
|
|
err(1, "malloc");
|
|
if ( !access(path, F_OK) )
|
|
return path;
|
|
free(path);
|
|
return NULL;
|
|
}
|
|
|
|
static char* FindTixBuildInfo(char* package_dir)
|
|
{
|
|
char* path = join_paths(package_dir, "tixbuildinfo");
|
|
if ( !path )
|
|
err(1, "malloc");
|
|
if ( !access(path, F_OK) )
|
|
return path;
|
|
free(path);
|
|
return NULL;
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
PurifyMakeflags();
|
|
|
|
struct metainfo minfo;
|
|
memset(&minfo, 0, sizeof(minfo));
|
|
minfo.build = NULL;
|
|
minfo.destination = strdup(".");
|
|
minfo.host = NULL;
|
|
char* generation_string = strdup(DEFAULT_GENERATION);
|
|
minfo.makeflags = strdup_null(getenv_def("MAKEFLAGS", NULL));
|
|
minfo.make = strdup(getenv_def("MAKE", "make"));
|
|
minfo.prefix = strdup("");
|
|
minfo.exec_prefix = NULL;
|
|
minfo.sysroot = NULL;
|
|
minfo.target = NULL;
|
|
minfo.tar = strdup("tar");
|
|
char* tmp = strdup(getenv_def("TMPDIR", "/tmp"));
|
|
char* start_step_string = strdup("start");
|
|
char* end_step_string = strdup("end");
|
|
char* source_port = NULL;
|
|
|
|
const char* argv0 = argv[0];
|
|
for ( int i = 0; i < argc; i++ )
|
|
{
|
|
const char* arg = argv[i];
|
|
if ( arg[0] != '-' || !arg[1] )
|
|
continue;
|
|
argv[i] = NULL;
|
|
if ( !strcmp(arg, "--") )
|
|
break;
|
|
if ( arg[1] != '-' )
|
|
{
|
|
char c;
|
|
while ( (c = *++arg) ) switch ( c )
|
|
{
|
|
default:
|
|
errx(1, "unknown option -- '%c'", c);
|
|
}
|
|
}
|
|
else if ( GET_OPTION_VARIABLE("--build", &minfo.build) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--destination", &minfo.destination) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--end", &end_step_string) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--exec-prefix", &minfo.exec_prefix) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--generation", &generation_string) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--host", &minfo.host) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--make", &minfo.make) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--makeflags", &minfo.makeflags) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--prefix", &minfo.prefix) ) { }
|
|
// TODO: After releasing Sortix 1.1, remove this option.
|
|
else if ( GET_OPTION_VARIABLE("--source-package", &source_port) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--source-port", &source_port) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--start", &start_step_string) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--sysroot", &minfo.sysroot) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--tar", &minfo.tar) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--target", &minfo.target) ) { }
|
|
else if ( GET_OPTION_VARIABLE("--tmp", &minfo.tmp) ) { }
|
|
else
|
|
errx(1, "unknown option: %s", arg);
|
|
}
|
|
|
|
minfo.generation = atoi(generation_string);
|
|
free(generation_string);
|
|
|
|
if ( !(minfo.start_step = step_of_step_name(start_step_string)) )
|
|
{
|
|
fprintf(stderr, "%s: no such step `%s'\n", argv0, start_step_string);
|
|
exit(1);
|
|
}
|
|
|
|
if ( !(minfo.end_step = step_of_step_name(end_step_string)) )
|
|
{
|
|
fprintf(stderr, "%s: no such step `%s'\n", argv0, end_step_string);
|
|
exit(1);
|
|
}
|
|
|
|
compact_arguments(&argc, &argv);
|
|
|
|
if ( minfo.prefix && !strcmp(minfo.prefix, "/") )
|
|
minfo.prefix[0] = '\0';
|
|
|
|
if ( argc < 2 )
|
|
{
|
|
fprintf(stderr, "%s: no package specified\n", argv0);
|
|
exit(1);
|
|
}
|
|
|
|
if ( 2 < argc )
|
|
{
|
|
fprintf(stderr, "%s: unexpected extra operand `%s'\n", argv0, argv[2]);
|
|
exit(1);
|
|
}
|
|
|
|
initialize_tmp(tmp, "tixbuild");
|
|
|
|
const char* srctix = argv[1];
|
|
minfo.package_dir = realpath(srctix, NULL);
|
|
if ( !minfo.package_dir )
|
|
err(1, "%s", srctix);
|
|
|
|
if ( minfo.build && !minfo.build[0] )
|
|
free(minfo.build), minfo.build = NULL;
|
|
if ( minfo.host && !minfo.host[0] )
|
|
free(minfo.host), minfo.host = NULL;
|
|
if ( minfo.target && !minfo.target[0] )
|
|
free(minfo.target), minfo.target = NULL;
|
|
|
|
if ( !minfo.build && !(minfo.build = GetBuildTriplet()) )
|
|
err(1, "unable to determine build, use --build");
|
|
if ( !minfo.host )
|
|
minfo.host = strdup(minfo.build);
|
|
if ( !minfo.target )
|
|
minfo.target = strdup(minfo.host);
|
|
|
|
minfo.cross = strcmp(minfo.build, minfo.host) != 0 || minfo.sysroot;
|
|
|
|
if ( minfo.prefix && !minfo.exec_prefix )
|
|
minfo.exec_prefix = strdup(minfo.prefix);
|
|
|
|
if ( !IsDirectory(minfo.package_dir) )
|
|
err(1, "`%s'", minfo.package_dir);
|
|
|
|
if ( (minfo.package_info_path = FindPortFile(minfo.package_dir)) )
|
|
{
|
|
minfo.tixbuildinfo = false;
|
|
minfo.package_info = string_array_make();
|
|
string_array_t* package_info = &minfo.package_info;
|
|
int ret = variables_append_file_path(package_info,
|
|
minfo.package_info_path);
|
|
if ( ret == -1 )
|
|
err(1, "`%s'", minfo.package_info_path);
|
|
else if ( ret == -2 )
|
|
errx(1, "`%s': Syntax error", minfo.package_info_path);
|
|
}
|
|
else if ( (minfo.package_info_path = FindTixBuildInfo(minfo.package_dir)) )
|
|
{
|
|
minfo.tixbuildinfo = true;
|
|
minfo.package_info = string_array_make();
|
|
string_array_t* package_info = &minfo.package_info;
|
|
if ( !dictionary_append_file_path(package_info,
|
|
minfo.package_info_path) )
|
|
err(1, "`%s'", minfo.package_info_path);
|
|
}
|
|
else
|
|
err(1, "Failed to find: %s.port or %s/tix.port or %s/tixbuildinfo",
|
|
minfo.package_dir, minfo.package_dir, minfo.package_dir);
|
|
|
|
VerifySourceTixInformation(&minfo);
|
|
minfo.package_name = strdup(metainfo_get(&minfo, "NAME", "pkg.name"));
|
|
|
|
const char* pkg_source_port =
|
|
metainfo_get(&minfo, "SOURCE_PORT", "pkg.source-package");
|
|
if ( pkg_source_port && !source_port )
|
|
{
|
|
// TODO: Change this default location to match tix-port(8)?
|
|
source_port = print_string("%s/../%s", srctix, pkg_source_port);
|
|
if ( !source_port )
|
|
err(1, "malloc");
|
|
}
|
|
|
|
if ( source_port )
|
|
{
|
|
free(minfo.package_dir);
|
|
minfo.package_dir = realpath(source_port, NULL);
|
|
if ( !minfo.package_dir )
|
|
err(1, "%s: looking for source port: %s", srctix, source_port);
|
|
}
|
|
|
|
BuildPackage(&minfo);
|
|
|
|
return 0;
|
|
}
|