Escribiendo un compilador: ¿cómo hacer que funcionen plantillas simples?

Question

Tengo un lenguaje con una sintaxis similar a C++. El lexer y el analizador están en su lugar y producen el AST correcto. Para la parte más grande, el back-end también está hecho.

El sistema básico que el compilador usa para crear tipos es muy simple: todos los tipos se consideran incorporados y todas las instancias son globales. Así que solo hay un mapa simple que coincide con el nombre de un tipo con un método que crea una variable que es básicamente un tipo genérico como boost :: any. Otro mapa con el nombre de la variable como llave y la variable como valor sirve como el ámbito global:

std::map< std::string, std::function< Variable() > typeList; 

    //register some types 
typeList[ "X" ] = Variable::Create<X>; 
typeList[ "Y" ] = CreateInstanceOfY; 
.... 

Cuando el compilador obtiene el nodo AST para una inicialización como X myVar; hace básicamente

std::map< std::string, Variable > globalScope; 
globalScope[ "myVar" ] = typeList[ "X" ](); 

Cuando miVar se utiliza más adelante se puede acceder mediante un simple despacho tipo como

X& x = myVar.GetReference<X>(); 

Ahora me gustaría extender esta un poco y utilizar plantillas simples. Supongamos que hay un tipo de "matriz" que se implementa utilizando un vector. Yo podría registrar todo como

typeList[ "array<X>" ] = Variable::Create< std::vector<X> >; 

pero eso no es muy manejable, ya que tendría que repetirse para todas las combinaciones. Lo ideal sería que iba a necesitar una funcionalidad que permite a escribir algo como esto:

typeList.CreateTemplateVariable("array", "X") 

que luego crear una instancia de variable que internamente tiene un std :: vector < X>. Intenté mucho, pero no puedo entender cómo hacerlo. Quizás comencé el camino equivocado con el mapeo simple de tipos y esa es la razón por la cual no puedo entenderlo.

Entonces la pregunta es simple: ¿es posible hacer esto? ¿Y cómo?

Answer 1

No estoy seguro de que tengo el problema de la derecha, pero si usted tiene tipos M paramétricas (vector<>, list<>, ...) y los N tipos simples (int, double, ...), lo que se necesita MxN implementaciones reales si quieres admitir todas las combinaciones. Todas estas implementaciones deben conocerse en tiempo de compilación (o, en principio, puede invocar el compilador de C++ sobre la marcha). ¿De verdad quieres esto?

Una solución alternativa podría ser el uso de contenedores no tipados en su lugar. Por ejemplo, vector<Object*> almacenando punteros que pueden convertirse posteriormente al tipo requerido, por ejemplo con un dynamic_cast. De esta forma solo necesitaría implementaciones M para tipos paramétricos, y puede resolver "array" a vector, y "X" a X de forma independiente.

Answer 2

En general, la forma en que hace los tipos de plantillas es como usted describe, pero en lugar de crear todas las combinaciones posibles con anticipación, las crea a pedido. Lo que podría tener una rutina getType como:

std::function< Variable() > getType(std::string name) { 
    auto rv = typeList[name]; 
    if (rv) return rv; 
    auto template_start = name.find('<'); 
    if (template_start != string::npos) { 
     auto template_end = name.rfind('>'); 
     std::string arg = name.substr(template_start+1, template_end); 
     std::string base = name.substr(0, template_start); 
     typeList[name] = rv = InstantiateTemplate(base, arg); 
     return rv; } 
    throw UnknownTypeError(name); 
} 

Esta es llamada para cualquier tipo mencionado en el programa, la creación de las instancias de plantilla necesarios en la demanda.