kslicer_utils.cpp

#include "kslicer.h"
#include "initial_pass.h"
#include "template_rendering.h"

#include <algorithm>
#include <fstream>
#include <cctype>
#include <string>

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::string kslicer::GetRangeSourceCode(const clang::SourceRange a_range, const clang::CompilerInstance& compiler)
{
  const clang::SourceManager& sm = compiler.getSourceManager();
  const clang::LangOptions& lopt = compiler.getLangOpts();

  clang::SourceLocation b(a_range.getBegin()), _e(a_range.getEnd());
  clang::SourceLocation e(clang::Lexer::getLocForEndOfToken(_e, 0, sm, lopt));
  if(e < b)
    return std::string("");
  else
    return std::string(sm.getCharacterData(b), sm.getCharacterData(e));
}

std::string kslicer::GetRangeSourceCode(const clang::SourceRange a_range, const clang::SourceManager& sm)
{
  clang::LangOptions lopt;

  clang::SourceLocation b(a_range.getBegin()), _e(a_range.getEnd());
  clang::SourceLocation e(clang::Lexer::getLocForEndOfToken(_e, 0, sm, lopt));

  return std::string(sm.getCharacterData(b), sm.getCharacterData(e));
}

// Converts token range to a char range in file which ends right after the last token.
// Ranges which begin or end inside macro expansion (like 'const uint32_t a = MY_DEFINE') are expanded to the macro use site.
//
static clang::CharSourceRange FileCharRangeAfterLastToken(const clang::Rewriter& a_rewriter, const clang::SourceRange a_range)
{
  const clang::SourceManager& sm = a_rewriter.getSourceMgr();
  const clang::LangOptions&   lo = a_rewriter.getLangOpts();
  clang::CharSourceRange res = clang::Lexer::makeFileCharRange(clang::CharSourceRange::getTokenRange(a_range), sm, lo);
  if(res.isValid())
    return res;
  clang::SourceLocation b = a_range.getBegin();
  clang::SourceLocation e = a_range.getEnd();
  if(b.isMacroID())
    b = sm.getExpansionRange(b).getBegin();
  if(e.isMacroID())
    e = sm.getExpansionRange(e).getEnd();
  e = clang::Lexer::getLocForEndOfToken(e, 0, sm, lo);
  if(b.isInvalid() || e.isInvalid() || e < b)
    return clang::CharSourceRange();
  return clang::CharSourceRange::getCharRange(b, e);
}

std::string kslicer::GetRewrittenText(const clang::Rewriter& a_rewriter, const clang::SourceRange a_range)
{
  // Rewriter::getRewrittenText(SourceRange) maps the beginning of the last token and then adds the ORIGINAL token length.
  // If the last token was replaced by a text of different length, the result is cut ('m_summ' ==> 'ubo[0').
  // So, we convert token range to char range which ends right after the last token.
  //
  const clang::CharSourceRange range = FileCharRangeAfterLastToken(a_rewriter, a_range);
  if(range.isInvalid())
    return a_rewriter.getRewrittenText(a_range);
  return a_rewriter.getRewrittenText(range);
}

bool kslicer::ReplaceTextSafe(clang::Rewriter& a_rewriter, const clang::SourceRange a_range, const std::string& a_text)
{
  // Rewriter::ReplaceText(SourceRange) erases 'getRangeSize(range)' chars, which has the same problem as getRewrittenText:
  // if the last token was already replaced, only its ORIGINAL length is erased and the tail of previous replacement remains ('m_winWidth' ==> 'ubo[0].m_winWidthinWidth').
  // So we measure the current (rewritten) size of a char range which ends right after the last token.
  //
  const clang::CharSourceRange range = FileCharRangeAfterLastToken(a_rewriter, a_range);
  if(range.isInvalid())
    return a_rewriter.ReplaceText(a_range, a_text);
  clang::Rewriter::RewriteOptions opts;
  opts.IncludeInsertsAtBeginOfRange = false; // ReplaceText(loc, ...) starts after text inserted at 'loc', so measure the size from the same point
  const int currSize = a_rewriter.getRangeSize(range, opts);
  if(currSize < 0)
    return a_rewriter.ReplaceText(a_range, a_text);
  return a_rewriter.ReplaceText(range.getBegin(), unsigned(currSize), a_text);
}

