src/klftools/klfdefs.cpp

Go to the documentation of this file.

/***************************************************************************
 *   file klfdefs.cpp
 *   This file is part of the KLatexFormula Project.
 *   Copyright (C) 2011 by Philippe Faist
 *   philippe.faist at bluewin.ch
 *                                                                         *
 *   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.             *
 ***************************************************************************/
/* $Id$ */

#include <stdlib.h>
#include <stdio.h> // vsprintf(), vsnprintf
#include <stdarg.h> // va_list, va_arg, va_end in klfFmt()
#include <sys/time.h>

#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QRegExp>
#include <QApplication>
#include <QMetaObject>
#include <QDebug>
#include <QDateTime>

#include "klfdefs.h"

/* * This is not a bug, it's cosmetic... \ bug Remove Qt3 support w/ KLFBACKEND_QT4 in all files */


/* -- * ------- NOT PROVIDED. NOT NICE. -------------------
  \def KLF_PROPERTY_GET
  \hideinitializer
 
  \bug DOES THIS MACRO PREVENT DOXYGEN DOCUMENTATION ?
 
  Declares a functions, one public designed to get a property value. This macro is to be used
  within a class declaration.
 
  Useful in conjunction with Q_PROPERTY declarations.
 
  This macro expands to
  \code 
    public: <type and propertyName>() const;
  \endcode
 
  \param type_and_prop is the type and the name of the property, separated by space
 
  Possible definitions of this functions are provided with the macros \ref KLF_DEFINE_PROPERTY_GET
  and \ref KLF_DEFINE_PROPERTY_GETSET.
*/

// INTERNAL

static char __klf_version_string[] = KLF_VERSION_STRING;


KLF_EXPORT const char * klfVersion()
{
  return __klf_version_string;
}

KLF_EXPORT int klfVersionMaj()
{
  return KLF_VERSION_MAJ;
}
KLF_EXPORT int klfVersionMin()
{
  return KLF_VERSION_MIN;
}
KLF_EXPORT int klfVersionRelease()
{
  return KLF_VERSION_REL;
}




// declared in klfdebug.h

class KLFDebugObjectWatcherPrivate
{
public:
  QMap<quintptr, QString> refInfos;
};

// static
KLFDebugObjectWatcher *KLFDebugObjectWatcher::instance = NULL;
// static
KLFDebugObjectWatcher *KLFDebugObjectWatcher::getWatcher()
{
  if (instance == NULL)
    instance = new KLFDebugObjectWatcher;
  return instance;
}

void KLFDebugObjectWatcher::registerObjectRefInfo(QObject *object, const QString& refinfo)
{
  p->refInfos[(quintptr)object] = refinfo;
}

KLFDebugObjectWatcher::KLFDebugObjectWatcher()
  : QObject(qApp)
{
  p = new KLFDebugObjectWatcherPrivate;
}
KLFDebugObjectWatcher::~KLFDebugObjectWatcher()
{
  delete p;
}
void KLFDebugObjectWatcher::debugObjectDestroyed(QObject *object)
{
  quintptr obji = (quintptr) object;
  if (p->refInfos.contains(obji)) {
    klfDbg(klfFmtCC("Object destroyed: (%s*)%p; object reference name is `%s'",
                    (object ? object->metaObject()->className() : "void"),
                    (void*)object, qPrintable(p->refInfos[obji])));
  } else {
    klfDbg(klfFmtCC("Object destroyed: (%s*)%p",
                    (object ? object->metaObject()->className() : "void"),
                    (void*)object));
  }
}



KLF_EXPORT QByteArray klfShortFuncSignature(const QByteArray& funcname)
{
  // returns the section between the last space before the first open paren and the first open paren
  int iSpc, iParen;
  iParen = funcname.indexOf('(');
  iSpc = funcname.lastIndexOf(' ', iParen-2);
  // if iSpc is -1, leave it at -1 (eg. constructor signature), the following code still works.
  if (iParen == -1 || iSpc > iParen) {
    qWarning("klfShortFuncSignature('%s'): Signature parse error!", funcname.constData());
    return funcname;
  }
  // shorten name
  QByteArray f = funcname.mid(iSpc+1, iParen-(iSpc+1));
  // special case: if 'operator...' then keep the arguments, because it doesn't help us much otherwise!
  if (f.startsWith("operator")) {
    return funcname.mid(iSpc+1);
  }
  return f;
}




KLF_EXPORT QByteArray klfFmt(const char * fmt, va_list pp)
{
  static const int bufferSize = 8192;
  char buffer[bufferSize];
  int len;
#if defined(_BSD_SOURCE) || _XOPEN_SOURCE >= 500 || defined(_ISOC99_SOURCE)
  // stdio.h provided vsnprintf()
  len = vsnprintf(buffer, bufferSize, fmt, pp);
  if (len >= bufferSize) {
    // output was truncated
    qWarning("%s(): output from format string \"%s\" was truncated from %d to %d bytes.",
             KLF_FUNC_NAME, fmt, len, (bufferSize-1));
    len = bufferSize-1;
  }
#else
  len = vsprintf(buffer, fmt, pp);
#endif

  if (len < 0) {
    qWarning("%s(): vs(n)printf() failed for format \"%s\"", KLF_FUNC_NAME, fmt);
    return QByteArray();
  }

  // create a QByteArray
  QByteArray data;
  data = QByteArray(buffer, len);
  return data;
}

