compopt.c

   1 /*
   2  * Copyright (C) 2010 Joel Rosdahl
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; either version 3 of the License, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 51
  16  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "ccache.h"
  20 #include "compopt.h"
  21
  22 #define TOO_HARD         (1 << 0)
  23 #define TOO_HARD_DIRECT  (1 << 1)
  24 #define TAKES_ARG        (1 << 2)
  25 #define TAKES_CONCAT_ARG (1 << 3)
  26 #define TAKES_PATH       (1 << 4)
  27 #define AFFECTS_CPP      (1 << 5)
  28
  29 struct compopt {
  30         const char *name;
  31         int type;
  32 };
  33
  34 static const struct compopt compopts[] = {
  35         {"--coverage",      TOO_HARD},
  36         {"--param",         TAKES_ARG},
  37         {"-A",              TAKES_ARG},
  38         {"-D",              AFFECTS_CPP | TAKES_ARG | TAKES_CONCAT_ARG},
  39         {"-E",              TOO_HARD},
  40         {"-F",              AFFECTS_CPP | TAKES_ARG | TAKES_CONCAT_ARG | TAKES_PATH},
  41         {"-G",              TAKES_ARG},
  42         {"-I",              AFFECTS_CPP | TAKES_ARG | TAKES_CONCAT_ARG | TAKES_PATH},
  43         {"-L",              TAKES_ARG},
  44         {"-M",              TOO_HARD},
  45         {"-MF",             TAKES_ARG},
  46         {"-MM",             TOO_HARD},
  47         {"-MQ",             TAKES_ARG},
  48         {"-MT",             TAKES_ARG},
  49         {"-U",              AFFECTS_CPP | TAKES_ARG | TAKES_CONCAT_ARG},
  50         {"-V",              TAKES_ARG},
  51         {"-Xassembler",     TAKES_ARG},
  52         {"-Xlinker",        TAKES_ARG},
  53         {"-Xpreprocessor",  TOO_HARD_DIRECT | TAKES_ARG},
  54         {"-aux-info",       TAKES_ARG},
  55         {"-b",              TAKES_ARG},
  56         {"-fbranch-probabilities", TOO_HARD},
  57         {"-fprofile-arcs",  TOO_HARD},
  58         {"-fprofile-generate", TOO_HARD},
  59         {"-fprofile-use",   TOO_HARD},
  60         {"-frepo",          TOO_HARD},
  61         {"-ftest-coverage", TOO_HARD},
  62         {"-idirafter",      AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  63         {"-iframework",     AFFECTS_CPP | TAKES_ARG | TAKES_CONCAT_ARG | TAKES_PATH},
  64         {"-imacros",        AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  65         {"-imultilib",      AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  66         {"-include",        AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  67         {"-install_name",   TAKES_ARG}, /* Darwin linker option */
  68         {"-iprefix",        AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  69         {"-iquote",         AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  70         {"-isysroot",       AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  71         {"-isystem",        AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  72         {"-iwithprefix",    AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  73         {"-iwithprefixbefore", AFFECTS_CPP | TAKES_ARG | TAKES_PATH},
  74         {"-nostdinc",       AFFECTS_CPP},
  75         {"-nostdinc++",     AFFECTS_CPP},
  76         {"-save-temps",     TOO_HARD},
  77         {"-u",              TAKES_ARG},
  78 };
  79
  80 static int
  81 compare_compopts(const void *key1, const void *key2)
  82 {
  83         const struct compopt *opt1 = (const struct compopt *)key1;
  84         const struct compopt *opt2 = (const struct compopt *)key2;
  85         return strcmp(opt1->name, opt2->name);
  86 }
  87
  88 static const struct compopt *
  89 find(const char *option)
  90 {
  91         struct compopt key;
  92         key.name = option;
  93         return bsearch(
  94                 &key, compopts, sizeof(compopts) / sizeof(compopts[0]),
  95                 sizeof(compopts[0]), compare_compopts);
  96 }
  97
  98 /* Runs fn on the first two characters of option. */
  99 bool
 100 compopt_short(bool (*fn)(const char *), const char *option)
 101 {
 102         char *short_opt = x_strndup(option, 2);
 103         bool retval = fn(short_opt);
 104         free(short_opt);
 105         return retval;
 106 }
 107
 108 /* For test purposes. */
 109 bool
 110 compopt_verify_sortedness(void)
 111 {
 112         size_t i;
 113         for (i = 1; i < sizeof(compopts)/sizeof(compopts[0]); i++) {
 114                 if (strcmp(compopts[i-1].name, compopts[i].name) >= 0) {
 115                         fprintf(stderr,
 116                                 "compopt_verify_sortedness: %s >= %s\n",
 117                                 compopts[i-1].name,
 118                                 compopts[i].name);
 119                         return false;
 120                 }
 121         }
 122         return true;
 123 }
 124
 125 bool
 126 compopt_affects_cpp(const char *option)
 127 {
 128         const struct compopt *co = find(option);
 129         return co && (co->type & AFFECTS_CPP);
 130 }
 131
 132 bool
 133 compopt_too_hard(const char *option)
 134 {
 135         const struct compopt *co = find(option);
 136         return co && (co->type & TOO_HARD);
 137 }
 138
 139 bool
 140 compopt_too_hard_for_direct_mode(const char *option)
 141 {
 142         const struct compopt *co = find(option);
 143         return co && (co->type & TOO_HARD_DIRECT);
 144 }
 145
 146 bool
 147 compopt_takes_path(const char *option)
 148 {
 149         const struct compopt *co = find(option);
 150         return co && (co->type & TAKES_PATH);
 151 }
 152
 153 bool
 154 compopt_takes_arg(const char *option)
 155 {
 156         const struct compopt *co = find(option);
 157         return co && (co->type & TAKES_ARG);
 158 }