uint64_t kslicer::GetHashOfSourceRange(const clang::SourceRange& a_range)
{
  const uint32_t hash1 = a_range.getBegin().getRawEncoding();
  const uint32_t hash2 = a_range.getEnd().getRawEncoding();
  return (uint64_t(hash1) << 32) | uint64_t(hash2);
}


void kslicer::PrintError(const std::string& a_msg, const clang::SourceRange& a_range, const clang::SourceManager& a_sm)
{
  const auto beginLoc  = a_range.getBegin();
  const auto inFileLoc = a_sm.getPresumedLoc(beginLoc);

  const auto fileName = std::string(a_sm.getFilename(beginLoc));
  const auto line     = inFileLoc.getLine();
  const auto col      = inFileLoc.getColumn();

  std::string code = GetRangeSourceCode(a_range, a_sm);

  std::cout << fileName.c_str() << ":" << line << ":" << col << ": error: " << a_msg << std::endl;
  std::cout << "--> " << code.c_str() << std::endl;
}

void kslicer::PrintWarning(const std::string& a_msg, const clang::SourceRange& a_range, const clang::SourceManager& a_sm)
{
  const auto beginLoc  = a_range.getBegin();
  const auto inFileLoc = a_sm.getPresumedLoc(beginLoc);

  const auto fileName = std::string(a_sm.getFilename(beginLoc));
  const auto line     = inFileLoc.getLine();
  const auto col      = inFileLoc.getColumn();

  std::string code = GetRangeSourceCode(a_range, a_sm);

  std::cout << fileName.c_str() << ":" << line << ":" << col << ": warning: " << a_msg << " --> " << code.c_str() << std::endl;
}

void kslicer::ExtractTypeAndVarNameFromConstructor(clang::CXXConstructExpr* constructExpr, clang::ASTContext* astContext, std::string& varName, std::string& typeName) 
{
  // (0) очищаем строки
  //
  varName = ""; 
  typeName = "";
  
  // (1) Получаем имя типа
  //
  clang::CXXConstructorDecl* ctor = constructExpr->getConstructor();
  typeName = ctor->getNameInfo().getName().getAsString();
  
  // (2) Получаем имя переменной
  clang::DynTypedNodeList parents = astContext->getParents(*constructExpr);
  for (const clang::DynTypedNode& parent : parents) {
      if (const clang::VarDecl* varDecl = parent.get<clang::VarDecl>()) {
          varName = varDecl->getNameAsString();
          break;
      }
  }
}


const clang::Expr* kslicer::RemoveImplicitCast(const clang::Expr* nextNode)
{
  if(nextNode == nullptr)
    return nullptr;
  while(clang::isa<clang::ImplicitCastExpr>(nextNode))
  {
    auto cast = dyn_cast<const clang::ImplicitCastExpr>(nextNode);
    nextNode  = cast->getSubExpr();
  }
  return nextNode;
}

clang::Expr* kslicer::RemoveImplicitCast(clang::Expr* nextNode)
{
  if(nextNode == nullptr)
    return nullptr;
  while(clang::isa<clang::ImplicitCastExpr>(nextNode))
  {
    auto cast = dyn_cast<clang::ImplicitCastExpr>(nextNode);
    nextNode  = cast->getSubExpr();
  }
  return nextNode;
}


std::string kslicer::CutOffFileExt(const std::string& a_filePath)
{
  const size_t lastindex = a_filePath.find_last_of(".");
  if(lastindex != std::string::npos)
    return a_filePath.substr(0, lastindex);
  else
    return a_filePath;
}

std::string kslicer::CutOffStructClass(const std::string& a_typeName)
{
  auto spacePos = a_typeName.find_last_of(" ");
  if(spacePos != std::string::npos)
    return a_typeName.substr(spacePos+1);
  return a_typeName;
}

void MakeAbsolutePathRelativeTo(std::filesystem::path& a_filePath, const std::filesystem::path& a_folderPath)
{
  a_filePath = std::filesystem::relative(a_filePath, a_folderPath);
}

