LCOV - code coverage report
Current view: top level - oksdalgen/apps - parse_cmdl.cpp (source / functions) Coverage Total Hit
Test: code.result Lines: 0.0 % 73 0
Test Date: 2026-10-11 15:05:20 Functions: 0.0 % 3 0

            Line data    Source code
       1              : //
       2              : // DUNE DAQ modification notice:
       3              : // This file has been modified from the original ATLAS genconfig source for the DUNE DAQ project.
       4              : // Fork baseline commit: genconfig-03-10-00 (2021-04-26).
       5              : // Renamed since fork: yes (from src/parse_cmdl.cpp to apps/parse_cmdl.cpp).
       6              : //
       7              : 
       8              : #include <cstdlib>
       9              : #include <cstring>
      10              : 
      11              : #include <iostream>
      12              : #include <list>
      13              : #include <string>
      14              : 
      15              : static void
      16            0 : usage()
      17              : {
      18            0 :   std::cout << "usage: oksdalgen [-d | --c++-dir-name directory-name]\n"
      19              :                "                 [-n | --c++-namespace namespace\n"
      20              :                "                 [-i | --c++-headers-dir directory-prefix]\n"
      21              :                "                 [-I | --include-dirs dirs*]\n"
      22              :                "                 [-c | --classes class*]\n"
      23              :                "                 [-D | --user-defined-classes [namespace::]user-class[@dir-prefix]*]\n"
      24              :                "                 [-f | --info-file-name file-name]\n"
      25              :                "                 [-v | --verbose]\n"
      26              :                "                 [-h | --help]\n"
      27              :                "                 -s | --schema-files file.schema.xml+\n"
      28              :                "\n"
      29              :                "Options/Arguments:\n"
      30              :                "       -d directory-name    name of directory for c++ header and implementation files\n"
      31              :                "       -n namespace         namespace for c++ classes\n"
      32              :                "       -i directory-prefix  name of directory prefix for c++ header files\n"
      33              :                "       -I dirs*             directories where to search for already generated files\n"
      34              :                "       -c class*            explicit list of classes to be generated\n"
      35              :                "       -D [x::]c[@d]*       user-defined classes\n"
      36              :                "       -f filename          name of output file describing generated files\n"
      37              :                "       -v                   switch on verbose output\n"
      38              :                "       -h                   this message\n"
      39              :                "       -s files+            the schema files (at least one is mandatory)\n"
      40              :                "\n"
      41              :                "Description:\n"
      42            0 :                "       The utility generates c++ code for OKS schema files.\n\n";
      43            0 : }
      44              : 
      45              : static void
      46            0 : no_param(const char* s)
      47              : {
      48            0 :   std::cerr << "ERROR: the required argument for option \'" << s << "\' is missing\n\n";
      49            0 :   exit(EXIT_FAILURE);
      50              : }
      51              : 
      52              : void
      53            0 : parse_arguments(int argc,
      54              :                 char* argv[],
      55              :                 std::list<std::string>& class_names,
      56              :                 std::list<std::string>& file_names,
      57              :                 std::list<std::string>& include_dirs,
      58              :                 std::list<std::string>& user_classes,
      59              :                 std::string& cpp_dir_name,
      60              :                 std::string& cpp_ns_name,
      61              :                 std::string& cpp_hdr_dir,
      62              :                 std::string& info_file_name,
      63              :                 bool& verbose)
      64              : {
      65              : 
      66            0 :   for (int i = 1; i < argc; i++) {
      67            0 :     const char* cp = argv[i];
      68              : 
      69            0 :     if (!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
      70            0 :       usage();
      71            0 :       exit(EXIT_SUCCESS);
      72            0 :     } else if (!strcmp(cp, "-v") || !strcmp(cp, "--verbose")) {
      73            0 :       verbose = true;
      74            0 :     } else if (!strcmp(cp, "-d") || !strcmp(cp, "--c++-dir-name")) {
      75            0 :       if (++i == argc || argv[i][0] == '-')
      76            0 :         no_param(cp);
      77              :       else
      78            0 :         cpp_dir_name = argv[i];
      79            0 :     } else if (!strcmp(cp, "-n") || !strcmp(cp, "--c++-namespace")) {
      80            0 :       if (++i == argc || argv[i][0] == '-')
      81            0 :         no_param(cp);
      82              :       else
      83            0 :         cpp_ns_name = argv[i];
      84            0 :     } else if (!strcmp(cp, "-i") || !strcmp(cp, "--c++-headers-dir")) {
      85            0 :       if (++i == argc || argv[i][0] == '-')
      86            0 :         no_param(cp);
      87              :       else
      88            0 :         cpp_hdr_dir = argv[i];
      89            0 :     } else if (!strcmp(cp, "-f") || !strcmp(cp, "--info-file-name")) {
      90            0 :       if (++i == argc || argv[i][0] == '-')
      91            0 :         no_param(cp);
      92              :       else
      93            0 :         info_file_name = argv[i];
      94              :     } else {
      95            0 :       std::list<std::string>* slist = ((!strcmp(cp, "-c") || !strcmp(cp, "--classes"))                ? &class_names
      96            0 :                                        : (!strcmp(cp, "-s") || !strcmp(cp, "--schema-files"))         ? &file_names
      97            0 :                                        : (!strcmp(cp, "-I") || !strcmp(cp, "--include-dirs"))         ? &include_dirs
      98            0 :                                        : (!strcmp(cp, "-D") || !strcmp(cp, "--user-defined-classes")) ? &user_classes
      99              :                                                                                                       : nullptr);
     100              : 
     101            0 :       if (slist) {
     102              :         int j = 0;
     103            0 :         for (; j < argc - i - 1; ++j) {
     104            0 :           if (argv[i + 1 + j][0] != '-')
     105            0 :             slist->push_back(argv[i + 1 + j]);
     106              :           else
     107              :             break;
     108              :         }
     109            0 :         i += j;
     110              :       } else {
     111            0 :         std::cerr << "ERROR: Unexpected parameter: \"" << cp << "\"\n\n";
     112            0 :         usage();
     113            0 :         exit(EXIT_FAILURE);
     114              :       }
     115              :     }
     116              :   }
     117              : 
     118            0 :   if (file_names.size() == 0) {
     119            0 :     std::cerr << "At least one schema file is required\n";
     120            0 :     exit(EXIT_FAILURE);
     121              :   }
     122              : 
     123            0 :   if (verbose) {
     124            0 :     std::cout << "VERBOSE:\n"
     125              :                  "  Command line parameters:\n"
     126              :                  "    c++ directory name:    \""
     127              :               << cpp_dir_name
     128              :               << "\"\n"
     129              :                  "    c++ namespace name:    \""
     130              :               << cpp_ns_name
     131              :               << "\"\n"
     132              :                  "    c++ headers directory: \""
     133              :               << cpp_hdr_dir
     134              :               << "\"\n"
     135            0 :                  "    classes:";
     136              : 
     137            0 :     if (!class_names.empty()) {
     138            0 :       std::cout << std::endl;
     139              : 
     140            0 :       for (const auto& i : class_names)
     141            0 :         std::cout << "      - " << i << std::endl;
     142              :     } else {
     143            0 :       std::cout << " no\n";
     144              :     }
     145              : 
     146            0 :     std::cout << "    file names:";
     147              : 
     148            0 :     if (!file_names.empty()) {
     149            0 :       std::cout << std::endl;
     150              : 
     151            0 :       for (const auto& i : file_names)
     152            0 :         std::cout << "      * " << i << std::endl;
     153              :     } else {
     154            0 :       std::cout << " no\n";
     155              :     }
     156              : 
     157            0 :     std::cout << "    include directories for search:";
     158              : 
     159            0 :     if (!include_dirs.empty()) {
     160            0 :       std::cout << std::endl;
     161              : 
     162            0 :       for (const auto& i : include_dirs)
     163            0 :         std::cout << "      * " << i << std::endl;
     164              :     } else {
     165            0 :       std::cout << " no\n";
     166              :     }
     167              : 
     168            0 :     std::cout << "    user-defined classes:";
     169              : 
     170            0 :     if (!user_classes.empty()) {
     171            0 :       std::cout << std::endl;
     172              : 
     173            0 :       for (const auto& i : user_classes)
     174            0 :         std::cout << "      * " << i << std::endl;
     175              :     } else {
     176            0 :       std::cout << " no\n";
     177              :     }
     178              :   }
     179            0 : }
        

Generated by: LCOV version 2.0-1