contrib/atf/atf-c/h_build.h

   1 /* Copyright (c) 2009 The NetBSD Foundation, Inc.
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  14  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  15  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  16  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  20  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  22  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  24  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  */
  25
  26 #if defined(ATF_C_H_BUILD_H)
  27 #   error "Cannot include h_build.h more than once."
  28 #else
  29 #   define ATF_C_H_BUILD_H
  30 #endif
  31
  32 /* ---------------------------------------------------------------------
  33  * Test case data.
  34  * --------------------------------------------------------------------- */
  35
  36 static struct c_o_test {
  37     const char *msg;
  38     const char *cc;
  39     const char *cflags;
  40     const char *cppflags;
  41     const char *sfile;
  42     const char *ofile;
  43     bool hasoptargs;
  44     const char *const optargs[16];
  45     const char *const expargv[16];
  46 } c_o_tests[] = {
  47     {
  48         "No flags",
  49         "cc",
  50         "",
  51         "",
  52         "test.c",
  53         "test.o",
  54         false,
  55         {
  56             NULL
  57         },
  58         {
  59             "cc", "-o", "test.o", "-c", "test.c", NULL
  60         },
  61     },
  62
  63     {
  64         "Multi-word program name",
  65         "cc -foo",
  66         "",
  67         "",
  68         "test.c",
  69         "test.o",
  70         false,
  71         {
  72             NULL
  73         },
  74         {
  75             "cc", "-foo", "-o", "test.o", "-c", "test.c", NULL
  76         },
  77     },
  78
  79     {
  80         "Some cflags",
  81         "cc",
  82         "-f1 -f2    -f3 -f4-f5",
  83         "",
  84         "test.c",
  85         "test.o",
  86         false,
  87         {
  88             NULL
  89         },
  90         {
  91             "cc", "-f1", "-f2", "-f3", "-f4-f5", "-o", "test.o",
  92             "-c", "test.c", NULL
  93         },
  94     },
  95
  96     {
  97         "Some cppflags",
  98         "cc",
  99         "",
 100         "-f1 -f2    -f3 -f4-f5",
 101         "test.c",
 102         "test.o",
 103         false,
 104         {
 105             NULL
 106         },
 107         {
 108             "cc", "-f1", "-f2", "-f3", "-f4-f5", "-o", "test.o",
 109             "-c", "test.c", NULL
 110         },
 111     },
 112
 113     {
 114         "Some cflags and cppflags",
 115         "cc",
 116         "-f2",
 117         "-f1",
 118         "test.c",
 119         "test.o",
 120         false,
 121         {
 122             NULL
 123         },
 124         {
 125             "cc", "-f1", "-f2", "-o", "test.o", "-c", "test.c", NULL
 126         },
 127     },
 128
 129     {
 130         "Some optional arguments",
 131         "cc",
 132         "",
 133         "",
 134         "test.c",
 135         "test.o",
 136         true,
 137         {
 138             "-o1", "-o2", NULL
 139         },
 140         {
 141             "cc", "-o1", "-o2", "-o", "test.o", "-c", "test.c", NULL
 142         },
 143     },
 144
 145     {
 146         "Some cflags, cppflags and optional arguments",
 147         "cc",
 148         "-f2",
 149         "-f1",
 150         "test.c",
 151         "test.o",
 152         true,
 153         {
 154             "-o1", "-o2", NULL
 155         },
 156         {
 157             "cc", "-f1", "-f2", "-o1", "-o2", "-o", "test.o",
 158             "-c", "test.c", NULL
 159         },
 160     },
 161
 162     {
 163         NULL,
 164         NULL,
 165         NULL,
 166         NULL,
 167         NULL,
 168         NULL,
 169         false,
 170         { NULL },
 171         { NULL },
 172     },
 173 };
 174
 175 static struct cpp_test {
 176     const char *msg;
 177     const char *cpp;
 178     const char *cppflags;
 179     const char *sfile;
 180     const char *ofile;
 181     bool hasoptargs;
 182     const char *const optargs[16];
 183     const char *const expargv[16];
 184 } cpp_tests[] = {
 185     {
 186         "No flags",
 187         "cpp",
 188         "",
 189         "test.c",
 190         "test.out",
 191         false,
 192         {
 193             NULL
 194         },
 195         {
 196             "cpp", "-o", "test.out", "test.c", NULL
 197         },
 198     },
 199
 200     {
 201         "Multi-word program name",
 202         "cpp -foo",
 203         "",
 204         "test.c",
 205         "test.out",
 206         false,
 207         {
 208             NULL
 209         },
 210         {
 211             "cpp", "-foo", "-o", "test.out", "test.c", NULL
 212         },
 213     },
 214
 215     {
 216         "Some cppflags",
 217         "cpp",
 218         "-f1 -f2    -f3 -f4-f5",
 219         "test.c",
 220         "test.out",
 221         false,
 222         {
 223             NULL
 224         },
 225         {
 226             "cpp", "-f1", "-f2", "-f3", "-f4-f5", "-o", "test.out",
 227             "test.c", NULL
 228         },
 229     },
 230
 231     {
 232         "Some optional arguments",
 233         "cpp",
 234         "",
 235         "test.c",
 236         "test.out",
 237         true,
 238         {
 239             "-o1", "-o2", NULL
 240         },
 241         {
 242             "cpp", "-o1", "-o2", "-o", "test.out", "test.c", NULL
 243         },
 244     },
 245
 246     {
 247         "Some cppflags and optional arguments",
 248         "cpp",
 249         "-f1",
 250         "test.c",
 251         "test.out",
 252         true,
 253         {
 254             "-o1", "-o2", NULL
 255         },
 256         {
 257             "cpp", "-f1", "-o1", "-o2", "-o", "test.out", "test.c", NULL
 258         },
 259     },
 260
 261     {
 262         NULL,
 263         NULL,
 264         NULL,
 265         NULL,
 266         NULL,
 267         false,
 268         { NULL },
 269         { NULL },
 270     },
 271 };
 272
 273 static struct cxx_o_test {
 274     const char *msg;
 275     const char *cxx;
 276     const char *cxxflags;
 277     const char *cppflags;
 278     const char *sfile;
 279     const char *ofile;
 280     bool hasoptargs;
 281     const char *const optargs[16];
 282     const char *const expargv[16];
 283 } cxx_o_tests[] = {
 284     {
 285         "No flags",
 286         "c++",
 287         "",
 288         "",
 289         "test.c",
 290         "test.o",
 291         false,
 292         {
 293             NULL
 294         },
 295         {
 296             "c++", "-o", "test.o", "-c", "test.c", NULL
 297         },
 298     },
 299
 300     {
 301         "Multi-word program name",
 302         "c++ -foo",
 303         "",
 304         "",
 305         "test.c",
 306         "test.o",
 307         false,
 308         {
 309             NULL
 310         },
 311         {
 312             "c++", "-foo", "-o", "test.o", "-c", "test.c", NULL
 313         },
 314     },
 315
 316     {
 317         "Some cxxflags",
 318         "c++",
 319         "-f1 -f2    -f3 -f4-f5",
 320         "",
 321         "test.c",
 322         "test.o",
 323         false,
 324         {
 325             NULL
 326         },
 327         {
 328             "c++", "-f1", "-f2", "-f3", "-f4-f5", "-o", "test.o",
 329             "-c", "test.c", NULL
 330         },
 331     },
 332
 333     {
 334         "Some cppflags",
 335         "c++",
 336         "",
 337         "-f1 -f2    -f3 -f4-f5",
 338         "test.c",
 339         "test.o",
 340         false,
 341         {
 342             NULL
 343         },
 344         {
 345             "c++", "-f1", "-f2", "-f3", "-f4-f5", "-o", "test.o",
 346             "-c", "test.c", NULL
 347         },
 348     },
 349
 350     {
 351         "Some cxxflags and cppflags",
 352         "c++",
 353         "-f2",
 354         "-f1",
 355         "test.c",
 356         "test.o",
 357         false,
 358         {
 359             NULL
 360         },
 361         {
 362             "c++", "-f1", "-f2", "-o", "test.o", "-c", "test.c", NULL
 363         },
 364     },
 365
 366     {
 367         "Some optional arguments",
 368         "c++",
 369         "",
 370         "",
 371         "test.c",
 372         "test.o",
 373         true,
 374         {
 375             "-o1", "-o2", NULL
 376         },
 377         {
 378             "c++", "-o1", "-o2", "-o", "test.o", "-c", "test.c", NULL
 379         },
 380     },
 381
 382     {
 383         "Some cxxflags, cppflags and optional arguments",
 384         "c++",
 385         "-f2",
 386         "-f1",
 387         "test.c",
 388         "test.o",
 389         true,
 390         {
 391             "-o1", "-o2", NULL
 392         },
 393         {
 394             "c++", "-f1", "-f2", "-o1", "-o2", "-o", "test.o",
 395             "-c", "test.c", NULL
 396         },
 397     },
 398
 399     {
 400         NULL,
 401         NULL,
 402         NULL,
 403         NULL,
 404         NULL,
 405         NULL,
 406         false,
 407         { NULL },
 408         { NULL },
 409     },
 410 };