gcc/opts.h

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_OPTS_H
  22 #define GCC_OPTS_H
  23
  24 /* Specifies how a switch's VAR_VALUE relates to its FLAG_VAR.  */
  25 enum cl_var_type {
  26   /* The switch is enabled when FLAG_VAR is nonzero.  */
  27   CLVC_BOOLEAN,
  28
  29   /* The switch is enabled when FLAG_VAR == VAR_VALUE.  */
  30   CLVC_EQUAL,
  31
  32   /* The switch is enabled when VAR_VALUE is not set in FLAG_VAR.  */
  33   CLVC_BIT_CLEAR,
  34
  35   /* The switch is enabled when VAR_VALUE is set in FLAG_VAR.  */
  36   CLVC_BIT_SET,
  37
  38   /* The switch takes a string argument and FLAG_VAR points to that
  39      argument.  */
  40   CLVC_STRING
  41 };
  42
  43 struct cl_option
  44 {
  45   const char *opt_text;
  46   const char *help;
  47   const char *missing_argument_error;
  48   const char *warn_message;
  49   const char *alias_arg;
  50   const char *neg_alias_arg;
  51   unsigned short alias_target;
  52   unsigned short back_chain;
  53   unsigned char opt_len;
  54   int neg_index;
  55   unsigned int flags;
  56   unsigned short flag_var_offset;
  57   enum cl_var_type var_type;
  58   int var_value;
  59 };
  60
  61 /* Records that the state of an option consists of SIZE bytes starting
  62    at DATA.  DATA might point to CH in some cases.  */
  63 struct cl_option_state {
  64   const void *data;
  65   size_t size;
  66   char ch;
  67 };
  68
  69 extern const struct cl_option cl_options[];
  70 extern const unsigned int cl_options_count;
  71 extern const char *const lang_names[];
  72 extern const unsigned int cl_lang_count;
  73
  74 #define CL_PARAMS               (1 << 11) /* Fake entry.  Used to display --param info with --help.  */
  75 #define CL_WARNING              (1 << 12) /* Enables an (optional) warning message.  */
  76 #define CL_OPTIMIZATION         (1 << 13) /* Enables an (optional) optimization.  */
  77 #define CL_DRIVER               (1 << 14) /* Driver option.  */
  78 #define CL_TARGET               (1 << 15) /* Target-specific option.  */
  79 #define CL_COMMON               (1 << 16) /* Language-independent.  */
  80
  81 #define CL_MIN_OPTION_CLASS     CL_PARAMS
  82 #define CL_MAX_OPTION_CLASS     CL_COMMON
  83
  84 /* From here on the bits describe attributes of the options.
  85    Before this point the bits have described the class of the option.
  86    This distinction is important because --help will not list options
  87    which only have these higher bits set.  */
  88
  89 /* Options marked with CL_SEPARATE take a number of separate arguments
  90    (1 to 4) that is one more than the number in this bit-field.  */
  91 #define CL_SEPARATE_NARGS_SHIFT 17
  92 #define CL_SEPARATE_NARGS_MASK  (3 << CL_SEPARATE_NARGS_SHIFT)
  93
  94 #define CL_SEPARATE_ALIAS       (1 << 19) /* Option is an alias when used with separate argument.  */
  95 #define CL_NO_DRIVER_ARG        (1 << 20) /* Option takes no argument in the driver.  */
  96 #define CL_REJECT_DRIVER        (1 << 21) /* Reject this option in the driver.  */
  97 #define CL_SAVE                 (1 << 22) /* Target-specific option for attribute.  */
  98 #define CL_DISABLED             (1 << 23) /* Disabled in this configuration.  */
  99 #define CL_REPORT               (1 << 24) /* Report argument with -fverbose-asm  */
 100 #define CL_JOINED               (1 << 25) /* If takes joined argument.  */
 101 #define CL_SEPARATE             (1 << 26) /* If takes a separate argument.  */
 102 #define CL_REJECT_NEGATIVE      (1 << 27) /* Reject no- form.  */
 103 #define CL_MISSING_OK           (1 << 28) /* Missing argument OK (joined).  */
 104 #define CL_UINTEGER             (1 << 29) /* Argument is an integer >=0.  */
 105 #define CL_UNDOCUMENTED         (1 << 30) /* Do not output with --help.  */
 106
 107 /* Possible ways in which a command-line option may be erroneous.
 108    These do not include not being known at all; an option index of
 109    OPT_SPECIAL_unknown is used for that.  */
 110
 111 #define CL_ERR_DISABLED         (1 << 0) /* Disabled in this configuration.  */
 112 #define CL_ERR_MISSING_ARG      (1 << 1) /* Argument required but missing.  */
 113 #define CL_ERR_WRONG_LANG       (1 << 2) /* Option for wrong language.  */
 114 #define CL_ERR_UINT_ARG         (1 << 3) /* Bad unsigned integer argument.  */
 115 #define CL_ERR_NEGATIVE         (1 << 4) /* Negative form of option
 116                                             not permitted (together
 117                                             with OPT_SPECIAL_unknown).  */
 118
 119 /* Structure describing the result of decoding an option.  */
 120
 121 struct cl_decoded_option
 122 {
 123   /* The index of this option, or an OPT_SPECIAL_* value for
 124      non-options and unknown options.  */
 125   size_t opt_index;
 126
 127   /* Any warning to give for use of this option, or NULL if none.  */
 128   const char *warn_message;
 129
 130   /* The string argument, or NULL if none.  For OPT_SPECIAL_* cases,
 131      the option or non-option command-line argument.  */
 132   const char *arg;
 133
 134   /* The original text of option plus arguments, with separate argv
 135      elements concatenated into one string with spaces separating
 136      them.  This is for such uses as diagnostics and
 137      -frecord-gcc-switches.  */
 138   const char *orig_option_with_args_text;
 139
 140   /* The canonical form of the option and its argument, for when it is
 141      necessary to reconstruct argv elements (in particular, for
 142      processing specs and passing options to subprocesses from the
 143      driver).  */
 144   const char *canonical_option[4];
 145
 146   /* The number of elements in the canonical form of the option and
 147      arguments; always at least 1.  */
 148   size_t canonical_option_num_elements;
 149
 150   /* For a boolean option, 1 for the true case and 0 for the "no-"
 151      case.  For an unsigned integer option, the value of the
 152      argument.  1 in all other cases.  */
 153   int value;
 154
 155   /* Any flags describing errors detected in this option.  */
 156   int errors;
 157 };
 158
 159 /* Structure describing a single option-handling callback.  */
 160
 161 struct cl_option_handler_func
 162 {
 163   /* The function called to handle the option.  */
 164   bool (*handler) (struct gcc_options *opts,
 165                    struct gcc_options *opts_set,
 166                    const struct cl_decoded_option *decoded,
 167                    unsigned int lang_mask, int kind,
 168                    const struct cl_option_handlers *handlers,
 169                    diagnostic_context *dc);
 170
 171   /* The mask that must have some bit in common with the flags for the
 172      option for this particular handler to be used.  */
 173   unsigned int mask;
 174 };
 175
 176 /* Structure describing the callbacks used in handling options.  */
 177
 178 struct cl_option_handlers
 179 {
 180   /* Callback for an unknown option to determine whether to give an
 181      error for it, and possibly store information to diagnose the
 182      option at a later point.  Return true if an error should be
 183      given, false otherwise.  */
 184   bool (*unknown_option_callback) (const struct cl_decoded_option *decoded);
 185
 186   /* Callback to handle, and possibly diagnose, an option for another
 187      language.  */
 188   void (*wrong_lang_callback) (const struct cl_decoded_option *decoded,
 189                                unsigned int lang_mask);
 190
 191   /* Callback to call after the successful handling of any option.  */
 192   void (*post_handling_callback) (const struct cl_decoded_option *decoded,
 193                                   unsigned int mask);
 194
 195   /* The number of individual handlers.  */
 196   size_t num_handlers;
 197
 198   /* The handlers themselves.  */
 199   struct cl_option_handler_func handlers[3];
 200 };
 201
 202 /* Input file names.  */
 203
 204 extern const char **in_fnames;
 205
 206 /* The count of input filenames.  */
 207
 208 extern unsigned num_in_fnames;
 209
 210 size_t find_opt (const char *input, int lang_mask);
 211 extern int integral_argument (const char *arg);
 212 extern void decode_cmdline_options_to_array (unsigned int argc,
 213                                              const char **argv,
 214                                              unsigned int lang_mask,
 215                                              struct cl_decoded_option **decoded_options,
 216                                              unsigned int *decoded_options_count);
 217 extern void init_options_once (void);
 218 extern void init_options_struct (struct gcc_options *opts,
 219                                  struct gcc_options *opts_set);
 220 extern void decode_cmdline_options_to_array_default_mask (unsigned int argc,
 221                                                           const char **argv,
 222                                                           struct cl_decoded_option **decoded_options,
 223                                                           unsigned int *decoded_options_count);
 224 extern void decode_options (struct gcc_options *opts,
 225                             struct gcc_options *opts_set,
 226                             struct cl_decoded_option *decoded_options,
 227                             unsigned int decoded_options_count,
 228                             diagnostic_context *dc);
 229 extern int option_enabled (int opt_idx, void *opts);
 230 extern bool get_option_state (struct gcc_options *, int,
 231                               struct cl_option_state *);
 232 extern void set_option (struct gcc_options *opts,
 233                         struct gcc_options *opts_set,
 234                         int opt_index, int value, const char *arg, int kind,
 235                         diagnostic_context *dc);
 236 extern void *option_flag_var (int opt_index, struct gcc_options *opts);
 237 bool handle_option (struct gcc_options *opts,
 238                     struct gcc_options *opts_set,
 239                     const struct cl_decoded_option *decoded,
 240                     unsigned int lang_mask, int kind,
 241                     const struct cl_option_handlers *handlers,
 242                     bool generated_p, diagnostic_context *dc);
 243 bool handle_generated_option (struct gcc_options *opts,
 244                               struct gcc_options *opts_set,
 245                               size_t opt_index, const char *arg, int value,
 246                               unsigned int lang_mask, int kind,
 247                               const struct cl_option_handlers *handlers,
 248                               diagnostic_context *dc);
 249 void generate_option (size_t opt_index, const char *arg, int value,
 250                       unsigned int lang_mask,
 251                       struct cl_decoded_option *decoded);
 252 void generate_option_input_file (const char *file,
 253                                  struct cl_decoded_option *decoded);
 254 extern void read_cmdline_option (struct gcc_options *opts,
 255                                  struct gcc_options *opts_set,
 256                                  struct cl_decoded_option *decoded,
 257                                  unsigned int lang_mask,
 258                                  const struct cl_option_handlers *handlers,
 259                                  diagnostic_context *dc);
 260 extern void register_warning_as_error_callback (void (*callback) (int));
 261 extern void enable_warning_as_error (const char *arg, int value,
 262                                      unsigned int lang_mask,
 263                                      const struct cl_option_handlers *handlers,
 264                                      diagnostic_context *dc);
 265 extern void print_ignored_options (void);
 266 #endif