inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/agentutils.h

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef AGENT_UTILS_H
#define AGENT_UTILS_H

#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
#  if !defined(WIN32_LEAN_AND_MEAN)
#   define WIN32_LEAN_AND_MEAN
#  endif // !defined(WIN32_LEAN_AND_MEAN)
#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
        
#include <iostream>        
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdarg.h>
#include <ctime>
#include <QString>
#include <QStringList>
#include <QStringListIterator>
#include <QList>
#include <QRegExp>
#include "jvmti.h"


char *getToken(char *str, char *seps, char *buf, int max);
bool coveredByList(char *cname, char *mname, QList<QRegExp>*);
bool interested(char *cname, char *mname, QList<QRegExp>*);
void createAgentClassFilter(QRegExp &regexp, QString filterString);
                                
namespace inspectorj {
namespace agent {
            
class AgentLogger
{
    public: 
                
        static int loglevel;
        
        static void
        print(const char * format, ...)
        {
            va_list ap;
        
            va_start(ap, format);
            (void)vfprintf(stdout, format, ap);
            va_end(ap);
            (void)fflush(stdout);
        }     
           
        static void
        println(const char * format, ...)
        {
            va_list ap;
        
            va_start(ap, format);
            (void)vfprintf(stdout, format, ap);
            va_end(ap);
            fprintf(stdout, "\n");
            (void)fflush(stdout);
        }         
        
        static void
        debug(const char * format, ...)
        {
            if (loglevel < 99) return;
            va_list ap;

            printTimeString(stdout);
            fprintf(stdout, " [DEBUG] ");
            va_start(ap, format);
            (void)vfprintf(stdout, format, ap);
            va_end(ap);
            fprintf(stdout, "\n");
            (void)fflush(stdout);              

        }        
        
        static void
        info(const char * format, ...)
        {
            if (loglevel < 2) return;
            va_list ap;
            printTimeString(stdout);
            fprintf(stdout, " [INFO] ");
            va_start(ap, format);
            (void)vfprintf(stdout, format, ap);
            va_end(ap);
            fprintf(stdout, "\n");
            (void)fflush(stdout);            
        }
        
        static void
        warn(const char * format, ...)
        {
            if (loglevel < 1) return;
            va_list ap;
        
            printTimeString(stdout);
            fprintf(stdout, " [WARN] ");            
            va_start(ap, format);
            (void)vfprintf(stdout, format, ap);
            va_end(ap);
            fprintf(stdout, "\n");
            (void)fflush(stdout);              
        }        
        
        static void
        error(const char * format, ...)
        {
            va_list ap;
        
            printTimeString(stderr);
            fprintf(stderr, " [ERROR] ");             
            va_start(ap, format);
            (void)vfprintf(stderr, format, ap);
            fprintf(stderr, "\n");            
            (void)fflush(stderr);
            va_end(ap);
        }  
         
        static void
        fatal(const char * format, ...)
        {
            va_list ap;
        
            printTimeString(stderr);
            fprintf(stderr, " [FATAL] ");             
            va_start(ap, format);
            (void)vfprintf(stderr, format, ap);
            fprintf(stderr, "\n");            
            (void)fflush(stderr);
            va_end(ap);
            exit(3);
        }  
                       
        static char*
        toChar(const QString& qstr)
        {
            return qstr.toLocal8Bit().data();
        }
                
        /* Convenience wrappers */
        static void print (const QString qstr, ...) { va_list va; print(toChar(qstr),va); } 
        static void println (const QString qstr, ...) { va_list va; println(toChar(qstr),va); }
        static void debug (const QString qstr, ...) { va_list va; debug(toChar(qstr),va); }
        static void info (const QString qstr, ...) { va_list va; info(toChar(qstr),va); }
        static void warn (const QString qstr, ...) { va_list va; warn(toChar(qstr),va); }
        static void error (const QString qstr, ...) { va_list va; error(toChar(qstr),va); }
        static void fatal (const QString qstr, ...) { va_list va; fatal(toChar(qstr),va); }
             
    private:
        
        static void printTimeString(FILE * stream)
        {
            using namespace std;
            time_t now = time(0);
            tm *timer = localtime (&now);

            char tmp[24];
            char* format = "%Y-%m-%d %I:%M:%S -";
            size_t cnt = strftime(tmp, 24, format, timer);
            fprintf(stream, tmp);
        }                
};

} // end namespace agent
} // end namespace inspectorj


/* Evaluate JVMTI error code */
static void
check_jvmti_error(jvmtiEnv *jvmti, jvmtiError errnum, const char *str)
{
    if ( errnum != JVMTI_ERROR_NONE ) {
    char       *errnum_str;

    errnum_str = NULL;
    (void)jvmti->GetErrorName(errnum, &errnum_str);

    inspectorj::agent::AgentLogger::error("ERROR: JVMTI: %d(%s): %s", errnum,
        (errnum_str==NULL?"Unknown":errnum_str),
        (str==NULL?"":str));
    }
}

#endif // end AGENT_UTILS_H

---