utils.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/utils.cpp to apps/utils.cpp).
//
 
#include "class_info.hpp"
 
#include "oks/kernel.hpp"
#include "oks/method.hpp"
 
#include <ctype.h>
 
#include <algorithm>
#include <ctime>
#include <initializer_list>
#include <iomanip>
#include <iostream>
 
using namespace dunedaq::oks;
using namespace dunedaq::oksdalgen;

 
char
cvt_symbol(char c)
{
  return (isalnum(c) ? c : '_');
}
 
std::string
alnum_name(const std::string& in)
{
  std::string s(in);
  std::transform(s.begin(), s.end(), s.begin(), cvt_symbol);
  return s;
}
 
std::string
capitalize_name(const std::string& in)
{
  std::string s(in);
  if (!in.empty()) {
    if (isalpha(in[0])) {
      if (islower(in[0]))
        s[0] = toupper(in[0]);
    } else {
      s.insert(s.begin(), '_');
    }
  }
  return s;
}

 
void
print_description(std::ostream& s, const std::string& text, const char* dx)
{
  if (!text.empty()) {
    s << dx << " /**\n";
 
    Oks::Tokenizer t(text, "\n");
    std::string token;
 
    while (!(token = t.next()).empty()) {
      s << dx << "  *  " << token << std::endl;
    }
 
    s << dx << "  */\n\n";
  }
}
 
void
print_indented(std::ostream& s, const std::string& text, const char* dx)
{
  if (!text.empty()) {
    Oks::Tokenizer t(text, "\n");
    std::string token;
 
    while (!(token = t.next()).empty()) {
      s << dx << token << std::endl;
    }
  }
}
 
std::string
get_type(OksData::Type oks_type, bool is_cpp)
{
  switch (oks_type) {
    case OksData::unknown_type:
      return "UNKNOWN";
    case OksData::s8_int_type:
      return (is_cpp ? "int8_t" : "char");
    case OksData::u8_int_type:
      return (is_cpp ? "uint8_t" : "byte");
    case OksData::s16_int_type:
      return (is_cpp ? "int16_t" : "short");
    case OksData::u16_int_type:
      return (is_cpp ? "uint16_t" : "short");
    case OksData::s32_int_type:
      return (is_cpp ? "int32_t" : "int");
    case OksData::u32_int_type:
      return (is_cpp ? "uint32_t" : "int");
    case OksData::s64_int_type:
      return (is_cpp ? "int64_t" : "long");
    case OksData::u64_int_type:
      return (is_cpp ? "uint64_t" : "long");
    case OksData::float_type:
      return "float";
    case OksData::double_type:
      return "double";
    case OksData::bool_type:
      return (is_cpp ? "bool" : "boolean");
 
    case OksData::string_type:
    case OksData::enum_type:
    case OksData::date_type:
    case OksData::time_type:
    case OksData::class_type:
      return (is_cpp ? "std::string" : "String");
 
    case OksData::object_type:
    case OksData::list_type:
    case OksData::uid_type:
    case OksData::uid2_type:
      return "funnytype";
  }
 
  return "invalid";
}
 
// std::string
// get_java_impl_name(const std::string& s)
// {
//   std::string str(s);
//   str += "_Impl";
//   return str;
// }
 
// std::string
// get_java_helper_name(const std::string& s)
// {
//   std::string str(s);
//   str += "_Helper";
//   return str;
// }
 
