configure

Browse Download file Permalink

/* $Id$ */

/* This file is part of DeforaOS Devel configure */

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

#include <System.h>

#include <sys/stat.h>

#include <unistd.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <libgen.h>

#include <errno.h>

#include "common.h"

#include "settings.h"

#include "configure.h"

#include "../config.h"

#ifndef PROGNAME_CONFIGURE

# define PROGNAME_CONFIGURE PACKAGE

#endif

/* private */

/* types */

typedef struct _Makefile

{

Configure * configure;

FILE * fp;

} Makefile;

/* prototypes */

/* accessors */

static String const * _makefile_get_config(Makefile * makefile,

String const * section, String const * variable);

static String const * _makefile_get_config_mode(Makefile * makefile,

String const * mode, String const * variable);

static TargetType _makefile_get_type(Makefile * makefile,

String const * target);

static int _makefile_is_enabled(Makefile * makefile, char const * target);

static unsigned int _makefile_is_flag_set(Makefile * makefile,

unsigned int flag);

static int _makefile_is_phony(Makefile * makefile, char const * target);

/* useful */

static int _makefile_expand(Makefile * makefile, char const * field);

static int _makefile_link(Makefile * makefile, int symlink, char const * link,

char const * path);

static int _makefile_output_extension(Makefile * makefile,

String const * extension);

static int _makefile_output_path(Makefile * makefile, String const * path);

static int _makefile_output_program(Makefile * makefile, String const * name,

unsigned int override);

static int _makefile_output_variable(Makefile * makefile, String const * name,

String const * value);

static int _makefile_mkdir(Makefile * makefile, char const * directory);

static int _makefile_print(Makefile * makefile, char const * format, ...);

static int _makefile_print_escape(Makefile * makefile, char const * str);

static int _makefile_print_escape_variable(Makefile * makefile,

char const * str);

static int _makefile_print_target(Makefile * makefile, String const * target);

static int _makefile_remove(Makefile * makefile, int recursive, ...);

static int _makefile_subdirs(Makefile * makefile, char const * target);

static int _makefile_target(Makefile * makefile, char const * target, ...);

#ifdef WITH_UNUSED

static int _makefile_targetv(Makefile * makefile, char const * target,

char const ** depends);

#endif

/* functions */

/* makefile */

static int _makefile_write(Makefile * makefile, configArray * ca,

int from, int to);

int makefile(Configure * configure, String const * directory, configArray * ca,

int from, int to)

{

Makefile makefile;

String * filename;

int ret = 0;

if(directory == NULL || string_get_length(directory) == 0)

filename = string_new(MAKEFILE);

else

filename = string_new_append(directory, "/", MAKEFILE, NULL);

if(filename == NULL)

return -1;

makefile.configure = configure;

makefile.fp = NULL;

if(!_makefile_is_flag_set(&makefile, PREFS_n)

&& (makefile.fp = fopen(filename, "w")) == NULL)

ret = configure_error(1, "%s: %s", filename, strerror(errno));

else

{

if(_makefile_is_flag_set(&makefile, PREFS_v))

printf("%s%s\n", "Creating ", filename);

ret |= _makefile_write(&makefile, ca, from, to);

if(makefile.fp != NULL)

fclose(makefile.fp);

}

string_delete(filename);

return ret;

}

static int _write_variables(Makefile * makefile);

static int _write_targets(Makefile * makefile);

static int _write_objects(Makefile * makefile);

static int _write_clean(Makefile * makefile);

static int _write_distclean(Makefile * makefile);

static int _write_dist(Makefile * makefile, configArray * ca, int from, int to);

static int _write_distcheck(Makefile * makefile);

static int _write_install(Makefile * makefile);

static int _write_phony(Makefile * makefile,

char const ** targets);

static int _write_uninstall(Makefile * makefile);

static int _makefile_write(Makefile * makefile, configArray * ca,

int from, int to)

{

char const * depends[9] = { "all" };

size_t i = 1;

if(_write_variables(makefile) != 0

|| _write_targets(makefile) != 0

|| _write_objects(makefile) != 0

|| _write_clean(makefile) != 0

|| _write_distclean(makefile) != 0

|| _write_dist(makefile, ca, from, to) != 0

|| _write_distcheck(makefile) != 0

|| _write_install(makefile) != 0

|| _write_uninstall(makefile) != 0)

return 1;

if(_makefile_get_config_mode(makefile, NULL, "subdirs") != NULL)

depends[i++] = "subdirs";

depends[i++] = "clean";

depends[i++] = "distclean";

if(_makefile_get_config_mode(makefile, NULL, "package") != NULL

&& _makefile_get_config_mode(makefile, NULL,

"version") != NULL)

{

depends[i++] = "dist";

depends[i++] = "distcheck";

}

depends[i++] = "install";

depends[i++] = "uninstall";

depends[i++] = NULL;

return _write_phony(makefile, depends);

}

static int _variables_package(Makefile * makefile,

String const * directory);

static int _variables_print(Makefile * makefile,

char const * input, char const * output);

static int _variables_dist(Makefile * makefile, char * done);

static int _variables_targets(Makefile * makefile);

static int _variables_executables(Makefile * makefile, char * done);

static int _variables_includes(Makefile * makefile);

static int _variables_subdirs(Makefile * makefile);

static int _write_variables(Makefile * makefile)

{

int ret = 0;

String const * directory;

char done[TT_LAST]; /* FIXME even better if'd be variable by variable */

memset(&done, 0, sizeof(done));

directory = _makefile_get_config(makefile, NULL, "_directory");

ret |= _variables_package(makefile, directory);

ret |= _variables_print(makefile, "subdirs", "SUBDIRS");

ret |= _variables_dist(makefile, done);

ret |= _variables_targets(makefile);

ret |= _variables_executables(makefile, done);

ret |= _variables_includes(makefile);

ret |= _variables_subdirs(makefile);

_makefile_print(makefile, "\n");

return ret;

}

static int _variables_package(Makefile * makefile,

String const * directory)

{

String const * package;

String const * version;

String const * vendor;

String const * p;

if((package = _makefile_get_config_mode(makefile, NULL, "package"))

== NULL)

return 0;

if(_makefile_is_flag_set(makefile, PREFS_v))

printf("%s%s", "Package: ", package);

if((version = _makefile_get_config_mode(makefile, NULL, "version"))

== NULL)

{

if(_makefile_is_flag_set(makefile, PREFS_v))

fputc('\n', stdout);

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", directory,

": \"package\" needs \"version\"\n");

return 1;

}

if(_makefile_is_flag_set(makefile, PREFS_v))

printf(" %s\n", version);

if((vendor = _makefile_get_config_mode(makefile, NULL, "vendor"))

== NULL)

vendor = "DeforaOS";

_makefile_output_variable(makefile, "PACKAGE", package);

_makefile_output_variable(makefile, "VERSION", version);

_makefile_output_variable(makefile, "VENDOR", vendor);

if((p = _makefile_get_config_mode(makefile, NULL, "config")) != NULL)

return settings(makefile->configure, directory, package,

version, vendor);

return 0;

}

static int _variables_print(Makefile * makefile,

char const * input, char const * output)

{

String const * p;

String * prints;

String * q;

unsigned long i;

char c;

if((p = _makefile_get_config_mode(makefile, NULL, input)) == NULL)

return 0;

if((prints = string_new(p)) == NULL)

return 1;

q = prints;

_makefile_print(makefile, "%s%s", output, "\t=");

for(i = 0;; i++)

{

if(prints[i] != ',' && prints[i] != '\0')

continue;

c = prints[i];

prints[i] = '\0';

if(strchr(prints, ' ') != NULL)

_makefile_print(makefile, " \"%s\"", prints);

else

_makefile_print(makefile, " %s", prints);

if(c == '\0')

break;

prints += i + 1;

i = 0;

}

_makefile_print(makefile, "\n");

string_delete(q);

return 0;

}

static int _variables_dist(Makefile * makefile, char * done)

{

String const * p;

String * dist;

String * q;

size_t i;

char c;

if((p = _makefile_get_config_mode(makefile, NULL, "dist")) == NULL)

return 0;

if((dist = string_new(p)) == NULL)

return 1;

q = dist;

for(i = 0;; i++)

{

if(dist[i] != ',' && dist[i] != '\0')

continue;

c = dist[i];

dist[i] = '\0';

if(_makefile_get_config(makefile, dist, "install") != NULL)

{

_makefile_output_path(makefile, "objdir");

_makefile_output_path(makefile, "prefix");

_makefile_output_path(makefile, "destdir");

done[TT_SCRIPT] = 1;

_makefile_output_program(makefile, "mkdir", 0);

_makefile_output_program(makefile, "install", 0);

_makefile_output_program(makefile, "rm", 0);

break;

}

if(c == '\0')

break;

dist += i + 1;

i = 0;

}

string_delete(q);

return 0;

}

static int _variables_targets(Makefile * makefile)

{

int ret = 0;

String const * p;

String * prints;

String * q;

size_t i;

char c;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((prints = string_new(p)) == NULL)

return 1;

q = prints;

_makefile_print(makefile, "%s", "TARGETS\t=");

for(i = 0;; i++)

{

if(prints[i] != ',' && prints[i] != '\0')

continue;

c = prints[i];

prints[i] = '\0';

_makefile_print(makefile, " ");

_makefile_print_target(makefile, prints);

if(c == '\0')

break;

prints += i + 1;

i = 0;

}

_makefile_print(makefile, "\n");

string_delete(q);

return ret;

}

static void _executables_variables(Makefile * makefile,

String const * target, char * done);

static int _variables_executables(Makefile * makefile, char * done)

{

String const * targets;

String const * includes;

String const * package;

String * p;

String * q;

size_t i;

char c;

targets = _makefile_get_config_mode(makefile, NULL, "targets");

includes = _makefile_get_config_mode(makefile, NULL, "includes");

package = _makefile_get_config_mode(makefile, NULL, "package");

if(targets != NULL)

{

if((p = string_new(targets)) == NULL)

return 1;

q = p;

for(i = 0;; i++)

{

if(p[i] != ',' && p[i] != '\0')

continue;

c = p[i];

p[i] = '\0';

_executables_variables(makefile, p, done);

if(c == '\0')

break;

p += i + 1;

i = 0;

}

string_delete(q);

}

else if(includes != NULL)

{

_makefile_output_path(makefile, "objdir");

_makefile_output_path(makefile, "prefix");

_makefile_output_path(makefile, "destdir");

}

if(targets != NULL || includes != NULL || package != NULL)

{

_makefile_output_program(makefile, "rm", 0);

_makefile_output_program(makefile, "ln", 0);

}

if(package != NULL)

{

_makefile_output_program(makefile, "tar", 0);

_makefile_output_extension(makefile, "tgz");

_makefile_output_program(makefile, "mkdir", 0);

}

if(targets != NULL || includes != NULL)

{

if(package == NULL)

_makefile_output_program(makefile, "mkdir", 0);

_makefile_output_program(makefile, "install", 0);

}

return 0;

}

static void _variables_binary(Makefile * makefile, char * done);

static void _variables_library(Makefile * makefile, char * done);

static void _variables_library_static(Makefile * makefile);

static void _variables_libtool(Makefile * makefile, char * done);

static void _variables_script(Makefile * makefile, char * done);

static void _executables_variables(Makefile * makefile, String const * target,

char * done)

{

String const * type;

TargetType tt;

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

return;

if(done[(tt = enum_string(TT_LAST, sTargetType, type))])

return;

switch(tt)

{

case TT_BINARY:

_variables_binary(makefile, done);

done[TT_OBJECT] = 1;

break;

case TT_COMMAND:

break;

case TT_OBJECT:

_variables_binary(makefile, done);

done[TT_BINARY] = 1;

break;

case TT_LIBRARY:

_variables_library(makefile, done);

done[TT_PLUGIN] = 1;

break;

case TT_PLUGIN:

_variables_library(makefile, done);

done[TT_LIBRARY] = 1;

break;

case TT_LIBTOOL:

_variables_libtool(makefile, done);

break;

case TT_SCRIPT:

_variables_script(makefile, done);

done[TT_SCRIPT] = 1;

break;

case TT_UNKNOWN:

break;

}

done[tt] = 1;

return;

}