KLF_EXPORT QByteArray klfFmt(const char * fmt, ...)
{
  va_list pp;
  va_start(pp, fmt);
  QByteArray data = klfFmt(fmt, pp);
  va_end(pp);
  return data;
}


KLF_EXPORT QByteArray klfFmtDouble(double num, char fmt, int precision)
{
  QString s = QString::number(num, fmt, precision);

  QByteArray data;
  data = s.toLatin1();
  return data;
}




KLF_EXPORT QString klfTimeOfDay(bool shortfmt)
{
  struct timeval tv;
  gettimeofday(&tv, NULL);
  char temp[128];
  if (shortfmt)
    sprintf(temp, "%03ld.%06ld", (ulong)tv.tv_sec % 1000, (ulong)tv.tv_usec);
  else
    sprintf(temp, "%ld.%06ld", (ulong)tv.tv_sec, (ulong)tv.tv_usec);
  return QString::fromLatin1(temp);
}


//#ifdef KLF_DEBUG // see comment in KLFDebugBlock::KLFDebugBlock()
static int __klf_dbg_block_depth_counter = 0;
//#endif

KLFDebugBlock::KLFDebugBlock(const QString& blockName)
  : pBlockName(blockName), pPrintMsg(true)
{
  // unconditionally display the debug message. If we compile the library without KLF_DEBUG
  // and then use this feature in a program /with/ KLF_DEBUG, then we want the debug message
  // to display.

  //#ifdef KLF_DEBUG
  qDebug("%s: [%02d]block begin", qPrintable(pBlockName), ++__klf_dbg_block_depth_counter);
  //#endif
}
KLFDebugBlock::KLFDebugBlock(bool printmsg, const QString& blockName)
  : pBlockName(blockName), pPrintMsg(printmsg)
{
  //#ifdef KLF_DEBUG // see comment in other constructor.
  // convention: __klf_dbg_block_depth_counter is incremented/decremented only when displayed
  if (printmsg)
    qDebug("%s: [%02d]block begin", qPrintable(pBlockName), ++__klf_dbg_block_depth_counter);
  //#endif
}
KLFDebugBlock::~KLFDebugBlock()
{
  //#ifdef KLF_DEBUG // see comment in KLFDebugBlock::KLFDebugBlock()
  // convention: __klf_dbg_block_depth_counter is incremented/decremented only when displayed
  if (pPrintMsg)
    qDebug("%s: [%02d]block end", qPrintable(pBlockName), __klf_dbg_block_depth_counter--);
  //#endif
}
KLFDebugBlockTimer::KLFDebugBlockTimer(const QString& blockName)
  : KLFDebugBlock(false, blockName)
{
  //#ifdef KLF_DEBUG // see comment in KLFDebugBlock::KLFDebugBlock()
  // convention: __klf_dbg_block_depth_counter is incremented/decremented only when displayed
  qDebug("+T:%s: %s: [%02d]block begin", KLF_SHORT_TIME, qPrintable(pBlockName), ++__klf_dbg_block_depth_counter);
  //#endif
}
KLFDebugBlockTimer::~KLFDebugBlockTimer()
{
  //#ifdef KLF_DEBUG // see comment in KLFDebugBlock::KLFDebugBlock()
  // convention: __klf_dbg_block_depth_counter is incremented/decremented only when displayed
  qDebug("+T:%s: %s: [%02d]block end", KLF_SHORT_TIME, qPrintable(pBlockName), __klf_dbg_block_depth_counter--);
  //#endif
}

inline QString func_name_w_parens(const char *f)
{
  QString s = QLatin1String(f);
  if (s.indexOf('(') == -1)
    return s+"()";
  return s;
}

// the following is defined for both debug and non-debug modes. In non-debug modes, it provides the symbol
// __klf_dbg_hdr for debugging eg. plugins compiled in debug mode
KLF_EXPORT QDebug __klf_dbg_hdr(QDebug dbg, const char * funcname, const char *refinstance, const char * shorttime)
{
  if (shorttime == NULL)
    return dbg.nospace()<<qPrintable(func_name_w_parens(funcname))<<":"<<refinstance
                        <<"\n        ";
  else
    return dbg.nospace()<<"+T:"<<shorttime<<": "<<qPrintable(func_name_w_parens(funcname))<<":"<<refinstance
                        <<"\n        ";
}

KLF_EXPORT QDebug __klf_warning_hdr(QDebug warndbg, const char * funcname, const char * shorttime)
{
  Q_UNUSED(shorttime) ; // maybe if I one day decide to change the format to include shorttime... (?)
  return warndbg.nospace()<<"***** In function "<<qPrintable(func_name_w_parens(funcname))
                          <<"  " // shorttime is too short:
                          <<qPrintable(QDateTime::currentDateTime().toString(Qt::DefaultLocaleShortDate))
                          <<" *****"
                          <<"\n        ";

}