void
gen_dump_application(std::ostream& s,
                     std::list<std::string>& class_names,
                     const std::string& cpp_ns_name,
                     const std::string& cpp_hdr_dir,
                     const char* conf_header,
                     const char* conf_name,
                     const char* headres_prologue,
                     const char* main_function_prologue)
{
  s << "  // *** this file is generated by oksdalgen ***\n"
       "\n"
       "#include \"conffwk/ConfigObject.hpp\"\n"
       "#include \""
    << conf_header << "\"\n\n";
 
  // generate list of includes
  for (const auto& i : class_names) {
    std::string hname(cpp_hdr_dir);
    if (!hname.empty())
      hname += '/';
    hname += i;
    s << "#include \"" << hname << ".hpp\"\n";
  }
 
  if (headres_prologue && *headres_prologue) {
    s << "\n  // db implementation-specific headrers prologue\n\n" << headres_prologue << "\n";
  }
 
  s << "\n"
       "\n"
       "static void usage(const char * s)\n"
       "{\n"
       "  std::cout << s << \" -d db-name -c class-name [-q query | -i object-id] [-t]\\n\"\n"
       "    \"\\n\"\n"
       "    \"Options/Arguments:\\n\"\n"
       "    \"  -d | --data db-name            mandatory name of the database\\n\"\n"
       "    \"  -c | --class-name class-name   mandatory name of class\\n\"\n"
       "    \"  -q | --query query             optional query to select class objects\\n\"\n"
       "    \"  -i | --object-id object-id     optional identity to select one object\\n\"\n"
       "    \"  -t | --init-children           all referenced objects are initialized (is used\\n\"\n"
       "    \"                                 for debug purposes and performance measurements)\\n\"\n"
       "    \"  -h | --help                    print this message\\n\"\n"
       "    \"\\n\"\n"
       "    \"Description:\\n\"\n"
       "    \"  The program prints out object(s) of given class.\\n\"\n"
       "    \"  If no query or object id is provided, all objects of the class are printed.\\n\"\n"
       "    \"  It is automatically generated by oksdalgen utility.\\n\"\n"
       "    \"\\n\";\n"
       "}\n"
       "\n"
       "static void no_param(const char * s)\n"
       "{\n"
       "  std::cerr << \"ERROR: the required argument for option \\\'\" << s << \"\\\' is missing\\n\\n\";\n"
       "  exit (EXIT_FAILURE);\n"
       "}\n"
       "\n"
       "int main(int argc, char *argv[])\n"
       "{\n";
 
  if (main_function_prologue && *main_function_prologue) {
    s << "    // db implementation-specific main function prologue\n\n  " << main_function_prologue << "\n\n";
  }
 
  s << "    // parse parameters\n"
       "\n"
       "  const char * db_name = nullptr;\n"
       "  const char * object_id = nullptr;\n"
       "  const char * query = \"\";\n"
       "  std::string class_name;\n"
       "  bool init_children = false;\n"
       "\n"
       "  for(int i = 1; i < argc; i++) {\n"
       "    const char * cp = argv[i];\n"
       "    if(!strcmp(cp, \"-h\") || !strcmp(cp, \"--help\")) {\n"
       "      usage(argv[0]);\n"
       "      return 0;\n"
       "    }\n"
       "    if(!strcmp(cp, \"-t\") || !strcmp(cp, \"--init-children\")) {\n"
       "      init_children = true;\n"
       "    }\n"
       "    else if(!strcmp(cp, \"-d\") || !strcmp(cp, \"--data\")) {\n"
       "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { db_name = argv[i]; }\n"
       "    }\n"
       "    else if(!strcmp(cp, \"-c\") || !strcmp(cp, \"--class-name\")) {\n"
       "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { class_name = argv[i]; }\n"
       "    }\n"
       "    else if(!strcmp(cp, \"-i\") || !strcmp(cp, \"--object-id\")) {\n"
       "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { object_id = argv[i]; }\n"
       "    }\n"
       "    else if(!strcmp(cp, \"-q\") || !strcmp(cp, \"--query\")) {\n"
       "      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { query = argv[i]; }\n"
       "    }\n"
       "    else {\n"
       "      std::cerr << \"ERROR: bad parameter \" << cp << std::endl;\n"
       "      usage(argv[0]);\n"
       "      return (EXIT_FAILURE);\n"
       "    }\n"
       "  }\n"
       "\n"
       "  if(db_name == nullptr) {\n"
       "    std::cerr << \"ERROR: no database name provided\\n\";\n"
       "    return (EXIT_FAILURE);\n"
       "  }\n"
       "\n"
       "  if(class_name.empty()) {\n"
       "    std::cerr << \"ERROR: no class name provided\\n\";\n"
       "    return (EXIT_FAILURE);\n"
       "  }\n"
       "\n"
       "  if(*query != 0 && object_id != nullptr) {\n"
       "    std::cerr << \"ERROR: only one parameter -i or -q can be provided\\n\";\n"
       "    return (EXIT_FAILURE);\n"
       "  }\n"
       "\n"
       "\n"
       "std::cout << std::boolalpha;\n"
       "\n";
 
  if (conf_name) {
    s << "  " << conf_name
      << " impl_conf;\n"
         "\n"
         "  {\n"
         "    dunedaq::conffwk::Configuration conf(db_name, &impl_conf);\n";
  } else {
    s << "  try {\n"
         "    dunedaq::conffwk::Configuration conf(db_name);\n";
  }
 
  s << "\n"
       "    if(!conf.loaded()) {\n"
       "      std::cerr << \"Can not load database: \" << db_name << std::endl;\n"
       "      return (EXIT_FAILURE);\n"
       "    }\n"
       "    \n"
       "    std::vector< dunedaq::conffwk::ConfigObject > objects;\n"
       "    \n"
       "    if(object_id) {\n"
       "      dunedaq::conffwk::ConfigObject obj;\n"
       "      try {\n"
       "        conf.get(class_name, object_id, obj, 1);\n"
       "      }\n"
       "      catch (dunedaq::conffwk::NotFound & ex) {\n"
       "        std::cerr << \"Can not get object \\'\" << object_id << \"\\' of class \\'\" << class_name << "
       "\"\\':\\n\" << ex << std::endl;\n"
       "        return (EXIT_FAILURE);\n"
       "      }\n"
       "      objects.push_back(obj);\n"
       "    }\n"
       "    else {\n"
       "      try {\n"
       "        conf.get(class_name, objects, query, 1);\n"
       "      }\n"
       "      catch (dunedaq::conffwk::NotFound & ex) {\n"
       "        std::cerr << \"Can not get objects of class \\'\" << class_name << \"\\':\\n\" << ex << std::endl;\n"
       "        return (EXIT_FAILURE);\n"
       "      }\n"
       "    }\n"
       "    \n"
       "    struct SortByUId {\n"
       "      bool operator() (const dunedaq::conffwk::ConfigObject * o1, const dunedaq::conffwk::ConfigObject * o2) "
       "const {\n"
       "        return (o1->UID() < o2->UID());\n"
       "      };\n"
       "    };\n"
       "    \n"
       "    std::set< dunedaq::conffwk::ConfigObject *, SortByUId > sorted_objects;\n"
       "    \n"
       "    for(auto& i : objects)\n"
       "      sorted_objects.insert(&i);\n"
       "    \n"
       "    for(auto& i : sorted_objects) {\n";
 
  for (std::list<std::string>::iterator i = class_names.begin(); i != class_names.end(); ++i) {
    const char* op = (i == class_names.begin() ? "if" : "else if");
    std::string cname(cpp_ns_name);
 
    if (!cname.empty())
      cname += "::";
 
    cname += *i;
 
    s << "      " << op << "(class_name == \"" << *i
      << "\") {\n"
         "        std::cout << *conf.get<"
      << cname
      << ">(*i, init_children) << std::endl;\n"
         "      }\n";
  }
 
  s << "      else {\n"
       "        std::cerr << \"ERROR: do not know how to dump object of \" << class_name << \" class\\n\";\n"
       "        return (EXIT_FAILURE);\n"
       "      }\n"
       "    }\n"
       "  }\n"
       "  catch (dunedaq::conffwk::Exception & ex) {\n"
       "    std::cerr << \"Caught \" << ex << std::endl;\n"
       "    return (EXIT_FAILURE);\n"
       "  }\n"
       "\n"
       "  return 0;\n"
       "}\n";
}
 
