external/bsd/atf/dist/atf-c/build.c

   1 /*
   2  * Automated Testing Framework (atf)
   3  *
   4  * Copyright (c) 2009 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <string.h>
  31
  32 #include "atf-c/build.h"
  33 #include "atf-c/config.h"
  34 #include "atf-c/error.h"
  35 #include "atf-c/sanity.h"
  36 #include "atf-c/text.h"
  37
  38 /* ---------------------------------------------------------------------
  39  * Auxiliary functions.
  40  * --------------------------------------------------------------------- */
  41
  42 static
  43 atf_error_t
  44 append_config_var(const char *var, atf_list_t *argv)
  45 {
  46     atf_error_t err;
  47     atf_list_t words;
  48
  49     err = atf_text_split(atf_config_get(var), " ", &words);
  50     if (atf_is_error(err))
  51         goto out;
  52
  53     atf_list_append_list(argv, &words);
  54
  55 out:
  56     return err;
  57 }
  58
  59 static
  60 atf_error_t
  61 append_arg1(const char *arg, atf_list_t *argv)
  62 {
  63     return atf_list_append(argv, strdup(arg), true);
  64 }
  65
  66 static
  67 atf_error_t
  68 append_arg2(const char *flag, const char *arg, atf_list_t *argv)
  69 {
  70     atf_error_t err;
  71
  72     err = append_arg1(flag, argv);
  73     if (!atf_is_error(err))
  74         err = append_arg1(arg, argv);
  75
  76     return err;
  77 }
  78
  79 static
  80 atf_error_t
  81 append_optargs(const char *const optargs[], atf_list_t *argv)
  82 {
  83     atf_error_t err;
  84
  85     err = atf_no_error();
  86     while (*optargs != NULL && !atf_is_error(err)) {
  87         err = append_arg1(strdup(*optargs), argv);
  88         optargs++;
  89     }
  90
  91     return err;
  92 }
  93
  94 static
  95 atf_error_t
  96 append_src_out(const char *src, const char *obj, atf_list_t *argv)
  97 {
  98     atf_error_t err;
  99
 100     err = append_arg2("-o", obj, argv);
 101     if (atf_is_error(err))
 102         goto out;
 103
 104     err = append_arg1("-c", argv);
 105     if (atf_is_error(err))
 106         goto out;
 107
 108     err = append_arg1(src, argv);
 109
 110 out:
 111     return err;
 112 }
 113
 114 /* ---------------------------------------------------------------------
 115  * Free functions.
 116  * --------------------------------------------------------------------- */
 117
 118 atf_error_t
 119 atf_build_c_o(const char *sfile,
 120               const char *ofile,
 121               const char *const optargs[],
 122               atf_list_t *argv)
 123 {
 124     atf_error_t err;
 125
 126     err = atf_list_init(argv);
 127     if (atf_is_error(err))
 128         goto err;
 129
 130     err = append_config_var("atf_build_cc", argv);
 131     if (atf_is_error(err))
 132         goto err_list;
 133
 134     err = append_config_var("atf_build_cppflags", argv);
 135     if (atf_is_error(err))
 136         goto err_list;
 137
 138     err = append_config_var("atf_build_cflags", argv);
 139     if (atf_is_error(err))
 140         goto err_list;
 141
 142     if (optargs != NULL) {
 143         err = append_optargs(optargs, argv);
 144         if (atf_is_error(err))
 145             goto err_list;
 146     }
 147
 148     err = append_src_out(sfile, ofile, argv);
 149     if (atf_is_error(err))
 150         goto err_list;
 151
 152     INV(!atf_is_error(err));
 153     return err;
 154
 155 err_list:
 156     atf_list_fini(argv);
 157 err:
 158     return err;
 159 }
 160
 161 atf_error_t
 162 atf_build_cpp(const char *sfile,
 163               const char *ofile,
 164               const char *const optargs[],
 165               atf_list_t *argv)
 166 {
 167     atf_error_t err;
 168
 169     err = atf_list_init(argv);
 170     if (atf_is_error(err))
 171         goto err;
 172
 173     err = append_config_var("atf_build_cpp", argv);
 174     if (atf_is_error(err))
 175         goto err_list;
 176
 177     err = append_config_var("atf_build_cppflags", argv);
 178     if (atf_is_error(err))
 179         goto err_list;
 180
 181     if (optargs != NULL) {
 182         err = append_optargs(optargs, argv);
 183         if (atf_is_error(err))
 184             goto err_list;
 185     }
 186
 187     err = append_arg2("-o", ofile, argv);
 188     if (atf_is_error(err))
 189         goto err_list;
 190
 191     err = append_arg1(sfile, argv);
 192     if (atf_is_error(err))
 193         goto err_list;
 194
 195     INV(!atf_is_error(err));
 196     return err;
 197
 198 err_list:
 199     atf_list_fini(argv);
 200 err:
 201     return err;
 202 }
 203
 204 atf_error_t
 205 atf_build_cxx_o(const char *sfile,
 206                 const char *ofile,
 207                 const char *const optargs[],
 208                 atf_list_t *argv)
 209 {
 210     atf_error_t err;
 211
 212     err = atf_list_init(argv);
 213     if (atf_is_error(err))
 214         goto err;
 215
 216     err = append_config_var("atf_build_cxx", argv);
 217     if (atf_is_error(err))
 218         goto err_list;
 219
 220     err = append_config_var("atf_build_cppflags", argv);
 221     if (atf_is_error(err))
 222         goto err_list;
 223
 224     err = append_config_var("atf_build_cxxflags", argv);
 225     if (atf_is_error(err))
 226         goto err_list;
 227
 228     if (optargs != NULL) {
 229         err = append_optargs(optargs, argv);
 230         if (atf_is_error(err))
 231             goto err_list;
 232     }
 233
 234     err = append_src_out(sfile, ofile, argv);
 235     if (atf_is_error(err))
 236         goto err_list;
 237
 238     INV(!atf_is_error(err));
 239     return err;
 240
 241 err_list:
 242     atf_list_fini(argv);
 243 err:
 244     return err;
 245 }