Come includere una nuova riga in un C ++ macro o il modo di utilizzare i modelli C ++ a fare lo stesso?

Question

ho visto la seguente domanda: Come generare una nuova riga in una macro cpp?

Vi faccio una breve requisito di un bisogno di ritorno a capo in un preprocessore C ++. Sto lavorando su ARM Realview compilatore 3.1 su un codice che utilizza il codice assembly embedded con codice 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 precedente dichiara una funzione complesso integrato che richiede forza nuova riga tra ogni chiusura del corpo della funzione.

Credo che questo sia perché il testo nel corpo della funzione viene inviata alla cieca per ARM assembler dal compilatore ARM.

Perché C ++ preprocessore è ancora oggi che non supportano le sostituzioni multilinea? e, inoltre, non posso usare # nella stringa di sostituzione. per esempio, per questo tipo di assemblaggio,

str lr, [sp, #0x04]

Ho provato un sacco di metodi e modi, ma niente di veramente lavorato fuori. ARM assemblatore / compilatore è così fondamentale che non v'è alcuna API come asm volatile nel GCC.

macro DEFINE_FUNCTION viene utilizzato in un sacco di posti, in modo da non può ignorare che anche.

Quindi, in ultima istanza a pensare le seguenti soluzioni:

• Uso m4 preprocessore invece di C ++ preprocesser
• Utilizzare i modelli C ++ per ottenere in qualche modo questo e sostituire DEFINE_FUNCTION usando grep / sed

Qualcuno può darmi puntatori o modi di fare le cose di cui sopra? Non posso usare qualsiasi compilatore diverso da ARM Realview compilatore 3.1.

Ho bisogno di espansione come qui di seguito con la nuova linea per, 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

ho risolto il problema di cui sopra utilizzando GNU m4 preprocessore con successo.

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)
{
}

Preprocessing il codice di cui sopra usando m4 risolto il mio problema del fabbisogno di nuova riga nel codice. Ran m4 -P come un evento prebuild in modo che il file di origine viene elaborato anche prima C preprocessore e fase di compilazione entra in foto.

Grazie per l'aiuto e scusa per confondere un sacco. Ma c'è davvero un ambito per buona macro pre-processore ultimi compilatori C ++.

Answer 2

tutte le versioni a gas ha diversa a capo carattere sostituzione per esempio. AVR ha $ cercare il personaggio per la versione a gas ARM

Answer 3

Il vostro esempio è estremamente confusa, ma non sarebbe questo lavoro?

#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*)

e quando viene chiamato come

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

si otterrebbe

__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
 }

che è esattamente quello che stai chiedendo.