static void _targets_asflags(Makefile * makefile);

static void _targets_cflags(Makefile * makefile);

static void _targets_cxxflags(Makefile * makefile);

static void _targets_exeext(Makefile * makefile);

static void _targets_goflags(Makefile * makefile);

static void _targets_ldflags(Makefile * makefile);

static void _targets_jflags(Makefile * makefile);

static void _targets_vflags(Makefile * makefile);

static void _binary_ldflags(Makefile * makefile, String const * ldflags);

static void _variables_binary(Makefile * makefile, char * done)

{

if(!done[TT_LIBRARY] && !done[TT_SCRIPT])

{

_makefile_output_path(makefile, "objdir");

_makefile_output_path(makefile, "prefix");

_makefile_output_path(makefile, "destdir");

}

_makefile_output_path(makefile, "bindir");

_makefile_output_path(makefile, "sbindir");

if(!done[TT_LIBRARY])

{

_targets_asflags(makefile);

_targets_cflags(makefile);

_targets_cxxflags(makefile);

_targets_ldflags(makefile);

_targets_goflags(makefile);

_targets_jflags(makefile);

_targets_vflags(makefile);

_targets_exeext(makefile);

}

static void _targets_asflags(Makefile * makefile)

{

String const * as;

String const * asf;

String const * asff;

as = _makefile_get_config_mode(makefile, NULL, "as");

asff = _makefile_get_config_mode(makefile, NULL, "asflags_force");

asf = _makefile_get_config_mode(makefile, NULL, "asflags");

if(as != NULL || asff != NULL || asf != NULL)

{

_makefile_output_variable(makefile, "AS", (as != NULL) ? as

: configure_get_program(makefile->configure,

"as"));

_makefile_output_variable(makefile, "ASFLAGSF", asff);

_makefile_output_variable(makefile, "ASFLAGS", asf);

}

static void _targets_cflags(Makefile * makefile)

{

String const * cc;

String const * cff;

String const * cf;

String const * cppf;

String const * cpp;

String * p;

HostOS os;

/* TODO: only output when the targets are relevant */

cppf = _makefile_get_config_mode(makefile, NULL, "cppflags_force");

cpp = _makefile_get_config_mode(makefile, NULL, "cppflags");

cff = _makefile_get_config_mode(makefile, NULL, "cflags_force");

cf = _makefile_get_config_mode(makefile, NULL, "cflags");

cc = _makefile_get_config_mode(makefile, NULL, "cc");

if(cppf == NULL && cpp == NULL && cff == NULL && cf == NULL

&& cc == NULL)

return;

_makefile_output_program(makefile, "cc", 1);

_makefile_output_variable(makefile, "CPPFLAGSF", cppf);

_makefile_output_variable(makefile, "CPPFLAGS", cpp);

p = NULL;

if((os = configure_get_os(makefile->configure)) == HO_GNU_LINUX

&& cff != NULL && string_find(cff, "-ansi"))

p = string_new_append(cff, " -D _GNU_SOURCE");

_makefile_output_variable(makefile, "CFLAGSF", (p != NULL) ? p : cff);

string_delete(p);

p = NULL;

if(os == HO_GNU_LINUX && cf != NULL && string_find(cf, "-ansi"))

p = string_new_append(cf, " -D _GNU_SOURCE");

_makefile_output_variable(makefile, "CFLAGS", (p != NULL) ? p : cf);

string_delete(p);

}

static void _targets_cxxflags(Makefile * makefile)

{

String const * cxx;

String const * cxxff;

String const * cxxf;

cxx = _makefile_get_config_mode(makefile, NULL, "cxx");

cxxff = _makefile_get_config_mode(makefile, NULL, "cxxflags_force");

cxxf = _makefile_get_config_mode(makefile, NULL, "cxxflags");

if(cxx != NULL || cxxff != NULL || cxxf != NULL)

_makefile_output_program(makefile, "cxx", 1);

if(cxxff != NULL)

{

_makefile_print(makefile, "%s%s", "CXXFLAGSF= ", cxxff);

if(configure_get_os(makefile->configure) == HO_GNU_LINUX

&& string_find(cxxff, "-ansi"))

_makefile_print(makefile, "%s", " -D _GNU_SOURCE");

_makefile_print(makefile, "\n");

}

if(cxxf != NULL)

{

_makefile_print(makefile, "%s%s", "CXXFLAGS= ", cxxf);

if(configure_get_os(makefile->configure) == HO_GNU_LINUX

&& string_find(cxxf, "-ansi"))

_makefile_print(makefile, "%s", " -D _GNU_SOURCE");

_makefile_print(makefile, "\n");

}

static void _targets_exeext(Makefile * makefile)

{

_makefile_output_extension(makefile, "exe");

}

static void _targets_goflags(Makefile * makefile)

{

String const * p;

String * targets;

String * q;

size_t i;

char c;

String const * go = NULL;

String const * gof;

String const * goff;

/* TODO: simplify the detection for Go targets */

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return;

if((targets = string_new(p)) == NULL)

/* FIXME report the error */

return;

q = targets;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if((p = _makefile_get_config(makefile, targets, "sources"))

!= NULL

/* XXX only checks the last source */

&& (p = source_extension(p)) != NULL

&& source_type(p) == OT_GOLANG_SOURCE)

{

if((go = _makefile_get_config_mode(makefile, NULL,

"go")) == NULL)

go = "go";

}

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

goff = _makefile_get_config_mode(makefile, NULL, "goflags_force");

gof = _makefile_get_config_mode(makefile, NULL, "goflags");

if(go != NULL || goff != NULL || gof != NULL)

{

_makefile_output_program(makefile, "go", 1);

_makefile_output_variable(makefile, "GOFLAGSF", goff);

_makefile_output_variable(makefile, "GOFLAGS", gof);

}

static void _targets_ldflags(Makefile * makefile)

{

String const * p;

if((p = _makefile_get_config_mode(makefile, NULL, "ldflags_force"))

!= NULL)

{

_makefile_print(makefile, "%s", "LDFLAGSF=");

_binary_ldflags(makefile, p);

_makefile_print(makefile, "\n");

}

if((p = _makefile_get_config_mode(makefile, NULL, "ldflags")) != NULL)

{

_makefile_print(makefile, "%s", "LDFLAGS\t=");

_binary_ldflags(makefile, p);

_makefile_print(makefile, "\n");

}

static void _targets_jflags(Makefile * makefile)

{

String const * j;

String const * jff;

String const * jf;

j = _makefile_get_config_mode(makefile, NULL, "javac");

jff = _makefile_get_config_mode(makefile, NULL, "jflags_force");

jf = _makefile_get_config_mode(makefile, NULL, "jflags");

if(j != NULL || jff != NULL || jf != NULL)

_makefile_output_program(makefile, "javac", 1);

if(jff != NULL)

_makefile_output_variable(makefile, "JFLAGSF", jff);

if(jf != NULL)

_makefile_output_variable(makefile, "JFLAGS", jf);

}

static void _targets_vflags(Makefile * makefile)

{

String const * v;

String const * vff;

String const * vf;

v = _makefile_get_config_mode(makefile, NULL, "verilog");

vff = _makefile_get_config_mode(makefile, NULL, "vflags_force");

vf = _makefile_get_config_mode(makefile, NULL, "vflags");

if(v != NULL || vff != NULL || vf != NULL)

_makefile_output_program(makefile, "verilog", 1);

if(vff != NULL)

_makefile_output_variable(makefile, "VFLAGSF", vff);

if(vf != NULL)

_makefile_output_variable(makefile, "VFLAGS", vf);

}

static void _binary_ldflags(Makefile * makefile, String const * ldflags)

{

char const * libs_bsd[] = { "dl", "resolv", "ossaudio", "socket",

"ws2_32", NULL };

char const * libs_darwin[] = { "crypt", "ossaudio", "socket", "ws2_32",

NULL };

char const * libs_deforaos[] = { "ossaudio", "resolv", "ssl", "ws2_32",

NULL };

char const * libs_gnu[] = { "intl", "ossaudio", "resolv", "socket",

"ws2_32", NULL };

char const * libs_netbsd[] = { "dl", "resolv", "socket", "ws2_32",

NULL };

char const * libs_sunos[] = { "dl", "ossaudio", "ws2_32", NULL };

char const * libs_win32[] = { "dl", "ossaudio", NULL };

char const * flags_darwin[] = { "-Wl,--export-dynamic",

"--export-dynamic", NULL };

char buf[16];

char const ** libs;

char const ** flags = NULL;

String * p;

String * q;

size_t i;

if((p = string_new(ldflags)) == NULL) /* XXX report error? */

{

_makefile_print(makefile, " %s%s", ldflags, "\n");

return;

}

switch(configure_get_os(makefile->configure))

{

case HO_DARWIN:

libs = libs_darwin;

flags = flags_darwin;

break;

case HO_DEFORAOS:

libs = libs_deforaos;

break;

case HO_FREEBSD:

case HO_OPENBSD:

libs = libs_bsd;

break;

case HO_GNU_LINUX:

libs = libs_gnu;

break;

case HO_NETBSD:

libs = libs_netbsd;

break;

case HO_SUNOS:

libs = libs_sunos;

break;

case HO_WIN32:

libs = libs_win32;

break;

default:

libs = libs_gnu;

break;

}

for(i = 0; libs[i] != NULL; i++)

{

snprintf(buf, sizeof(buf), "-l%s", libs[i]);

if((q = string_find(p, buf)) == NULL)

continue;

memmove(q, q + strlen(buf), strlen(q) - strlen(buf) + 1);

}

for(i = 0; flags != NULL && flags[i] != NULL; i++)

{

if((q = string_find(p, flags[i])) == NULL)

continue;

memmove(q, q + string_get_length(flags[i]),

string_get_length(q

+ string_get_length(flags[i])) + 1);

}

_makefile_print(makefile, " %s", p);

string_delete(p);

}

static void _variables_library(Makefile * makefile, char * done)

{

String const * p;

if(!done[TT_LIBRARY] && !done[TT_SCRIPT])

{

_makefile_output_path(makefile, "objdir");

_makefile_output_path(makefile, "prefix");

_makefile_output_path(makefile, "destdir");

}

_makefile_output_path(makefile, "libdir");

if(!done[TT_BINARY])

{

_targets_asflags(makefile);

_targets_cflags(makefile);

_targets_cxxflags(makefile);

_targets_ldflags(makefile);

_targets_goflags(makefile);

_targets_vflags(makefile);

_targets_exeext(makefile);

}

if(configure_can_library_static(makefile->configure))

_variables_library_static(makefile);

if((p = _makefile_get_config_mode(makefile, NULL, "ld")) == NULL)

_makefile_output_program(makefile, "ccshared", 0);

else

_makefile_output_variable(makefile, "CCSHARED", p);

_makefile_output_extension(makefile, "so");

}

static void _variables_library_static(Makefile * makefile)

{

String const * p;

if((p = _makefile_get_config_mode(makefile, NULL, "ar")) == NULL)

_makefile_output_program(makefile, "ar", 0);

else

_makefile_output_variable(makefile, "AR", p);

_makefile_output_variable(makefile, "ARFLAGS", "-rc");

if((p = _makefile_get_config_mode(makefile, NULL, "ranlib")) == NULL)

_makefile_output_program(makefile, "ranlib", 0);

else

_makefile_output_variable(makefile, "RANLIB", p);

}

static void _variables_libtool(Makefile * makefile, char * done)

{

_variables_library(makefile, done);

if(!done[TT_LIBTOOL])

_makefile_output_program(makefile, "libtool", 1);

}

static void _variables_script(Makefile * makefile, char * done)

{

if(!done[TT_BINARY] && !done[TT_LIBRARY] && !done[TT_SCRIPT])

{

_makefile_output_path(makefile, "objdir");

_makefile_output_path(makefile, "prefix");

_makefile_output_path(makefile, "destdir");

}

static int _variables_includes(Makefile * makefile)

{

String const * includes;

if((includes = _makefile_get_config_mode(makefile, NULL, "includes"))

== NULL)

return 0;

if(makefile->fp == NULL)

return 0;

_makefile_output_path(makefile, "includedir");

return 0;

}

static int _variables_subdirs(Makefile * makefile)

{

String const * sections[] = { "dist" };

size_t i;

String * p;

String const * q;

if(_makefile_get_config_mode(makefile, NULL, "subdirs") == NULL

|| _makefile_get_config_mode(makefile, NULL,

"package") != NULL

|| _makefile_get_config_mode(makefile, NULL,

"targets") != NULL

|| _makefile_get_config_mode(makefile, NULL,

"includes") != NULL)

return 0;

for(i = 0; i < sizeof(sections) / sizeof(*sections); i++)

{

if((q = _makefile_get_config_mode(makefile, NULL, sections[i]))

== NULL)

continue;

if((p = strdup(q)) == NULL)

return -1;

for(q = strtok(p, ","); q != NULL; q = strtok(NULL, ","))

if(_makefile_get_config(makefile, q, "install") != NULL)

break;

free(p);

if(q != NULL)

return 0;

}

return _makefile_output_program(makefile, "mkdir", 0);

}

static int _targets_all(Makefile * makefile);

static int _targets_subdirs(Makefile * makefile);

static int _targets_target(Makefile * makefile, String const * target);

static int _write_targets(Makefile * makefile)

{

int ret = 0;

String const * p;

String * targets;

String * q;

size_t i;

char c;

if(_targets_all(makefile) != 0

|| _targets_subdirs(makefile) != 0)

return 1;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

ret |= _targets_target(makefile, targets);

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static int _targets_all(Makefile * makefile)

{

char const * depends[] = { NULL, NULL };

size_t j = 0;

String const * subdirs;

String const * p;

String * targets;

String * q;

size_t i;

char c;

int enabled = 1;

if(_makefile_get_config(makefile, "all", "type") != NULL)

return _targets_target(makefile, "all");

if((subdirs = _makefile_get_config_mode(makefile, NULL, "subdirs"))

!= NULL)

depends[j++] = "subdirs";

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) != NULL

&& string_get_length(p) > 0)

depends[j++] = "$(TARGETS)";

if(p == NULL || string_get_length(p) == 0)

{

_makefile_target(makefile, "all", depends[0], depends[1], NULL);

return 0;

}

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_is_enabled(makefile, targets) == 0)

enabled = 0;

if(c == '\0')

break;

targets[i] = c;

targets += i + 1;

i = 0;

}

if(enabled > 0)

_makefile_target(makefile, "all", depends[0], depends[1], NULL);

else

{

_makefile_print(makefile, "\nall:%s",

(subdirs != NULL) ? " subdirs" : "");

targets = q;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_is_enabled(makefile, targets))

{

_makefile_print(makefile, " ");

_makefile_print_target(makefile, targets);

}

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

_makefile_print(makefile, "\n");

}

string_delete(q);

return 0;

}

static int _targets_subdirs(Makefile * makefile)

{

String const * subdirs;

if((subdirs = _makefile_get_config_mode(makefile, NULL, "subdirs"))

!= NULL)

{

_makefile_target(makefile, "subdirs", NULL);

_makefile_subdirs(makefile, NULL);

}

return 0;

}

static int _target_objs(Makefile * makefile, String const * target);

static int _target_binary(Makefile * makefile, String const * target);

static int _target_command(Makefile * makefile, String const * target);

static int _target_library(Makefile * makefile, String const * target);

static int _target_library_static(Makefile * makefile, String const * target);

static int _target_libtool(Makefile * makefile, String const * target);

static int _target_object(Makefile * makefile, String const * target);

static int _target_plugin(Makefile * makefile, String const * target);

static int _target_script(Makefile * makefile, String const * target);

static int _targets_target(Makefile * makefile, String const * target)

{

String const * type;

TargetType tt;

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

{

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", target,

": no type defined for target\n");

return 1;

}

tt = enum_string(TT_LAST, sTargetType, type);

switch(tt)

{

case TT_BINARY:

return _target_binary(makefile, target);

case TT_COMMAND:

return _target_command(makefile, target);

case TT_LIBRARY:

return _target_library(makefile, target);

case TT_LIBTOOL:

return _target_libtool(makefile, target);

case TT_OBJECT:

return _target_object(makefile, target);

case TT_PLUGIN:

return _target_plugin(makefile, target);

case TT_SCRIPT:

return _target_script(makefile, target);

case TT_UNKNOWN:

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

target, ": unknown type for target\n");

return 1;

}

return 0;

}

