amroc/weno/CLESLog.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef AMROC_CLESLOG_H
#define AMROC_CLESLOG_H

//
// Created: 4/1/06
// Author : C. Pantano
// Purpose: Simple logging system
//

#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include "DAGH.h"
#include "../weno/src/generic/cles.h"

#define CLESLOG_MSGMAXLEN 256
#define CLESLOG_KEYMAXLEN 24
#define CLESLOG_MAXINDENT 100
#define CLESLOG_HEADERLEN 72

#define CLESLOG_DEBUG   0
#define CLESLOG_WARNING 1
#define CLESLOG_ERROR   2

#define CLESLOG_CBC         1
#define CLESLOG_CBC_EIGENSYSTEM 1
#define CLESLOG_CBC_REFPRESSURE 2

#define CLESLOG_ROE         2
#define CLESLOG_ROE_STATES      1

#define CLESLOG_TCD         3
#define CLESLOG_TCD_STENCIL     1

class CLESLog {

public:

// main datastructure containing log messages
struct ldtype {
    int _active;  // is this message activated
    int _mod;     // module ID
    int _loc;     // locatio ID
    int _lev;     // level or type of message
    char _msg[CLESLOG_MSGMAXLEN];      // message text
    char _mod_msg[CLESLOG_KEYMAXLEN];  // module name
    char _loc_msg[CLESLOG_KEYMAXLEN];  // location name
};

  void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    ControlDevice LocCtrl = Ctrl.getSubDevice(prefix+"Logging");
    
    RegisterAt(LocCtrl,"ActiveLogs",_DefFile);
    RegisterAt(LocCtrl,"Trace",_trace);
    
  }

// report errors to stderr
void jerror(const char* msg) {
    fprintf(stderr, "Error: ");
    fprintf(stderr, msg);
    fprintf(stderr, "\n");
    fflush(stderr);
}

char* trim(char* input) {
    // search beggining spaces
    int len = std::strlen(input);
    for ( int i = 0 ; i < len && isspace(input[i]) ; i ++ ) 
        input ++;
    
    len = std::strlen(input);
    for ( int i = len-1; i>=0 && isspace(input[i]) ; i-- ) 
        input[i] = '\0';
    return input;
}

// lookup log messages structures
ldtype* lookup(int mod, int loc) {
    for ( int i=0 ; i < log_table_size ; i++ ) {
        ldtype* p = &(logtable[i]);
        if ( p->_mod == mod && p->_loc == loc )
            return p;
    }

    return NULL;
}

ldtype* lookup(char* mod, char* loc) {
    for ( int i=0 ; i < log_table_size ; i++ ) {
        ldtype* p = &(logtable[i]);
        if ( std::strncmp(p->_mod_msg,mod,CLESLOG_KEYMAXLEN-1) == 0 && 
             std::strncmp(p->_loc_msg, loc,CLESLOG_KEYMAXLEN-1) == 0 ) 
            return p;
    }

    return NULL;
}

// print a nice header
 void header() {
     char header[CLESLOG_HEADERLEN+1];
     header[0] = '#';
     for ( int i = 1; i < CLESLOG_HEADERLEN-1 ; i++ )
         header[i] = ( i%2 == 0 ? '/' : '\\' );
     header[CLESLOG_HEADERLEN-1] = '#';
     header[CLESLOG_HEADERLEN] = 0;
     for ( int i = 0 ; i < log_indent ; i++ )
         comm_service::log() << "   " ;
     // print msg header 
     (comm_service::log() << header << "\n").flush();
 }

 void mark(ldtype* p) {
     log_indent ++;
     requested_last[log_indent] = p;
 }

  void unmark() {
      requested_last[log_indent] = NULL;
      log_indent --;
  }

// static variables
static int reporting_level ; 
static bool active_log ;
static ldtype* requested_last[CLESLOG_MAXINDENT];
static ldtype logtable[];
static std::string _DefFile;
static int log_table_size;
static int log_indent;
static int _trace;
static int trace_indent;

 CLESLog() { } 
 ~CLESLog() { }

// test if a log is active
 int inactive() {
     if ( active_log == false ) return 1;
     if ( requested_last[log_indent] == NULL ) return 1;
     if ( requested_last[log_indent]->_active == false ) return 1;
     return 0;
 }

// read input keys and initialize
 void initialize() {
     for ( int i = 0 ; i < CLESLOG_MAXINDENT ; i ++ )
        requested_last[i] = NULL;

     if ( _DefFile.length() ) {
         active_log = true;
         
         FILE* pfile = fopen(_DefFile.c_str(), "r");
         if ( pfile == NULL ) return;

         char mod[CLESLOG_KEYMAXLEN];
         char loc[CLESLOG_KEYMAXLEN];

         while(feof(pfile) == 0) {
             if ( fscanf(pfile, "%s %s", mod, loc) == EOF ) break;
             
             ldtype* entry = lookup(mod, loc);
             if ( entry != NULL ) entry->_active = true;
         }
         fclose(pfile);
     }
 }

// cleanup
 void finalize() {
     
 }

};

