La réflexion de soutien en C

les trucs autour d'elle? Des conseils à donner?

Le compilateur va probablement éventuellement générer des "symboles de débogage du fichier", ce qui d'un débogueur pouvez utiliser pour vous aider à déboguer le code. L'éditeur de liens peut également générer une "carte" dossier de.

Un truc/astuce peut être de générer puis de lire ces fichiers.

Trucs et astuces existe toujours. Jetez un oeil à Metaresc bibliothèque https://github.com/alexanderchuranov/Metaresc

Il fournit une interface pour les types de déclaration qui permettra également de générer des méta-données pour le type. Basés sur des méta-données, vous pouvez facilement sérialiser/désérialiser des objets de n'importe quelle complexité. Hors de la boîte, vous pouvez sérialiser/désérialiser des données XML, JSON, XDR, Lisp comme la notation, C-init notation.

Voici un exemple simple:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "metaresc.h"

TYPEDEF_STRUCT (point_t,
                double x,
                double y
                );

int main (int argc, char * argv[])
{
  point_t point = {
    .x = M_PI,
    .y = M_E,
  };
  char * str = MR_SAVE_XML (point_t, &point);
  if (str)
    {
      printf ("%s\n", str);
      free (str);
    }
  return (EXIT_SUCCESS);
}

Ce programme permettra de sortie

$ ./point
<?xml version="1.0"?>
<point>
  <x>3.1415926535897931</x>
  <y>2.7182818284590451</y>
</point>

Bibliothèque fonctionne très bien pour la dernière version de gcc et clang.

J'avais besoin de réflexion dans un tas de structs dans un projet C++.

J'ai créé un fichier xml avec la description de toutes ces structures - heureusement, les champs, les types de types primitifs.

J'ai utilisé un modèle (pas C++ template) pour générer automatiquement une class pour chaque struct avec des méthodes setter/getter.

Dans chaque class j'ai utilisé une carte d'associer des noms de chaîne et les membres de la classe (des pointeurs pour les membres).

Je ne regrette pas du tout l'utilisation de la réflexion, car il a ouvert de nouvelles voies pour la conception de ma fonctionnalités de base que je ne pouvais même pas imaginer sans réflexion.

