C++ Template preprocessor tool

Question

Is there a compiler or standalone preprocessor which takes C++ files and runs a template expansion pass, generating new C++ code with expanded template instantiations?

I remember such a tool in the mid-90s when templates were still new and experimental, and the preprocessor was a way to do template programming with compilers without native template support.

This is a lot more complicated than a macro-processing step since it would likely require parsing and tokenizing the code to understand the contexts.

My hope is to use such a tool when writing OpenCL code. OpenCL is C++, but does not support templates. I'm hoping I can write templates, even simple ones like with integer or bool only arguments, and have some tool pre-parse the file and go through and find the use of the templates and expand the invocations and give me new C++ code that the OpenCL compiler can understand.

Even a very limited tool could be useful, it does not need to support every template quirk, nor even support multiple modules or anything.

The alternative: #define macros everywhere.. uglier, unsafe, less efficient, and less versatile.

Answer 1

Comeau C++ can "compile" C++ to C. This would seem to be close to your goal, as OpenCL does not support C++ – it's much closer to C.

Answer 2

C++ Insights (https://cppinsights.io/) is able to do this (and more generally expansion of "high-level" syntax-sugary C++ constructs. It is based on Clang so it has an understanding of the code which is as good as possible, and supports latest standards.

It will for instance expand

extern "C" void printf(...);
template<typename T>
int foo(T t)
{
  if constexpr(sizeof(T) == 4) {
    printf("int: %d", t);
  }
  else {
    printf("something else: %d", (int)t);
  }
}

int main()
{
    const char arr[10]{2,4,6,8};

    for(const char& c : arr)
    {
      foo(c);
    }
}

into

extern "C" void printf(...);
template<typename T>
int foo(T t)
{
  if constexpr(sizeof(T) == 4) {
    printf("int: %d", t);
  }
  else {
    printf("something else: %d", (int)t);
  }
}

/* First instantiated from: insights.cpp:19 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
int foo<char>(char t)
{
  if constexpr(false) {
  } else /* constexpr */ {
    printf("something else: %d", static_cast<int>(t));
  } 
  
}
#endif


int main()
{
  const char arr[10] = {2, 4, 6, 8, '\0', '\0', '\0', '\0', '\0', '\0'};
  {
    char const (&__range1)[10] = arr;
    const char * __begin1 = __range1;
    const char * __end1 = __range1 + 10L;
    for(; __begin1 != __end1; ++__begin1) {
      const char & c = *__begin1;
      foo(c);
    }
    
  }
  return 0;
}

Answer 3

There is no such tool - templates are part of the language, not some pre-processor pass - they are processed by the compiler, just like other code.