std::string ToLowerCase(std::string a_str)
{
  std::transform(a_str.begin(), a_str.end(), a_str.begin(), [](unsigned char c){ return std::tolower(c); });
  return a_str;
}

std::unordered_set<std::string> kslicer::GetAllServiceKernels()
{
  std::unordered_set<std::string> names;
  names.insert("copyKernelFloat");
  names.insert("matMulTranspose");
  return names;
}

std::string kslicer::ExtractSizeFromArgExpression(const std::string& a_str)
{
  auto posOfPlus = a_str.find("+");
  auto posOfEnd  = a_str.find(".end()");

  if(posOfPlus != std::string::npos)
  {
    std::string sizeExpr = a_str.substr(posOfPlus+1);
    ReplaceFirst(sizeExpr," ", "");
    return sizeExpr;
  }
  else if(posOfEnd != std::string::npos)
  {
    return a_str.substr(0, posOfEnd) + ".size()";
  }

  return a_str;
}

std::string kslicer::ClearNameFromBegin(const std::string& a_str)
{
  auto posOfBeg = a_str.find(".begin()");
  if(posOfBeg != std::string::npos)
    return a_str.substr(0, posOfBeg);

  return a_str;
}

std::string kslicer::FixLamdbaSourceCode(std::string a_str)
{
  while(ReplaceFirst(a_str, "uint32_t ", "uint "));
  while(ReplaceFirst(a_str, "unsigned int ", "uint "));

  while(ReplaceFirst(a_str, "uint2 ",    "uvec2 "));
  while(ReplaceFirst(a_str, "uint3 ",    "uvec3 "));
  while(ReplaceFirst(a_str, "uint4 ",    "uvec4 "));

  while(ReplaceFirst(a_str, "int2 ",     "ivec2 "));
  while(ReplaceFirst(a_str, "int3 ",     "ivec3 "));
  while(ReplaceFirst(a_str, "int4 ",     "ivec4 "));

  while(ReplaceFirst(a_str, "float2 ",   "vec2 "));
  while(ReplaceFirst(a_str, "float3 ",   "vec3 "));
  while(ReplaceFirst(a_str, "float4 ",   "vec4 "));

  return a_str;
}

std::string kslicer::SubstrBetween(const std::string& a_str, const std::string& first, const std::string& second)
{
  auto pos1 = a_str.find(first);
  auto pos2 = a_str.find(second);
  if(pos1 != std::string::npos && pos2 != std::string::npos)
    return a_str.substr(pos1+1, pos2 - pos1 - 1);
  return a_str;
}

bool kslicer::IsTexture(clang::QualType a_qt)
{
  if(a_qt->isReferenceType())
    a_qt = a_qt.getNonReferenceType();

  auto typeDecl = a_qt->getAsRecordDecl();
  if(typeDecl == nullptr || !clang::isa<clang::ClassTemplateSpecializationDecl>(typeDecl))
    return false;

  const std::string typeName = a_qt.getAsString();
  return (typeName.find("Texture") != std::string::npos || typeName.find("Image") != std::string::npos);
}

bool kslicer::IsAccelStruct(const std::string& a_typeName)
{
  if( (a_typeName == "struct ISceneObject")  || (a_typeName == "ISceneObject") || 
      (a_typeName == "struct ISceneObject2") || (a_typeName == "ISceneObject2") )
    return true;
  else if(a_typeName.find("ISceneObject_") != std::string::npos)  
    return true;
  else
    return false;
}

bool kslicer::IsVectorContainer(const std::string& a_typeName)
{
  return (a_typeName == "vector") || (a_typeName == "std::vector") || (a_typeName == "cvex::vector");
}

bool kslicer::IsPointerContainer(const std::string& a_typeName)
{
  return (a_typeName == "shared_ptr") || (a_typeName == "unique_ptr") ||
         (a_typeName == "std::shared_ptr") || (a_typeName == "std::unique_ptr");
}

