Cómo incluir un salto de línea en una macro o C ++ cómo utilizar plantillas de C ++ para hacer lo mismo?

Question

vi la siguiente pregunta: Cómo generar una nueva línea en una macro CPP?

Permítanme dar una breve exigencia de una necesidad en la nueva línea en un preprocesador C ++. Estoy trabajando en ARM RealView compilador 3.1 en un código que utiliza el código de montaje empotrado con código C ++.

#define DEFINE_FUNCTION(rtype, op, val) \
    __asm rtype nt_##op(void*) { \   
      str lr, [sp, ##val];bl vThunk_##op;ldr lr, [sp,##val];bx lr; \
    } \
   void vThunk_##op(void*)

DEFINE_FUNCTION(void*, mov_lt, #0x04)
{
     // do some operation
}

La macro anterior declara una función de montaje incorporado que fuerza requiere nueva línea entre cada uno de los estados en el cuerpo de la función.

Creo que esto es debido a que el texto en el cuerpo de la función se envía a ciegas ARM ensamblador por el compilador ARM.

¿Por qué preprocesador de C ++ es aún ahora no apoyar reemplazos multilínea? y también que no puedo usar # en la cadena de reemplazo. por ejemplo, para este tipo de montaje,

str lr, [sp, #0x04]

He intentado un montón de métodos y formas, pero nada realmente funcionó. ensamblador ARM / compilador es tan básico que no hay ninguna API como asm volátil en GCC.

macro DEFINE_FUNCTION se utiliza en muchos lugares, por lo que no puede pasar por alto también.

Así que, en última instancia pensando en las siguientes soluciones:

• Uso preprocesador m4 en lugar de C ++ preprocesser
• Usar plantillas de C ++ para lograr esto y de alguna manera reemplazan DEFINE_FUNCTION usando grep / SED

Puede alguien darme punteros o maneras de hacer las cosas de arriba? No puedo utilizar cualquier compilador que no sea ARM RealView compilador 3.1.

Necesito una cierta expansión, como a continuación con la nueva línea para, DEFINE_FUNCTION(void*, mov_lt, #0x04) {},

__asm void* nt_mov_lt(void*) {   
      str lr, [sp, 0x04];
      bl vThunk_mov_lt;
      ldr lr, [sp,0x04];
      bx lr;
    }
 void vThunk_mov_lt(void*)
 {
     // do something
  }

Answer 1

He resuelto el problema anterior usando GNU m4 preprocesador éxito.

m4_define('DEFINE_FUNCTION','
     __asm rtype nt_$2(void*) {  
      str lr, [sp, $3];
      bl vThunk_$1;
      ldr lr, [sp,$3];
      bx lr;
    } 
   void vThunk_$2(void*)')

DEFINE_FUNCTION(void*, mov_lt, 0x04)
{
}

Preprocesamiento el código anterior usando m4 resolvió mi problema de requerimiento de nueva línea de código. Ran m4 -P como un evento prebuild de manera que el archivo de origen se procesa incluso antes C preprocesador y etapa de compilación entra en el cuadro.

Gracias por la ayuda y perdón por confundir mucho. Pero realmente hay una buena posibilidad de pre-procesador de macros en últimas compiladores de C ++.

Answer 2

todas las versiones de gas tiene carácter de sustitución diferente de nueva línea p.ej. AVR tiene $ buscar el carácter de la versión ARM de gas

Answer 3

Su ejemplo es muy confuso, pero no haría este trabajo?

#define DEFINE_FUNCTION(rtype, op, val) \
    __asm rtype nt_##op(void*) { \   
      str lr, [sp, val];\
      bl vThunk_##op;\
      ldr lr, [sp,val];\
      bx lr;\
    }\
   void vThunk_##op(void*)

y cuando se le llama como

DEFINE_FUNCTION(void*, mov_lt, 0x04)  // notice no # here
{
     // do some operation
}

se obtendría

__asm void* nt_mov_lt(void*) {   
      str lr, [sp, 0x04];
      bl vThunk_mov_lt;
      ldr lr, [sp,0x04];
      bx lr;
    }
 void vThunk_mov_lt(void*)
 {
     // do something
 }

que es exactamente lo que está pidiendo.