Prise en charge personnalisée pour __attribute __ ((format))

Un an et demi après avoir posé cette question, je suis sorti avec une approche totalement différente pour résoudre le problème réel: existe-t-il un moyen de vérifier statiquement les types d'instructions de formatage de variadiques personnalisées? em>

Pour l'exhaustivité et parce que cela peut aider d'autres personnes, voici la solution que j'ai enfin mise en œuvre. Il a deux avantages sur la question initiale: p>

• relativement simple: mis en œuvre en moins d'une journée; Li>
• compilateur indépendant: peut vérifier le code C ++ sur n'importe quelle plate-forme (Windows, Android, OSX, ...). LI> ul>

  Un script Perl analyse le code source, trouve les chaînes de formatage et décode les modificateurs en pourcentage en eux. Il enveloppe ensuite tous les arguments avec un appel à une fonction d'identité de modèle checkformat code>. Exemple: P>

  enum class CFL
  {
      c, d, i=d, star=i, u, o=u, x=u, X=u, f, F=f, e=f, E=f, g=f, G=f, p, s, S, P=S, at
  };
  enum class CFM
  {
      hh, h, l, z, ll, L=ll, _
  };
  template<CFL letter, CFM modifier, typename T> inline T CheckFormat(T value) { CFL test= value; (void)test; return value; }
  template<> inline const BaseString* CheckFormat<CFL::S, CFM::_, const BaseString*>(const BaseString* value) { return value; }
  template<> inline const BaseObject* CheckFormat<CFL::at, CFM::_, const BaseObject*>(const BaseObject* value) { return value; }
  template<> inline const char* CheckFormat<CFL::s, CFM::_, const char*>(const char* value) { return value; }
  template<> inline const void* CheckFormat<CFL::p, CFM::_, const void*>(const void* value) { return value; }
  template<> inline char CheckFormat<CFL::c, CFM::_, char>(char value) { return value; }
  template<> inline double CheckFormat<CFL::f, CFM::_, double>(double value) { return value; }
  template<> inline float CheckFormat<CFL::f, CFM::_, float>(float value) { return value; }
  template<> inline int CheckFormat<CFL::d, CFM::_, int>(int value) { return value; }
  
  ...
  

avec C ++ 11, il est possible de résoudre ce problème en remplaçant __ attribut__ ((Format)) CODE> avec une combinaison intelligente de consexpr code>, déclencheur et paquets de paramètres variadic. Passez la chaîne de format dans une fonction consexpr code> qui extrait tous les spécificateurs % code> à la compilation et validez que le N'th Specififier correspond au déclinger code > de l'argument ST (N + 1) 'ST.

Voici un croquis de la solution ... p>

Si vous avez: p> xxx pré>

Vous aurez besoin d'une wrapper macro pour my_printf code>, à l'aide du truc décrite ici , pour obtenir quelque chose comme ceci: p> xxx pré>

Vous devez écrire fmtvalidator code> et maqueypeholder () code>. p>

Maketypeholder code> va ressembler à ceci: p>

    template<>
    struct specmatch<int>
    {
        static constexpr bool match(const char* c, const char* cend)
        {
            return strmatches(c, cend, "d") ||
                    strmatches(c, cend, "i");
        }
    };

    // add other specmatch specializations for float, const char*, etc.