Como incluir uma nova linha em uma macro C ++ ou como usar os modelos C ++ para fazer o mesmo?

Question

Eu vi a seguinte pergunta:Como gerar uma nova linha em uma macro CPP?

Deixe -me dar um breve requisito de necessidade na Newline em um pré -processador C ++. Estou trabalhando no ARM RealView Compiler 3.1 em um código que usa código de montagem incorporado com 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
}

A macro acima declara uma função de montagem incorporada que requer com força nova linha entre cada afirmação no corpo da função.

Eu acho que isso ocorre porque o texto no corpo da função é enviado cegamente para o montador do braço pelo compilador de braço.

Por que o pré-processador C ++ ainda não está suportando substituições de várias linhas? E também não posso usar # na sequência de substituição. por exemplo, para este tipo de montagem,

str lr, [sp, #0x04]

Eu tentei muitos métodos e maneiras, mas nada realmente deu certo. O assembler/compilador do ARM é tão básico que não há API como ASM Volátil no GCC.

A macro define_function é usada em muitos lugares; portanto, não pode ignorá -la também.

Então, no resort final, pensando nas seguintes soluções:

• Usando o pré -processador M4 em vez de pré -processador C ++
• Use modelos C ++ para conseguir de alguma forma e substituir define_function usando grep/sed

Alguém pode me dar ponteiros ou maneiras de fazer as coisas acima? Não posso usar nenhum compilador que não seja o ARM RealView Compiler 3.1.

Eu preciso de alguma expansão, como abaixo com a nova linha 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

Resolvi o problema acima usando o pré -processador GNU M4 com sucesso.

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

O pré -processamento do código acima usando o M4 resolveu meu problema de requisito de nova linha no código. RAN M4 -P como um evento de pré -construção, para que o arquivo de origem seja processado mesmo antes de o pré -processador C e o estágio de compilação entrar em cena.

Obrigado pela ajuda e desculpe por confundir muito. Mas há realmente um escopo para um bom pré-processador de macro nos mais recentes compiladores C ++.

Answer 2

Cada versão gasosa possui um caractere de substituição de nova linha, por exemplo, Avr possui $ procure o personagem para a versão do ARM Gas

Answer 3

Seu exemplo é extremamente confuso, mas isso não funcionaria?

#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 chamado como

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

você ficaria

__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 é exatamente o que você está pedindo.