Le rôle d'un analyseur d'erreur est de reconnaître les avertissements, les erreurs et autres messages importants dans la sortie du compilateur ou de l'outil de génération et de créer des objets "marqueur de problème" correspondants. Eclipse affiche les marqueurs de problème comme des icônes d'erreur ou d'avertissement (selon la gravité du problème) dans les vues Explorateur de projets et Erreurs, ainsi que dans l'éditeur.

Si vous utilisez un outil de génération ou un compilateur qui n'est pas actuellement pris en charge par IBM Rational Developer for Power Systems Software, il est possible que celui-ci ne puisse pas reconnaître les erreurs de génération. Vous pouvez alors envisager d'écrire votre propre plug-in analyseur d'erreur afin d'améliorer l'intégration entre l'environnement de développement et votre outil de génération.
La première étape consiste à mettre en place un environnement pour l'écriture et le développement de plug-ins. Elle est décrite à la section Extension avec des plug-ins. Une fois votre environnement en place, enchaînez avec le tutoriel suivant, qui explique comment créer un analyseur d'erreur.
Sélectionnez Fichier > Nouveau > Projet pour ouvrir la boîte de dialogue Nouveau projet (Sélection d'un assistant). Dans cette boîte de dialogue, sélectionnez Projet de plug-in et cliquez sur Suivant.

Donnez un nom à votre projet. Les noms de plug-in obéissent généralement aux mêmes conventions de dénomination que les packages Java.
Dans la section Plateforme cible, assurez-vous que la version Eclipse sélectionnée est bien la 3.4. IBM Rational Developer for Power Systems Software est actuellement basé sur cette version. Les versions suivantes ne fonctionneront pas.

Cliquez sur Suivant pour passer à la seconde page de l'assistant.
Sur la seconde page de l'assistant, décochez la case intitulée "Ce plug-in apporte des contributions à l'interface utilisateur". Ce tutoriel ne prévoit pas de vous faire développer des composants d'interface utilisateur.
Vous pouvez laisser la case "Générer un activateur" cochée. Une classe d'activateur sera ainsi générée et sera utilisée pour répondre aux événements de cycle de vie du plug-in. Pour ce tutoriel, nous n'avons pas véritablement besoin de répondre à ces événements. Cependant, la plupart des plug-ins quelque peu avancés ont besoin de répondre à de tels événements. Mieux vaut donc générer cette classe maintenant, même si elle n'est pas utile dans un premier temps.

Cliquez sur Terminer.
Dans la vue Explorateur de packages, localisez le projet nouvellement créé, ouvrez le dossier META-INF et faites un double clic sur le fichier MANIFEST.MF.

Cette action ouvre l'éditeur de manifeste de plug-in, qui sert à configurer les métadonnées du plug-in. En bas de l'éditeur, cliquez sur l'onglet Dépendances.

Vous devez ajouter deux dépendances (des plug-ins requis) afin d'avoir accès aux API nécessaires à l'écriture d'un analyseur d'erreur. Commencez par cliquer sur le bouton Ajouter, dans la section Plug-ins requis, afin d'ouvrir la boîte de dialogue Sélection de plug-in. Tapez org.eclipse.cdt.core dans la zone de filtrage, sélectionnez ce plug-in dans la zone de résultats et cliquez sur OK. Répétez cette étape pour ajouter le plug-in org.eclipse.core.resources.

La liste des plug-ins requis doit à présent ressembler à ce qui suit. Sauvegardez vos changements.

Il est maintenant temps de créer une classe Java qui contiendra le code de l'analyseur d'erreur. Développez la branche du dossier src dans la vue Explorateur de packages. Elle doit révéler un package Java, qui a été créé automatiquement pour vous. Faites un clic droit sur le package et sélectionnez Nouveau > Classe.

Cette action ouvre l'assistant Nouvelle classe Java. Donnez un nom à la classe ; par exemple, "MonAnalyseurErreur".

Cliquez sur le bouton Ajouter à droite de la zone Interfaces. Vous obtenez la boîte de dialogue Sélection des interfaces implémentées. Tapez "IErrorParser" dans la zone de filtrage et choisissez l'interface IErrorParser dans la zone de résultats.

Cliquez sur Terminer. Une nouvelle classe est alors créée pour votre analyseur d'erreur, avec une implémentation souche (ou raccord) de la méthode processLine().

Avant de commencer à écrire le code, vérifiez que votre nouvel analyseur d'erreur est reconnu par IBM Rational Developer for Power Systems Software. Ouvrez à nouveau l'éditeur de manifeste de plug-in et cliquez sur l'onglet Extensions, en bas de la vue.

Cliquez sur le bouton Ajouter pour ouvrir la boîte de dialogue Nouvelle extension. Sélectionnez le point d'extension org.eclipse.cdt.core.ErrorParser et cliquez sur Terminer.

L'extension org.eclipse.cdt.core.ErrorParser doit à présent figurer sous la section Toutes les extensions.

Cliquez sur l'onglet plugin.xml en bas de l'éditeur pour ouvrir le fichier plugin.xml. Editez le fichier de manière à le rendre similaire au contenu suivant.
<plugin>
<extension
id="org.monentreprise.errorparser.MonAnalyseurErreur"
name="Tester l'analyseur d'erreur"
point="org.eclipse.cdt.core.ErrorParser">
<errorparser
class="org.monentreprise.errorparser.MonAnalyseurErreur">
</errorparser>
</extension>
</plugin>
L'attribut class de l'élément <errorparser> doit contenir le chemin qualifié complet de la classe qui implémente l'interface IErrorParser.
A ce stade, il est bon de vérifier que votre nouvel analyseur d'erreur est reconnu par IBM Rational Developer for Power Systems Software. Lancez IBM Rational Developer for Power Systems Software en utilisant la configuration d'exécution que vous avez créée à la section Extension avec des plug-ins. Dans IBM Rational Developer for Power Systems Software, passez dans la perspective C/C++ distant. Si vous n'avez pas encore de projet dans l'espace de travail, créez-en un.
Faites un clic droit sur un projet et ouvrez sa fenêtre de propriétés. Naviguez jusqu'à Génération C/C++ > Paramètres. Votre nouvel analyseur doit figurer dans la liste, sous l'onglet Analyseurs d'erreur. Cochez-le pour l'activer et faites-le remonter jusqu'en tête de liste pour qu'il soit prioritaire sur les autres analyseurs d'erreur. Par précaution, vous pouvez aussi désactiver tous les autres analyseurs d'erreur pendant que vous développez. Cliquez sur OK.

Il est maintenant temps de commencer à écrire le code de l'analyseur d'erreur.
Lorsqu'une génération a lieu, la sortie de la commande de génération est envoyée à l'analyseur d'erreur à raison d'une ligne à la fois. La méthode processLine() est appelée une fois pour chaque ligne de sortie et reçoit deux arguments : une chaîne (String) qui contient la ligne de sortie proprement dite et une référence à l'objet ErrorParserManager. Celui-ci est un gestionnaire qui fournit des méthodes visant à faciliter la création des objets marqueur de problème.
Le mécanisme habituellement mis en oeuvre avec cette méthode est de tenter de reconnaître chaque ligne soit comme un message d'avertissement du compilateur, soit comme un message d'erreur du compilateur. Un moyen pratique consiste à confronter la ligne à une expression régulière et à utiliser des régions de capture pour extraire les parties de la ligne qui présentent un intérêt, telles que le nom du fichier, le numéro de la ligne et le message d'erreur proprement dit.
A partir de là, le code à écrire pour votre analyseur d'erreur dépend véritablement de l'outil de génération et du compilateur que vous utilisez. L'exemple ci-après est une implémentation qui reconnaît les messages d'erreur émis par le compilateur XLC d'IBM.
package org.monentreprise.errorparser;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.cdt.core.ErrorParserManager;
import org.eclipse.cdt.core.IErrorParser;
import org.eclipse.cdt.core.IMarkerGenerator;
import org.eclipse.core.resources.IResource;
public class MonAnalyseurErreur implements IErrorParser {
static String regexp = "\"((?:\\w|\\.)+)\", line (\\d+)\\.\\d+: (.*)";
static Pattern errorPattern = Pattern.compile(regexp);
public boolean processLine(String line, ErrorParserManager manager) {
Matcher matcher = errorPattern.matcher(line);
if(!matcher.matches())
return false;
String fileName = matcher.group(1);
int lineNumber = Integer.parseInt(matcher.group(2));
String message = matcher.group(3);
IResource resource = manager.findFileName(fileName);
if(resource == null)
resource = manager.findFilePath(fileName);
if(resource == null)
resource = manager.getProject(); // fichier non trouvé dans l'espace de travail, associer le problème au projet
// créer un marqueur de problème qui apparaîtra dans la vue Erreurs
int severity = IMarkerGenerator.SEVERITY_ERROR_RESOURCE;
manager.generateMarker(resource, lineNumber, message, severity, null);
return true;
}
}
La ligne est d'abord comparée à l'expression régulière. Si elle ne concorde pas, false est renvoyé. Cela indique au gestionnaire ErrorParserManager que cet analyseur d'erreur n'a pas reconnu la ligne. Dans ce cas, l'ErrorParserManager envoie la ligne à l'analyseur d'erreur suivant parmi ceux qui sont activés (sous l'onglet Analyseurs d'erreur décrit au début de ce tutoriel).
Si la ligne concorde, l'analyseur d'erreur doit alors créer un "marqueur de problème", que le plan de travail Eclipse se chargera de présenter à l'utilisateur. Dans cet exemple, des groupes de capture sont utilisés pour extraire les informations appropriées de la ligne. Consultez la documentation Javadoc de la classe java.util.regex.Pattern pour une description détaillée des expressions régulières et des groupes de capture. Si vous ne voulez pas utiliser d'expression régulière, vous pouvez tirer parti des méthodes standard d'interprétation de chaînes de la classe String, ainsi que de la classe java.util.StringTokenizer.
L'étape suivante consiste à trouver un objet IResource qui concorde avec le nom de fichier dans le message d'erreur. Un objet IResource représente un fichier ou un répertoire dans l'espace de travail Eclipse. (Pour plus d'informations, consultez le Javadoc de l'interface org.eclipse.core.resources.IResource). La classe ErrorParserManager fournit plusieurs méthodes utiles pour convertir les noms de fichier en objets IResource. Si aucun objet IResource correspondant au nom de fichier n'est trouvé, on choisit d'associer le problème au projet lui-même.
Une fois ces informations déterminées, on utilise la méthode generateMarker() pour créer l'objet marqueur de problème. L'interface org.eclipse.cdt.core.IMarkerGenerator contient des constantes qui correspondent aux différents niveaux de gravité. Dans cet exemple, volontairement simplifié, l'analyseur d'erreur génère seulement des marqueurs avec le niveau de gravité erreur (constante SEVERITY_ERROR_RESOURCE), mais dans la réalité, il devrait aussi générer des marqueurs d'avertissement (warning) et d'information (info).
Lors du développement de votre analyseur d'erreur sur-mesure, vous trouverez certainement très pratique d'exécuter IBM Rational Developer for Power Systems Software dans le débogueur d'Eclipse. Ce dernier est en effet capable de changer les fichiers classe "à chaud". Cela signifie que vous pouvez apporter des modifications au code de votre analyseur sans qu'il soit nécessaire de redémarrer ensuite le débogueur pour qu'elles soient prises en compte. Dès que vous sauvegardez le fichier source, Eclipse recompile automatiquement le code et charge la nouvelle version du fichier classe dans l'instance active d'IBM Rational Developer for Power Systems Software.
Si votre analyseur d'erreur génère correctement les marqueurs de problème, vous devez les voir apparaître dans les vues Explorateur de projets et Erreurs ainsi que dans l'éditeur de code lui-même.

Lorsque vous êtes satisfait du fonctionnement de votre analyseur d'erreur, il est temps pour vous de générer le plug-in et de le distribuer. Ce processus est très simple. Faites un clic droit sur le projet et sélectionnez Exporter. Ensuite, dans l'assistant d'exportation, sélectionnez Développement de plug-in > Plug-ins et fragments déployables et cliquez sur Suivant.

Sur la seconde page de l'assistant, sélectionnez le plug-in, choisissez une destination d'exportation, puis cliquez sur Terminer.

A l'emplacement choisi comme répertoire de destination, vous trouverez un dossier nommé plugins et, dans ce dossier, un fichier jar contenant votre plug-in. Copiez simplement ce fichier dans le dossier plugins du dossier SDPShared de votre installation d'IBM Rational Developer for Power Systems Software et lancez ce dernier comme vous le faites habituellement. Il ne vous reste plus qu'à activer l'analyseur d'erreur dans les propriétés de votre projet.

Désormais, IBM Rational Developer for Power Systems Software reconnaîtra la sortie de votre outil de génération personnalisé.