void
write_info_file(std::ostream& s,
                const std::string& cpp_namespace,
                const std::string& cpp_header_dir,
                // const std::string& java_pname,
                const std::set<const OksClass*, std::less<const OksClass*>>& classes)
{
  std::time_t now = std::time(nullptr);
 
  s << "// the file is generated " << std::put_time(std::localtime(&now), "%F %T %Z")
    << " by oksdalgen utility\n"
       "// *** do not modify the file ***\n"
       "c++-namespace="
    << cpp_namespace
    << "\n"
       "c++-header-dir-prefix="
    << cpp_header_dir
    << "\n"
       // "java-package-name=" << java_pname << "\n"
       "classes:\n";
 
  for (const auto& i : classes)
    s << "  " << i->get_name() << std::endl;
}

 
std::string
get_full_cpp_class_name(const OksClass* c, const ClassInfo::Map& cl_info, const std::string& cpp_ns_name)
{
  std::string s;
  ClassInfo::Map::const_iterator idx = cl_info.find(c);
 
  if (idx != cl_info.end())
    s = (*idx).second.get_namespace();
  else
    s = cpp_ns_name;
 
  if (!s.empty())
    s += "::";
 
  s += alnum_name(c->get_name());
 
  return s;
}
 
std::string
get_include_dir(const OksClass* c, const ClassInfo::Map& cl_info, const std::string& cpp_hdr_dir)
{
  std::string s;
 
  ClassInfo::Map::const_iterator idx = cl_info.find(c);
 
  if (idx != cl_info.end()) {
    const std::string include_prefix = (*idx).second.get_include_prefix();
    if (!include_prefix.empty()) {
      s = include_prefix;
      s += '/';
    }
  } else if (!cpp_hdr_dir.empty()) {
    s = cpp_hdr_dir;
    s += '/';
  }
 
  s += alnum_name(c->get_name());
 
  return s;
}
 