static int _objs_source(Makefile * makefile, String * source, TargetType tt);

static int _target_objs(Makefile * makefile, String const * target)

{

int ret = 0;

String const * p;

TargetType tt = TT_UNKNOWN;

String * sources;

String * q;

size_t i;

char c;

if((p = _makefile_get_config(makefile, target, "type")) != NULL)

tt = enum_string(TT_LAST, sTargetType, p);

if((p = _makefile_get_config(makefile, target, "sources")) == NULL)

/* a binary target may have no sources */

return 0;

if((sources = string_new(p)) == NULL)

return 1;

q = sources;

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS =");

for(i = 0; ret == 0; i++)

{

if(sources[i] != ',' && sources[i] != '\0')

continue;

c = sources[i];

sources[i] = '\0';

ret = _objs_source(makefile, sources, tt);

if(c == '\0')

break;

sources += i + 1;

i = 0;

}

_makefile_print(makefile, "\n");

string_delete(q);

return ret;

}

static int _objs_source(Makefile * makefile, String * source, TargetType tt)

{

int ret = 0;

String const * extension;

size_t len;

if((extension = source_extension(source)) == NULL)

{

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", source,

": no extension for source\n");

return 1;

}

len = string_get_length(source) - string_get_length(extension) - 1;

source[len] = '\0';

switch(source_type(extension))

{

case OT_ASM_SOURCE:

case OT_ASMPP_SOURCE:

case OT_C_SOURCE:

case OT_CXX_SOURCE:

case OT_OBJC_SOURCE:

case OT_OBJCXX_SOURCE:

_makefile_print(makefile, "%s", " $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s",

(tt == TT_LIBTOOL) ? ".lo" : ".o");

break;

case OT_GOLANG_SOURCE:

break;

case OT_JAVA_SOURCE:

_makefile_print(makefile, "%s", " $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s", ".class");

break;

case OT_VERILOG_SOURCE:

_makefile_print(makefile, "%s", " $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s", ".o");

break;

case OT_UNKNOWN:

ret = 1;

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

source,

": Unknown extension for source\n");

break;

default:

ret = 2;

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

source,

": Unsupported extension for source\n");

break;

}

source[len] = '.';

return ret;

}

static int _target_binary_cc(Makefile * makefile, String const * target);

static int _target_binary_golang(Makefile * makefile, String const * target);

static int _target_flags(Makefile * makefile, String const * target);

static int _target_binary(Makefile * makefile, String const * target)

{

String const * p;

if(_target_objs(makefile, target) != 0)

return 1;

if(_target_flags(makefile, target) != 0)

return 1;

_makefile_print(makefile, "\n");

if((p = _makefile_get_config(makefile, target, "sources")) != NULL

/* XXX only checks the last source */

&& (p = source_extension(p)) != NULL

&& source_type(p) == OT_GOLANG_SOURCE)

return _target_binary_golang(makefile, target);

else

return _target_binary_cc(makefile, target);

}

static int _target_binary_cc(Makefile * makefile, String const * target)

{

String const * p;

/* output the binary target */

_makefile_print(makefile, "%s", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT): $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

_makefile_print(makefile, "\n");

/* build the binary */

_makefile_print(makefile, "%s", "\t$(CC) -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS)\n");

return 0;

}

static int _target_binary_golang(Makefile * makefile, String const * target)

{

String const * sources;

String const * p;

/* output the binary target */

_makefile_print(makefile, "%s", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT):");

if((sources = _makefile_get_config(makefile, target, "sources")) != NULL

&& _makefile_expand(makefile, sources) != 0)

return error_print(PROGNAME_CONFIGURE);

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

_makefile_print(makefile, "%s", "\n");

/* build the binary */

_makefile_print(makefile, "%s", "\t$(GO) build $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_GOFLAGS) -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT)");

if(sources != NULL)

_makefile_expand(makefile, sources);

_makefile_print(makefile, "%s", "\n");

return 0;

}

static void _flags_asm(Makefile * makefile, String const * target);

static void _flags_asmpp(Makefile * makefile, String const * target);

static void _flags_c(Makefile * makefile, String const * target);

static void _flags_cxx(Makefile * makefile, String const * target);

static void _flags_golang(Makefile * makefile, String const * target);

static void _flags_java(Makefile * makefile, String const * target);

static void _flags_verilog(Makefile * makefile, String const * target);

static int _target_flags(Makefile * makefile, String const * target)