std::string kslicer::MakeKernellCallSignature(const std::string& a_mainFuncName, const std::vector<ArgReferenceOnCall>& a_args, const std::map<std::string, UsedContainerInfo>& a_usedContainers)
{
  std::stringstream strOut;
  for(const auto& arg : a_args)
  {
    switch(arg.argType)
    {
      case KERN_CALL_ARG_TYPE::ARG_REFERENCE_LOCAL:
      strOut << "[L]";
      break;

      case KERN_CALL_ARG_TYPE::ARG_REFERENCE_ARG:
      strOut << "[A][" << a_mainFuncName.c_str() << "]" ;
      break;

      case KERN_CALL_ARG_TYPE::ARG_REFERENCE_CLASS_VECTOR:
      strOut << "[V]";
      break;

      case KERN_CALL_ARG_TYPE::ARG_REFERENCE_CLASS_POD:
      strOut << "[P]";
      break;

      case KERN_CALL_ARG_TYPE::ARG_REFERENCE_THREAD_ID:
      strOut << "[T]";
      break;

      default:
      strOut << "[U]";
      break;
    };

    strOut << arg.name.c_str();
  }

  for(const auto& vecName : a_usedContainers)
    strOut << "[MV][" << vecName.second.name.c_str() << "]";

  return strOut.str();
}