// const std::string&
// get_package_name(const OksClass * c, const ClassInfo::Map& cl_info, const std::string& java_p_name)
// {
//   std::string s;
 
//   ClassInfo::Map::const_iterator idx = cl_info.find(c);
 
//   if (idx != cl_info.end())
//     {
//       return (*idx).second.get_package_name();
//     }
//   else
//     {
//       return java_p_name;
//     }
// }
 
bool
process_external_class(ClassInfo::Map& cl_info,
                       const OksClass* c,
                       const std::list<std::string>& include_dirs,
                       const std::list<std::string>& user_classes,
                       bool verbose)
{
  if (cl_info.find(c) != cl_info.end())
    return true;
 
  // process list of user-defined classes first
 
  for (const auto& s : user_classes) {
    std::string::size_type idx = s.find("::");
    std::string::size_type idx2 = s.find("@", idx + 2);
 
    std::string cpp_ns_name;
    std::string class_name;
    std::string cpp_dir_name;
 
    if (idx == std::string::npos) {
      class_name = s.substr(0, idx2);
    } else {
      cpp_ns_name = s.substr(0, idx);
      class_name = s.substr(idx + 2, idx2 - idx - 2);
    }
 
    if (idx2 != std::string::npos)
      cpp_dir_name = s.substr(idx2 + 1);
 
    if (class_name == c->get_name()) {
      cl_info[c] = ClassInfo(cpp_ns_name, cpp_dir_name);
      if (verbose) {
        std::cout << " * class " << c->get_name() << " is defined by user in ";
 
        if (cpp_ns_name.empty())
          std::cout << "global namespace";
        else
          std::cout << "namespace \"" << cpp_ns_name << '\"';
 
        if (!cpp_dir_name.empty())
          std::cout << " with \"" << cpp_dir_name << "\" include prefix";
 
        std::cout << std::endl;
      }
 
      return true;
    }
  }
 
  // process oksdalgen files
 
  if (verbose)
    std::cout << "Looking for oksdalgen info files ...\n";
 
  bool found_class_declaration = false;
 
  for (const auto& i : include_dirs) {
    std::string file_name(i);
    file_name += "/oksdalgen.info";
 
    std::ifstream f(file_name.c_str());
 
    if (f) {
      if (verbose)
        std::cout << " *** found file \"" << file_name << "\" ***\n";
 
      std::string cpp_ns_name;
      std::string cpp_dir_name;
      // std::string java_pname;
      bool is_class = false;
 
      std::string s;
      while (std::getline(f, s)) {
        if (s.find("//") != std::string::npos) {
          if (verbose)
            std::cout << " - skip comment \"" << s << "\"\n";
        } else if (s.find("classes:") != std::string::npos) {
          if (verbose)
            std::cout << " - found classes keyword\n";
          is_class = true;
        } else {
          const char s1[] = "c++-namespace=";
          std::string::size_type idx = s.find(s1);
          if (idx != std::string::npos) {
            cpp_ns_name = s.substr(sizeof(s1) - 1);
            if (verbose)
              std::cout << " - c++ namespace = \"" << cpp_ns_name << "\"\n";
          } else {
            const char s2[] = "c++-header-dir-prefix=";
            std::string::size_type idx = s.find(s2);
            if (idx != std::string::npos) {
              cpp_dir_name = s.substr(sizeof(s2) - 1);
              if (verbose)
                std::cout << " - c++ header dir prefix name = \"" << cpp_dir_name << "\"\n";
            }
            // else
            // {
            //   const char s3[] = "java-package-name=";
            //   std::string::size_type idx = s.find(s3);
            //   if (idx != std::string::npos)
            //     {
            //       java_pname = s.substr(sizeof(s3) - 1);
            //       if (verbose)
            //         std::cout << " - java package name = \"" << java_pname << "\"\n";
            //     }
            else if (is_class) {
              std::string cname = s.substr(2);
              OksClass* cl = c->get_kernel()->find_class(cname);
              if (cl && cl_info.find(cl) == cl_info.end()) {
                cl_info[cl] = ClassInfo(cpp_ns_name, cpp_dir_name);
                if (verbose)
                  std::cout << " * class " << cl->get_name() << " is defined by " << file_name << " in namespace \""
                            << cpp_ns_name << "\" with include prefix \"" << cpp_dir_name << "\"\n";
                if (cl == c)
                  found_class_declaration = true;
              } else if (verbose) {
                std::cout << " - skip class \"" << cname << "\" declaration\n";
              }
            } else {
              std::cerr << "Failed to parse line \"" << s << "\"\n";
            }
            // }
          }
        }
      }
    } else if (verbose) {
      std::cout << " *** file \"" << file_name << "\" does not exist ***\n";
    }
  }
 
  return found_class_declaration;
}
 