// ----------------------------------------




QStringList klf_version_suffixes =
  QStringList() << "a" << "alpha" << "b" << "beta" << "p" << "pre" << "preview" << "RC" << "rc"
/* */           << "" // empty suffix or any unrecognized suffix
/* */           << "post" << "dev" << "devel";

static int __klf_version_compare_suffix_words(QString w1, QString w2)
{
  // a list of known words
  const QStringList& words = klf_version_suffixes;
  // now compare the words
  int borderBeforeAfter = words.indexOf("");
  if (borderBeforeAfter < 0)
    qWarning("klfVersionCompare: suffix words list doesn't contain \"\"!");
  int i1 = words.indexOf(w1);
  int i2 = words.indexOf(w2);
  if (i1 == -1 && i2 == -1)
    return QString::compare(w1, w2);
  if (i2 == -1)
    return i1 < borderBeforeAfter ? -1 : +1;
  if (i1 == -1)
    return i2 < borderBeforeAfter ? +1 : -1;
  // both are recognized words
  return i1 - i2;
}

#define VERSION_RX "^(\\d+)(\\.(\\d+)(\\.(\\d+)([a-zA-Z]+\\d*)?)?)?$"

KLF_EXPORT bool klfIsValidVersion(const QString& v)
{
  QRegExp rx(VERSION_RX);
  return rx.exactMatch(v);
}

KLF_EXPORT int klfVersionCompare(const QString& v1, const QString& v2)
{
  qDebug("klfVersionCompare(): Comparing versions %s and %s", qPrintable(v1), qPrintable(v2));
  if (v1 == v2)
    return 0;
  if (v1.isEmpty()) // v1 is empty, but v2 is not empty because of test above
    return -1;
  if (v2.isEmpty()) // v2 is empty, but not v1 because of test above
    return 1;
  //           *1     2  *3     4  *5    *6
  QRegExp rx1(VERSION_RX);
  QRegExp rx2(rx1);
  if (!rx1.exactMatch(v1)) {
    qWarning("klfVersionLessThan: Invalid version number format: %s", qPrintable(v1));
    return -200;
  }
  if (!rx2.exactMatch(v2)) {
    qWarning("klfVersionLessThan: Invalid version number format: %s", qPrintable(v2));
    return -200;
  }
  int maj1 = rx1.cap(1).toInt();
  int maj2 = rx2.cap(1).toInt();
  if (maj1 != maj2)
    return maj1 - maj2;
  bool hasmin1 = !rx1.cap(2).isEmpty();
  bool hasmin2 = !rx2.cap(2).isEmpty();
  if ( ! hasmin1 && ! hasmin2 )
    return 0; // equal
  if ( ! hasmin1 && hasmin2 )
    return -1; // 3 < 3.x
  if ( hasmin1 && ! hasmin2 )
    return +1; // 3.x > 3
  int min1 = rx1.cap(3).toInt();
  int min2 = rx2.cap(3).toInt();
  if ( min1 != min2 )
    return min1 - min2;

  bool hasrel1 = !rx1.cap(4).isEmpty();
  bool hasrel2 = !rx2.cap(4).isEmpty();
  if ( ! hasrel1 && ! hasrel2 )
    return 0; // equal
  if ( ! hasrel1 && hasrel2 )
    return -1; // 3.x < 3.x.y
  if ( hasrel1 && ! hasrel2 )
    return +1; // 3.x.y > 3.x
  int rel1 = rx1.cap(5).toInt();
  int rel2 = rx2.cap(5).toInt();
  if ( rel1 != rel2 )
    return rel1 - rel2;

  QString suffix1 = rx1.cap(6);
  QString suffix2 = rx2.cap(6);

  //  qDebug("Suffix1=%s, suffix2=%s", qPrintable(suffix1), qPrintable(suffix2));

  if (suffix1 == suffix2)
    return 0; // equal

  //             1          2
  QRegExp rxs1("^([a-zA-Z]*)(\\d*)$");
  QRegExp rxs2(rxs1);
  rxs1.exactMatch(suffix1); // must necessarily match, already matched global regex
  rxs2.exactMatch(suffix2);

  QString w1 = rxs1.cap(1);
  QString w2 = rxs2.cap(1);
  QString ns1 = rxs1.cap(2);
  QString ns2 = rxs2.cap(2);

  int cmp = __klf_version_compare_suffix_words(w1, w2);
  if (cmp != 0)
    return cmp; // words are enough to make the difference

  // the words are the same -> compare ns1<->ns2
  if (ns1.isEmpty()) {
    if (ns2.isEmpty())
      return 0; // equal
    // with suffix number compares greater than without
    return -1;
  }
  if (ns2.isEmpty()) {
    return +1;
  }

  int n1 = ns1.toInt();
  int n2 = ns2.toInt();
  return n1 - n2;
}

KLF_EXPORT bool klfVersionCompareLessThan(const QString& v1, const QString& v2)
{
  return klfVersionCompare(v1,v2) < 0;
}