std::vector<kslicer::NameFlagsPair> kslicer::ListAccessedTextures(const std::vector<kslicer::ArgReferenceOnCall>& args, const kslicer::KernelInfo& kernel)
{
  std::vector<kslicer::NameFlagsPair> accesedTextures;
  accesedTextures.reserve(16);
  for(uint32_t i=0;i<uint32_t(args.size());i++)
  {
    if(args[i].isTexture())
    {
      std::string argNameInKernel = kernel.args[i].name;
      auto pFlags = kernel.texAccessInArgs.find(argNameInKernel);
      kslicer::NameFlagsPair tex;
      tex.name  = args[i].name;
      if(pFlags != kernel.texAccessInArgs.end())
        tex.flags = pFlags->second;
      tex.isArg = true;
      tex.argId = i;
      accesedTextures.push_back(tex);
    }
  }
  for(const auto& container : kernel.usedContainers)
  {
    if(container.second.isTexture())
    {
      auto pFlags = kernel.texAccessInMemb.find(container.second.name);
      kslicer::NameFlagsPair tex;
      tex.name  = container.second.name;
      if(pFlags != kernel.texAccessInMemb.end())
        tex.flags = pFlags->second;
      else
        tex.flags = kslicer::TEX_ACCESS::TEX_ACCESS_SAMPLE;
      tex.isArg = false;
      accesedTextures.push_back(tex);
    }
  }
  return accesedTextures;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::unordered_map<std::string, std::string> ReadCommandLineParams(int argc, const char** argv, 
                                                                   std::unordered_map<std::string, std::string>& defines,
                                                                   std::filesystem::path& fileName,
                                                                   std::vector<std::string>& allFiles,
                                                                   std::vector<std::string>& ignoreFiles,
                                                                   std::vector<std::string>& processFiles,
                                                                   std::vector<std::string>& cppIncludes)
{
  std::unordered_map<std::string, std::string> cmdLineParams;
  for(int i=0; i<argc; i++)
  {
    std::string key(argv[i]);

    const bool isDefine = key.size() > 1 && key.substr(0,2) == "-D";
    const bool isKey    = key.size() > 0 && key[0] == '-';

    if(key == "-ignore")
      ignoreFiles.push_back(argv[i+1]);
    else if (key == "-process")
      processFiles.push_back(argv[i+1]);
    else if (key == "-cpp_include")
      cppIncludes.push_back(argv[i+1]);
    else if(key != "-v" && !isDefine && isKey) // exclude special "-IfoldePath" form, exclude "-v"
    {
      if(i != argc-1) // not last argument
      {
        cmdLineParams[key] = argv[i+1];
        i++;
      }
      else
        cmdLineParams[key] = "";
    }
    else if(key.find(".cpp") != std::string::npos)
      allFiles.push_back(key);
    else if(isDefine)
    {
      std::string name, value; 
      size_t spacePos = key.find(' ', 2);
      if (spacePos != std::string::npos) 
      {
        // Извлекаем имя определения (после -D и до пробела)
        name = key.substr(2, spacePos - 2);
        // Извлекаем значение (после пробела)
        value = key.substr(spacePos + 1);
      } 
      else 
      {
        // Если пробела нет, вся строка после -D считается именем, значение пустое
        name = key.substr(2);
        value = "";
      }

      if(name != "")
        defines[name] = value;
    }
  }

  if(allFiles.size() == 0)
  {
    std::cout << "[main]: no input file is specified " << std::endl;
    exit(0);
  }
  //else if(allFiles.size() == 1)
  //  fileName = allFiles[0];
  else
  {
    fileName = allFiles[0];

    // merge files to a single temporary file
    auto folderPath = fileName.parent_path();
    auto fileName2  = fileName.filename();
    fileName2.replace_extension("");
    
    if (cmdLineParams.find("-temp_suffix") != cmdLineParams.end())
    {
      std::cout << "[kslicer] Found custom temp file suffix \"" << cmdLineParams["-temp_suffix"] << "\"" << std::endl;
      fileName2.concat("_" + cmdLineParams["-temp_suffix"] + "_temp.cpp");
    }
    else {
      fileName2.concat("_temp.cpp");
    }
    auto fileNameT  = folderPath / fileName2;
    
    std::cout << "[kslicer]: merging input files to temporary file " << fileName2 << std::endl;
    
    std::ofstream fout(fileNameT);
    for(auto def : defines)
      fout << "#define " << def.first << " " << def.second << std::endl;

    auto pExpand = cmdLineParams.find("-expand_macro");
    if(pExpand != cmdLineParams.end() && (pExpand->second == "1" || pExpand->second == "true")) // merging with macro expansion
    {
      std::cout << "[kslicer]: expand multiline macro defs; please note kslicer calls separate clang installation!" << std::endl;
      
      std::vector<std::string> linesWithIncludes;
      linesWithIncludes.reserve(64);
      
      for(auto file : allFiles)
      {
        std::ifstream fin(file);
        std::string line;
        // (1) extract includes
        //
        int lastInclude = 0;
        int lineNumber = 0;
        linesWithIncludes.clear();
        while (std::getline(fin, line))
        { 
          if(line.find("#include") != std::string::npos)
          {
            linesWithIncludes.push_back(line);
            lastInclude = lineNumber;
          }
          lineNumber++;
        }
        
        // (1) extract code and process it with clang++ to expand macro definitions
        //
        std::string tempFileName1 = file + "_temp1.cpp";
        std::string tempFileName2 = file + "_temp2.cpp";
        std::ofstream tempOutForExpand(tempFileName1.c_str());

        fin.close();
        fin.open(file);
        //std::cout << "[kslicer]: seekg is failed! " << std::endl;
      
        lineNumber = 0;
        while (std::getline(fin, line))
        {
          if(lineNumber > lastInclude)
            tempOutForExpand << line.c_str() << std::endl;
          lineNumber++;
        }
        
        std::string commandLine = std::string("clang++ ") + tempFileName1 + " -E -o " + tempFileName2; 
        tempOutForExpand.close();
        std::cout << "[kslicer]: exec '" << commandLine.c_str() << "'" << std::endl;
        int result = std::system(commandLine.c_str()); 
        if(result != 0)
          std::cout << "[kslicer]: exec FAILED! : " << std::endl;
        
        // (3) join files
        //
        fout << "////////////////////////////////////////////////////" << std::endl;
        fout << "//// input file: " << file << std::endl;
        fout << "////////////////////////////////////////////////////" << std::endl;

        for(auto line : linesWithIncludes)
          fout << line.c_str() << std::endl;
        std::ifstream fin2(tempFileName2);
        while (std::getline(fin2, line)) {
          if(line[0] == '#')
            continue;
          fout << line.c_str() << std::endl;
        }
      
        std::filesystem::remove(tempFileName1);
        std::filesystem::remove(tempFileName2);
      }
    }
    else // normal merging
    {  
      for(auto file : allFiles)
      {
        fout << "////////////////////////////////////////////////////" << std::endl;
        fout << "//// input file: " << file << std::endl;
        fout << "////////////////////////////////////////////////////" << std::endl;
        std::ifstream fin(file);
        std::string line;
        while (std::getline(fin, line))
          fout << line.c_str() << std::endl;
      }
    }

    fout.close();
    fileName = std::filesystem::absolute(fileNameT);
    std::cout << "[kslicer]: merging finished to '" << fileName.c_str() << "'" << std::endl;
  }

  return cmdLineParams;
}

std::vector<const char*> ExcludeSlicerParams(int argc, const char** argv, const std::unordered_map<std::string,std::string>& params, const char* a_mainFileName,  const std::unordered_map<std::string,std::string>& defines)
{
  std::unordered_set<std::string> values;
  for(auto p : params)
    values.insert(p.second);

  bool foundDSlicer  = false;
  bool foundMainFile = false;

  static std::vector<std::string> g_data;
  g_data.reserve(128);

  std::vector<const char*> argsForClang; // exclude our input from cmdline parameters and pass the rest to clang
  argsForClang.reserve(argc);
  for(int i=1;i<argc;i++)
  {
    if(params.find(argv[i]) == params.end() && values.find(argv[i]) == values.end())
      argsForClang.push_back(argv[i]);

    if(std::string(argv[i]) == "-DKERNEL_SLICER")
      foundDSlicer = true;
    else if(std::string(argv[i]) == a_mainFileName)
      foundMainFile = true;
  }
  
  if(!foundMainFile)
  {
    argsForClang.insert(argsForClang.begin(), a_mainFileName);
  }

  if(!foundDSlicer)
    argsForClang.push_back("-DKERNEL_SLICER");
  
  for(auto def : defines)
  {
    std::string name = def.first;
    if(name.find("-D") != 0)
      name = std::string("-D") + name;
    
    g_data.push_back(name);
    argsForClang.push_back(g_data.back().c_str());
    if(def.second != "")
    {
      g_data.push_back(def.second);
      argsForClang.push_back(g_data.back().c_str());
    }
  }

  return argsForClang;
}

const char* GetClangToolingErrorCodeMessage(int code)
{
  if(code == 0)
    return "OK";
  else if (code == 1)
    return "ERROR";
  else
    return "SKIPPED_FILES";
}

void ReadThreadsOrderFromStr(const std::string& threadsOrderStr, uint32_t  threadsOrder[3])
{
  auto size = std::min<size_t>(threadsOrderStr.size(), 3);
  for(size_t symbId = 0; symbId < size; symbId++)
  {
    switch(threadsOrderStr[symbId])
    {
      case 'x':
      case 'X':
      case '0':
      threadsOrder[symbId] = 0;
      break;
      case 'y':
      case 'Y':
      case '1':
      threadsOrder[symbId] = 1;
      break;
      case 'z':
      case 'Z':
      case '2':
      threadsOrder[symbId] = 2;
      break;
      default:
      break;
    };
  }
}


// Парсит строку: либо число ("13"), либо "spirv_X_Y" -> X*10+Y
// Возвращает 0, если результат не двузначное число [10..99]
int parseVersionString(const std::string& s) 
{
    // Попытка распарсить формат spirv_X_Y
    const std::string prefix = "spirv_";
    if (s.size() > prefix.size() && s.compare(0, prefix.size(), prefix) == 0) {
        size_t underscore = s.find('_', prefix.size());
        if (underscore == std::string::npos)
            return 0;

        std::string majorStr = s.substr(prefix.size(), underscore - prefix.size());
        std::string minorStr = s.substr(underscore + 1);

        if (majorStr.empty() || minorStr.empty())
            return 0;

        for (char c : majorStr) if (!std::isdigit((unsigned char)c)) return 0;
        for (char c : minorStr) if (!std::isdigit((unsigned char)c)) return 0;

        int major = std::stoi(majorStr);
        int minor = std::stoi(minorStr);
        int result = major * 10 + minor;
        return (result >= 10 && result <= 99) ? result : 0;
    }

    // Попытка распарсить как просто число
    if (s.empty()) return 0;
    for (char c : s) if (!std::isdigit((unsigned char)c)) return 0;

    int result = std::stoi(s);
    return (result >= 10 && result <= 99) ? result : 0;
}

// Преобразует двузначное число в формат "spirv_X_Y"
// Возвращает пустую строку если число == 0 или не двузначное
std::string toSpirvString(int n) 
{
    if (n < 10 || n > 99)
        return "";

    int major = n / 10;
    int minor = n % 10;
    return "spirv_" + std::to_string(major) + "_" + std::to_string(minor);
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static std::string ShellSingleQuote(const std::string& a_str) // 'abc'  ==> 'abc', it's ==> 'it'\''s'
{
  std::string res = "'";
  for(char c : a_str)
  {
    if(c == '\'')
      res += "'\\''";
    else
      res += c;
  }
  return res + "'";
}

void kslicer::WriteShaderBuildScript(const std::filesystem::path& a_scriptPath, const std::string& a_commands, bool a_parallel)
{
  std::ofstream out(a_scriptPath);
  if(!a_parallel)
  {
    out << a_commands;  // sequential script, exactly as it was generated before
    return;
  }

  // split commands, skip '#!' line and empty lines
  //
  std::vector<std::string> commands;
  {
    std::istringstream input(a_commands);
    std::string line;
    while(std::getline(input, line))
    {
      if(!line.empty() && line.back() == '\r')
        line.pop_back();
      if(line.find_first_not_of(" \t") == std::string::npos || line.rfind("#!", 0) == 0)
        continue;
      commands.push_back(line);
    }
  }

  out << "#!/bin/bash" << std::endl;
  out << "# Generated by kernel_slicer: shaders are compiled in parallel (use '-mt_shader_compile 0' to generate a sequential script)." << std::endl;
  out << "# Each compiler call writes stdout/stderr into its own log file, logs are printed in the original order" << std::endl;
  out << "# after all calls have finished, so the output of different jobs is never mixed." << std::endl;
  out << "# Number of parallel jobs: $KSLICER_SHADER_JOBS if set, otherwise the number of CPU cores." << std::endl;
  out << "JOBS=${KSLICER_SHADER_JOBS:-$(nproc 2>/dev/null || echo 4)}" << std::endl;
  out << "LOG_DIR=$(mktemp -d \"${TMPDIR:-/tmp}/kslicer_shaders.XXXXXX\") || exit 1" << std::endl;
  out << "trap 'rm -rf \"$LOG_DIR\"' EXIT" << std::endl;
  out << "CMD_NUM=0" << std::endl;
  out << "RUNNING=0" << std::endl;
  out << std::endl;
  out << "launch() # $1 -- command line, it is executed exactly as a line of the sequential script" << std::endl;
  out << "{" << std::endl;
  out << "  if [ \"$RUNNING\" -ge \"$JOBS\" ]; then" << std::endl;
  out << "    wait -n" << std::endl;
  out << "    RUNNING=$((RUNNING-1))" << std::endl;
  out << "  fi" << std::endl;
  out << "  local id=$CMD_NUM" << std::endl;
  out << "  printf '%s\\n' \"$1\" > \"$LOG_DIR/$id.cmd\"" << std::endl;
  out << "  ( bash -c \"$1\" > \"$LOG_DIR/$id.log\" 2>&1; echo $? > \"$LOG_DIR/$id.status\" ) &" << std::endl;
  out << "  CMD_NUM=$((CMD_NUM+1))" << std::endl;
  out << "  RUNNING=$((RUNNING+1))" << std::endl;
  out << "}" << std::endl;
  out << std::endl;
  out << "echo \"compiling " << commands.size() << " shaders with $JOBS parallel jobs ...\"" << std::endl;
  for(const auto& cmd : commands)
    out << "launch " << ShellSingleQuote(cmd) << std::endl;
  out << "wait" << std::endl;
  out << std::endl;
  out << "FAILED=0" << std::endl;
  out << "for ((i=0; i<CMD_NUM; i++)); do" << std::endl;
  out << "  cat \"$LOG_DIR/$i.log\" 2>/dev/null" << std::endl;
  out << "  STATUS=$(cat \"$LOG_DIR/$i.status\" 2>/dev/null || echo 1)" << std::endl;
  out << "  if [ \"$STATUS\" != \"0\" ]; then" << std::endl;
  out << "    echo \"[FAILED, exit code $STATUS]: $(cat \"$LOG_DIR/$i.cmd\")\"" << std::endl;
  out << "    FAILED=$((FAILED+1))" << std::endl;
  out << "  fi" << std::endl;
  out << "done" << std::endl;
  out << "if [ \"$FAILED\" -ne 0 ]; then" << std::endl;
  out << "  echo \"$FAILED of $CMD_NUM shader compilations FAILED\"" << std::endl;
  out << "  exit 1" << std::endl;
  out << "fi" << std::endl;
  out << "echo \"all $CMD_NUM shaders compiled\"" << std::endl;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static void CollectStorageFeaturesRec(clang::QualType a_type, kslicer::ShaderFeatures& a_res, int a_depth)
{
  if(a_type.isNull() || a_depth > 32)
    return;

  const clang::QualType qt = a_type.getCanonicalType().getNonReferenceType();
  if(const clang::ArrayType* pArray = qt->getAsArrayTypeUnsafe())
  {
    CollectStorageFeaturesRec(pArray->getElementType(), a_res, a_depth+1);
    return;
  }

  if(const clang::BuiltinType* pBuiltin = qt->getAs<clang::BuiltinType>())
  {
    switch(pBuiltin->getKind())
    {
      case clang::BuiltinType::Short:      // shader code works with 16-bit integers loaded from buffer (OpCapability Int16)
      case clang::BuiltinType::UShort:
      a_res.use16BitStorage = true;
      a_res.useShortType    = true;
      break;

      case clang::BuiltinType::Half:
      case clang::BuiltinType::Float16:
      case clang::BuiltinType::BFloat16:
      a_res.use16BitStorage = true;
      a_res.useHalfType     = true;
      break;

      case clang::BuiltinType::Char_S:
      case clang::BuiltinType::Char_U:
      case clang::BuiltinType::SChar:
      case clang::BuiltinType::UChar:
      a_res.use8BitStorage = true;
      a_res.useByteType    = true;
      break;

      default:
      break;
    };
    return;
  }

  if(qt->isPointerType()) // pointer fields are not placed to GPU buffers
    return;

  const clang::RecordDecl* pRecord = qt->getAsRecordDecl();
  if(pRecord == nullptr)
    return;
  pRecord = pRecord->getDefinition();
  if(pRecord == nullptr)
    return;

  if(pRecord->getNameAsString() == "half") // half_float::half (LiteMath::half) is 'half' in shaders
  {
    a_res.use16BitStorage = true;
    a_res.useHalfType     = true;
    return;
  }

  if(auto pCXXRecord = llvm::dyn_cast<clang::CXXRecordDecl>(pRecord))
  {
    for(const auto& base : pCXXRecord->bases())
      CollectStorageFeaturesRec(base.getType(), a_res, a_depth+1);
  }

  for(const clang::FieldDecl* field : pRecord->fields())
    CollectStorageFeaturesRec(field->getType(), a_res, a_depth+1);
}

kslicer::ShaderFeatures kslicer::GetStorageFeaturesFromType(clang::QualType a_type)
{
  kslicer::ShaderFeatures res;
  CollectStorageFeaturesRec(a_type, res, 0);
  return res;
}

kslicer::ShaderFeatures kslicer::GetStorageFeaturesFromDataMember(const kslicer::DataMemberInfo& a_member)
{
  kslicer::ShaderFeatures res;
  if(a_member.IsUsedTexture() || a_member.kind == kslicer::DATA_KIND::KIND_ACCEL_STRUCT)
    return res;

  const clang::TypeDecl* pDecl = a_member.isContainer ? a_member.pContainerDataTypeDeclIfRecord : a_member.pTypeDeclIfRecord;
  if(pDecl != nullptr && pDecl->getTypeForDecl() != nullptr)
    return kslicer::GetStorageFeaturesFromType(clang::QualType(pDecl->getTypeForDecl(), 0));

  // builtin types: analyze type name
  //
  const std::string typeName = (a_member.isContainer || a_member.isArray) ? a_member.containerDataType : a_member.type;
  const auto features = kslicer::GetUsedShaderFeaturesFromTypeName(typeName);
  res.use16BitStorage = features.useShortType || features.useHalfType;
  res.use8BitStorage  = features.useByteType;
  res.useShortType    = features.useShortType;
  res.useHalfType     = features.useHalfType;
  res.useByteType     = features.useByteType;
  return res;
}