std::string
int2dx(int level)
{
  return std::string(level * 2, ' ');
}
 
int
open_cpp_namespace(std::ostream& s, const std::string& value)
{
  int level = 0;
  std::string dx;
 
  if (!value.empty()) {
    Oks::Tokenizer t(value, ":");
    std::string token;
 
    while (!(token = t.next()).empty()) {
      s << dx << "namespace " << token << " {\n";
      level++;
      dx += "  ";
    }
  }
 
  return level;
}
 
void
close_cpp_namespace(std::ostream& s, int level)
{
  while (level > 0) {
    std::string dx = int2dx(--level);
    s << dx << "}\n";
  }
}
 
const std::string begin_header_prologue("BEGIN_HEADER_PROLOGUE");
const std::string end_header_prologue("END_HEADER_PROLOGUE");
const std::string begin_header_epilogue("BEGIN_HEADER_EPILOGUE");
const std::string end_header_epilogue("END_HEADER_EPILOGUE");
const std::string begin_public_section("BEGIN_PUBLIC_SECTION"); // => java interface
const std::string end_public_section("END_PUBLIC_SECTION");
const std::string begin_private_section("BEGIN_PRIVATE_SECTION"); // => c++ and java
const std::string end_private_section("END_PRIVATE_SECTION");
const std::string begin_member_initializer_list("BEGIN_MEMBER_INITIALIZER_LIST");
const std::string end_member_initializer_list("END_MEMBER_INITIALIZER_LIST");
const std::string has_add_algo_1("ADD_ALGO_1");
const std::string has_add_algo_n("ADD_ALGO_N");
 
