parse_cmdl.cpp

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS genconfig source for the DUNE DAQ project.
// Fork baseline commit: genconfig-03-10-00 (2021-04-26).
// Renamed since fork: yes (from src/parse_cmdl.cpp to apps/parse_cmdl.cpp).
//
 
#include <cstdlib>
#include <cstring>
 
#include <iostream>
#include <list>
#include <string>
 
static void
usage()
{
  std::cout << "usage: oksdalgen [-d | --c++-dir-name directory-name]\n"
               "                 [-n | --c++-namespace namespace\n"
               "                 [-i | --c++-headers-dir directory-prefix]\n"
               "                 [-I | --include-dirs dirs*]\n"
               "                 [-c | --classes class*]\n"
               "                 [-D | --user-defined-classes [namespace::]user-class[@dir-prefix]*]\n"
               "                 [-f | --info-file-name file-name]\n"
               "                 [-v | --verbose]\n"
               "                 [-h | --help]\n"
               "                 -s | --schema-files file.schema.xml+\n"
               "\n"
               "Options/Arguments:\n"
               "       -d directory-name    name of directory for c++ header and implementation files\n"
               "       -n namespace         namespace for c++ classes\n"
               "       -i directory-prefix  name of directory prefix for c++ header files\n"
               "       -I dirs*             directories where to search for already generated files\n"
               "       -c class*            explicit list of classes to be generated\n"
               "       -D [x::]c[@d]*       user-defined classes\n"
               "       -f filename          name of output file describing generated files\n"
               "       -v                   switch on verbose output\n"
               "       -h                   this message\n"
               "       -s files+            the schema files (at least one is mandatory)\n"
               "\n"
               "Description:\n"
               "       The utility generates c++ code for OKS schema files.\n\n";
}
 
static void
no_param(const char* s)
{
  std::cerr << "ERROR: the required argument for option \'" << s << "\' is missing\n\n";
  exit(EXIT_FAILURE);
}
 
void
parse_arguments(int argc,
                char* argv[],
                std::list<std::string>& class_names,
                std::list<std::string>& file_names,
                std::list<std::string>& include_dirs,
                std::list<std::string>& user_classes,
                std::string& cpp_dir_name,
                std::string& cpp_ns_name,
                std::string& cpp_hdr_dir,
                std::string& info_file_name,
                bool& verbose)
{
 
  for (int i = 1; i < argc; i++) {
    const char* cp = argv[i];
 
    if (!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
      usage();
      exit(EXIT_SUCCESS);
    } else if (!strcmp(cp, "-v") || !strcmp(cp, "--verbose")) {
      verbose = true;
    } else if (!strcmp(cp, "-d") || !strcmp(cp, "--c++-dir-name")) {
      if (++i == argc || argv[i][0] == '-')
        no_param(cp);
      else
        cpp_dir_name = argv[i];
    } else if (!strcmp(cp, "-n") || !strcmp(cp, "--c++-namespace")) {
      if (++i == argc || argv[i][0] == '-')
        no_param(cp);
      else
        cpp_ns_name = argv[i];
    } else if (!strcmp(cp, "-i") || !strcmp(cp, "--c++-headers-dir")) {
      if (++i == argc || argv[i][0] == '-')
        no_param(cp);
      else
        cpp_hdr_dir = argv[i];
    } else if (!strcmp(cp, "-f") || !strcmp(cp, "--info-file-name")) {
      if (++i == argc || argv[i][0] == '-')
        no_param(cp);
      else
        info_file_name = argv[i];
    } else {
      std::list<std::string>* slist = ((!strcmp(cp, "-c") || !strcmp(cp, "--classes"))                ? &class_names
                                       : (!strcmp(cp, "-s") || !strcmp(cp, "--schema-files"))         ? &file_names
                                       : (!strcmp(cp, "-I") || !strcmp(cp, "--include-dirs"))         ? &include_dirs
                                       : (!strcmp(cp, "-D") || !strcmp(cp, "--user-defined-classes")) ? &user_classes
                                                                                                      : nullptr);
 
      if (slist) {
        int j = 0;
        for (; j < argc - i - 1; ++j) {
          if (argv[i + 1 + j][0] != '-')
            slist->push_back(argv[i + 1 + j]);
          else
            break;
        }
        i += j;
      } else {
        std::cerr << "ERROR: Unexpected parameter: \"" << cp << "\"\n\n";
        usage();
        exit(EXIT_FAILURE);
      }
    }
  }
 
  if (file_names.size() == 0) {
    std::cerr << "At least one schema file is required\n";
    exit(EXIT_FAILURE);
  }
 
  if (verbose) {
    std::cout << "VERBOSE:\n"
                 "  Command line parameters:\n"
                 "    c++ directory name:    \""
              << cpp_dir_name
              << "\"\n"
                 "    c++ namespace name:    \""
              << cpp_ns_name
              << "\"\n"
                 "    c++ headers directory: \""
              << cpp_hdr_dir
              << "\"\n"
                 "    classes:";
 
    if (!class_names.empty()) {
      std::cout << std::endl;
 
      for (const auto& i : class_names)
        std::cout << "      - " << i << std::endl;
    } else {
      std::cout << " no\n";
    }
 
    std::cout << "    file names:";
 
    if (!file_names.empty()) {
      std::cout << std::endl;
 
      for (const auto& i : file_names)
        std::cout << "      * " << i << std::endl;
    } else {
      std::cout << " no\n";
    }
 
    std::cout << "    include directories for search:";
 
    if (!include_dirs.empty()) {
      std::cout << std::endl;
 
      for (const auto& i : include_dirs)
        std::cout << "      * " << i << std::endl;
    } else {
      std::cout << " no\n";
    }
 
    std::cout << "    user-defined classes:";
 
    if (!user_classes.empty()) {
      std::cout << std::endl;
 
      for (const auto& i : user_classes)
        std::cout << "      * " << i << std::endl;
    } else {
      std::cout << " no\n";
    }
  }
}