// tracing activation
int  CLESLog::_trace = 0;
int  CLESLog::trace_indent = 0;

// default is error level
int CLESLog::reporting_level = CLESLOG_ERROR;
// default is inactive
bool CLESLog::active_log = false;
// nothing requested
CLESLog::ldtype* CLESLog::requested_last[CLESLOG_MAXINDENT];
// master table of message descriptions
CLESLog::ldtype  CLESLog::logtable[] = { 
    {false, CLESLOG_CBC, CLESLOG_CBC_EIGENSYSTEM, CLESLOG_DEBUG, 
     "CBC->EIGENSYSTEM", "CBC", "EIGENSYSTEM" },
    {false, CLESLOG_CBC, CLESLOG_CBC_REFPRESSURE, CLESLOG_DEBUG,
     "CBC->REFPRESSURE", "CBC", "REFPRESSURE" },
    {false, CLESLOG_ROE, CLESLOG_ROE_STATES, CLESLOG_DEBUG,
     "ROE->STATES", "ROE", "STATES" },
    {false, CLESLOG_TCD, CLESLOG_TCD_STENCIL, CLESLOG_DEBUG,
     "TCD->STENCIL", "TCD", "STENCIL" }};

// size of the table
int CLESLog::log_table_size = sizeof(CLESLog::logtable)/sizeof(CLESLog::ldtype);
int CLESLog::log_indent = -1;
// activation file
std::string CLESLog::_DefFile = "";

extern "C" {

    // test if a log message is active
#define f_cleslog_active FORTRAN_NAME_(cleslog_active, CLESLOG_ACTIVE)
    int f_cleslog_active(int& module, int& loc) {
        CLESLog me;
        CLESLog::ldtype* p;

        if ( me.active_log == false ) return CLES_FALSE;        
        if ( (p=me.lookup(module, loc)) == NULL ) return CLES_FALSE;
        if ( p->_active == false ) return CLES_FALSE;
        
        me.mark(p);
        me.header();

        const char * header;
        switch ( me.requested_last[me.log_indent]->_lev ) {
            case CLESLOG_DEBUG:   header = "DEBUG:   "; break;
            case CLESLOG_WARNING: header = "WARNING: "; break;
            case CLESLOG_ERROR:   header = "ERROR:   "; break;
            default: header = "UNKNOWN: ";
        }
        for ( int i = 0 ; i < me.log_indent ; i++ )
            comm_service::log() << "\t" ;
        (comm_service::log() << header << 
         me.requested_last[me.log_indent]->_msg << "\n").flush();
        return CLES_TRUE;
    }

    // test if a log message is active for warning and error messages
#define f_cleslog_activate FORTRAN_NAME_(cleslog_activate, CLESLOG_ACTIVATE)
    int f_cleslog_activate(int& module, int& loc) {
        CLESLog me;
        CLESLog::ldtype* p;

        if ( (p=me.lookup(module, loc)) == NULL ) return CLES_FALSE;
        if ( p->_lev > CLESLOG_DEBUG ) {
            me.active_log = true;
            p->_active = true;
            return f_cleslog_active(module, loc);
        }
        return CLES_FALSE;
    }

    // write log
#define f_cleslog_log FORTRAN_NAME_(cleslog_log, CLESLOG_LOG)
    void f_cleslog_log(char* msg) {
        CLESLog me;

        if ( me.inactive() ) return;
        
        for ( int i = 0 ; i < me.log_indent ; i++ )
            comm_service::log() << "   " ;
        //char *lmsg = (char*)malloc(std::strlen(msg)+1);
        //char *tmsg;
        //strcpy(lmsg, msg);
        //tmsg = me.trim(lmsg);
        (comm_service::log() << msg  << "\n").flush();
        //free(lmsg);
    }

    // close log
#define f_cleslog_log_flush FORTRAN_NAME_(cleslog_log_flush, CLESLOG_LOG)
    void f_cleslog_log_flush(void) {
        CLESLog me;
        
        if ( me.inactive() ) return;

        me.header();
        me.unmark();
    }

#define f_cleslog_trace_enter FORTRAN_NAME_(cleslog_trace_enter, CLESLOG_TRACE_ENTER)
    void f_cleslog_trace_enter(char* msg) {
        CLESLog me;

        if ( me._trace == 0 ) return;

        for ( int i = 0 ; i < me.trace_indent ; i++ )
            comm_service::log() << "\t" ;
        
        (comm_service::log() << "<*> Entering: " << msg << "\n").flush();
        me.trace_indent ++;
    }

#define f_cleslog_trace_exit FORTRAN_NAME_(cleslog_trace_exit, CLESLOG_TRACE_EXIT)
    void f_cleslog_trace_exit(char* msg) {
        CLESLog me;

        if ( me._trace == 0 ) return;
        
        me.trace_indent --;
        for ( int i = 0 ; i < me.trace_indent ; i++ )
            comm_service::log() << "\t" ;
        
        (comm_service::log() << "<*> Exiting:  " << msg << "\n").flush();
        
    }

}

#endif