LCOV - code coverage report
Current view: top level - oksdalgen/apps - parse_cmdl.cpp (source / functions) Coverage Total Hit
Test: code.result Lines: 0.0 % 74 0
Test Date: 2025-12-21 13:07:08 Functions: 0.0 % 3 0

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

Generated by: LCOV version 2.0-1