static std::string
get_method_header_x_logue(OksMethodImplementation* mi, const std::string& begin, const std::string& end)
{
  std::string::size_type begix_idx = mi->get_body().find(begin, 0);
  if (begix_idx == std::string::npos)
    return "";
  std::string::size_type end_idx = mi->get_body().find(end, begix_idx + begin.size());
  if (end_idx == std::string::npos)
    return "";
  return mi->get_body().substr(begix_idx + begin.size(), end_idx - begix_idx - begin.size());
}
 
std::string
get_method_header_prologue(OksMethodImplementation* mi)
{
  return get_method_header_x_logue(mi, begin_header_prologue, end_header_prologue);
}
 
std::string
get_method_header_epilogue(OksMethodImplementation* mi)
{
  return get_method_header_x_logue(mi, begin_header_epilogue, end_header_epilogue);
}
 
std::string
get_public_section(OksMethodImplementation* mi)
{
  return get_method_header_x_logue(mi, begin_public_section, end_public_section);
}
 
std::string
get_private_section(OksMethodImplementation* mi)
{
  return get_method_header_x_logue(mi, begin_private_section, end_private_section);
}
 
std::string
get_member_initializer_list(OksMethodImplementation* mi)
{
  return get_method_header_x_logue(mi, begin_member_initializer_list, end_member_initializer_list);
}
 
bool
get_add_algo_1(OksMethodImplementation* mi)
{
  return (mi->get_body().find(has_add_algo_1, 0) != std::string::npos);
}
 
bool
get_add_algo_n(OksMethodImplementation* mi)
{
  return (mi->get_body().find(has_add_algo_n, 0) != std::string::npos);
}
 
static void
remove_string_section(std::string& s, const std::string& begin, const std::string& end)
{
  std::string::size_type begix_idx = s.find(begin, 0);
  if (begix_idx == std::string::npos)
    return;
 
  std::string::size_type end_idx = (end.empty() ? (begix_idx + begin.size()) : s.find(end, begix_idx + begin.size()));
  if (end_idx == std::string::npos)
    return;
 
  end_idx += end.size();
  while (s[end_idx] == '\n')
    end_idx++;
 
  s.erase(begix_idx, end_idx - begix_idx);
}
 
std::string
get_method_implementation_body(OksMethodImplementation* mi)
{
  std::string s = mi->get_body();
  remove_string_section(s, begin_header_prologue, end_header_prologue);
  remove_string_section(s, begin_header_epilogue, end_header_epilogue);
  remove_string_section(s, begin_public_section, end_public_section);
  remove_string_section(s, begin_private_section, end_private_section);
  remove_string_section(s, begin_member_initializer_list, end_member_initializer_list);
  remove_string_section(s, has_add_algo_1, "");
  remove_string_section(s, has_add_algo_n, "");
 
  if (std::all_of(s.begin(), s.end(), isspace))
    return "";
  else
    return s;
}
 
static OksMethodImplementation*
find_method_implementation(const OksMethod* method, std::initializer_list<std::string> names)
{
  for (const auto& name : names) {
    if (OksMethodImplementation* mi = method->find_implementation(name))
      if (mi->get_prototype().empty() == false)
        return mi;
  }
 
  return nullptr;
}
 
OksMethodImplementation*
find_cpp_method_implementation(const OksMethod* method)
{
  return find_method_implementation(method, { "c++", "C++" });
}