コード例 #1
0
ファイル: log.cpp プロジェクト: DINKIN/CopyQ
QString readLogFile()
{
    SystemMutexLocker lock(getSessionMutex());

    QString content;
    for (int i = 0; i < logFileCount; ++i)
        content.prepend( readLogFile(logFileName(i)) );

    content.prepend(logFileName() + "\n\n");

    return content;
}
コード例 #2
0
bool patchBinaryWithQtPathes(const char *fileName, const char *baseQtPath)
{
    bool result = true;

    static const struct
    {
        const char *variable;
        const char *subDirectory;
    } variables[] = {
        {"qt_prfxpath=", ""},
        {"qt_docspath=", "/doc"},
        {"qt_hdrspath=", "/include"},
        {"qt_libspath=", "/lib"},
        {"qt_binspath=", "/bin"},
        {"qt_plugpath=", "/plugins"},
        {"qt_datapath=", ""},
        {"qt_trnspath=", "/translations"},
        {"qt_xmplpath=", "/examples"},
        {"qt_demopath=", "/demos"}
    };

    logFileName(fileName);
    for (int i = 0; i < (int)(sizeof(variables) / sizeof(variables[0])); i++) {
        const char * const newStr = allocFileNameCopyAppend(
            variables[i].variable, baseQtPath, variables[i].subDirectory);
        BinPatch binFile(fileName);
        const bool success = binFile.patch(variables[i].variable, newStr);
        delete[] newStr;
        if (!success) {
            result = false;
        }
    }

    return result;
}
コード例 #3
0
ファイル: logdialog.cpp プロジェクト: amosbird/CopyQ
LogDialog::LogDialog(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::LogDialog)
    , m_showError(true)
    , m_showWarning(true)
    , m_showNote(true)
    , m_showDebug(true)
    , m_showTrace(true)
{
    ui->setupUi(this);

    auto font = ui->textBrowserLog->font();
    font.setFamily("Monospace");
    ui->textBrowserLog->setFont(font);

    m_logDecorator = new LogDecorator(font, this);
    m_stringDecorator = new StringDecorator(this);
    m_threadNameDecorator = new ThreadNameDecorator(font, this);

    ui->labelLogFileName->setText(logFileName());

    addFilterCheckBox(LogError, &LogDialog::showError);
    addFilterCheckBox(LogWarning, &LogDialog::showWarning);
    addFilterCheckBox(LogNote, &LogDialog::showNote);
    addFilterCheckBox(LogDebug, &LogDialog::showDebug);
    addFilterCheckBox(LogTrace, &LogDialog::showTrace);
    ui->layoutFilters->addStretch(1);

    updateLog();
}
コード例 #4
0
ファイル: proxy.cpp プロジェクト: bobalm/udpproxy
string getLogFileName()
{
    char buff[128];
    long ti;
    struct tm *tm;
    string logFileName("proxy_");

    time(&ti);
    tm=localtime(&ti);
    sprintf(buff,"%04d_%02d%02d_%02d%02d",
            tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,
            tm->tm_hour,tm->tm_min);

    return logFileName+string(buff);
}
コード例 #5
0
void patchTextFiles(const char *newInstallBase)
{
#ifndef Q_OS_WIN
    const char * const baseQtPath = newInstallBase;
    const char * const newSourceBase = newInstallBase;
    const int fileCount = sizeof(textFileFileNames) / sizeof(const char *);
    for (int i = 0; i < fileCount; i++) {
        char * const fileName = allocFileNameCopyAppend(baseQtPath, textFileFileNames[i]);
        logFileName(fileName);
        logDiff(oldSourceBase, newSourceBase);
        logDiff(oldInstallBase, newInstallBase);
        replaceInTextFile(fileName,
                oldSourceBase, newSourceBase,
                oldInstallBase, newInstallBase);
        delete[] fileName;
    }
#endif

    patchQMakeSpec(newInstallBase);
}
コード例 #6
0
void patchQMakeSpec(const char *path)
{
    QString baseQtPath(path);
    const QString fileName(baseQtPath + "/mkspecs/default/qmake.conf");
    QFile f(fileName);
    logFileName(qPrintable(fileName));
    f.open(QIODevice::ReadOnly);
    QTextStream in(&f);
    QString all = in.readAll();
    f.close();
    // Old value is QMAKESPEC_ORIGINAL=C:/somepath/mkspecs/amakespce
    // New value should be QMAKESPEC_ORIGINAL=baseQtPath/mkspec/amakespec
    // We don't care to match the line end we simply match to the end of the file
    QRegExp regExp("(QMAKESPEC_ORIGINAL=).*(/mkspecs/.*)");
    all.replace(regExp, "\\1"+baseQtPath+"\\2");

    f.open(QIODevice::WriteOnly);
    QTextStream out(&f);
    out << all;
}
コード例 #7
0
ファイル: EKF.cpp プロジェクト: wishchin/SlamWishG2O
EKF::EKF(const char *configurationFileName, const char *outputPath) : _ekfSteps(0), _strOutputPath(outputPath)
{
    ConfigurationManager &configManager = ConfigurationManager::getInstance();
    configManager.loadConfigurationFromFile(configurationFileName);

    if (!_strOutputPath.empty())
    {
        std::string outputFileName(_strOutputPath + "output.yml");

        _outputFileStorage.open(outputFileName, cv::FileStorage::WRITE);

        std::string logFileName(_strOutputPath + "log.txt");
        _logFile.open(logFileName.c_str(), std::ios_base::out);

#ifndef ANDROID
        // Se genera el video en el cual se va a guardar la secuencia de predicciones
        cv::Size size(configManager.cameraCalibration->pixelsX, configManager.cameraCalibration->pixelsY);
        _outputVideoWriter.open(_strOutputPath + "videoOutput.mpg", CV_FOURCC('P','I','M','1'), 20, size, true);
#endif
    }
}
コード例 #8
0
GLC_TraceLog* GLC_TraceLog::instance(QString baseName)
{
	if (NULL == m_pTraceLog)
	{
		if (baseName.isEmpty())
		{
			QString fileName(QApplication::applicationName());
			if (fileName.isEmpty())
			{
				baseName= "GLC_lib_TraceLog";
			}
			else
			{
				baseName= fileName + "_TraceLog";
			}
		}
		QString logFileName(QDir::tempPath() + QDir::separator() + baseName);
		m_pTraceLog= new GLC_TraceLog(logFileName);
		m_pTraceLog->writeHeader();
	}
	return m_pTraceLog;
}
コード例 #9
0
ファイル: log.cpp プロジェクト: DINKIN/CopyQ
void log(const QString &text, const LogLevel level)
{
    if ( !hasLogLevel(level) )
        return;

    SystemMutexLocker lock(getSessionMutex());

    const QByteArray msg = createLogMessage(text, level).toUtf8();

    QFile f( logFileName() );
    const bool writtenToLogFile = f.open(QIODevice::Append) && f.write(msg);
    if (writtenToLogFile)
        f.close();

    // Log to file and if needed to stderr.
    if ( !writtenToLogFile || level <= LogWarning ) {
        QFile ferr;
        ferr.open(stderr, QIODevice::WriteOnly);
        ferr.write(msg);
    }

    if ( writtenToLogFile && f.size() > logFileSize )
        rotateLogFiles();
}
コード例 #10
0
bool patchDebugLibrariesWithQtPath(const char *baseQtPath)
{
    bool result = true;

    static const struct
    {
        const char *fileName;
    } libraries[] = {
#ifdef Q_OS_WIN
        { "/bin/Qt3Supportd4.dll" },
        { "/bin/QtCored4.dll" },
        { "/bin/QtGuid4.dll" },
        { "/bin/QtHelpd4.dll" },
        { "/bin/QtNetworkd4.dll" },
        { "/bin/QtOpenGLd4.dll" },
        { "/bin/QtScriptd4.dll" },
        { "/bin/QtScriptToolsd4.dll" },
        { "/bin/QtSqld4.dll" },
        { "/bin/QtSvgd4.dll" },
        { "/bin/QtTestd4.dll" },
        { "/bin/QtWebKitd4.dll" },
        { "/bin/QtXmld4.dll" },
        { "/bin/QtXmlPatternsd4.dll" },
        { "/lib/Qt3Supportd4.dll" },
        { "/lib/QtCored4.dll" },
        { "/lib/QtGuid4.dll" },
        { "/lib/QtHelpd4.dll" },
        { "/lib/QtNetworkd4.dll" },
        { "/lib/QtOpenGLd4.dll" },
        { "/lib/QtScriptd4.dll" },
        { "/lib/QtScriptToolsd4.dll" },
        { "/lib/QtSqld4.dll" },
        { "/lib/QtSvgd4.dll" },
        { "/lib/QtTestd4.dll" },
        { "/lib/QtWebKitd4.dll" },
        { "/lib/QtXmld4.dll" },
        { "/lib/QtXmlPatternsd4.dll" },
        { "/plugins/accessible/qtaccessiblecompatwidgetsd4.dll" },
        { "/plugins/accessible/qtaccessiblewidgetsd4.dll" },
        { "/plugins/codecs/qcncodecsd4.dll" },
        { "/plugins/codecs/qjpcodecsd4.dll" },
        { "/plugins/codecs/qkrcodecsd4.dll" },
        { "/plugins/codecs/qtwcodecsd4.dll" },
        { "/plugins/iconengines/qsvgicond4.dll" },
        { "/plugins/imageformats/qgifd4.dll" },
        { "/plugins/imageformats/qjpegd4.dll" },
        { "/plugins/imageformats/qmngd4.dll" },
        { "/plugins/imageformats/qsvgd4.dll" },
        { "/plugins/imageformats/qtiffd4.dll" },
        { "/plugins/sqldrivers/qsqlited4.dll" },
//        { "/plugins/sqldrivers/qsqlodbcd4.dll" }
#else
        { "/bin/assistant" },
        { "/bin/assistant_adp" },
        { "/bin/designer" },
        { "/bin/linguist" },
        { "/bin/lrelease" },
        { "/bin/lupdate" },
        { "/bin/moc" },
        { "/bin/pixeltool" },
        { "/bin/qcollectiongenerator" },
        { "/bin/qdbus" },
        { "/bin/qdbuscpp2xml" },
        { "/bin/qdbuscpp2xml" },
        { "/bin/qdbusviewer" },
        { "/bin/qdbusxml2cpp" },
        { "/bin/qhelpconverter" },
        { "/bin/qhelpgenerator" },
        { "/bin/qmake" },
        { "/bin/qt3to4" },
        { "/bin/qtconfig" },
        { "/bin/qtdemo" },
        { "/bin/rcc" },
        { "/bin/uic" },
        { "/bin/uic3" },
        { "/bin/xmlpatterns" },
        { "/demos/affine/affine" },
        { "/demos/books/books" },
        { "/demos/browser/browser" },
        { "/demos/chip/chip" },
        { "/demos/composition/composition" },
        { "/demos/deform/deform" },
        { "/demos/embeddeddialogs/embeddeddialogs" },
        { "/demos/gradients/gradients" },
        { "/demos/interview/interview" },
        { "/demos/mainwindow/mainwindow" },
        { "/demos/pathstroke/pathstroke" },
        { "/demos/shared/libdemo_shared.a" },
        { "/demos/spreadsheet/spreadsheet" },
        { "/demos/sqlbrowser/sqlbrowser" },
        { "/demos/textedit/textedit" },
        { "/demos/undo/undo" },
        { "/examples/assistant/simpletextviewer/simpletextviewer" },
        { "/examples/dbus/chat/dbus-chat" },
        { "/examples/dbus/complexpingpong/complexping" },
        { "/examples/dbus/complexpingpong/complexpong" },
        { "/examples/dbus/listnames/listnames" },
        { "/examples/dbus/pingpong/ping" },
        { "/examples/dbus/pingpong/pong" },
        { "/examples/dbus/remotecontrolledcar/car/car" },
        { "/examples/dbus/remotecontrolledcar/controller/controller" },
        { "/examples/designer/calculatorbuilder/calculatorbuilder" },
        { "/examples/designer/calculatorform/calculatorform" },
        { "/examples/designer/worldtimeclockbuilder/worldtimeclockbuilder" },
        { "/examples/desktop/screenshot/screenshot" },
        { "/examples/desktop/systray/systray" },
        { "/examples/dialogs/classwizard/classwizard" },
        { "/examples/dialogs/configdialog/configdialog" },
        { "/examples/dialogs/extension/extension" },
        { "/examples/dialogs/findfiles/findfiles" },
        { "/examples/dialogs/licensewizard/licensewizard" },
        { "/examples/dialogs/standarddialogs/standarddialogs" },
        { "/examples/dialogs/tabdialog/tabdialog" },
        { "/examples/dialogs/trivialwizard/trivialwizard" },
        { "/examples/draganddrop/draggableicons/draggableicons" },
        { "/examples/draganddrop/draggabletext/draggabletext" },
        { "/examples/draganddrop/dropsite/dropsite" },
        { "/examples/draganddrop/fridgemagnets/fridgemagnets" },
        { "/examples/draganddrop/puzzle/puzzle" },
        { "/examples/graphicsview/collidingmice/collidingmice" },
        { "/examples/graphicsview/diagramscene/diagramscene" },
        { "/examples/graphicsview/dragdroprobot/dragdroprobot" },
        { "/examples/graphicsview/elasticnodes/elasticnodes" },
        { "/examples/graphicsview/padnavigator/padnavigator" },
        { "/examples/graphicsview/portedasteroids/portedasteroids" },
        { "/examples/graphicsview/portedcanvas/portedcanvas" },
        { "/examples/help/contextsensitivehelp/contextsensitivehelp" },
        { "/examples/help/remotecontrol/remotecontrol" },
        { "/examples/help/simpletextviewer/simpletextviewer" },
        { "/examples/ipc/localfortuneclient/localfortuneclient" },
        { "/examples/ipc/localfortuneserver/localfortuneserver" },
        { "/examples/ipc/sharedmemory/sharedmemory" },
        { "/examples/itemviews/addressbook/addressbook" },
        { "/examples/itemviews/basicsortfiltermodel/basicsortfiltermodel" },
        { "/examples/itemviews/chart/chart" },
        { "/examples/itemviews/coloreditorfactory/coloreditorfactory" },
        { "/examples/itemviews/customsortfiltermodel/customsortfiltermodel" },
        { "/examples/itemviews/dirview/dirview" },
        { "/examples/itemviews/editabletreemodel/editabletreemodel" },
        { "/examples/itemviews/pixelator/pixelator" },
        { "/examples/itemviews/puzzle/puzzle" },
        { "/examples/itemviews/simpledommodel/simpledommodel" },
        { "/examples/itemviews/simpletreemodel/simpletreemodel" },
        { "/examples/itemviews/simplewidgetmapper/simplewidgetmapper" },
        { "/examples/itemviews/spinboxdelegate/spinboxdelegate" },
        { "/examples/itemviews/stardelegate/stardelegate" },
        { "/examples/layouts/basiclayouts/basiclayouts" },
        { "/examples/layouts/borderlayout/borderlayout" },
        { "/examples/layouts/dynamiclayouts/dynamiclayouts" },
        { "/examples/layouts/flowlayout/flowlayout" },
        { "/examples/linguist/arrowpad/arrowpad" },
        { "/examples/linguist/hellotr/hellotr" },
        { "/examples/linguist/trollprint/trollprint" },
        { "/examples/mainwindows/application/application" },
        { "/examples/mainwindows/dockwidgets/dockwidgets" },
        { "/examples/mainwindows/mdi/mdi" },
        { "/examples/mainwindows/menus/menus" },
        { "/examples/mainwindows/recentfiles/recentfiles" },
        { "/examples/mainwindows/sdi/sdi" },
        { "/examples/network/blockingfortuneclient/blockingfortuneclient" },
        { "/examples/network/broadcastreceiver/broadcastreceiver" },
        { "/examples/network/broadcastsender/broadcastsender" },
        { "/examples/network/chat/network-chat" },
        { "/examples/network/download/download" },
        { "/examples/network/downloadmanager/downloadmanager" },
        { "/examples/network/fortuneclient/fortuneclient" },
        { "/examples/network/fortuneserver/fortuneserver" },
        { "/examples/network/ftp/ftp" },
        { "/examples/network/http/http" },
        { "/examples/network/loopback/loopback" },
        { "/examples/network/securesocketclient/securesocketclient" },
        { "/examples/network/threadedfortuneserver/threadedfortuneserver" },
        { "/examples/network/torrent/torrent" },
        { "/examples/opengl/2dpainting/2dpainting" },
        { "/examples/opengl/framebufferobject/framebufferobject" },
        { "/examples/opengl/framebufferobject2/framebufferobject2" },
        { "/examples/opengl/grabber/grabber" },
        { "/examples/opengl/hellogl/hellogl" },
        { "/examples/opengl/overpainting/overpainting" },
        { "/examples/opengl/pbuffers/pbuffers" },
        { "/examples/opengl/pbuffers2/pbuffers2" },
        { "/examples/opengl/samplebuffers/samplebuffers" },
        { "/examples/opengl/textures/textures" },
        { "/examples/painting/basicdrawing/basicdrawing" },
        { "/examples/painting/concentriccircles/concentriccircles" },
        { "/examples/painting/fontsampler/fontsampler" },
        { "/examples/painting/imagecomposition/imagecomposition" },
        { "/examples/painting/painterpaths/painterpaths" },
        { "/examples/painting/svgviewer/svgviewer" },
        { "/examples/painting/transformations/transformations" },
        { "/examples/qtconcurrent/imagescaling/imagescaling" },
        { "/examples/qtconcurrent/map/mapdemo" },
        { "/examples/qtconcurrent/progressdialog/progressdialog" },
        { "/examples/qtconcurrent/runfunction/runfunction" },
        { "/examples/qtconcurrent/wordcount/wordcount" },
        { "/examples/qtestlib/tutorial1/tutorial1" },
        { "/examples/qtestlib/tutorial2/tutorial2" },
        { "/examples/qtestlib/tutorial3/tutorial3" },
        { "/examples/qtestlib/tutorial4/tutorial4" },
        { "/examples/richtext/calendar/calendar" },
        { "/examples/richtext/orderform/orderform" },
        { "/examples/richtext/syntaxhighlighter/syntaxhighlighter" },
        { "/examples/script/calculator/calculator" },
        { "/examples/script/context2d/context2d" },
        { "/examples/script/customclass/customclass" },
        { "/examples/script/defaultprototypes/defaultprototypes" },
        { "/examples/script/helloscript/helloscript" },
        { "/examples/script/marshal/marshal" },
        { "/examples/script/qscript/qscript" },
        { "/examples/script/tetrix/tetrix" },
        { "/examples/sql/cachedtable/cachedtable" },
        { "/examples/sql/drilldown/drilldown" },
        { "/examples/sql/masterdetail/masterdetail" },
        { "/examples/sql/querymodel/querymodel" },
        { "/examples/sql/relationaltablemodel/relationaltablemodel" },
        { "/examples/sql/tablemodel/tablemodel" },
        { "/examples/threads/mandelbrot/mandelbrot" },
        { "/examples/threads/semaphores/semaphores" },
        { "/examples/threads/waitconditions/waitconditions" },
        { "/examples/tools/codecs/codecs" },
        { "/examples/tools/completer/completer" },
        { "/examples/tools/customcompleter/customcompleter" },
        { "/examples/tools/echoplugin/echoplugin" },
        { "/examples/tools/echoplugin/plugin/libechoplugin.so" },
        { "/examples/tools/i18n/i18n" },
        { "/examples/tools/plugandpaint/plugandpaint" },
        { "/examples/tools/plugandpaint/plugins/libpnp_basictools.a" },
        { "/examples/tools/plugandpaint/plugins/libpnp_extrafilters.so" },
        { "/examples/tools/regexp/regexp" },
        { "/examples/tools/settingseditor/settingseditor" },
        { "/examples/tools/styleplugin/styleplugin" },
        { "/examples/tools/styleplugin/styles/libsimplestyleplugin.so" },
        { "/examples/tools/treemodelcompleter/treemodelcompleter" },
        { "/examples/tools/undoframework/undoframework" },
        { "/examples/tutorials/addressbook/part1/part1" },
        { "/examples/tutorials/addressbook/part2/part2" },
        { "/examples/tutorials/addressbook/part3/part3" },
        { "/examples/tutorials/addressbook/part4/part4" },
        { "/examples/tutorials/addressbook/part5/part5" },
        { "/examples/tutorials/addressbook/part6/part6" },
        { "/examples/tutorials/addressbook/part7/part7" },
        { "/examples/tutorials/tutorial/t1/t1" },
        { "/examples/tutorials/tutorial/t10/t10" },
        { "/examples/tutorials/tutorial/t11/t11" },
        { "/examples/tutorials/tutorial/t12/t12" },
        { "/examples/tutorials/tutorial/t13/t13" },
        { "/examples/tutorials/tutorial/t14/t14" },
        { "/examples/tutorials/tutorial/t2/t2" },
        { "/examples/tutorials/tutorial/t3/t3" },
        { "/examples/tutorials/tutorial/t4/t4" },
        { "/examples/tutorials/tutorial/t5/t5" },
        { "/examples/tutorials/tutorial/t6/t6" },
        { "/examples/tutorials/tutorial/t7/t7" },
        { "/examples/tutorials/tutorial/t8/t8" },
        { "/examples/tutorials/tutorial/t9/t9" },
        { "/examples/uitools/multipleinheritance/multipleinheritance" },
        { "/examples/uitools/textfinder/textfinder" },
        { "/examples/webkit/formextractor/formExtractor" },
        { "/examples/webkit/previewer/previewer" },
        { "/examples/widgets/analogclock/analogclock" },
        { "/examples/widgets/calculator/calculator" },
        { "/examples/widgets/calendarwidget/calendarwidget" },
        { "/examples/widgets/charactermap/charactermap" },
        { "/examples/widgets/digitalclock/digitalclock" },
        { "/examples/widgets/groupbox/groupbox" },
        { "/examples/widgets/icons/icons" },
        { "/examples/widgets/imageviewer/imageviewer" },
        { "/examples/widgets/lineedits/lineedits" },
        { "/examples/widgets/movie/movie" },
        { "/examples/widgets/scribble/scribble" },
        { "/examples/widgets/shapedclock/shapedclock" },
        { "/examples/widgets/sliders/sliders" },
        { "/examples/widgets/spinboxes/spinboxes" },
        { "/examples/widgets/styles/styles" },
        { "/examples/widgets/stylesheet/stylesheet" },
        { "/examples/widgets/tablet/tablet" },
        { "/examples/widgets/tetrix/tetrix" },
        { "/examples/widgets/tooltips/tooltips" },
        { "/examples/widgets/validators/validators" },
        { "/examples/widgets/wiggly/wiggly" },
        { "/examples/widgets/windowflags/windowflags" },
        { "/examples/xml/dombookmarks/dombookmarks" },
        { "/examples/xml/rsslisting/rsslisting" },
        { "/examples/xml/saxbookmarks/saxbookmarks" },
        { "/examples/xml/streambookmarks/streambookmarks" },
        { "/examples/xml/xmlstreamlint/xmlstreamlint" },
        { "/examples/xmlpatterns/filetree/filetree" },
        { "/examples/xmlpatterns/qobjectxmlmodel/qobjectxmlmodel" },
        { "/examples/xmlpatterns/recipes/recipes" },
        { "/lib/libQt3Support.so.4.5.0" },
        { "/lib/libQtAssistantClient.so.4.5.0" },
        { "/lib/libQtCLucene.so.4.5.0" },
        { "/lib/libQtCore.so.4.5.0" },
        { "/lib/libQtDBus.so.4.5.0" },
        { "/lib/libQtDesigner.so.4.5.0" },
        { "/lib/libQtDesignerComponents.so.4.5.0" },
        { "/lib/libQtGui.so.4.5.0" },
        { "/lib/libQtHelp.so.4.5.0" },
        { "/lib/libQtNetwork.so.4.5.0" },
        { "/lib/libQtOpenGL.so.4.5.0" },
        { "/lib/libQtScript.so.4.5.0" },
        { "/lib/libQtScriptTools.so.4.5.0" },
        { "/lib/libQtSql.so.4.5.0" },
        { "/lib/libQtSvg.so.4.5.0" },
        { "/lib/libQtTest.so.4.5.0" },
        { "/lib/libQtUiTools.a" },
        { "/lib/libQtWebKit.so.4.5.0" },
        { "/lib/libQtXml.so.4.5.0" },
        { "/lib/libQtXmlPatterns.so.4.5.0" },
        { "/plugins/accessible/libqtaccessiblecompatwidgets.so" },
        { "/plugins/accessible/libqtaccessiblewidgets.so" },
        { "/plugins/codecs/libqcncodecs.so" },
        { "/plugins/codecs/libqjpcodecs.so" },
        { "/plugins/codecs/libqkrcodecs.so" },
        { "/plugins/codecs/libqtwcodecs.so" },
        { "/plugins/designer/libarthurplugin.so" },
        { "/plugins/designer/libcontainerextension.so" },
        { "/plugins/designer/libcustomwidgetplugin.so" },
        { "/plugins/designer/libqt3supportwidgets.so" },
        { "/plugins/designer/libqwebview.so" },
        { "/plugins/designer/libtaskmenuextension.so" },
        { "/plugins/designer/libworldtimeclockplugin.so" },
        { "/plugins/iconengines/libqsvgicon.so" },
        { "/plugins/imageformats/libqgif.so" },
        { "/plugins/imageformats/libqico.so" },
        { "/plugins/imageformats/libqjpeg.so" },
        { "/plugins/imageformats/libqmng.so" },
        { "/plugins/imageformats/libqsvg.so" },
        { "/plugins/imageformats/libqtiff.so" },
        { "/plugins/inputmethods/libqimsw-multi.so" },
        { "/plugins/script/libqtscriptdbus.so" },
        { "/plugins/sqldrivers/libqsqlite.so" },
        { "/plugins/sqldrivers/libqsqlite2.so" },
        { "/plugins/sqldrivers/libqsqlmysql.so" },
        { "/plugins/sqldrivers/libqsqlpsql.so" }
#endif
    };


    for (int i = 0; i < (int)(sizeof(libraries) / sizeof(libraries[0])); i++) {
        // USAGE NOTE: Don't use FILENAME_MAX as the size of an array in which to store a file name!
        // [In some cases] you [may not be able to statically] make an array that big!
        // Use dynamic allocation [..] instead.
        // From http://www.gnu.org/software/libc/manual/html_mono/libc.html#Limits-for-Files

        // Make filename
        char * const fileName = allocFileNameCopyAppend(baseQtPath, libraries[i].fileName);
        logFileName(fileName);

        logDiff(oldSourceBase, baseQtPath);

        // Patch
        BinPatch binFile(fileName);
        binFile.enableInsertReplace(true);
        if (!binFile.patch(oldSourceBase, baseQtPath))
            result = false;

        delete[] fileName;
    }

    return result;
}
コード例 #11
0
ファイル: main.cpp プロジェクト: cdaffara/symbiandump-mw1
int main (int argc, char** argv) 
	{
	int returnCode = 0;

	try
		{
		const char* epocRoot = getenv("EPOCROOT");		
		if(NULL == epocRoot)
			{
			throw CException("EPOCROOT environment variable not specified.", ExceptionCodes::EEnvNotSpecified);
			}
		std::string epocRootStr(epocRoot); 
		
		COptions options(argc, argv);

		std::string logFileName(options.GetLogFileName());
		std::auto_ptr<CLogger> logger(new CLogger(logFileName, options.GetLogLevel()));
		
   #ifdef __LINUX__
  	  	 std::string dllPath = "sqlite-3.6.1.so";
   #else
 	       std::string dllPath = "sqlite3.dll";
   #endif
  	  	 	 
		std::auto_ptr<CDbLayer> db( new CDbLayer(dllPath, options.GetDbFileName()));
		std::auto_ptr<CScrXmlParser> xmlParser( new CScrXmlParser());

		if(options.IsDbAbsent())
			{
		  #ifdef __LINUX__ 		  
			std::string dbFileName = epocRootStr + "epoc32/tools/create_db.xml";
			#else
			std::string dbFileName = epocRootStr + "epoc32\\tools\\create_db.xml";
			#endif
			
			std::auto_ptr<SchemaDetails> schema(xmlParser->ParseDbSchema(dbFileName));
			db->CreateScrDatabase(*schema);
			}

		std::vector<std::string> xmlFileNames = options.GetEnvFileNames();
		for(StringIterator xmlIter=xmlFileNames.begin(); xmlIter != xmlFileNames.end(); ++xmlIter)
			{
			std::auto_ptr<EnvDetails> envDetails(xmlParser->GetEnvironmentDetails(*xmlIter));
			db->PopulateScrDatabase(*envDetails);
			}
		
		if(options.IsPreProvisionInfoAvailable())
			{
			std::string preProvFileName = options.GetPrePovisionFileName();
			XmlDetails::TScrPreProvisionDetail preProvisionDetailList = xmlParser->GetPreProvisionDetails(preProvFileName);
			db->PopulatePreProvisionDetails(preProvisionDetailList);
			}
		}
	catch(CException& aException)
		{
		const std::string& exc = aException.GetMessageA();
		returnCode = aException.GetCode();
		std::cout << "Exception caught::" << exc << std::endl;
		std::cout << "Error Code::" << returnCode << std::endl;
		}
		
	return returnCode;
	}
