Comment pouvez-vous analyser de simples instructions typedef C++?

Question

Je voudrais analyser C++ typedef instructions simples telles que

typedef Class NewNameForClass; 
typedef Class::InsideTypedef NewNameForTypedef; 
typedef TemplateClass<Arg1,Arg2> AliasForObject; 

j'ai écrit la grammaire correspondante que je voudrais voir utilisé dans l'analyse syntaxique.

Name <- ('_'|letter)('_'|letter|digit)* 
Type <- Name 
Type <- Type::Name 
Type <- Name Templates 
Templates <- '<' Type (',' Type)* '>' 
Instruction <- "typedef" Type Name ';' 

Une fois que cela est analysé, tout ce que je vais vouloir faire est de générer du code XML avec les mêmes informations (mais pondus différemment)

Quelle est la langue la plus efficace pour la rédaction d'un tel programme? Comment pouvez-vous y parvenir?

EDIT: Ce que je suis venu avec l'aide de Spirit Boost (ce n'est pas parfait, mais il est assez bon pour moi, au moins pour l'instant)

rule<> sep_p = space_p; 
    rule<> name_p = (ch_p('_')|alpha_p) >> *(ch_p('_')|alpha_p|digit_p); 
    rule<> type_p = name_p 
      >> !(*sep_p >>str_p("::") >> *sep_p>> name_p) 
      >> *(*sep_p >> ch_p('*')) 
      >> !(*sep_p >> str_p("const")) 
      >> !(*sep_p >> ch_p('&')); 
    rule<> templated_type_p = name_p >> *sep_p 
      >> ch_p('<') >> *sep_p 
      >> (*sep_p>>type_p>>*sep_p)%ch_p(',') 
      >> ch_p('>') >> *sep_p; 

    rule<> typedef_p = *sep_p 
        >> str_p ("typedef") 
        >> +sep_p >> (type_p|templated_type_p) 
        >> +sep_p >> name_p 
        >> *sep_p >> ch_p(';') >> *sep_p; 
    rule<> typedef_list_p = *typedef_p; 

Answer 1

Je modifieraient la grammaire un peu

ShortName <- ('_'|letter)('_'|letter|digit)* 
Name <- ShortName 
Name <- Name::ShortName 
Type <- Name 
Type <- Name Templates 
Templates <- '<' Type (',' Type)* '>' 
Instruction <- "typedef" Type Name ';' 

Aussi votre grammaire laisse les cas suivants

1. cibles typedef multiples.
2. pointeur cible
3. pointeurs de fonction (ce qui est de loin le plus difficile)

une grammaire Parsing (j'aime l'ironie) est une opération assez simple. Si vous vouliez réellement utiliser la grammaire de manière fonctionnelle, je dirais que le meilleur pari est une combinaison lex/yacc.

Mais à partir de votre question, il semble que vous voulez le cracher dans un autre format. Il n'y a vraiment pas de langage conçu pour cela, donc je dirais d'utiliser n'importe quelle langue avec laquelle vous êtes le plus à l'aise.

Modifier

L'OP interrogé sur plusieurs cibles typedef. Il est parfaitement légal pour une déclaration typedef d'avoir plus d'une cible. Par exemple:

typedef _SomeStruct SomeStruct, *PSomeStruct 

Ceci crée 2 noms de type typedef.

1. SomeStruct qui équivaut à « struct _SomeStruct »
2. PSomeStruct qui équivaut à « _SomeStruct struct * »

Answer 2

Eh bien, puisque vous êtes apparemment déjà travailler avec/sur C++, avez-vous envisagé d'utiliser Boost.Spirit? Cela vous permet de coder en dur la grammaire en C++ en tant que langage spécifique au domaine et de le programmer par rapport au code C++ normal.