stringManipulationHelperFunctions.cpp

#include <cctype>
#include <string>
#include <vector>

bool isAllWhitespace(const std::string token) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(token, std::regex(R"(^\s*$)"));
  for (unsigned i = 0; i < token.size(); i++)
    if (not(std::isspace(token[i])))
      return false;
  return true;
}

bool isAllDigits(const std::string token) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(token, std::regex(R"(^\d+$)"));
  if (not(token.size()))
    return false;
  for (unsigned i = 0; i < token.size(); i++)
    if (not(std::isdigit(token[i])))
      return false;
  return true;
}

bool isWordCharacterButNotDigit(const char c) {
  return (std::isalnum(c) or c == '_') and not(std::isdigit(c));
}

bool isInteger(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str,
                             std::regex(R"((^\d+$)|(^0x(\d|[a-f]|[A-F])+$))"));
  if (not(str.size()))
    return false;
  if (str.substr(0, 2) == "0x") { // Hexadecimal numbers...
    if (str.size() == 2)
      return false;
    for (unsigned i = 2; i < str.size(); i++)
      if (not(std::isdigit(str[i])) and not((str[i] >= 'A' and str[i] <= 'F') or
                                            (str[i] >= 'a' and str[i] <= 'f')))
        return false;
    return true;
  }
  // Integer decimal numbers...
  for (unsigned i = 0; i < str.size(); i++)
    if (not(std::isdigit(str[i])))
      return false;
  return true;
}

bool isDecimalNumber(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str, std::regex(R"(^([+-])?\d+\.\d*$)"));
  if (not(str.size()))
    return false;
  bool haveWePassedOverADecimalPoint = false;
  if (str[0] == '.')
    return false;
  for (unsigned i = 0; i < str.size(); i++)
    if (str[i] == '.' and not(haveWePassedOverADecimalPoint))
      haveWePassedOverADecimalPoint = true;
    else if (str[i] == '.')
      return false;
    else if (!isdigit(str[i]))
      return false;
  return true;
}

bool isValidVariableName(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str, std::regex(R"(^(_|[a-z]|[A-Z])\w*\[?$)"));
  if (!str.size())
    return false;
  if (std::isdigit(str[0]))
    return false;
  for (unsigned i = 0; i < str.size(); i++)
    if (not(std::isalnum(str[i])) and str[i] != '_' and
        not(i == str.size() - 1 and str[i] == '['))
      return false;
  return true;
}

bool isPointerType(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str, std::regex("Pointer$"));
  if (str.size() < std::string("Pointer").size())
    return false;
  return str.substr(str.size() - std::string("Pointer").size()) == "Pointer";
}

bool isArray(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str, std::regex(R"(\[$)"));
  if (str.empty())
    return false;
  return str.back() == '[';
}

bool isFunction(std::string str) {
  if (the_cpp_runtime_library_supports_regexes)
    return std::regex_search(str, std::regex(R"(\($)"));
  if (str.empty())
    return false;
  return str.back() == '(';
}

bool isDecimalType(std::string str) {
  return str == "Decimal32" or str == "Decimal64";
}

bool isComposedOfAlnumsAndOneDot(
    std::string token) // Done often in the tokenizer, so it's probably better
                       // (and more portable) to do it this way than in REGEX.
{
  bool passedOverADot = false;
  for (unsigned i = 0; i < token.size(); i++)
    if (token[i] == '.' and not(passedOverADot) and i != 0)
      passedOverADot = true;
    else if (token[i] == '.')
      return false;
    else if (not(std::isalnum(token[i])) and token[i] != '_')
      return false;
  return true;
}

int longest_common_subsequence_length(std::string first, std::string second) {
  // Adapted from the Domagoj Kusalić'es book "Napredno programiranje i
  // algoritmi u C-u i C++-u", chapter 8.4.3, page 331 (in the 2014 edition).
  std::map<int, std::map<int, int>>
      DP; // There are, of course, faster ways to make multi-dimensional arrays
          // in C++, but let's not worry about performance of a function that
          // will be run only upon an error (to suggest a true name of a
          // misspelled variable name). Still, they are probably all easier than
          // dealing with multi-dimensional arrays in JavaScript.
  for (size_t i = 0; i < first.size();
       i++) // Microsoft C++ Compiler issues a warning if you put "unsigned"
            // instead of "size_t" here, I am not sure why.
    for (size_t j = 0; j < second.size(); j++)
      if (first[i] == second[j])
        DP[int(i)][int(j)] =
            DP[int(i - 1)][int(j - 1)] +
            1; // Had we used vectors instead of maps, we could not do
               // this so simply (What if 'i' or 'j' are zero?).
      else
        DP[int(i)][int(j)] =
            std::max(DP[int(i - 1)][int(j)], DP[int(i)][int(j - 1)]);
  return DP[int(first.size() - 1)][int(second.size() - 1)];
}

int Levenstein_distance(std::string A, std::string B) {
  // https://discord.com/channels/530598289813536771/847014270922391563/867319320485167115
  //  |
  //  V
  // https://github.com/royalpranjal/Interview-Bit/blob/master/DynamicProgramming/EditDistance.cpp
  using std::min;
  using std::vector;

  int row = int(A.size());
  int col = int(B.size());

  vector<vector<int>> temp(row + 1, vector<int>(col + 1));

  for (size_t i = 0; i < temp.size();
       i++) { // Apparently, GCC issues a warning under "-Wall" unless you
              // replace "int" with "size_t" here. I do not know why.
    for (size_t j = 0; j < temp[0].size(); j++) {
      if (j == 0) {
        temp[i][j] = int(i);
      } else if (i == 0) {
        temp[i][j] = int(j);
      } else if (A[i - 1] == B[j - 1]) {
        temp[i][j] = temp[i - 1][j - 1];
      } else {
        temp[i][j] =
            min(<%temp[i - 1][j - 1], temp[i - 1][j], temp[i][j - 1]%>) +
            1; // This is valid since C++14
               // (because std::min accepts
               // initialization lists as
               // arguments and invokes
               // std::min_element in that case),
               // and I guess most C++11 compilers
               // will accept this code (but I have
               // not tested that).
      }
    }
  }

  return temp[row][col];
}

#define USING_LEVENSTEIN_DISTANCE

bool ends_with(
    const std::string &first,
    const std::string &
        second) { // https://stackoverflow.com/questions/67451951/how-to-use-pointers-to-figure-out-if-a-c-string-ends-with-another-c-string/67452057?noredirect=1#comment119223072_67452057
  if (second.size() > first.size())
    return false;
  return first.substr(first.size() - second.size()) == second;
}

std::string demanglePointerType(std::string pointerType) {
  if (pointerType.substr(0, std::string("PointerTo").size()) == "PointerTo")
    return demanglePointerType(
        pointerType.substr(std::string("PointerTo").size()) + "Pointer");
  return pointerType;
}