cmake/gengetopt/gengetopt.cc

   1 /**
   2  * Copyright (C) 1999-2007  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU gengetopt
   5  *
   6  * GNU gengetopt is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU gengetopt is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
  14  * Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with gengetopt; see the file COPYING. If not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <iostream>
  29
  30 void gengetopt_free (void);
  31
  32 /* The following one is generated by gengetopt itself */
  33 #include "cmdline.h"
  34
  35 extern int yyparse () ;
  36
  37 #include "gengetopt.h"
  38 #include "errorcodes.h"
  39
  40 #include "argsdef.h"
  41 #include "global_opts.h"
  42
  43 #include "my_sstream.h"
  44 #include "my_string.h"
  45
  46 #include "gm.h"
  47 #include "groups.h"
  48 #include "gm_utils.h"
  49
  50 #include "skels/copyright.h"
  51
  52 #include "yyerror.h"
  53 #include "globals.h"
  54
  55 char * gengetopt_package = NULL;
  56 char * gengetopt_version = NULL;
  57 char * gengetopt_purpose = NULL;
  58 char * gengetopt_description = NULL;
  59 char * gengetopt_usage = NULL;
  60
  61 modes_collection_t gengetopt_modes;
  62
  63 int gengetopt_count_line = 1;
  64 char * gengetopt_input_filename = 0;
  65 char *current_section = 0;
  66 char *current_section_desc = 0;
  67 char *current_text = 0;
  68 char *current_args = 0;
  69
  70 /// whether, if not specified, an option is considered optional
  71 bool default_to_optional = false;
  72
  73 int canonize_vars (void);
  74 static void set_default_required_properties(void);
  75
  76 static void print_copyright();
  77 static void print_reportbugs();
  78
  79 static void output_formatted_string(const string &);
  80
  81 static bool check_dependencies();
  82
  83 static int gengetopt_create_option (gengetopt_option *&opt, const char * long_opt, char short_opt,
  84                           const char * desc,
  85                           int type, int flagstat, int required,
  86                           const char *default_value,
  87                           const char * group_value,
  88                           const char * mode_value,
  89                           const char * type_str,
  90                           const AcceptedValues *acceptedvalues,
  91                           int multiple = 0,
  92                           int argoptional = 0);
  93
  94
  95 #include <algorithm>
  96 #include <iterator>
  97
  98 using namespace std;
  99
 100 /// the structure for command line arguments
 101 struct gengetopt_args_info args_info ;
 102
 103 int
 104 main (int argc, char **argv)
 105 {
 106   char *cmdline_parser_name ; /* name of the generated function */
 107   char *cmdline_filename ; /* name of generated file */
 108   char *c_ext ; /* extenstion of c file */
 109   char *header_ext  ; /* extenstion of header file */
 110   string output_dir, header_output_dir, src_output_dir; /* output directory (default empty -> current dir)*/
 111
 112   int i, has_help, has_version;
 113   FILE *input_file ;
 114
 115   if (cmdline_parser (argc, argv, &args_info) != 0) {
 116       fprintf (stderr, "Run gengetopt --help to see the list of options.\n");
 117       exit(1) ;
 118   }
 119
 120   if (args_info.help_given)
 121   {
 122     cmdline_parser_print_help ();
 123     print_reportbugs ();
 124     exit (0);
 125   }
 126
 127   if (args_info.detailed_help_given)
 128     {
 129       cmdline_parser_print_detailed_help ();
 130       print_reportbugs ();
 131       exit (0);
 132     }
 133
 134   if (args_info.version_given)
 135   {
 136     cmdline_parser_print_version ();
 137     print_copyright ();
 138     exit (0);
 139   }
 140
 141   if ( args_info.input_arg )
 142     {
 143       gengetopt_input_filename = strdup (args_info.input_arg);
 144       input_file = freopen (args_info.input_arg, "r", stdin) ;
 145       if (!input_file)
 146         {
 147           fprintf (stderr, "Error opening input file: %s\n",
 148                    args_info.input_arg);
 149           exit (1);
 150         }
 151     } /* else standard input is used */
 152
 153   if (yyparse () != 0) {
 154         gengetopt_free ();
 155         return 1;
 156   }
 157
 158   // check whether some options were given in the input file
 159   bool no_options = (gengetopt_options.size() == 0);
 160
 161   if (current_args) {
 162     // parse the arguments passed in the "args" part of the input file
 163     // by possibily overriding those given at command line
 164     if (cmdline_parser_string2 (current_args, &args_info, "gengetopt", 1, 0, 0) != 0) {
 165       fprintf (stderr, "Error in the args specification of the input_file.\n");
 166       exit(1) ;
 167     }
 168   }
 169
 170   cmdline_parser_name = args_info.func_name_arg ;
 171   cmdline_filename = args_info.file_name_arg ;
 172   c_ext = args_info.c_extension_arg;
 173   header_ext = args_info.header_extension_arg;
 174
 175   default_to_optional = args_info.default_optional_given;
 176
 177   // now set the default "required" property for options
 178   set_default_required_properties();
 179
 180   if (! check_dependencies()) {
 181     gengetopt_free();
 182     return 1;
 183   }
 184
 185   // insert options for help and version if not already present
 186   gengetopt_option *opt;
 187
 188   if (current_section)
 189     free(current_section);
 190   current_section = 0;
 191
 192   has_version = gengetopt_has_option (VERSION_LONG_OPT, VERSION_SHORT_OPT);
 193
 194   if (has_version != REQ_LONG_OPTION && !args_info.no_version_given) {
 195     gengetopt_create_option (opt, VERSION_LONG_OPT, has_version ? '-' : VERSION_SHORT_OPT,
 196                                  VERSION_OPT_DESCR, ARG_NO, 0, 0, 0, 0, 0, 0, 0);
 197     gengetopt_options.push_front(opt);
 198   }
 199
 200   if (!args_info.no_help_given && has_hidden_options() && gengetopt_has_option(FULL_HELP_LONG_OPT, 0) == 0) {
 201       gengetopt_create_option (opt, FULL_HELP_LONG_OPT, '-',
 202                                FULL_HELP_OPT_DESCR, ARG_NO, 0, 0, 0, 0, 0, 0, 0);
 203       gengetopt_options.push_front(opt);
 204   }
 205
 206   if (!args_info.no_help_given && has_options_with_details() && gengetopt_has_option(DETAILED_HELP_LONG_OPT, 0) == 0) {
 207       gengetopt_create_option (opt, DETAILED_HELP_LONG_OPT, '-',
 208               DETAILED_HELP_OPT_DESCR, ARG_NO, 0, 0, 0, 0, 0, 0, 0);
 209       gengetopt_options.push_front(opt);
 210   }
 211
 212   has_help = gengetopt_has_option(HELP_LONG_OPT, HELP_SHORT_OPT);
 213
 214   if (has_help != REQ_LONG_OPTION && !args_info.no_help_given) {
 215     gengetopt_create_option (opt, HELP_LONG_OPT, has_help ? '-' : HELP_SHORT_OPT,
 216                                  HELP_OPT_DESCR, ARG_NO, 0, 0, 0, 0, 0, 0, 0);
 217     gengetopt_options.push_front(opt);
 218   }
 219
 220   // check whether there's pending text after all options and
 221   // in case, set it to the last option
 222   if (current_text && gengetopt_options.size()) {
 223     gengetopt_options.back()->text_after = current_text;
 224     gengetopt_set_text(0);
 225   }
 226
 227   if (canonize_vars ()) {
 228         gengetopt_free ();
 229         return 1;
 230   }
 231
 232   if (args_info.set_package_given) {
 233     if (gengetopt_package)
 234       free (gengetopt_package);
 235     gengetopt_package = args_info.set_package_arg;
 236   }
 237
 238   if (args_info.set_version_given) {
 239     if (gengetopt_version)
 240       free (gengetopt_version);
 241     gengetopt_version = args_info.set_version_arg;
 242   }
 243
 244   ostringstream command_line;
 245   for ( i = 0; i < argc ; ++i )
 246       command_line << argv[i] << " ";
 247
 248   // add also possible args specification in the input file
 249   if (current_args)
 250     command_line << current_args;
 251
 252   if (args_info.output_dir_given)
 253       output_dir = args_info.output_dir_arg;
 254   if (args_info.header_output_dir_given)
 255       header_output_dir = args_info.header_output_dir_arg;
 256   if (args_info.src_output_dir_given)
 257       src_output_dir = args_info.src_output_dir_arg;
 258
 259   CmdlineParserCreator cmdline_parser_creator
 260     (cmdline_parser_name,
 261      args_info.arg_struct_name_arg,
 262      (args_info.unamed_opts_given ? args_info.unamed_opts_arg : 0),
 263      cmdline_filename,
 264      header_ext,
 265      c_ext,
 266      args_info.long_help_given,
 267      args_info.no_handle_help_given,
 268      args_info.no_help_given,
 269      args_info.no_handle_version_given,
 270      args_info.no_version_given,
 271      args_info.no_handle_error_given,
 272      args_info.conf_parser_given,
 273      args_info.string_parser_given,
 274      args_info.gen_version_flag,
 275      args_info.include_getopt_given,
 276      no_options,
 277      command_line.str (),
 278      output_dir,
 279      header_output_dir,
 280      src_output_dir,
 281      (args_info.show_required_given ? args_info.show_required_arg : ""));
 282
 283   if (! gengetopt_package && (args_info.show_version_given || args_info.show_help_given))
 284     {
 285       cerr << "package not defined; please specify it with --set-package" << endl;
 286       return 1;
 287     }
 288   else if (! gengetopt_version && (args_info.show_version_given || args_info.show_help_given))
 289     {
 290       cerr << "version not defined; please specify it with --set-version" << endl;
 291       return 1;
 292     }
 293   else if (args_info.show_version_given)
 294     {
 295       cout << gengetopt_package << " " << gengetopt_version << endl;
 296     }
 297   else if (args_info.show_help_given ||
 298           args_info.show_full_help_given || args_info.show_detailed_help_given)
 299     {
 300       cout << gengetopt_package << " " << gengetopt_version << "\n" << endl;
 301
 302       if (gengetopt_purpose) {
 303         output_formatted_string(cmdline_parser_creator.generate_purpose());
 304         cout << endl;
 305       }
 306
 307       output_formatted_string("Usage: " +
 308         cmdline_parser_creator.generate_usage_string(false) + "\n");
 309
 310       if (gengetopt_description) {
 311         output_formatted_string(cmdline_parser_creator.generate_description());
 312         cout << endl;
 313       }
 314
 315       // if --show-full-help is specified we have to generate also hidden options
 316       OptionHelpList *option_list =
 317           cmdline_parser_creator.generate_help_option_list(args_info.show_full_help_given, args_info.show_detailed_help_given);
 318
 319       std::for_each(option_list->begin(), option_list->end(),
 320               output_formatted_string);
 321
 322       delete option_list;
 323     }
 324   else if (cmdline_parser_creator.generate ())
 325     {
 326         gengetopt_free ();
 327         return 1;
 328     }
 329
 330   gengetopt_free ();
 331
 332   return 0;
 333 }
 334
 335 void
 336 output_formatted_string(const string &s)
 337 {
 338   for (string::const_iterator it = s.begin(); it != s.end(); ++it)
 339     {
 340       if (*it == '\\' && ((it+1) != s.end()) && *(it+1) == 'n') {
 341         cout << "\n";
 342         ++it;
 343       } else if (*it == '\\' && ((it+1) != s.end()) && *(it+1) == '"') {
 344         cout << "\"";
 345         ++it;
 346       } else
 347         cout << *it;
 348     }
 349
 350   cout << endl;
 351 }
 352
 353 /* ************* */
 354
 355 int
 356 gengetopt_define_package (char * s)
 357 {
 358         gengetopt_package = strdup (s);
 359         if (gengetopt_package == NULL)
 360                 return 1;
 361         return 0;
 362 }
 363
 364 int
 365 gengetopt_define_version (char * s)
 366 {
 367         gengetopt_version = strdup (s);
 368         if (gengetopt_version == NULL)
 369                 return 1;
 370         return 0;
 371 }
 372
 373 int
 374 gengetopt_define_purpose (char * s)
 375 {
 376   gengetopt_purpose = strdup (s);
 377   if (gengetopt_purpose == NULL)
 378     return 1;
 379   return 0;
 380 }
 381
 382 int
 383 gengetopt_define_description (char * s)
 384 {
 385   gengetopt_description = strdup (s);
 386   if (gengetopt_description == NULL)
 387     return 1;
 388   return 0;
 389 }
 390
 391 int gengetopt_define_usage (char * s)
 392 {
 393   gengetopt_usage = strdup (s);
 394   if (gengetopt_usage == NULL)
 395     return 1;
 396   return 0;
 397 }
 398
 399 int
 400 gengetopt_add_group (const char *s, const char *desc, int required)
 401 {
 402   string group_desc;
 403   if (desc)
 404     group_desc = desc;
 405   if ( !gengetopt_groups.insert
 406        (make_pair(string(s),Group (group_desc, required != 0))).second )
 407     return 1;
 408   else
 409     return 0;
 410 }
 411
 412 int
 413 gengetopt_add_mode (const char *s, const char *desc)
 414 {
 415   string mode_desc;
 416   if (desc)
 417     mode_desc = desc;
 418   if ( !gengetopt_modes.insert
 419        (make_pair(string(s),Mode (mode_desc))).second )
 420     return 1;
 421   else
 422     return 0;
 423 }
 424
 425 void
 426 gengetopt_set_section (const char * s, const char *desc)
 427 {
 428   if (current_section)
 429     free (current_section);
 430   if (current_section_desc)
 431     free (current_section_desc);
 432   current_section = strdup (s);
 433   if (desc)
 434     current_section_desc = strdup (desc);
 435   else
 436     current_section_desc = 0;
 437 }
 438
 439 void
 440 gengetopt_set_text (const char * desc)
 441 {
 442   /*
 443   no need to free it, since it will be then owned by the
 444   option only
 445
 446   if (current_text)
 447     free (current_text);
 448   */
 449
 450   // the current text is reset
 451   if (!desc) {
 452     current_text = 0;
 453     return;
 454   }
 455
 456   if (current_text) {
 457     // a previous text was collected, so we append the new text
 458     // to the current one.
 459     string buffer = current_text;
 460     buffer += desc;
 461     current_text = strdup(buffer.c_str());
 462     return;
 463   }
 464
 465   // otherwise simply copy the passed text
 466   current_text = strdup (desc);
 467 }
 468
 469 void gengetopt_set_args(const char *a)
 470 {
 471   if (current_args)
 472     free(current_args);
 473
 474   if (a)
 475     current_args = strdup(a);
 476   else
 477     current_args = 0;
 478 }
 479
 480 int
 481 gengetopt_has_option (const char * long_opt, char short_opt)
 482 {
 483   gengetopt_option * n;
 484
 485   for (gengetopt_option_list::const_iterator it = gengetopt_options.begin();
 486        it != gengetopt_options.end(); ++it)
 487     {
 488       n = *it;
 489       if (!strcmp (n->long_opt, long_opt)) return REQ_LONG_OPTION;
 490       if (short_opt && n->short_opt == short_opt)
 491         return REQ_SHORT_OPTION;
 492     }
 493
 494   return 0;
 495 }
 496
 497 bool check_numeric_validity(const char *val, int opt_type)
 498 {
 499     char *end_of_string, *expected_eos;
 500
 501     expected_eos = (char *) (val + strlen(val));
 502
 503     switch ( opt_type )
 504       {
 505       case ARG_INT :
 506       case ARG_SHORT :
 507       case ARG_LONG :
 508       case ARG_LONGLONG :
 509         (void) strtol(val, &end_of_string, 0);
 510         break;
 511
 512       case ARG_FLOAT:
 513       case ARG_DOUBLE:
 514       case ARG_LONGDOUBLE:
 515         (void) strtod(val, &end_of_string);
 516         break;
 517
 518       default :
 519         // This will allow us to factorise as a single line the
 520         // test for correctness of the default value
 521         end_of_string = expected_eos;
 522         break;
 523       }
 524     return ( end_of_string == expected_eos );
 525 }
 526
 527 bool
 528 check_values(const AcceptedValues *acceptedvalues, int opt_type)
 529 {
 530     for (AcceptedValues::const_iterator it = acceptedvalues->begin();
 531         it != acceptedvalues->end(); ++it) {
 532         if (!check_numeric_validity((*it).c_str(), opt_type))
 533             return false;
 534     }
 535
 536     return true;
 537 }
 538
 539 int
 540 gengetopt_create_option (gengetopt_option *&n, const char * long_opt, char short_opt,
 541                       const char * desc,
 542                       int type, int flagstat, int required,
 543                       const char * default_value,
 544                       const char * group_value,
 545                       const char * mode_value,
 546                       const char * type_str,
 547                       const AcceptedValues *acceptedvalues,
 548                       int multiple,
 549                       int argoptional)
 550 {
 551   if ((long_opt == NULL) ||
 552       (long_opt[0] == 0) ||
 553       (desc == NULL))
 554     return FOUND_BUG;
 555
 556   n = new gengetopt_option;
 557   if (n == NULL)
 558     return NOT_ENOUGH_MEMORY;
 559
 560   // here we will set required anyway
 561   n->required_set = true;
 562
 563   n->long_opt = strdup (long_opt);
 564   if (n->long_opt == NULL)
 565     {
 566       free (n);
 567       return NOT_ENOUGH_MEMORY;
 568     }
 569
 570   n->desc = strdup (desc);
 571   if (n->desc == NULL)
 572     {
 573       free (n->long_opt);
 574       free (n);
 575       return NOT_ENOUGH_MEMORY;
 576     }
 577
 578   n->short_opt = ((short_opt == '-') ? 0 : short_opt);
 579   n->type = type;
 580   n->flagstat = flagstat;
 581   n->required = required;
 582   n->multiple = (multiple != 0);
 583   n->arg_is_optional = (argoptional != 0);
 584
 585   if (type_str != 0)
 586     n->type_str = strdup(type_str);
 587   else
 588     n->type_str = NULL;
 589
 590   n->section = 0;
 591   n->section_desc = 0;
 592   if (current_section)
 593     n->section = strdup (current_section);
 594   if (current_section_desc)
 595     n->section_desc = strdup (current_section_desc);
 596
 597   if (group_value != 0)
 598     {
 599       n->group_value = strdup(group_value);
 600       n->required = 0;
 601       groups_collection_t::const_iterator it =
 602         gengetopt_groups.find(string(n->group_value));
 603       if (it == gengetopt_groups.end())
 604         return GROUP_UNDEFINED;
 605       n->group_desc = strdup (it->second.desc.c_str ());
 606     }
 607   else
 608     {
 609       n->group_value = 0;
 610     }
 611
 612   if (mode_value != 0) {
 613       n->mode_value = strdup(mode_value);
 614       modes_collection_t::const_iterator it =
 615           gengetopt_modes.find(string(n->mode_value));
 616       if (it == gengetopt_modes.end())
 617           return MODE_UNDEFINED;
 618       n->mode_desc = strdup (it->second.desc.c_str ());
 619   } else {
 620       n->mode_value = 0;
 621   }
 622
 623   if (n->group_value && n->mode_value)
 624       return FOUND_BUG;
 625
 626
 627   n->acceptedvalues = acceptedvalues;
 628
 629   // if (acceptedvalues && type != ARG_NO)
 630   // return NOT_REQUESTED_TYPE;
 631
 632   if (acceptedvalues && ! (n->type))
 633     n->type = ARG_STRING;
 634
 635   n->default_string = 0;
 636   n->default_given = (default_value != 0);
 637   if (n->default_given)
 638     {
 639       n->default_string = strdup (default_value);
 640       if ( ! check_numeric_validity(default_value, n->type) )
 641         {
 642           free (n);
 643           return INVALID_DEFAULT_VALUE;
 644         }
 645
 646       if (acceptedvalues)
 647         {
 648           if (! acceptedvalues->contains(n->default_string))
 649             return INVALID_DEFAULT_VALUE;
 650         }
 651     }
 652
 653   if (acceptedvalues) {
 654       if (!check_values(acceptedvalues, n->type))
 655           return INVALID_NUMERIC_VALUE;
 656   }
 657
 658   n->var_arg = NULL;
 659
 660   return 0;
 661 }
 662
 663 int
 664 gengetopt_check_option (gengetopt_option *n, bool groupoption, bool modeoption)
 665 {
 666   if ((n->long_opt == NULL) ||
 667       (n->long_opt[0] == 0) ||
 668       (n->desc == NULL))
 669     return FOUND_BUG;
 670
 671   if (strcmp(n->long_opt, HELP_LONG_OPT) == 0 && !args_info.no_help_given)
 672       return HELP_REDEFINED;
 673
 674   if (strcmp(n->long_opt, VERSION_LONG_OPT) == 0 && !args_info.no_version_given)
 675       return VERSION_REDEFINED;
 676
 677   n->section = 0;
 678   n->section_desc = 0;
 679   if (current_section)
 680     n->section = strdup (current_section);
 681   if (current_section_desc)
 682     n->section_desc = strdup (current_section_desc);
 683
 684   n->text_before = current_text;
 685   // reset the description
 686   gengetopt_set_text(0);
 687
 688   if (n->group_value != 0)
 689   {
 690       if (! groupoption)
 691           return NOT_GROUP_OPTION;
 692
 693       n->required = 0;
 694       n->required_set = true;
 695
 696       groups_collection_t::const_iterator it =
 697           gengetopt_groups.find(string(n->group_value));
 698       if (it == gengetopt_groups.end())
 699           return GROUP_UNDEFINED;
 700       n->group_desc = strdup (it->second.desc.c_str ());
 701   }
 702   else
 703   {
 704       if (groupoption)
 705           return SPECIFY_GROUP;
 706   }
 707
 708   if (n->mode_value != 0)
 709   {
 710       if (! modeoption)
 711           return NOT_MODE_OPTION;
 712
 713       modes_collection_t::const_iterator it =
 714           gengetopt_modes.find(string(n->mode_value));
 715       if (it == gengetopt_modes.end())
 716           return MODE_UNDEFINED;
 717       n->mode_desc = strdup (it->second.desc.c_str ());
 718   }
 719   else
 720   {
 721       if (modeoption)
 722           return SPECIFY_MODE;
 723   }
 724
 725   if (n->group_value && n->mode_value)
 726       return FOUND_BUG;
 727
 728   // now we have to check for flag options
 729   if (n->type == ARG_FLAG)
 730   {
 731     if (n->flagstat < 0)
 732       return SPECIFY_FLAG_STAT;
 733
 734     if (n->default_string || n->multiple || n->arg_is_optional
 735         || n->type_str || n->acceptedvalues || n->required_set)
 736       return NOT_VALID_SPECIFICATION;
 737
 738     n->required = 0;
 739     n->required_set = true;
 740   }
 741   else
 742   {
 743     if (n->flagstat >= 0)
 744       return NOT_VALID_SPECIFICATION;
 745   }
 746
 747   // enum type can only be specified with options with values
 748   if (n->type == ARG_ENUM && !(n->acceptedvalues)) {
 749       return INVALID_ENUM_TYPE_USE;
 750   }
 751
 752   // if (acceptedvalues && type != ARG_NO)
 753   // return NOT_REQUESTED_TYPE;
 754
 755   if (n->acceptedvalues && ! (n->type))
 756     n->type = ARG_STRING;
 757
 758   n->default_given = (n->default_string != 0);
 759   if (n->default_given)
 760     {
 761       if ( !check_numeric_validity(n->default_string, n->type) )
 762         {
 763           return INVALID_DEFAULT_VALUE;
 764         }
 765
 766       if (n->acceptedvalues)
 767         {
 768           if (! n->acceptedvalues->contains(n->default_string))
 769             return INVALID_DEFAULT_VALUE;
 770         }
 771     }
 772
 773   if (n->acceptedvalues) {
 774       if (!check_values(n->acceptedvalues, n->type))
 775           return INVALID_NUMERIC_VALUE;
 776   }
 777
 778   n->var_arg = NULL;
 779
 780   return 0;
 781 }
 782
 783 int
 784 gengetopt_add_option (const char * long_opt, char short_opt,
 785                       const char * desc,
 786                       int type, int flagstat, int required,
 787                       const char * default_value,
 788                       const char * group_value,
 789                       const char * mode_value,
 790                       const char * type_str,
 791                       const AcceptedValues *acceptedvalues,
 792                       int multiple,
 793                       int argoptional)
 794 {
 795   gengetopt_option * n;
 796
 797   /* search for collisions */
 798   int res = gengetopt_has_option(long_opt, short_opt);
 799   if (res != 0)
 800     return res;
 801
 802   res = gengetopt_create_option(n, long_opt, short_opt,
 803     desc, type, flagstat, required, default_value, group_value, mode_value,
 804     type_str, acceptedvalues, multiple, argoptional);
 805   if (res != 0)
 806     return res;
 807
 808   gengetopt_options.push_back(n);
 809
 810   return 0;
 811 }
 812
 813 int
 814 gengetopt_add_option (gengetopt_option * n)
 815 {
 816   /* search for collisions */
 817   int res = gengetopt_has_option(n);
 818   if (res != 0)
 819     return res;
 820
 821   gengetopt_options.push_back(n);
 822
 823   return 0;
 824 }
 825
 826 int
 827 gengetopt_has_option (gengetopt_option * opt)
 828 {
 829   gengetopt_option * n;
 830
 831   for (gengetopt_option_list::const_iterator it = gengetopt_options.begin();
 832        it != gengetopt_options.end(); ++it)
 833     {
 834       n = *it;
 835       if (!strcmp (n->long_opt, opt->long_opt))
 836         return REQ_LONG_OPTION;
 837       if (opt->short_opt && n->short_opt == opt->short_opt)
 838         return REQ_SHORT_OPTION;
 839     }
 840
 841   return 0;
 842 }
 843
 844 bool
 845 check_dependencies()
 846 {
 847   gengetopt_option * n;
 848   bool result = true;
 849
 850   for (gengetopt_option_list::const_iterator it = gengetopt_options.begin();
 851        it != gengetopt_options.end(); ++it)
 852   {
 853     n = *it;
 854     if (n->dependon) {
 855         if (strcmp(n->dependon, n->long_opt) == 0) {
 856             yyerror(n, "option depends on itself");
 857             result = false;
 858             continue;
 859         }
 860
 861         bool found = false;
 862         for (gengetopt_option_list::const_iterator it2 = gengetopt_options.begin();
 863             it2 != gengetopt_options.end(); ++it2)
 864         {
 865             if (strcmp(n->dependon, (*it2)->long_opt) == 0) {
 866                 found = true;
 867                 break;
 868             }
 869         }
 870
 871         if (! found) {
 872             yyerror (n, "option depends on undefined option");
 873             result = false;
 874         }
 875     }
 876   }
 877
 878   return result;
 879 }
 880
 881 void
 882 gengetopt_free (void)
 883 {
 884   gengetopt_option *p;
 885
 886   if (gengetopt_package != NULL)
 887     free (gengetopt_package);
 888
 889   for (gengetopt_option_list::iterator it = gengetopt_options.begin(); it != gengetopt_options.end(); ++it)
 890   {
 891         p = *it;
 892         if (p->long_opt != NULL) free (p->long_opt);
 893         if (p->desc != NULL) free (p->desc);
 894         if (p->var_arg != NULL) free (p->var_arg);
 895         if (p->acceptedvalues) delete p->acceptedvalues;
 896         delete p;
 897   }
 898 }
 899
 900 static void
 901 canonize_var (gengetopt_option *p)
 902 {
 903   char *pvar;
 904
 905   p->var_arg = strdup (p->long_opt);
 906   if (p->var_arg == NULL) {
 907       printf ("gengetopt: not enough memory to canonize vars\n");
 908       abort();
 909   }
 910
 911   for (pvar = p->var_arg; *pvar; pvar++)
 912     if (*pvar == '.' || *pvar == '-') *pvar = '_';
 913 }
 914
 915 int
 916 canonize_vars (void)
 917 {
 918   for_each(gengetopt_options.begin(), gengetopt_options.end(), canonize_var);
 919
 920   return 0;
 921 }
 922
 923 static void
 924 set_default_required_prop (gengetopt_option *p)
 925 {
 926     if (!p->required_set)
 927         p->required = (default_to_optional ? 0 : 1);
 928 }
 929
 930 static void set_default_required_properties(void)
 931 {
 932   for_each(gengetopt_options.begin(), gengetopt_options.end(), set_default_required_prop);
 933 }
 934
 935 void
 936 print_copyright()
 937 {
 938   copyright_gen_class copyright_g;
 939
 940   copyright_g.set_year ("1999-2009");
 941   copyright_g.generate_copyright (cout);
 942 }
 943
 944 void
 945 print_reportbugs()
 946 {
 947   cout << endl;
 948   cout << "Maintained by Lorenzo Bettini <http://www.lorenzobettini.it>" << endl;
 949   cout << "Report bugs to <bug-gengetopt at gnu.org>" << endl;
 950 }