{

char done[OT_COUNT];

String const * p;

String * sources;

String * q;

String const * extension;

ObjectType type;

char c;

size_t i;

memset(&done, 0, sizeof(done));

if((p = _makefile_get_config(makefile, target, "sources")) == NULL

|| string_get_length(p) == 0)

{

if((p = _makefile_get_config(makefile, target, "type")) != NULL

&& string_compare(p, "binary") == 0)

_flags_c(makefile, target);

return 0;

}

if((sources = string_new(p)) == NULL)

return 1;

q = sources;

for(i = 0;; i++)

{

if(sources[i] != ',' && sources[i] != '\0')

continue;

c = sources[i];

sources[i] = '\0';

extension = source_extension(sources);

if(extension == NULL)

{

sources[i] = c;

continue;

}

type = source_type(extension);

if(!done[type])

{

if(type != OT_UNKNOWN)

done[type] = 1;

switch(type)

{

case OT_ASMPP_SOURCE:

_flags_asmpp(makefile, target);

if(done[OT_ASM_SOURCE])

break;

/* fallthrough */

case OT_ASM_SOURCE:

_flags_asm(makefile, target);

break;

case OT_JAVA_SOURCE:

_flags_java(makefile, target);

break;

case OT_OBJC_SOURCE:

done[OT_C_SOURCE] = 1;

/* fallthrough */

case OT_C_SOURCE:

_flags_c(makefile, target);

break;

case OT_OBJCXX_SOURCE:

done[OT_CXX_SOURCE] = 1;

/* fallthrough */

case OT_CXX_SOURCE:

_flags_cxx(makefile, target);

break;

case OT_GOLANG_SOURCE:

_flags_golang(makefile, target);

break;

case OT_VERILOG_SOURCE:

done[OT_VERILOG_SOURCE] = 1;

_flags_verilog(makefile, target);

break;

case OT_UNKNOWN:

break;

}

if(c == '\0')

break;

sources += i + 1;

i = 0;

}

string_delete(q);

return 0;

}

static void _flags_asm(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print(makefile, "%s%s", target, "_ASFLAGS = $(ASFLAGSF)"

" $(ASFLAGS)");

if((p = _makefile_get_config(makefile, target, "asflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS = $(LDFLAGSF) $(LDFLAGS)");

if((p = _makefile_get_config(makefile, target, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

_makefile_print(makefile, "\n");

}

static void _flags_asmpp(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print(makefile, "%s%s", target, "_CPPFLAGS = $(CPPFLAGSF)"

" $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target, "cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

}

static void _flags_c(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_CFLAGS = $(CPPFLAGSF) $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target, "cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "%s", " $(CFLAGSF) $(CFLAGS)");

if((p = _makefile_get_config(makefile, target, "cflags")) != NULL)

{

_makefile_print(makefile, " %s", p);

if(configure_get_os(makefile->configure) == HO_GNU_LINUX

&& string_find(p, "-ansi"))

_makefile_print(makefile, "%s", " -D _GNU_SOURCE");

}

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS = $(LDFLAGSF) $(LDFLAGS)");

if((p = _makefile_get_config(makefile, target, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

_makefile_print(makefile, "\n");

}

static void _flags_cxx(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_CXXFLAGS = $(CPPFLAGSF) $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target, "cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "%s", " $(CXXFLAGSF) $(CXXFLAGS)");

if((p = _makefile_get_config(makefile, target, "cxxflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS = $(LDFLAGSF) $(LDFLAGS)");

if((p = _makefile_get_config(makefile, target, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

_makefile_print(makefile, "\n");

}

static void _flags_golang(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_GOFLAGS = $(GOFLAGSF) $(GOFLAGS)");

if((p = _makefile_get_config(makefile, target, "goflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

}

static void _flags_java(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_JFLAGS = $(JFLAGSF) $(JFLAGS)");

if((p = _makefile_get_config(makefile, target, "jflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

}

static void _flags_verilog(Makefile * makefile, String const * target)

{

String const * p;

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s",

"_VFLAGS = $(VFLAGSF) $(VFLAGS)");

if((p = _makefile_get_config(makefile, target, "vflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

}

static void _command_security(Makefile * makefile, String const * target,

String const * command);

static int _target_command(Makefile * makefile, String const * target)

{

String const * p;

int phony;

phony = _makefile_is_phony(makefile, target);

_makefile_print(makefile, "\n%s", phony ? "" : "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ":");

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

if((p = _makefile_get_config(makefile, target, "command")) == NULL)

return error_print(PROGNAME_CONFIGURE);

if(_makefile_is_flag_set(makefile, PREFS_S))

_command_security(makefile, target, p);

_makefile_print(makefile, "\n\t%s\n", p);

return 0;

}

static void _command_security(Makefile * makefile, String const * target,

String const * command)

{

(void) makefile;

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s%s%s", target,

"Command \"", command,

"\" is executed while compiling");

}

static int _target_library(Makefile * makefile, String const * target)

{

String const * p;

String * q;

String * soname;

HostOS os;

if(_target_objs(makefile, target) != 0)

return 1;

if(_target_flags(makefile, target) != 0)

return 1;

if(configure_can_library_static(makefile->configure)

/* generate a static library */

&& _target_library_static(makefile, target) != 0)

return 1;

os = configure_get_os(makefile->configure);

if((p = _makefile_get_config(makefile, target, "soname")) != NULL)

soname = string_new(p);

else if(os == HO_DARWIN)

/* versioning is different on Darwin/macOS */

soname = string_new_append(target, ".0.0$(SOEXT)", NULL);

else if(os == HO_WIN32)

/* and on Windows */

soname = string_new_append(target, "$(SOEXT)", NULL);

else

soname = string_new_append(target, "$(SOEXT)", ".0", NULL);

if(soname == NULL)

return 1;

if(os == HO_DARWIN || os == HO_WIN32)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, soname);

}

else

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0");

}

_makefile_print(makefile, ": $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

_makefile_print(makefile, "\n");

/* build the shared library */

_makefile_print(makefile, "%s", "\t$(CCSHARED) -o $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", (os != HO_DARWIN && os != HO_WIN32)

? ".0" : "");

if((p = _makefile_get_config(makefile, target, "install")) != NULL)

{

/* soname is not available on Darwin/macOS */

if(os == HO_DARWIN)

{

_makefile_print(makefile, "%s", " -install_name ");

_makefile_print_escape(makefile, p);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".0$(SOEXT)");

}

else if(os != HO_WIN32)

{

_makefile_print(makefile, "%s", " -Wl,-soname,");

_makefile_print_escape(makefile, soname);

}

_makefile_print(makefile, "%s", " $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS)");

if((q = string_new_append(target, "$(SOEXT)", NULL)) == NULL)

{

string_delete(soname);

return 1;

}

if((p = _makefile_get_config(makefile, q, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

string_delete(q);

_makefile_print(makefile, "\n");

if(os == HO_DARWIN)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".0$(SOEXT): $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, " $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".0$(SOEXT)\n");

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT): $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", " $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)\n");

}

else if(os != HO_WIN32)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ": $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0 $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", "\n\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT): $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0 $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)\n");

}

string_delete(soname);

return 0;

}

static int _target_library_static(Makefile * makefile, String const * target)

{

String const * p;

String * q;

size_t len;

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".a: $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

_makefile_print(makefile, "\n");

/* build the static library */

_makefile_print(makefile, "%s", "\t$(AR) $(ARFLAGS) $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".a $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

len = strlen(target) + 3;

if((q = malloc(len)) == NULL)

return 1;

snprintf(q, len, "%s.a", target);

if((p = _makefile_get_config(makefile, q, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

free(q);

_makefile_print(makefile, "%s", "\n\t$(RANLIB) $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".a\n");

return 0;

}

static int _target_libtool(Makefile * makefile, String const * target)

{

String const * p;

if(_target_objs(makefile, target) != 0)

return 1;

if(_target_flags(makefile, target) != 0)

return 1;

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".la: $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)\n");

_makefile_print(makefile, "%s",

"\t$(LIBTOOL) --mode=link --tag=CC $(CC) -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".la $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

if((p = _makefile_get_config(makefile, target, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

_makefile_print(makefile, "%s", " -rpath $(LIBDIR) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS)\n");

return 0;

}

static int _target_object(Makefile * makefile, String const * target)

{

String const * p;

String const * extension;

if((p = _makefile_get_config(makefile, target, "sources")) == NULL)

{

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", target,

": No sources for target\n");

return 1;

}

if(strchr(p, ',') != NULL)

{

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", target,

": An object can have only one source file\n");

return 1;

}

if((extension = source_extension(p)) == NULL)

return 1;

switch(source_type(extension))

{

case OT_ASM_SOURCE:

_makefile_print(makefile, "\n%s%s",

target, "_OBJS = $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n%s%s", target, "_ASFLAGS ="

" $(ASFLAGSF) $(ASFLAGS)");

if((p = _makefile_get_config(makefile, target,

"asflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_ASMPP_SOURCE:

_makefile_print(makefile, "\n%s%s", target,

"_OBJS = $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n%s%s", target,

"_CPPFLAGS = $(CPPFLAGSF) $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target,

"cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n%s%s", target,

"_ASFLAGS = $(ASFLAGSF) $(ASFLAGS)");

if((p = _makefile_get_config(makefile, target,

"asflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_C_SOURCE:

case OT_OBJC_SOURCE:

_makefile_print(makefile, "\n%s%s%s", target,

"_OBJS = ", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n%s%s", target, "_CFLAGS ="

" $(CPPFLAGSF) $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target,

"cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "%s", " $(CFLAGSF)"

" $(CFLAGS)");

if((p = _makefile_get_config(makefile, target,

"cflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_CXX_SOURCE:

case OT_OBJCXX_SOURCE:

_makefile_print(makefile, "\n%s%s%s", target,

"_OBJS = ", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n%s%s", target,

"_CXXFLAGS = $(CPPFLAGSF) $(CPPFLAGS)");

if((p = _makefile_get_config(makefile, target,

"cppflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "%s", " $(CXXFLAGSF)"

" $(CXXFLAGS)");

if((p = _makefile_get_config(makefile, target,

"cxxflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_GOLANG_SOURCE:

_makefile_print(makefile, "\n%s%s", target, "_GOFLAGS ="

" $(GOFLAGSF) $(GOFLAGS)");

if((p = _makefile_get_config(makefile, target,

"goflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_JAVA_SOURCE:

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS = $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s",

"_JFLAGS = $(JFLAGSF) $(JFLAGS)");

if((p = _makefile_get_config(makefile, target,

"jflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_VERILOG_SOURCE:

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS = $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s",

"_VFLAGS = $(VFLAGSF) $(VFLAGS)");

if((p = _makefile_get_config(makefile, target,

"vflags")) != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "\n");

break;

case OT_UNKNOWN:

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

target,

": Unknown source type for object\n");

return 1;

}

return 0;

}

static int _target_plugin(Makefile * makefile, String const * target)

{

String const * p;

String * q;

if(_target_objs(makefile, target) != 0)

return 1;

if(_target_flags(makefile, target) != 0)

return 1;

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT): $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS)");

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

_makefile_print(makefile, "\n");

/* build the plug-in */

_makefile_print(makefile, "%s", "\t$(CCSHARED) -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_OBJS) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_LDFLAGS)");

if((q = string_new_append(target, "$(SOEXT)", NULL)) == NULL)

return error_print(PROGNAME_CONFIGURE);

if((p = _makefile_get_config(makefile, q, "ldflags")) != NULL)

_binary_ldflags(makefile, p);

string_delete(q);

_makefile_print(makefile, "\n");

return 0;

}

static int _objects_target(Makefile * makefile,

String const * target);

static int _write_objects(Makefile * makefile)

{

String const * p;

String * targets;

String * q;

char c;

size_t i;

int ret = 0;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

ret += _objects_target(makefile, targets);

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static void _script_check(Makefile * makefile, String const * target,

String const * script);

static int _script_depends(Makefile * makefile, String const * target);

static String * _script_path(Makefile * makefile, String const * script);

static void _script_security(Makefile * makefile, String const * target,

String const * script);

static int _target_script(Makefile * makefile,

String const * target)

{

String const * prefix;

String const * script;

String const * flags;

int phony;

if((script = _makefile_get_config(makefile, target, "script")) == NULL)

{

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ", target,

": No script for target\n");

return 1;

}

flags = _makefile_get_config(makefile, target, "flags");

if(makefile->fp == NULL)

_script_check(makefile, target, script);

if(_makefile_is_flag_set(makefile, PREFS_S))

_script_security(makefile, target, script);

phony = _makefile_is_phony(makefile, target);

_makefile_print(makefile, "\n%s", phony ? "" : "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ":");

_script_depends(makefile, target);

if((prefix = _makefile_get_config(makefile, target, "prefix")) == NULL)

prefix = "$(PREFIX)";

_makefile_print(makefile, "\n\t");

_makefile_print_escape(makefile, script);

_makefile_print(makefile, " -P \"%s\"", prefix);

if(flags != NULL && flags[0] != '\0')

_makefile_print(makefile, " %s", flags);

_makefile_print(makefile, " -- \"%s%s\"\n", phony ? "" : "$(OBJDIR)",

target);

return 0;

}

static void _script_check(Makefile * makefile, String const * target,

String const * script)

{

String * path;

if((path = _script_path(makefile, script)) == NULL)

{

error_print(PROGNAME_CONFIGURE);

return;

}

/* XXX make it clear these are warnings */

if(access(path, R_OK) != 0)

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s%s%s%s%s", target,

"The \"", path, "\" script is not readable (",

strerror(errno), ")");

else if(access(path, R_OK | X_OK) != 0)

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s%s%s%s%s", target,

"The \"", path, "\" script is not executable (",

strerror(errno), ")");

string_delete(path);

}

static int _script_depends(Makefile * makefile, String const * target)

{

String const * p;

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

return 0;

}

static String * _script_path(Makefile * makefile, String const * script)

{

String * ret;

String const * directory;

ssize_t i;

String * p = NULL;

if((directory = _makefile_get_config(makefile, NULL, "_directory"))

== NULL)

{

error_print(PROGNAME_CONFIGURE);

return NULL;

}

/* XXX truncate scripts at the first space (to allow arguments) */

if((i = string_index(script, " ")) > 0)

{

if((p = string_new_length(script, i)) == NULL)

{

error_print(PROGNAME_CONFIGURE);

return NULL;

}

script = p;

}

if(script[0] == '/')

ret = string_new(script);

else if(string_compare_length(script, "./", 2) == 0)

ret = string_new_append(directory, &script[1], NULL);

else

ret = string_new_append(directory, "/", script, NULL);

string_delete(p);

return ret;

}

static void _script_security(Makefile * makefile, String const * target,

String const * script)

{

String * path;

if((path = _script_path(makefile, script)) == NULL)

{

error_print(PROGNAME_CONFIGURE);

return;

}

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s%s%s", target, "The \"",

path, "\" script is executed while compiling");

string_delete(path);

}

static int _target_source(Makefile * makefile, String const * target,

String * source);

static int _objects_target(Makefile * makefile,

String const * target)

{

int ret = 0;

String const * p;

String * sources;

String * q;

size_t i;

char c;

if((p = _makefile_get_config(makefile, target, "sources")) == NULL)

return 0;

if((sources = string_new(p)) == NULL)

return 1;

q = sources;

for(i = 0;; i++)

{

if(sources[i] != ',' && sources[i] != '\0')

continue;

c = sources[i];

sources[i] = '\0';

ret |= _target_source(makefile, target, sources);

if(c == '\0')

break;

sources += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static int _source_depends(Makefile * makefile,

String const * source);

static int _source_subdir(Makefile * makefile, String * source);

static int _target_source(Makefile * makefile, String const * target,

String * source)

/* FIXME check calls to _source_depends() */

{

int ret = 0;

String const * extension;

TargetType tt = TT_UNKNOWN;

ObjectType ot;

size_t len;

String const * p;

String const * q;

if((p = _makefile_get_config(makefile, target, "type")) != NULL)

tt = enum_string(TT_LAST, sTargetType, p);

if((extension = source_extension(source)) == NULL)

return 1;

len = string_get_length(source) - string_get_length(extension) - 1;

source[len] = '\0';

switch((ot = source_type(extension)))

{

case OT_ASM_SOURCE:

case OT_ASMPP_SOURCE:

if(tt == TT_OBJECT)

_makefile_print(makefile, "%s%s", "\n$(OBJDIR)",

target);

else

_makefile_print(makefile, "%s%s%s",

"\n$(OBJDIR)", source, ".o");

if(tt == TT_LIBTOOL)

_makefile_print(makefile, " $(OBJDIR)%s.lo",

source);

_makefile_print(makefile, "%s%s%s%s", ": ", source, ".",

extension);

source[len] = '.'; /* FIXME ugly */

_source_depends(makefile, source);

source[len] = '\0';

_makefile_print(makefile, "%s", "\n\t");

if(strchr(source, '/') != NULL)

ret = _source_subdir(makefile, source);

if(tt == TT_LIBTOOL)

_makefile_print(makefile, "%s", "$(LIBTOOL)"

" --mode=compile --tag=CC ");

_makefile_print(makefile, "%s", "$(AS)");

source[len] = '.'; /* FIXME ugly */

if(ot == OT_ASMPP_SOURCE)

{

_makefile_print(makefile, "%s", " $(");

_makefile_print_escape_variable(makefile,

target);

_makefile_print(makefile, "%s", "_CPPFLAGS)");

if((p = _makefile_get_config(makefile, source,

"cppflags"))

!= NULL)

_makefile_print(makefile, " %s", p);

}

_makefile_print(makefile, "%s", " $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_ASFLAGS)");

if((p = _makefile_get_config(makefile, source,

"asflags")) != NULL)

_makefile_print(makefile, " %s", p);

source[len] = '\0'; /* FIXME ugly */

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s", " -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, " ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s\n", extension);

}

else

{

_makefile_print(makefile, "%s", " -o $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s\n", extension);

}

break;

case OT_C_SOURCE:

case OT_OBJC_SOURCE:

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o");

}

if(tt == TT_LIBTOOL)

{

_makefile_print(makefile, " $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s", ".lo");

}

_makefile_print(makefile, ": ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s", extension);

source[len] = '.'; /* FIXME ugly */

_source_depends(makefile, source);

_makefile_print(makefile, "%s", "\n\t");

if(strchr(source, '/') != NULL)

ret = _source_subdir(makefile, source);

/* FIXME do both wherever also relevant */

p = _makefile_get_config(makefile, source, "cppflags");

q = _makefile_get_config(makefile, source, "cflags");

source[len] = '\0';

if(tt == TT_LIBTOOL)

_makefile_print(makefile, "%s", "$(LIBTOOL)"

" --mode=compile --tag=CC ");

_makefile_print(makefile, "%s", "$(CC)");

if(p != NULL)

_makefile_print(makefile, " %s", p);

_makefile_print(makefile, "%s", " $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_CFLAGS)");

if(q != NULL)

{

_makefile_print(makefile, " %s", q);

if(configure_get_os(makefile->configure)

== HO_GNU_LINUX

&& string_find(q, "-ansi"))

_makefile_print(makefile, "%s",

" -D _GNU_SOURCE");

}

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s",

" -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s",

" -o $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o");

}

_makefile_print(makefile, "%s", " -c ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s\n", extension);

break;

case OT_CXX_SOURCE:

case OT_OBJCXX_SOURCE:

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s", ".o");

}

_makefile_print(makefile, "%s%s%s%s", ": ", source, ".",

extension);

source[len] = '.'; /* FIXME ugly */

_source_depends(makefile, source);

p = _makefile_get_config(makefile, source, "cxxflags");

source[len] = '\0';

_makefile_print(makefile, "\n\t");

if(strchr(source, '/') != NULL)

ret = _source_subdir(makefile, source);

if(tt == TT_LIBTOOL)

_makefile_print(makefile, "%s", "$(LIBTOOL)"

" --mode=compile --tag=CXX ");

_makefile_print(makefile, "%s", "$(CXX) $(");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "_CXXFLAGS)");

if(p != NULL)

_makefile_print(makefile, " %s", p);

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s", " -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s", " -o $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o");

}

_makefile_print(makefile, "%s", " -c ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s\n", extension);

break;

case OT_GOLANG_SOURCE:

break;

case OT_JAVA_SOURCE:

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ": ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s", extension);

source[len] = '.'; /* FIXME ugly */

_source_depends(makefile, source);

_makefile_print(makefile, "\n\t");

if(strchr(source, '/') != NULL)

ret = _source_subdir(makefile, source);

q = _makefile_get_config(makefile, source, "jflags");

source[len] = '\0';

_makefile_print(makefile, "%s", "$(JAVAC) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_JFLAGS)");

if(q != NULL)

_makefile_print(makefile, " %s", q);

_makefile_print(makefile, " ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s\n", extension);

break;

case OT_VERILOG_SOURCE:

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s", "\n$(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o");

}

_makefile_print(makefile, ": ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".%s", extension);

source[len] = '.'; /* FIXME ugly */

_source_depends(makefile, source);

_makefile_print(makefile, "\n\t");

if(strchr(source, '/') != NULL)

ret = _source_subdir(makefile, source);

q = _makefile_get_config(makefile, source, "vflags");

source[len] = '\0';

_makefile_print(makefile, "%s", "$(VERILOG) $(");

_makefile_print_escape_variable(makefile, target);

_makefile_print(makefile, "%s", "_VFLAGS)");

if(q != NULL)

_makefile_print(makefile, " %s", q);

if(tt == TT_OBJECT)

{

_makefile_print(makefile, "%s",

" -o $(OBJDIR)");

_makefile_print_escape(makefile, target);

}

else

{

_makefile_print(makefile, "%s",

" -o $(OBJDIR)");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, ".o");

}

_makefile_print(makefile, " ");

_makefile_print_escape(makefile, source);

_makefile_print(makefile, "%s%s\n", ".", extension);

break;

case OT_UNKNOWN:

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

target,

": Unknown source type for object\n");

ret = 1;

break;

default:

fprintf(stderr, "%s%s%s", PROGNAME_CONFIGURE ": ",

target,

": Unsupported source type for"

" object\n");

ret = 1;

break;

}

source[len] = '.';

return ret;

}

static int _source_depends(Makefile * makefile,

String const * target)

{

String const * p;

if((p = _makefile_get_config(makefile, target, "depends")) != NULL

&& _makefile_expand(makefile, p) != 0)

return error_print(PROGNAME_CONFIGURE);

return 0;

}

static int _source_subdir(Makefile * makefile, String * source)

{

char * p;

char const * q;

if((p = strdup(source)) == NULL)

return 1;

q = dirname(p);

_makefile_print(makefile,

"@[ -d \"%s%s\" ] || $(MKDIR) -- \"%s%s\"\n\t",

"$(OBJDIR)", q, "$(OBJDIR)", q);

free(p);

return 0;

}

static int _clean_targets(Makefile * makefile);

static int _write_clean(Makefile * makefile)

{

_makefile_target(makefile, "clean", NULL);

if(_makefile_get_config_mode(makefile, NULL, "subdirs") != NULL)

_makefile_subdirs(makefile, "clean");

return _clean_targets(makefile);

}

static int _clean_targets(Makefile * makefile)

{

String const * prefix;

String const * flags;

String const * p;

String * targets;

String * q;

size_t cnt;

size_t i;

char c;

int phony;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

/* remove all of the object files */

for(i = 0, cnt = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_get_type(makefile, targets) != TT_COMMAND

&& _makefile_get_type(makefile, targets)

!= TT_SCRIPT)

{

if(cnt++ == 0)

_makefile_print(makefile, "%s", "\t$(RM) --");

_makefile_print(makefile, "%s", " $(");

_makefile_print_escape_variable(makefile, targets);

_makefile_print(makefile, "%s", "_OBJS)");

}

if(c == '\0')

break;

targets[i] = c;

targets += i + 1;

i = 0;

}

if(cnt > 0)

_makefile_print(makefile, "\n");

targets = q;

/* let each scripted target remove the relevant object files */

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if((p = _makefile_get_config(makefile, targets, "type")) != NULL

&& strcmp(p, "script") == 0

&& (p = _makefile_get_config(makefile, targets,

"script")) != NULL)

{

if((prefix = _makefile_get_config(makefile, targets,

"prefix")) == NULL)

prefix = "$(PREFIX)";

flags = _makefile_get_config(makefile, targets,

"flags");

phony = _makefile_is_phony(makefile, targets);

_makefile_print(makefile, "\t");

_makefile_print_escape(makefile, p);

_makefile_print(makefile, "%s%s%s", " -c -P \"", prefix,

"\"");

if(flags != NULL && flags[0] != '\0')

_makefile_print(makefile, " %s", flags);

_makefile_print(makefile, "%s%s%s%s", " -- \"",

phony ? "" : "$(OBJDIR)",

targets, "\"\n");

}

if(c == '\0')

break;

targets[i] = c;

targets += i + 1;

i = 0;

}

string_delete(q);

return 0;

}

static int _write_distclean(Makefile * makefile)

{

String const * subdirs;

String const * p;

String * targets;

String * q;

size_t cnt;

size_t i;

char c;

int phony = 0;

/* only depend on the "clean" target if we do not have subfolders */

if((subdirs = _makefile_get_config_mode(makefile, NULL, "subdirs"))

== NULL)

_makefile_target(makefile, "distclean", "clean", NULL);

else

{

_makefile_target(makefile, "distclean", NULL);

_makefile_subdirs(makefile, "distclean");

_clean_targets(makefile);

}

/* XXX do not erase phony targets */

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0, cnt = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_is_phony(makefile, targets))

phony = 1;

else

cnt++;

if(c == '\0')

break;

targets[i] = c;

targets += i + 1;

i = 0;

}

/* FIXME do not erase targets that need be distributed */

if(!phony)

_makefile_remove(makefile, 0, "$(TARGETS)", NULL);

else if(cnt > 0)

{

targets = q;

for(i = 0, cnt = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(!_makefile_is_phony(makefile, targets))

{

if(cnt++ == 0)

_makefile_print(makefile, "\t$(RM) --");

_makefile_print(makefile, "%s", " $(OBJDIR)");

_makefile_print_escape(makefile, targets);

}

if(c == '\0')

break;

targets[i] = c;

targets += i + 1;

i = 0;

}

_makefile_print(makefile, "\n");

}

string_delete(q);

return 0;

}

static int _dist_subdir(Makefile * makefile, Config * subdir);

static int _write_dist(Makefile * makefile, configArray * ca, int from, int to)

{

String const * package;

String const * version;

Config * p;

int i;

package = _makefile_get_config_mode(makefile, NULL, "package");

version = _makefile_get_config_mode(makefile, NULL, "version");

if(package == NULL || version == NULL)

return 0;

_makefile_target(makefile, "dist", NULL);

_makefile_remove(makefile, 1, "$(OBJDIR)$(PACKAGE)-$(VERSION)", NULL);

_makefile_link(makefile, 1, "\"$$PWD\"",

"$(OBJDIR)$(PACKAGE)-$(VERSION)");

_makefile_print(makefile, "%s", "\t@cd $(OBJDIR). && $(TAR) -czvf"

" $(PACKAGE)-$(VERSION)$(TGZEXT) -- \\\n");

for(i = from + 1; i < to; i++)

{

array_get_copy(ca, i, &p);

_dist_subdir(makefile, p);

}

if(from < to)

{

array_get_copy(ca, from, &p);

_dist_subdir(makefile, p);

}

else

return 1;

_makefile_remove(makefile, 0, "$(OBJDIR)$(PACKAGE)-$(VERSION)", NULL);

return 0;

}

static int _write_distcheck(Makefile * makefile)

{

String const * package;

String const * version;

const char pretarget[] = "\ndistcheck: dist\n"

"\t$(TAR) -xzvf $(OBJDIR)$(PACKAGE)-$(VERSION)$(TGZEXT)\n"

"\t$(MKDIR) -- $(PACKAGE)-$(VERSION)/objdir\n"

"\t$(MKDIR) -- $(PACKAGE)-$(VERSION)/destdir\n";

const char target[] = "\tcd \"$(PACKAGE)-$(VERSION)\" && $(MAKE) OBJDIR=\"$$PWD/objdir/\"\n"

"\tcd \"$(PACKAGE)-$(VERSION)\" && $(MAKE) OBJDIR=\"$$PWD/objdir/\" DESTDIR=\"$$PWD/destdir\" install\n"

"\tcd \"$(PACKAGE)-$(VERSION)\" && $(MAKE) OBJDIR=\"$$PWD/objdir/\" DESTDIR=\"$$PWD/destdir\" uninstall\n"

"\tcd \"$(PACKAGE)-$(VERSION)\" && $(MAKE) OBJDIR=\"$$PWD/objdir/\" distclean\n"

"\tcd \"$(PACKAGE)-$(VERSION)\" && $(MAKE) dist\n";

const char posttarget[] = "\t$(RM) -r -- $(PACKAGE)-$(VERSION)\n";

package = _makefile_get_config_mode(makefile, NULL, "package");

version = _makefile_get_config_mode(makefile, NULL, "version");

if(package == NULL || version == NULL)

return 0;

_makefile_print(makefile, "%s%s%s", pretarget, target, posttarget);

return 0;

}

static int _dist_subdir_dist(Makefile * makefile, String const * path,

String const * dist);

static int _dist_subdir(Makefile * makefile, Config * subdir)

{

String const * path;

size_t len;

String const * p;

String * targets;

String * q;

String const * includes;

String const * dist;

size_t i;

char c;

String const * quote;

path = _makefile_get_config(makefile, NULL, "_directory");

len = (path != NULL) ? string_get_length(path) : 0;

if((path = config_get(subdir, NULL, "_directory")) == NULL)

path = "";

path = &path[len];

if(path[0] == '/')

path++;

if((p = config_get(subdir, NULL, "targets")) != NULL)

{

/* FIXME unique SOURCES */

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0;; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if((dist = config_get(subdir, targets, "sources"))

!= NULL)

_dist_subdir_dist(makefile, path, dist);

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

}

if((includes = config_get(subdir, NULL, "includes")) != NULL)

_dist_subdir_dist(makefile, path, includes);

if((dist = config_get(subdir, NULL, "dist")) != NULL)

_dist_subdir_dist(makefile, path, dist);

quote = (strchr(path, ' ') != NULL) ? "\"" : "";

_makefile_print(makefile, "%s%s%s%s%s%s%s%s", "\t\t", quote,

"$(PACKAGE)-$(VERSION)/", path,

(path[0] == '\0') ? "" : "/", PROJECT_CONF, quote,

(path[0] == '\0') ? "\n" : " \\\n");

return 0;

}

static int _dist_subdir_dist(Makefile * makefile, String const * path,

String const * dist)

{

String * d;

String * p;

size_t i;

char c;

String const * quote;

if((d = string_new(dist)) == NULL)

return 1;

p = d;

for(i = 0;; i++)

{

if(d[i] != ',' && d[i] != '\0')

continue;

c = d[i];

d[i] = '\0';

quote = (strchr(path, ' ') != NULL || strchr(d, ' ') != NULL)

? "\"" : "";

_makefile_print(makefile, "%s%s%s%s%s%s%s%s", "\t\t", quote,

"$(PACKAGE)-$(VERSION)/",

(path[0] == '\0') ? "" : path,

(path[0] == '\0') ? "" : "/",

d, quote, " \\\n");

if(c == '\0')

break;

d[i] = c;

d += i + 1;

i = 0;

}

string_delete(p);

return 0;

}

static int _install_targets(Makefile * makefile);

static int _install_includes(Makefile * makefile);

static int _install_dist(Makefile * makefile);

static int _write_install(Makefile * makefile)

{

int ret = 0;

_makefile_target(makefile, "install", "all", NULL);

if(_makefile_get_config_mode(makefile, NULL, "subdirs") != NULL)

_makefile_subdirs(makefile, "install");

ret |= _install_targets(makefile);

ret |= _install_includes(makefile);

ret |= _install_dist(makefile);

return ret;

}

static int _install_target(Makefile * makefile, String const * target);

static int _install_targets(Makefile * makefile)

{

int ret = 0;

String const * p;

String * q;

String * targets;

size_t i;

char c;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0; ret == 0; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_is_enabled(makefile, targets) != 0)

ret |= _install_target(makefile, targets);

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static void _install_target_binary(Makefile * makefile, String const * target);

static void _install_target_command(Makefile * makefile, String const * target);

static int _install_target_library(Makefile * makefile, String const * target);

static void _install_target_libtool(Makefile * makefile, String const * target);

static void _install_target_object(Makefile * makefile, String const * target);

static void _install_target_plugin(Makefile * makefile, String const * target);

static void _install_target_script(Makefile * makefile, String const * target);

static int _install_target(Makefile * makefile, String const * target)

{

int ret = 0;

String const * type;

TargetType tt;

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

return 1;

switch((tt = enum_string(TT_LAST, sTargetType, type)))

{

case TT_BINARY:

_install_target_binary(makefile, target);

break;

case TT_COMMAND:

_install_target_command(makefile, target);

break;

case TT_LIBRARY:

ret = _install_target_library(makefile, target);

break;

case TT_LIBTOOL:

_install_target_libtool(makefile, target);

break;

case TT_OBJECT:

_install_target_object(makefile, target);

break;

case TT_PLUGIN:

_install_target_plugin(makefile, target);

break;

case TT_SCRIPT:

_install_target_script(makefile, target);

break;

case TT_UNKNOWN:

break;

}

return ret;

}

static void _install_target_command(Makefile * makefile, String const * target)

{

String const * path;

String const * mode;

mode_t m = 0644;

String * p;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

if(_makefile_is_phony(makefile, target))

return;

if((mode = _makefile_get_config(makefile, target, "mode")) == NULL

/* XXX these tests are not sufficient */

|| mode[0] == '\0'

|| (m = strtol(mode, &p, 8)) == 0

|| *p != '\0')

mode = "0644";

_makefile_mkdir(makefile, path);

_makefile_print(makefile, "%s%s%s", "\t$(INSTALL) -m ", mode,

" $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s%s", " $(DESTDIR)", path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n");

}

static void _install_target_binary(Makefile * makefile, String const * target)

{

String const * path;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

_makefile_mkdir(makefile, path);

_makefile_print(makefile, "%s", "\t$(INSTALL) -m 0755 $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT) $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s\n", "$(EXEEXT)");

}

static int _install_target_library(Makefile * makefile, String const * target)

{

String const * path;

String const * p;

String * soname;

HostOS os;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return 0;

_makefile_mkdir(makefile, path);

if(configure_can_library_static(makefile->configure))

{

/* install the static library */

_makefile_print(makefile, "%s",

"\t$(INSTALL) -m 0644 $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".a $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".a\n");

}

os = configure_get_os(makefile->configure);

if((p = _makefile_get_config(makefile, target, "soname")) != NULL)

soname = string_new(p);

else if(os == HO_DARWIN)

/* versioning is different on Darwin/macOS */

soname = string_new_append(target, ".0.0$(SOEXT)", NULL);

else if(os == HO_WIN32)

/* and on Windows */

soname = string_new_append(target, "$(SOEXT)", NULL);

else

soname = string_new_append(target, "$(SOEXT)", ".0", NULL);

if(soname == NULL)

return 1;

/* install the shared library */

if(os == HO_DARWIN)

{

_makefile_print(makefile, "%s",

"\t$(INSTALL) -m 0755 $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", " $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, " $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".0$(SOEXT)\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", " $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "$(SOEXT)\n");

}

else if(os == HO_WIN32)

{

_makefile_print(makefile, "%s",

"\t$(INSTALL) -m 0755 $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", " $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

}

else

{

_makefile_print(makefile, "%s",

"\t$(INSTALL) -m 0755 $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, ".0 $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, ".0\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, ".0 $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

_makefile_print(makefile, "%s", "\t$(LN) -s -- ");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, ".0 $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)\n");

}

string_delete(soname);

return 0;

}

static void _install_target_libtool(Makefile * makefile, String const * target)

{

String const * path;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

_makefile_mkdir(makefile, path);

_makefile_print(makefile, "%s", "\t$(LIBTOOL) --mode=install $(INSTALL)"

" -m 0755 $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".la $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".la\n");

_makefile_print(makefile, "%s", "\t$(LIBTOOL) --mode=finish $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "\n");

}

static void _install_target_object(Makefile * makefile, String const * target)

{

String const * path;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

_makefile_mkdir(makefile, path);

_makefile_print(makefile, "%s%s%s%s/%s\n",

"\t$(INSTALL) -m 0644 $(OBJDIR)",

target, " $(DESTDIR)", path, target);

}

static void _install_target_plugin(Makefile * makefile, String const * target)

{

String const * path;

String const * mode;

mode_t m = 0755;

String * p;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

if((mode = _makefile_get_config(makefile, target, "mode")) == NULL

/* XXX these tests are not sufficient */

|| mode[0] == '\0'

|| (m = strtol(mode, &p, 8)) == 0

|| *p != '\0')

mode = "0755";

_makefile_mkdir(makefile, path);

_makefile_print(makefile, "%s%04o%s", "\t$(INSTALL) -m ", m,

" $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT) $(DESTDIR)");

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)\n");

}

static void _install_target_script(Makefile * makefile, String const * target)

{

String const * path;

String const * script;

String const * flags;

int phony;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return;

if((script = _makefile_get_config(makefile, target, "script")) == NULL)

return;

flags = _makefile_get_config(makefile, target, "flags");

phony = _makefile_is_phony(makefile, target);

_makefile_print(makefile, "\t");

_makefile_print_escape(makefile, script);

_makefile_print(makefile, "%s%s%s", " -P \"$(DESTDIR)",

(path[0] != '\0') ? path : "$(PREFIX)", "\" -i");

if(flags != NULL && flags[0] != '\0')

_makefile_print(makefile, " %s", flags);

_makefile_print(makefile, "%s%s%s%s", " -- \"",

phony ? "" : "$(OBJDIR)", target, "\"\n");

}

static int _install_include(Makefile * makefile, String const * include);

static int _install_includes(Makefile * makefile)

{

int ret = 0;

String const * p;

String * includes;

String * q;

size_t i;

char c;

if((p = _makefile_get_config_mode(makefile, NULL, "includes")) == NULL)

return 0;

if((includes = string_new(p)) == NULL)

return 1;

q = includes;

for(i = 0; ret == 0; i++)

{

if(includes[i] != ',' && includes[i] != '\0')

continue;

c = includes[i];

includes[i] = '\0';

ret |= _install_include(makefile, includes);

if(c == '\0')

break;

includes += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static int _install_include(Makefile * makefile, String const * include)

{

char const * install;

ssize_t i;

String * p = NULL;

String * directory;

if((install = _makefile_get_config(makefile, include, "install"))

== NULL)

{

install = "$(INCLUDEDIR)";

if((i = string_rindex(include, "/")) >= 0)

if((p = string_new_length(include, i)) == NULL)

return 2;

}

if(p != NULL)

{

directory = string_new_append(install, "/", p, NULL);

string_delete(p);

}

else

directory = string_new(install);

if(directory == NULL)

return 2;

_makefile_mkdir(makefile, directory);

string_delete(directory);

_makefile_print(makefile, "%s", "\t$(INSTALL) -m 0644 ");

_makefile_print_escape(makefile, include);

_makefile_print(makefile, "%s", " $(DESTDIR)");

_makefile_print_escape(makefile, install);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, include);

_makefile_print(makefile, "\n");

return 0;

}

static int _dist_check(Makefile * makefile, char const * target,

char const * mode);

static int _dist_install(Makefile * makefile, char const * directory,

char const * mode, char const * filename);

static int _install_dist(Makefile * makefile)

{

int ret = 0;

String const * p;

String * dist;

String * q;

size_t i;

char c;

String const * d;

String const * mode;

if((p = _makefile_get_config_mode(makefile, NULL, "dist")) == NULL)

return 0;

if((dist = string_new(p)) == NULL)

return 1;

q = dist;

for(i = 0;; i++)

{

if(dist[i] != ',' && dist[i] != '\0')

continue;

c = dist[i];

dist[i] = '\0';

if((mode = _makefile_get_config(makefile, dist, "mode"))

== NULL)

mode = "0644";

ret |= _dist_check(makefile, dist, mode);

if((d = _makefile_get_config(makefile, dist, "install"))

!= NULL)

_dist_install(makefile, d, mode, dist);

if(c == '\0')

break;

dist += i + 1;

i = 0;

}

string_delete(q);

return ret;

}

static int _dist_check(Makefile * makefile, char const * target,

char const * mode)

{

char * p;

mode_t m;

m = strtol(mode, &p, 8);

if(mode[0] == '\0' || *p != '\0')

return error_set_print(PROGNAME_CONFIGURE, 1, "%s: %s%s%s",

target, "Invalid permissions \"", mode, "\"");

if(_makefile_is_flag_set(makefile, PREFS_S) && (m & S_ISUID))

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s", target,

"Installed as a SUID file");

if(_makefile_is_flag_set(makefile, PREFS_S) && (m & S_ISUID))

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s", target,

"Installed as a SGID file");

if(_makefile_is_flag_set(makefile, PREFS_S)

&& (m & (S_IXUSR | S_IXGRP | S_IXOTH)))

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s", target,

"Installed as an executable file");

if(_makefile_is_flag_set(makefile, PREFS_S) && (m & S_IWGRP))

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s", target,

"Installed as a group-writable file");

if(_makefile_is_flag_set(makefile, PREFS_S) && (m & S_IWOTH))

error_set_print(PROGNAME_CONFIGURE, 0, "%s: %s", target,

"Installed as a writable file");

return 0;

}

static int _dist_install(Makefile * makefile, char const * directory,

char const * mode, char const * filename)

{

String * p;

char const * q;

if(strchr(filename, '/') != NULL)

{

if((p = string_new(filename)) == NULL)

return -1;

q = dirname(p);

/* TODO keep track of the directories created */

_makefile_print(makefile, "%s%s/%s\n", "\t$(MKDIR) $(DESTDIR)",

directory, q);

string_delete(p);

}

else

_makefile_mkdir(makefile, directory);

_makefile_print(makefile, "%s", "\t$(INSTALL) -m ");

_makefile_print_escape(makefile, mode);

_makefile_print(makefile, " ");

_makefile_print_escape(makefile, filename);

_makefile_print(makefile, " $(DESTDIR)");

_makefile_print_escape(makefile, directory);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, filename);

_makefile_print(makefile, "\n");

return 0;

}

static int _write_phony_targets(Makefile * makefile);

static int _write_phony(Makefile * makefile, char const ** targets)

{

size_t i;

_makefile_print(makefile, "%s:", "\n.PHONY");

for(i = 0; targets[i] != NULL; i++)

_makefile_print(makefile, " %s", targets[i]);

if(_write_phony_targets(makefile) != 0)

return 1;

_makefile_print(makefile, "\n");

return 0;

}

static int _write_phony_targets(Makefile * makefile)

{

String const * p;

String * prints;

size_t i;

char c;

String const * type;

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) == NULL)

return 0;

if((prints = string_new(p)) == NULL)

return 1;

for(i = 0;; i++)

{

if(prints[i] != ',' && prints[i] != '\0')

continue;

c = prints[i];

prints[i] = '\0';

if((type = _makefile_get_config(makefile, prints, "type"))

!= NULL)

switch(enum_string(TT_LAST, sTargetType, type))

{

case TT_COMMAND:

case TT_SCRIPT:

if(_makefile_is_phony(makefile, prints))

{

_makefile_print(makefile, " ");

_makefile_print_escape(makefile,

prints);

}

break;

}

if(c == '\0')

break;

prints += i + 1;

i = 0;

}

return 0;

}

static int _uninstall_target(Makefile * makefile, String const * target);

static int _uninstall_include(Makefile * makefile, String const * include);

static int _uninstall_dist(Makefile * makefile, String const * dist);

static int _write_uninstall(Makefile * makefile)

{

int ret = 0;

String const * p;

String * targets;

String * q;

String * includes;

String * dist;

size_t i;

char c;

_makefile_target(makefile, "uninstall", NULL);

if(_makefile_get_config_mode(makefile, NULL, "subdirs") != NULL)

_makefile_subdirs(makefile, "uninstall");

if((p = _makefile_get_config_mode(makefile, NULL, "targets")) != NULL)

{

if((targets = string_new(p)) == NULL)

return 1;

q = targets;

for(i = 0; ret == 0; i++)

{

if(targets[i] != ',' && targets[i] != '\0')

continue;

c = targets[i];

targets[i] = '\0';

if(_makefile_is_enabled(makefile, targets) != 0)

ret = _uninstall_target(makefile, targets);

if(c == '\0')

break;

targets += i + 1;

i = 0;

}

string_delete(q);

}

if((p = _makefile_get_config_mode(makefile, NULL, "includes")) != NULL)

{

if((includes = string_new(p)) == NULL)

return 1;

q = includes;

for(i = 0; ret == 0; i++)

{

if(includes[i] != ',' && includes[i] != '\0')

continue;

c = includes[i];

includes[i] = '\0';

ret = _uninstall_include(makefile, includes);

if(c == '\0')

break;

includes += i + 1;

i = 0;

}

string_delete(q);

}

if((p = _makefile_get_config_mode(makefile, NULL, "dist")) != NULL)

{

if((dist = string_new(p)) == NULL)

return 1;

q = dist;

for(i = 0; ret == 0; i++)

{

if(dist[i] != ',' && dist[i] != '\0')

continue;

c = dist[i];

dist[i] = '\0';

ret = _uninstall_dist(makefile, dist);

if(c == '\0')

break;

dist += i + 1;

i = 0;

}

string_delete(q);

}

return ret;

}

static int _uninstall_target_library(Makefile * makefile, String const * target,

String const * path);

static void _uninstall_target_script(Makefile * makefile, String const * target,

String const * path);

static int _uninstall_target(Makefile * makefile, String const * target)

{

String const * type;

String const * path;

TargetType tt;

const String rm_destdir[] = "$(RM) -- $(DESTDIR)";

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

return 1;

if((path = _makefile_get_config(makefile, target, "install")) == NULL)

return 0;

tt = enum_string(TT_LAST, sTargetType, type);

switch(tt)

{

case TT_BINARY:

_makefile_print(makefile, "\t%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "$(EXEEXT)\n");

break;

case TT_COMMAND:

_makefile_print(makefile, "\t%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n");

break;

case TT_LIBRARY:

if(_uninstall_target_library(makefile, target,

path) != 0)

return 1;

break;

case TT_LIBTOOL:

_makefile_print(makefile, "\t%s%s", "$(LIBTOOL)"

" --mode=uninstall ", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".la\n");

break;

case TT_OBJECT:

_makefile_print(makefile, "\t%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "\n");

break;

case TT_PLUGIN:

_makefile_print(makefile, "\t%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "$(SOEXT)\n");

break;

case TT_SCRIPT:

_uninstall_target_script(makefile, target, path);

break;

case TT_UNKNOWN:

break;

}

return 0;

}

static int _uninstall_target_library(Makefile * makefile, String const * target,

String const * path)

{

String * soname;

String const * p;

const String rm_destdir[] = "\t$(RM) -- $(DESTDIR)";

HostOS os;

if(configure_can_library_static(makefile->configure))

{

/* uninstall the static library */

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".a\n");

}

os = configure_get_os(makefile->configure);

if((p = _makefile_get_config(makefile, target, "soname")) != NULL)

soname = string_new(p);

else if(os == HO_DARWIN)

/* versioning is different on Darwin/macOS */

soname = string_new_append(target, ".0.0$(SOEXT)", NULL);

else if(os == HO_WIN32)

/* and on Windows */

soname = string_new_append(target, "$(SOEXT)", NULL);

else

soname = string_new_append(target, "$(SOEXT).0", NULL);

if(soname == NULL)

return 1;

/* uninstall the shared library */

if(os == HO_DARWIN)

{

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, ".0$(SOEXT)\n");

}

else if(os != HO_WIN32)

{

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "%s", ".0\n");

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, "\n");

}

_makefile_print(makefile, "%s", rm_destdir);

_makefile_print_escape(makefile, path);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "$(SOEXT)\n");

string_delete(soname);

return 0;

}

static void _uninstall_target_script(Makefile * makefile, String const * target,

String const * path)

{

String const * script;

String const * flags;

if((script = _makefile_get_config(makefile, target, "script")) == NULL)

return;

flags = _makefile_get_config(makefile, target, "flags");

_makefile_print(makefile, "\t");

_makefile_print_escape(makefile, script);

_makefile_print(makefile, "%s%s%s", " -P \"$(DESTDIR)",

(path[0] != '\0') ? path : "$(PREFIX)", "\" -u");

if(flags != NULL && flags[0] != '\0')

_makefile_print(makefile, " %s", flags);

_makefile_print(makefile, "%s%s%s", " -- \"", target, "\"\n");

}

static int _uninstall_include(Makefile * makefile, String const * include)

{

String const * install;

if((install = _makefile_get_config(makefile, include, "install"))

== NULL)

install = "$(INCLUDEDIR)";

_makefile_print(makefile, "%s", "\t$(RM) -- $(DESTDIR)");

_makefile_print_escape(makefile, install);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, include);

_makefile_print(makefile, "\n");

return 0;

}

static int _uninstall_dist(Makefile * makefile, String const * dist)

{

String const * install;

if((install = _makefile_get_config(makefile, dist, "install")) == NULL)

return 0;

_makefile_print(makefile, "%s", "\t$(RM) -- $(DESTDIR)");

_makefile_print_escape(makefile, install);

_makefile_print(makefile, "/");

_makefile_print_escape(makefile, dist);

_makefile_print(makefile, "\n");

return 0;

}

/* accessors */

/* makefile_get_config */

static String const * _makefile_get_config(Makefile * makefile,

String const * section, String const * variable)

{

return configure_get_config(makefile->configure, section, variable);

}

/* makefile_get_config_mode */

static String const * _makefile_get_config_mode(Makefile * makefile,

String const * mode, String const * variable)

{

return configure_get_config_mode(makefile->configure, mode, variable);

}

/* makefile_get_type */

static TargetType _makefile_get_type(Makefile * makefile,

String const * target)

{

String const * type;

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

return TT_UNKNOWN;

return enum_string(TT_LAST, sTargetType, type);

}

/* makefile_is_enabled */

static int _makefile_is_enabled(Makefile * makefile, char const * target)

{

String const * p;

if((p = _makefile_get_config(makefile, target, "enabled")) != NULL

&& strtol(p, NULL, 10) == 0)

return 0;

return 1;

}

/* makefile_is_flag_set */

static unsigned int _makefile_is_flag_set(Makefile * makefile,

unsigned int flag)

{

return configure_is_flag_set(makefile->configure, flag);

}

/* makefile_is_phony */

static int _makefile_is_phony(Makefile * makefile, char const * target)

{

String const * p;

if((p = _makefile_get_config(makefile, target, "phony")) != NULL

&& strtol(p, NULL, 10) == 1)

return 1;

return 0;

}

/* useful */

/* makefile_expand */

static int _makefile_expand(Makefile * makefile, char const * field)

{

int res = 0;

char c;

if(field == NULL)

return -1;

if(field[0] != '\0')

res = _makefile_print(makefile, " ");

while((c = *(field++)) != '\0')

{

if(c == ' ' || c == '\t')

res |= _makefile_print(makefile, "\\");

else if(c == ',')

c = ' ';

res |= _makefile_print(makefile, "%c", c);

}

return (res >= 0) ? 0 : -1;

}

/* makefile_link */

static int _makefile_link(Makefile * makefile, int symlink, char const * link,

char const * path)

{

_makefile_print(makefile, "\t$(LN)%s -- %s %s\n", symlink ? " -s" : "",

link, path);

return 0;

}

/* makefile_output_extension */

static int _makefile_output_extension(Makefile * makefile,

String const * extension)

{

int ret;

String const * value;

String * upper;

if((upper = string_new_append(extension, "EXT", NULL)) == NULL)

return -1;

string_toupper(upper);

value = configure_get_extension(makefile->configure, extension);

ret = _makefile_output_variable(makefile, upper, value);

string_delete(upper);

return ret;

}

/* makefile_output_path */

static int _makefile_output_path(Makefile * makefile, String const * path)

{

int ret;

String const * value;

String * upper;

String * p;

if((upper = string_new(path)) == NULL)

return -1;

string_toupper(upper);

value = configure_get_path(makefile->configure, path);

if(value != NULL && value[0] != '\0')

{

if(value[0] != '/')

{

p = string_new_append("$(PREFIX)/", value, NULL);

ret = _makefile_output_variable(makefile, upper, p);

string_delete(p);

}

else

ret = _makefile_output_variable(makefile, upper, value);

}

else

ret = _makefile_output_variable(makefile, upper, value);

string_delete(upper);

return ret;

}

/* makefile_output_program */

static int _makefile_output_program(Makefile * makefile, String const * name,

unsigned int override)

{

int ret;

String const * value;

String * upper;

if((upper = string_new(name)) == NULL)

return -1;

string_toupper(upper);

if(override)

value = _makefile_get_config_mode(makefile, NULL, name);

else

value = NULL;

if(value == NULL)

value = configure_get_program(makefile->configure, name);

ret = _makefile_output_variable(makefile, upper, value);

string_delete(upper);

return ret;

}

/* makefile_output_variable */

static int _makefile_output_variable(Makefile * makefile, String const * name,

String const * value)

{

int res;

size_t len;

if(makefile->fp == NULL)

return 0;

if(name == NULL || (len = strlen(name)) == 0)

return -1;

if(value == NULL)

value = "";

res = _makefile_print(makefile, "%s%s%s%s\n", name,

(len >= 8) ? "" : "\t",

(strlen(value) > 0) ? "= " : "=", value);

return (res >= 0) ? 0 : -1;

}

/* makefile_mkdir */

static int _makefile_mkdir(Makefile * makefile, char const * directory)

{

/* TODO keep track of the directories created */

if(_makefile_print(makefile, "%s", "\t$(MKDIR) $(DESTDIR)") < 0

|| _makefile_print_escape(makefile, directory) < 0

|| _makefile_print(makefile, "\n") < 0)

return -1;

return 0;

}

/* makefile_print */

static int _makefile_print(Makefile * makefile, char const * format, ...)

{

int ret;

va_list ap;

va_start(ap, format);

if(makefile->fp == NULL)

ret = vsnprintf(NULL, 0, format, ap);

else

ret = vfprintf(makefile->fp, format, ap);

va_end(ap);

return ret;

}

/* makefile_print_escape */

static int _makefile_print_escape(Makefile * makefile, char const * str)

{

if(str == NULL)

return -1;

if(makefile->fp == NULL)

return 0;

while(*str != '\0')

{

if(*str == ' ' || *str == '\t')

if(fputc('\\', makefile->fp) == EOF)

return -1;

if(fputc(*(str++), makefile->fp) == EOF)

return -1;

}

return 0;

}

/* makefile_print_escape_variable */

static int _makefile_print_escape_variable(Makefile * makefile,

char const * str)

{

char c;

if(str == NULL)

return -1;

if(makefile->fp == NULL)

return 0;

while((c = *(str++)) != '\0')

{

if(c == ' ' || c == '\t')

c = '_';

if(fputc(c, makefile->fp) == EOF)

return -1;

}

return 0;

}

/* makefile_print_target */

static int _print_target_library(Makefile * makefile, String const * target);

static int _makefile_print_target(Makefile * makefile, String const * target)

{

int ret = 0;

String const * type;

int phony;

if((type = _makefile_get_config(makefile, target, "type")) == NULL)

{

_makefile_print(makefile, "%s", target);

return 0;

}

switch(enum_string(TT_LAST, sTargetType, type))

{

case TT_BINARY:

_makefile_print(makefile, "%s", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(EXEEXT)");

break;

case TT_COMMAND:

phony = _makefile_is_phony(makefile, target);

_makefile_print(makefile, "%s",

phony ? "" : "$(OBJDIR)");

_makefile_print_escape(makefile, target);

break;

case TT_LIBRARY:

ret |= _print_target_library(makefile, target);

break;

case TT_LIBTOOL:

_makefile_print(makefile, "%s", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".la");

break;

case TT_OBJECT:

case TT_UNKNOWN:

_makefile_print(makefile, "$(OBJDIR)");

_makefile_print_escape(makefile, target);

break;

case TT_SCRIPT:

phony = _makefile_is_phony(makefile, target);

_makefile_print(makefile, "%s",

phony ? "" : "$(OBJDIR)");

_makefile_print_escape(makefile, target);

break;

case TT_PLUGIN:

_makefile_print(makefile, "%s", "$(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)");

break;

}

return ret;

}

static int _print_target_library(Makefile * makefile, String const * target)

{

String * soname;

String const * p;

String const * sep = "";

HostOS os;

if((p = _makefile_get_config(makefile, target, "soname")) != NULL)

soname = string_new(p);

else if(configure_get_os(makefile->configure) == HO_DARWIN)

/* versioning is different on Darwin/macOS */

soname = string_new_append(target, ".0.0$(SOEXT)", NULL);

else if(configure_get_os(makefile->configure) == HO_WIN32)

/* and on Windows */

soname = string_new_append(target, "$(SOEXT)", NULL);

else

soname = string_new_append(target, "$(SOEXT)", ".0", NULL);

if(soname == NULL)

return 1;

if(configure_can_library_static(makefile->configure))

{

/* generate a static library */

_makefile_print(makefile, "%s", "$(OBJDIR)", target, ".a");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".a");

sep = " ";

}

if((os = configure_get_os(makefile->configure)) == HO_DARWIN)

{

_makefile_print(makefile, "%s%s", sep, "$(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, " $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", ".0$(SOEXT) $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "$(SOEXT)");

}

else if(os == HO_WIN32)

{

_makefile_print(makefile, "%s%s", sep, "$(OBJDIR)");

_makefile_print_escape(makefile, soname);

}

else

{

_makefile_print(makefile, "%s%s", sep, "$(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, ".0 $(OBJDIR)");

_makefile_print_escape(makefile, soname);

_makefile_print(makefile, " $(OBJDIR)");

_makefile_print_escape(makefile, target);

_makefile_print(makefile, "%s", "$(SOEXT)");

}

string_delete(soname);

return 0;

}

/* makefile_remove */

static int _makefile_remove(Makefile * makefile, int recursive, ...)

{

va_list ap;

char const * sep = " -- ";

char const * p;

_makefile_print(makefile, "\t$(RM)%s", recursive ? " -r" : "");

va_start(ap, recursive);

while((p = va_arg(ap, char const * )) != NULL)

{

_makefile_print(makefile, "%s%s", sep, p);

sep = " ";

}

va_end(ap);

_makefile_print(makefile, "\n");

return 0;

}

/* makefile_subdirs */

static int _makefile_subdirs(Makefile * makefile, char const * target)

{

if(target != NULL)

_makefile_print(makefile,

"\t@for i in $(SUBDIRS); do (cd \"$$i\" && \\\n"

"\t\tif [ -n \"$(OBJDIR)\" ]; then \\\n"

"\t\t$(MAKE) OBJDIR=\"$(OBJDIR)$$i/\" %s; \\\n"

"\t\telse $(MAKE) %s; fi) || exit; done\n",

target, target);

else

_makefile_print(makefile, "%s",

"\t@for i in $(SUBDIRS); do (cd \"$$i\" && \\\n"

"\t\tif [ -n \"$(OBJDIR)\" ]; then \\\n"

"\t\t([ -d \"$(OBJDIR)$$i\" ]"

" || $(MKDIR) -- \"$(OBJDIR)$$i\") && \\\n"

"\t\t$(MAKE) OBJDIR=\"$(OBJDIR)$$i/\"; \\\n"

"\t\telse $(MAKE); fi) || exit; done\n");

return 0;

}

/* makefile_target */

static int _makefile_target(Makefile * makefile, char const * target, ...)

{

va_list ap;

char const * sep = " ";

char const * p;

if(target == NULL)

return -1;

_makefile_print(makefile, "\n%s:", target);

va_start(ap, target);

while((p = va_arg(ap, char const *)) != NULL)

_makefile_print(makefile, "%s%s", sep, p);

va_end(ap);

_makefile_print(makefile, "\n");

return 0;

}

#ifdef WITH_UNUSED

/* makefile_targetv */

static int _makefile_targetv(FILE * fp, char const * target,

char const ** depends)

{

char const ** p;

if(target == NULL)

return -1;

_makefile_print(makefile, "\n%s:", target);

if(depends != NULL)

for(p = depends; *p != NULL; p++)

_makefile_print(makefile, " %s", *p);

_makefile_print(makefile, "\n");

return 0;

}

#endif