journal.c

Aller à la documentation de ce fichier.

 
#include <manux/config.h>
#include <manux/memoire.h>  // NULL
#include <manux/journal.h>
#include <manux/string.h>   // strlen
 
#ifdef MANUX_FICHIER
Fichier _consoleFichier; // Pour éviter un kmalloc pour le moment
Fichier * consoleFichier = NULL;
#else
Console * consoleJournal = NULL;
#endif
 
static booleen journalInitialise = FALSE;
 
//static ExclusionMutuelle emj;
 
#ifdef MANUX_FICHIER
Fichier * fichierJournal = NULL;
 
[[maybe_unused]]
static
void journalInitialiserInoeud(INoeud * iNoeudConsole)
{
    //   initialiserExclusionMutuelle(&emj);
    //   entrerExclusionMutuelle(&emj);
 
   consoleFichier = &_consoleFichier;
   fichierOuvrir(iNoeudConsole, consoleFichier, O_WRONLY, 0);
 
   // Affichons un petit message   
   consoleNoyauAfficher("Journal+f de ManuX-32 \n");
 
   // A partir de maintenant, le journal est opérationnel
   journalInitialise = TRUE;
   
   //   sortirExclusionMutuelle(&emj);
}
 
void journalAffecterFichier(Fichier * pc)
{
   fichierJournal = pc;
}
 
#endif
 
void journalInitialiser(void)
{
    //   initialiserExclusionMutuelle(&emj);
    //   entrerExclusionMutuelle(&emj);
 
   // consoleAffecterCouleurTexte(consoleJournal, COUL_TXT_BLANC);
 
   // Affichons un petit message   
   consoleNoyauAfficher("Journal de ManuX-32\n");
 
   // A partir de maintenant, le journal est opérationnel
   journalInitialise = TRUE;
   
   //   sortirExclusionMutuelle(&emj);
}
 
static void journaliserNiveau(booleen console, booleen fichier,
               uint8_t niveau,
               char * message)
{
    //   entrerExclusionMutuelle(&emj);
 
   // Sur la console
   if ((console) && (niveau <= MANUX_JOURNAL_NIVEAU_DEFAUT)) {
#ifdef MANUX_FICHIER
      // Si le fichier a été ouvert, on y écrit ...
      if (consoleFichier) { 
         fichierEcrire(consoleFichier, message, strlen(message));
      // ... mais s'il n'est pas encore ouvert (pas initialisé), on
      // passe directement par la console
      } else {
         consoleNoyauAfficher(message);
      }
#else
      consoleNoyauAfficher(message);
#endif
   }
 
#ifdef MANUX_FICHIER
   // Sur le fichier s'il y en a un
   if (fichierJournal) {
      if ((fichier) && (niveau <= MANUX_JOURNAL_NIVEAU_DEFAUT)) {
    fichierEcrire(fichierJournal, message, strlen(message));   
      }
   }
#endif
   
  //   sortirExclusionMutuelle(&emj);
}
 
static void aiguillerMessage(char ** message,
              booleen * cons, booleen * fic, uint8_t * niv)
{
   int longueurPrefixe = 0;
   *cons = FALSE;
   *fic = FALSE;
   *niv = 0;
 
   switch ((*message)[0]) {
      case '[' :
         *cons = TRUE;
      break ;
      case '{' :
         *cons = TRUE;
     [[fallthrough]];
      case '(' :
         *fic = TRUE;
      break ;
      default :
         *cons = TRUE;  // WARNING defaut
         *fic = TRUE;
      return;
   };
 
   longueurPrefixe ++;
   if (((*message)[1] <= '9') && ((*message)[1] >= '0')) {
      *niv = (*message)[1] - '0';
      longueurPrefixe ++;
 
      if (((*message)[2] == ')') || ((*message)[2] == '}') || ((*message)[2] == ']')) {
         longueurPrefixe ++;
      }
   }
   (*message) += longueurPrefixe;
}
 
void journaliser(char * message)
{
   booleen console; //< affiche-t-on le message sur la console ?
   booleen fichier; //< envoie-t-on le message sur un fichier de log ?
   uint8_t niveau;  //< quel est le niveau de criticité ?
 
   // On détermine où il doit être envoyé pour affichage
   aiguillerMessage(&message, &console, &fichier, &niveau);
 
   // On l'envoie
   journaliserNiveau(console, fichier, niveau, 
             message);
}
 
booleen journalOperationnel(void)
{
   return journalInitialise;
}