コード例 #12
0
ファイル: csjp_logger.cpp プロジェクト: csjpeter/libcsjp
/*
 * Author: Csaszar, Peter <*****@*****.**>
 * Copyright (C) 2009-2012 Csaszar, Peter
 */

#include <sys/time.h>
#include <sys/stat.h>

#include <unistd.h>

#include <errno.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#ifdef FCLOG
#include <fclog.h>
#endif

#include "csjp_logger.h"

namespace csjp {

static void dateStamp(char res[16])
{
	time_t t = time(NULL);
	strftime(res, 16, "%Y-%m-%d-%a", localtime(&t));
}

static void timeStamp(char res[16])
{
	char timeStr[16] = {0};
	timeval unixTime;

	gettimeofday(&unixTime, NULL);
	time_t t = unixTime.tv_sec;
	int unixMillisecs = unixTime.tv_usec/1000;
	struct tm _tm;

	localtime_r(&t, &_tm);
	strftime(timeStr, sizeof(timeStr), "%H:%M:%S", &_tm);
	snprintf(res, 16, "%s:%03d", timeStr, unixMillisecs);
}

static char g_LogDir[256] = {0};
static char g_LogFileName[512] = {0};
static char g_LogFileNameSpecializer[128] = {0};
static char g_BinaryName[128] = "unknown";
bool verboseMode = false;
bool haveLogDir = true;

void resetLogFileName()
{
	g_LogFileName[0] = 0;
}

void setLogDir(const char * dir)
{
	if(dir)
		strncpy(g_LogDir, dir, sizeof(g_LogDir));
	else
		strncpy(g_LogDir, "./", sizeof(g_LogDir));
	haveLogDir = true;
	resetLogFileName();
}

void setBinaryName(const char * name)
{
	if(!name)
		return;

	const char *baseName = strrchr(name, '/');
	baseName = baseName ? baseName + 1 : name;
	strncpy(g_BinaryName, baseName, sizeof(g_BinaryName));

	resetLogFileName();
}

const char * getBinaryName()
{
	return g_BinaryName;
}

const char * logFileName()
{
#ifdef FCLOG
	return FCLOG_FILE;
#else
	if(g_LogFileName[0] == 0 && haveLogDir){
		struct stat fileStat;
		if(0 <= stat(g_LogDir, &fileStat))
			if(S_ISDIR(fileStat.st_mode)){
				snprintf(g_LogFileName, sizeof(g_LogFileName),
						"%s/%s%s.log", g_LogDir,
						g_BinaryName, g_LogFileNameSpecializer);
				return g_LogFileName;
			}
		haveLogDir = false;
	}
	return g_LogFileName;
#endif
}

void setLogFileNameSpecializer(const char * str)
{
	if(str != NULL){
		g_LogFileNameSpecializer[0] = '.';
		strncpy(g_LogFileNameSpecializer + 1, str, sizeof(g_LogFileNameSpecializer) - 1);
	} else
		g_LogFileNameSpecializer[0] = 0;
	resetLogFileName();
}

static unsigned loggerMutex = 0; /* Initialized before main() */
void msgLogger(FILE * stdfile, const char * string, size_t length)
{
	if(!length)
		length = strlen(string);

	char header[64];
	{
		char time_stamp[16];
		timeStamp(time_stamp);

		char date_stamp[16];
		dateStamp(date_stamp);

		double c = (double)(clock())/(double)(CLOCKS_PER_SEC);

		snprintf(header, sizeof(header), "%14s %12s %7.3f %5d",
				date_stamp, time_stamp, c, getpid());
	}

	const char * fmt = "%s %s ";

#if ! _ISOC99_SOURCE
#error We need to use C99 for calculating printed number of characters with vsnprintf().
#endif

	/* Now lets calculate the amount of memory needed by the full log message. */
	int size = 0;
	size += strlen(fmt);
	size += sizeof(header);
	size += length;

	/* Allocate memory */
	char * msg = (char*)malloc(size);
	if(!msg){
		if(stderr)
			fprintf(stderr, VT_RED VT_TA_BOLD "ERROR" VT_NORMAL
					"No enoguh memory for log message!");
		return;
	}

	/* Compose the log message */
	int len = snprintf(msg, size, fmt, header, string);
	if(len < 0){
		if(stderr)
			fprintf(stderr, VT_RED VT_TA_BOLD "ERROR" VT_NORMAL
					"Failed to snprintf the log message and its header!\n");
		free(msg);
		return;
	}

	msg[len++] = '\n';
	msg[len] = 0;

	/* We need to have logging thread safe.
	 * We should not use posix mutex since that might fail, and
	 * on posix failure we should report the issue, thus call
	 * this logger. This would be a circular dependency and a
	 * possible place to have infinite recursion.
	 *
	 * So we are going to use gcc special low level atomic operations.
	 * http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html#Atomic-Builtins
	 * type __sync_fetch_and_add (type *ptr, type value, ...)
	 * type __sync_fetch_and_sub (type *ptr, type value, ...)
	 */
#if not __GNUC__ >= 4
#error "We need gcc 4 or later for __sync_fetch_and_add() and __sync_fetch_and_sub()"
#endif
	unsigned loggerMutexLast = 1;
	while(loggerMutexLast){
		loggerMutexLast = __sync_fetch_and_add(&loggerMutex, 1);
		if(loggerMutexLast){
			__sync_fetch_and_sub(&loggerMutex, 1);
			usleep(100);
		}
	}

	if(haveLogDir && logFileName()[0]){
		FILE *log = fopen(logFileName(), "a");
		if(log){
			fputs(msg, log);
			fflush(log);
			TEMP_FAILURE_RETRY( fclose(log) );
		} else if(stderr) {
			fprintf(stderr, VT_RED VT_TA_BOLD "ERROR" VT_NORMAL
					" Could not open logfile: %s\n", logFileName());
			haveLogDir = false;
		}
	}

	basicLogger(msg, stdfile, g_BinaryName);

	__sync_fetch_and_sub(&loggerMutex, 1);

	free(msg);
}
コード例 #13
0
///////////////////////////////////////////////////////////////////////////////
// Note: this method should get speeded up (see Gnats PR 846).
MyString
MultiLogFiles::loadLogFileNameFromSubFile(const MyString &strSubFilename,
		const MyString &directory, bool &isXml, bool usingDefaultNode)
{
	dprintf( D_FULLDEBUG, "MultiLogFiles::loadLogFileNameFromSubFile(%s, %s)\n",
				strSubFilename.Value(), directory.Value() );

	TmpDir		td;
	if ( directory != "" ) {
		MyString	errMsg;
		if ( !td.Cd2TmpDir(directory.Value(), errMsg) ) {
			dprintf(D_ALWAYS, "Error from Cd2TmpDir: %s\n", errMsg.Value());
			return "";
		}
	}

	StringList	logicalLines;
	if ( fileNameToLogicalLines( strSubFilename, logicalLines ) != "" ) {
		return "";
	}

	MyString	logFileName("");
	MyString	initialDir("");
	MyString	isXmlLogStr("");

		// Now look through the submit file logical lines to find the
		// log file and initial directory (if specified) and combine
		// them into a path to the log file that's either absolute or
		// relative to the DAG submit directory.  Also look for log_xml.
	const char *logicalLine;
	while( (logicalLine = logicalLines.next()) != NULL ) {
		MyString	submitLine(logicalLine);
		MyString	tmpLogName = getParamFromSubmitLine(submitLine, "log");
		if ( tmpLogName != "" ) {
			logFileName = tmpLogName;
		}

			// If we are using the default node log, we don't care
			// about these
		if( !usingDefaultNode ) {
			MyString	tmpInitialDir = getParamFromSubmitLine(submitLine,
					"initialdir");
			if ( tmpInitialDir != "" ) {
				initialDir = tmpInitialDir;
			}

			MyString tmpLogXml = getParamFromSubmitLine(submitLine, "log_xml");
			if ( tmpLogXml != "" ) {
				isXmlLogStr = tmpLogXml;
			}
		}
	}

	if ( !usingDefaultNode ) {
			//
			// Check for macros in the log file name -- we currently don't
			// handle those.
			//
			// If we are using the default node, we don't need to check this
		if ( logFileName != "" ) {
			if ( strstr(logFileName.Value(), "$(") ) {
				dprintf(D_ALWAYS, "MultiLogFiles: macros ('$(...') not allowed "
						"in log file name (%s) in DAG node submit files\n",
						logFileName.Value());
				logFileName = "";
			}
		}

			// Do not need to prepend initialdir if we are using the 
			// default node log
		if ( logFileName != "" ) {
				// Prepend initialdir to log file name if log file name is not
				// an absolute path.
			if ( initialDir != "" && !fullpath(logFileName.Value()) ) {
				logFileName = initialDir + DIR_DELIM_STRING + logFileName;
			}

				// We do this in case the same log file is specified with a
				// relative and an absolute path.  
				// Note: we now do further checking that doesn't rely on
				// comparing paths to the log files.  wenger 2004-05-27.
			CondorError errstack;
			if ( !makePathAbsolute( logFileName, errstack ) ) {
				dprintf(D_ALWAYS, "%s\n", errstack.getFullText().c_str());
				return "";
			}
		}
		isXmlLogStr.lower_case();
		isXml = (isXmlLogStr == "true");
		if ( directory != "" ) {
			MyString	errMsg;
			if ( !td.Cd2MainDir(errMsg) ) {
				dprintf(D_ALWAYS, "Error from Cd2MainDir: %s\n", errMsg.Value());
				return "";
			}
		}
	}
	return logFileName;
}
コード例 #14
0
ファイル: xmlreport.cpp プロジェクト: rickerliang/testgit
bool XmlReport::createInformationLog(
	const QString& dir, const ER_EXCEPTIONRECORD& exceptionRecord, 
	const ER_ADDITIONALINFO& info, const ER_PROCESSOR& processor, 
	const ER_OPERATINGSYSTEM& os, const ER_MEMORY& memory, const MODULE_LIST& modules)
{
	//
	// 生成 XML 文件的名字。
	//
	QString logFileName("InforLog.xml");

	QString filePath = dir + "\\" + logFileName;
	QFile logFile(filePath);
	bool opened = 
		logFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
	if (!opened)
	{
		return false;
	}

	// 写 XML 文件的头。
	QTextStream xmlStream(&logFile);
	xmlStream << "<Exception>";
	//
	// 生成 ExceptionRecord 节点。
	//
	QString xRecord = QString(
		"<ExceptionRecord ModuleName=\"%1\" "
		"ExceptionCode=\"%2\" "
		"ExceptionDescription=\"%3\" "
		"ExceptionAddress=\"%4\" "
		"ExceptionModuleName=\"%5\" "
		"/>").arg(exceptionRecord.ModuleName)
		.arg(exceptionRecord.ExceptionCode)
		.arg(exceptionRecord.ExceptionDescription)
		.arg(exceptionRecord.ExceptionAddress)
		.arg(exceptionRecord.ExceptionModuleName);
	xmlStream << xRecord;

	QString xInfo = QString( 
		"<AdditionalInfomation Guid=\"%1\" DistSrc=\"%2\"/>").arg(info.Guid).arg(info.DistSrc);
	xmlStream << xInfo;

	//
	// 生成 Processor 节点。
	//
	QString xProcessor = QString(
		"<Processor Architecture=\"%1\" Level=\"%2\" NumberOfProcessors=\"%3\"/>")
		.arg(processor.Architecture).arg(processor.Level)
		.arg(processor.NumberOfProcessors);
	xmlStream << xProcessor;
	
	//
	// 生成 OperatingSystem 节点。
	//
	QString xOS = QString(
		"<OperatingSystem MajorVersion=\"%1\" "
		"MinorVersion=\"%2\" "
		"BuildNumber=\"%3\" "
		"CSDVersion=\"%4\" "
		"OSLanguage=\"%5\" "
		"/>").arg(os.MajorVersion).arg(os.MinorVersion).arg(os.BuildNumber).arg(os.CSDVersion)
		.arg(os.OSLanguage);
	xmlStream << xOS;

	//
	// 生成 Memory 节点。
	//
	QString xMemory = QString(
		"<Memory MemoryLoad=\"%1%\" "
		"TotalPhys=\"%2 MB\" "
		"AvailPhys=\"%3 MB\" "
		"TotalPageFile=\"%4 MB\" "
		"AvailPageFile=\"%5 MB\" "
		"TotalVirtual=\"%6 MB\" "
		"AvailVirtual=\"%7 MB\" "
		"/>").arg(memory.MemoryLoad).arg(memory.TotalPhys).arg(memory.AvailPhys)
		.arg(memory.TotalPageFile).arg(memory.AvailPageFile).arg(memory.TotalVirtual)
		.arg(memory.AvailVirtual);
	xmlStream << xMemory;

	//
	// 生成 Modules 和 Module 节点。
	//
	xmlStream << "<Modules>";
	int count = modules.size();
	for (int i = 0; i < count; ++i)
	{
		QString xModule = QString(
			"<Module FullPath=\"%1\" "
			"BaseAddress=\"%2\" "
			"Size=\"%3\" "
			"TimeStamp=\"%4\" "
			"FileVersion=\"%5\" "
			"ProductVersion=\"%6\" "
			"/>").arg(modules[i].FullPath).arg(modules[i].BaseAddress)
			.arg(modules[i].Size).arg(modules[i].TimeStamp).arg(modules[i].FileVersion)
			.arg(modules[i].ProductVersion);
		xmlStream << xModule;
	}
	xmlStream << "</Modules></Exception>";

	return true;
}
コード例 #15
0
ファイル: Main.cpp プロジェクト: J-Robinson/GridGA
int main(int argc, char* argv[])
{
	po::options_description desc("Usage");

	desc.add_options()
		("execute", new ArgTypeString(std::string("<directory>")), 
          "Backtest the configuration file in <directory>. Various files are output to the same location. The configuration file must be named config.xml or _config.xml.")

        ("genetic-algo", new ArgTypeString(std::string("<config template>")), 
            "Run a genetic algo using the supplied file as the template. Requires an HTCondor cluster.")

        //   ("tcp-port", new ArgTypeInt(std::string("<Port Number>")),
     //       "Used with --genetic-algo. Specifies the TCP port node comminicate with the GA server on.")
      //  ("test-send", "Send a test message to another DeepThought instance via ZeroMQ to test comms.")
      //  ("test-receive", "Test receiving messages via ZeroMQ to test comms.")
        
      ("version", "Print version info.")

	;

	po::variables_map variablesMap;
	try
	{
        namespace po_style = boost::program_options::command_line_style;
        po::store(po::command_line_parser(argc, argv).options(desc).style(po_style::unix_style|po_style::case_insensitive).run(), variablesMap);
	}
	catch (std::exception &e)
	{
		std::cout << "Error parsing command line : " << e.what() << "\n\n" << desc << "\n";
		return 1;
	}

	po::notify(variablesMap);

    if (variablesMap.count("version"))
    {
        std::cout << "GridGA Version :\t\t" << DEEPTHOUGHT_VERSION << std::endl <<
            "Build type :\t\t\t" << BUILD_TYPE << std::endl <<
            "Build host :\t\t\t" << COMPILE_HOST << std::endl <<
            "Compiler : \t\t\t" << COMPILER_ID << " " << COMPILER_VERSION << std::endl <<
            "Boost version : \t\t" << BOOST_COMPILE_VERSION << std::endl <<
            "Home directory : \t\t" << DeepThoughtLib::FileUtils::GetHomeDir() << std::endl <<
            "Binary install directory : \t" << DeepThoughtLib::FileUtils::GetExePath() << std::endl;
        return 1;
    }


    std::string logFileName("ga.log");

    if (variablesMap.count("execute"))
    {
        std::string	filesLocation(variablesMap["execute"].as<std::string>());
        logFileName = filesLocation + "/ga_execute.log";
    }

    
    if (variablesMap.count("genetic-algo"))
    {
        std::string filesLocation(variablesMap["genetic-algo"].as<std::string>());
        logFileName = filesLocation + "/genetic-algo.log";
    }

    Logger::Initialise(logFileName);

	if (variablesMap.count("help"))
	{
		std::cout << desc << std::endl;
		return 0;
	}


    if (variablesMap.count("genetic-algo"))
    {
        zmq::context_t zmqContext(1);
        GridGALib::GeneticAlgo geneticAlgo(variablesMap["genetic-algo"].as<std::string>(), zmqContext);
        if (!geneticAlgo.ReadConfig())
        {
            return 1;
        }        
        geneticAlgo.Evolve();
        return 0;
    }

    //if (variablesMap.count("test-send"))
    //{
    //    DeepThoughtLib::AppContext appContext;
    //    appContext.TransmitTestData();
    //    std::cerr << "finished" << std::endl;
    //    return 0;
    //}    

    //if (variablesMap.count("test-receive"))
    //{
    //    zmq::context_t zmqContext(1);
    //    DeepThoughtLib::GeneticAlgo geneticAlgo(false, "", zmqContext);
    //    std::deque<DeepThoughtLib::GenomePtr> genomesToTest;
    //    geneticAlgo.WaitForResults(genomesToTest);
    //    return 0;
    //}

	if (variablesMap.count("execute"))
	{
        std::string filesLocation = variablesMap["execute"].as<std::string>();

        if (!boost::filesystem::exists(filesLocation))
        {
            std::cerr << "Cannot find location \"" << filesLocation << "\"" << std::endl;
            return -1;
        }

        //DeepThoughtLib::AppContext appContext;
        //appContext.Backtest(filesLocation);

		return 0;
	}

	std::cout << desc << std::endl;

	return 0;
}