(BTW, c'était un externe générateur de rapport pour un programme qui utilise un raw base de données)

Donc, j'ai utilisé la génération de code, des pointeurs de fonction et des cartes pour simuler la réflexion.

Je sais que des options suivantes, mais que tous viennent à leur coût et beaucoup de limites:

• Utilisation libdl (#include <dfcln.h>)
• Appel à un outil comme objdump ou nm
• Analyser des fichiers de l'objet vous-même (à l'aide d'une bibliothèque correspondante)
• Impliquent l'un et l'analyseur de générer les informations nécessaires au moment de la compilation.
• Des"abus" de l'éditeur de liens pour générer le symbole de tableaux.

Je vais utiliser un peu de test de l'unité de cadres comme exemples plus bas, en raison de test automatique de découverte pour les infrastructures de test unitaire est un exemple typique où la réflexion est très pratique, et c'est quelque chose que la plupart des infrastructures de test unitaire pour C tomber à court de.

À l'aide de libdl (#include <dfcln.h>) (POSIX)

Si vous êtes sur un environnement POSIX, un peu de réflexion peut être fait en utilisant libdl. Les Plugins sont développés de cette façon.

Utilisation

#include <dfcln.h>

dans votre code source et lien avec -ldl.

Vous avez accès aux fonctions dlopen(), dlerror(), dlsym() et dlclose() avec lequel vous pouvez charger et accès /run objets partagés au moment de l'exécution. Cependant, cela ne vous donne pas un accès facile à la table des symboles.

Un autre inconvénient de cette approche est que vous avez essentiellement limiter la réflexion à des objets chargés bibliothèque dynamique (objet partagé chargés lors de l'exécution via dlopen()).

De course nm ou objdump

Vous pourriez exécuter nm ou objdump pour afficher la table de symboles et d'analyser les données en sortie.
Pour moi, nm -P --defined-only -g xyz.o donne de bons résultats, et l'analyse de la sortie est trivial.
Vous seriez intéressé dans le premier mot de chaque ligne, qui est le nom du symbole, et peut-être la seconde, qui est le type de section.

Si vous ne connaissez pas le nom de l'objet dans certains de manière statique, c'est à dire que l'objet est en fait un objet partagé, au moins sur Linux ensuite, vous pourriez voulez sauter le symbole dont le nom commence par '_'.

objdump, nm ou des outils similaires sont également souvent disponibles à l'extérieur de POSIX environnements.

L'analyse des fichiers de l'objet vous-même

Vous pu analyser des fichiers de l'objet vous-même. Vous ne voulez probablement pas à la mettre en œuvre à partir de zéro, mais utiliser une bibliothèque existante pour que. C'est de cette façon nm, objdump et même libdl sont mis en œuvre. Vous pouviez regarder le code source de nm, objdump et libdl et les bibliothèques qu'ils utilisent afin de savoir comment ils font ce qu'ils font.

Impliquant un Analyseur

Vous pourriez écrire un analyseur et un generateur de code qui génère le nécessaire réfléchissant de l'information au moment de la compilation et la stocke dans le fichier de l'objet. Ensuite, vous avez beaucoup de liberté et pourrait même mettre en œuvre des formes primitives d'annotations. C'est ce que certains de l'unité de frameworks de test comme AceUnit faire.

J'ai trouvé que l'écriture d'un analyseur qui couvre straight-forward de la syntaxe C est assez banale. Écrire un analyseur syntaxique qui comprend vraiment C et peut traiter tous les cas n'est PAS banal.
Donc, cela a des limites qui dépendent de la façon dont exotiques la syntaxe C est que vous voulez réfléchir sur.

"Abuse" de l'éditeur de liens pour générer symbole tableaux

Vous pourriez mettre des références à des symboles qui vous voulez réfléchir dans une section spéciale et l'utilisation d'un linker configuration à émettre de la section limites, alors vous pouvez y accéder en C.

J'ai décrit ici N-l'injection de Dépendance dans C - de meilleur moyen que de l'éditeur de liens définis par des tableaux? comment cela fonctionne.

Mais attention, c'est en fonction de beaucoup de choses et pas très portable. J'ai seulement essayé cela avec GCC/ld, et je sais qu'il ne fonctionne pas avec tous les compilateurs /linkers. Aussi, il est presque garanti que l'élimination du code mort ne détecte pas comment vous appelez ça, donc si vous utilisez l'élimination du code mort, vous devez ajouter tous les réfléchie des symboles comme des points d'entrée.

Pièges

Pour certains des mécanismes l'élimination du code mort peut être un problème, en particulier lorsque vous avez des "abus" de l'éditeur de liens pour générer un symbole de tableaux. Il peut être contourné en disant à la réflexion des symboles comme points d'entrée pour l'éditeur de liens, et en fonction de la quantité de symboles cela peut être ni gentil ni pratique.

Conclusion

Combinant nm et libdl peut réellement donner de bons résultats. La combinaison peut être presque aussi puissant que le niveau de Réflexion utilisé par JUnit 3.x en Java. Le niveau de réflexion donnée est suffisante pour mettre en œuvre un JUnit 3.x-style unit test framework pour C, y compris les tests de cas de découverte par la convention de nommage.

Impliquant un analyseur est plus de travail et limitée à des objets que vous compilez vous-même, mais vous donne plus de puissance et de liberté. Le niveau de réflexion peut être suffisante pour mettre en œuvre un JUnit 4.x-style unit test framework pour C, y compris les tests de cas de découverte par les annotations. AceUnit est une unit test framework pour C qui fait exactement cela.

Combinant l'analyse et l'éditeur de liens pour générer symbole tableaux peuvent donner de très bons résultats - si votre environnement est tellement sous votre contrôle que vous pouvez vous assurer que le travail avec l'éditeur de liens qui fonctionne pour vous.

Et bien sûr, vous pouvez combiner toutes les méthodes de coudre ensemble les morceaux jusqu'à ce qu'ils correspondent à vos besoins.

Les analyseurs et les Symboles de Débogage sont de bonnes idées. Cependant, la chasse aux sorcières est que C n'a pas vraiment d'avoir des tableaux. Juste des pointeurs vers des trucs.

Par exemple, il n'existe aucun moyen en lisant le code source pour savoir si un char * points à un personnage, une chaîne ou un tableau fixe d'octets selon une certaine "proximité" champ de longueur. C'est un problème pour les lecteurs humains et encore moins de tout outil automatisé.

Pourquoi ne pas utiliser un langage moderne, comme le Java ou le .Net? Peut être plus rapide que C aussi bien.