Asignar tipo a variables en C++

[@XSStringManolo]

Estoy generando código C++ a partir de otro código de un lenguaje que estoy desarrollando. La funciones las estoy implementando rollo bash.

Sabeis como puedo declarar los argumentos? Estoy forzado a hacer type inference en el preprocesador/compilador y declarar un template por cada llamada que utilice un tipo distinto (la única solución que se me ocurrió hasta el momento) o conoceis alguna alternativa más sencilla?

CÓDIGO A TRANSPILAR/COMPILAR:

Código (bash) [Seleccionar] Expandir

x = "Hello World";
showHelloWorld() {
  out($1);
  return 6 * 7;
}

showHelloWorld(x);
x = 8;


CÓDIGO QUE GENERO:

Código (cpp) [Seleccionar] Expandir

#include <string>

using namespace std;

auto showHelloWorld($1);

int main() {
  auto x = "Hello World" ;
  showHelloWorld ( x ) ;
  x = 8 ;

  return 0;
}

auto showHelloWorld($1) {
  cout << $1 << endl;
  return 6 * 7 ;
}


Lo que necesito hacer es asignarle un tipo (para que no de error) a los $1, $2, $3... y al $. Este último es un array con todos los argumentos dentro como en bash.

Hay que tener en cuenta que cada llamada a la función puede tener el mismo argumento con distinto tipo, ejemplo:

Código (cpp) [Seleccionar] Expandir

imprimir($1) {
  cout << $1 << endl;
}

int main() {
  imprimir("hola");
  imprimir(7);
  // ...
}

Se os ocurre alguna solución sencilla?

[Serapis]

Ufff...

Un lenguaje no se crea de esa manera.
1 - Para crear un lenguaje, lo primero es crear una especificación del mismo, que recoja todo lo que contendrá y como será contenido.
2 - Le sigue la definición (por ejemplo) en código BNF, con lo que una vez completado se puede programar y abordar el análisis léxico y el sintáctico.
Nota que la primera parte sería en prosa y la una y la otra van íntimamente unidas, la primera detalla partes de la semántica que la segunda deje 'al aire'. Además puede debería recojer también ejemplos, de cada definición así saca de dudas ante alguna complejidad...
Esa definición además debe ser filtrada para eliminar ambigüedades, eliminar entradas no accesibles, etc... es todo un proceso que llega a ser un arte por sí mismo.

La parte que pides corresponde al análisis semántico, es absurdo tratarlo si  previamente no se ha ido incluyendo cada símbolo en la tabla de simbolos (durante las fases de análisis léxico y sintáctico).
Es derivable durante el análisis semántico, el tratamiento de tipos, así como capturar los errores no interceptables en las fases previas.
Llegado a ese punto, resulta absurdo traducir de un lenguaje fuente a otro lenguaje fuente, suele reservarse para casos concretos en los que aún no esté completo el compilador (generalmente para un sistema distinto a aquel en el que se está operando). Como mínimo, lo adecuaod al caso es que invocaras directamente el mismo compilador que usa el lenguaje al que querías traducir.
Aunque lo más óptimo (de cara al rendimiento), es pasarlo luego a un código intermedio, previas optimizaciones, para al final compilarlo al sistema de destino (con las correspondientes optimizaciones según el sistema destino).

Hay quien tira de herramienrtas externas, como Flex, Bison, etc... para simplificar partes de la implementación del lenguaje. Tiene su beneficio y su perjuicio. Aunque claro, el tiempo de aprendizaje del mismo no difiere sustancialmente de implementar uno mismo su propio programa. El peor perjuicio que yo veo al usar herramientas externas, es que tu lenguaje debe cumplir ciertos requisitos, para acoplarse correctamente con ellos y sobretodo que determinados errores, aunque los intercepte, no ofrecen detalles específicos (lógicamente es algo personalizado de cada lenguaje), que es la principal razón por la que mucos lenguajes devuelven mensajes de error crípticos e ininteligibles muchas veces.

Si a pesar de todo insistes seguir por el camino que llevas, lo más que puedo sugerirte es que tu array, debe alojar una estructura y que esa estructura sea lo suficientemente flexible para contener los diferentes tipos por puntero... básicamente en ese array tendrías que albergar lo que has omitido que es la tabla de símbolos:
Así dicha estructura podría contenener al menos estos campos:
- Nombre del parametro.
- Fue declarado-inicializado el tipo.
- Valor de la enumeracion del tipo (por ejemplo byte=2, char=3, entero = 4, buleano =1, etc...)
- Se recibe por valor o por una direccion (qué se almacena en la pila, su valor o la dirección donde consta el valor?)
- Es un tipo simple o compuesto (los complejos serían aquellos que recogen varios campos. string y array de (cualquier otro tipo) aunque caigan en esta categoría deben considerarse simples, por cuando el único otro campo preciso es su cantidad de elementos, y el valor puede ser accedido por un indice sin más complicaciones que veirificar sus limites..., digamos que string y array son intermedios entre simple y complejo, pero se tratan como simples en prácticamente todos los lenguajes).
- ...

Vamos lo cojas por donde lo cojas, exige una especificación prácticamente antes de escribir una sola línea de código.

p.d.: Si es solo cambiar parcialmente la sintaxis de un lenguaje, podría ser aceptable como lo llevas...

[@XSStringManolo]

Ya resolví como hacerlo. Auto casi sirve para resolver el problema, variadic sirve pero es un malgasto de memoria porque reserva la mémoria máxima de un tipo para cada tipo. Por ejemplo reserva 32 bytes para un bool (1 byte). Any es la solución simple que estaba buscando.