root/trunk/thune/debugger/ThuneDebugger.cpp

/*==========================================================================*

 *==========================================================================*/


#include <QtGui>
#include "ThuneDebugger.h"
#include "ThuneHighlight.h"
#include "StackDisplay.h"
#include "internal.h"


#define APP_NAME          "Thune"
#define APP_SETTINGS      "Thune", "Debugger"


static QTextEdit*       gConsole;
static ThuneDebugger*   gDB;


ThuneDebugger::ThuneDebugger()
{
    gDB = this;

    _mode = kModeVoid;
    _env.threads = 0;

    _loop = new QEventLoop( this );


    // Editor

    _editor = new QTextEdit;
    _editor->setTabStopWidth( 8 * 4 /*_editor->fontMetrics().height() * 3*/ );
    new ThuneHighlight(_editor->document());
    setCentralWidget(_editor);


    // Console

    _console = new QTextEdit;
    _console->setReadOnly( true );

    QDockWidget* dock;
    dock = new QDockWidget( this );
    dock->setWindowTitle( "Output" );
    dock->setWidget( _console );
    dock->setAllowedAreas( Qt::TopDockWidgetArea |
                           Qt::BottomDockWidgetArea );
    dock->setFeatures( QDockWidget::DockWidgetMovable |
                       QDockWidget::DockWidgetFloatable );
    addDockWidget( Qt::BottomDockWidgetArea, dock );


    // Stack Display

    _stack = new StackDisplay;

    dock = new QDockWidget( this );
    dock->setWindowTitle( "Data Stack" );
    dock->setWidget( _stack );
    addDockWidget( Qt::RightDockWidgetArea, dock );


    createActions();
    createMenus();
    createToolBars();
    createStatusBar();

    readSettings();

    connect(_editor->document(), SIGNAL(contentsChanged()),
            this, SLOT(documentWasModified()));

    setCurrentFile("");
}


ThuneDebugger::~ThuneDebugger()
{
    destroyEnv();
}


void ThuneDebugger::closeEvent(QCloseEvent *event)
{
    if (maybeSave())
    {
        writeSettings();
        event->accept();
    }
    else
    {
        event->ignore();
    }
}


void ThuneDebugger::newFile()
{
    if (maybeSave())
    {
        _editor->clear();
        setCurrentFile("");
    }
}


void ThuneDebugger::open()
{
    if (maybeSave())
    {
        QString fileName = QFileDialog::getOpenFileName(this);
        if (!fileName.isEmpty())
            loadFile(fileName);
    }
}


bool ThuneDebugger::save()
{
    if (curFile.isEmpty())
    {
        return saveAs();
    }
    else
    {
        return saveFile(curFile);
    }
}


bool ThuneDebugger::saveAs()
{
    QString fileName = QFileDialog::getSaveFileName(this);
    if (fileName.isEmpty())
        return false;

    return saveFile(fileName);
}


void ThuneDebugger::openRecentFile()
{
    QAction* action = qobject_cast<QAction*>(sender());
    if( action )
        loadFile( action->data().toString() );
}


void ThuneDebugger::about()
{
    QMessageBox* dlg;
    QString msg = QString( "<h2>Thune Debugger</h2>\n"
                           "<p>Version %1 - %2</p><br/>"
                           "Written by Karl Robillard</p>"
                         ).arg( UR_VERSION_STR )
                          .arg( __DATE__ );

    dlg = new QMessageBox( this );
    dlg->setAttribute( Qt::WA_DeleteOnClose );
    dlg->setWindowTitle( tr("About Thune") );
    dlg->setTextFormat( Qt::RichText );
    dlg->setText( msg );
    dlg->setIconPixmap( QPixmap(":/images/thune.png") );
    dlg->show();
}


void ThuneDebugger::documentWasModified()
{
    setWindowModified(_editor->document()->isModified());
}


void ThuneDebugger::createActions()
{
    newAct = new QAction(QIcon(":/images/new.png"), tr("&New"), this);
    newAct->setShortcut(tr("Ctrl+N"));
    newAct->setStatusTip(tr("Create a new file"));
    connect(newAct, SIGNAL(triggered()), this, SLOT(newFile()));

    openAct = new QAction(QIcon(":/images/open.png"), tr("&Open..."), this);
    openAct->setShortcut(tr("Ctrl+O"));
    openAct->setStatusTip(tr("Open an existing file"));
    connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

    saveAct = new QAction(QIcon(":/images/save.png"), tr("&Save"), this);
    saveAct->setShortcut(tr("Ctrl+S"));
    saveAct->setStatusTip(tr("Save the document to disk"));
    connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));

    saveAsAct = new QAction(tr("Save &As..."), this);
    saveAsAct->setStatusTip(tr("Save the document under a new name"));
    connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));

    exitAct = new QAction(tr("E&xit"), this);
    exitAct->setShortcut(tr("Ctrl+Q"));
    exitAct->setStatusTip(tr("Exit the application"));
    connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

    cutAct = new QAction(QIcon(":/images/cut.png"), tr("Cu&t"), this);
    cutAct->setShortcut(tr("Ctrl+X"));
    cutAct->setStatusTip(tr("Cut the current selection's contents to the "
                            "clipboard"));
    connect(cutAct, SIGNAL(triggered()), _editor, SLOT(cut()));

    copyAct = new QAction(QIcon(":/images/copy.png"), tr("&Copy"), this);
    copyAct->setShortcut(tr("Ctrl+C"));
    copyAct->setStatusTip(tr("Copy the current selection's contents to the "
                             "clipboard"));
    connect(copyAct, SIGNAL(triggered()), _editor, SLOT(copy()));

    pasteAct = new QAction(QIcon(":/images/paste.png"), tr("&Paste"), this);
    pasteAct->setShortcut(tr("Ctrl+V"));
    pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
                              "selection"));
    connect(pasteAct, SIGNAL(triggered()), _editor, SLOT(paste()));

    aboutAct = new QAction(tr("&About"), this);
    aboutAct->setStatusTip(tr("Show the application's About box"));
    connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

    /*
    aboutQtAct = new QAction(tr("About &Qt"), this);
    aboutQtAct->setStatusTip(tr("Show the Qt library's About box"));
    connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
    */

    cutAct->setEnabled(false);
    copyAct->setEnabled(false);
    connect(_editor, SIGNAL(copyAvailable(bool)),
            cutAct, SLOT(setEnabled(bool)));
    connect(_editor, SIGNAL(copyAvailable(bool)),
            copyAct, SLOT(setEnabled(bool)));


    // Recent Files

    for( int i = 0; i < MaxRecentFiles; ++i )
    {
        recentFileActs[i] = new QAction(this);
        recentFileActs[i]->setVisible(false);
        connect(recentFileActs[i], SIGNAL(triggered()),
                this, SLOT(openRecentFile()));
    }


    // Debug actions

    _actRun = new QAction(QIcon(":/images/run.png"), tr("&Run"), this);
    _actRun->setShortcut(tr("F6"));
    _actRun->setStatusTip(tr("Run program"));
    connect(_actRun, SIGNAL(triggered()), this, SLOT(dbRun()));

    _actStep = new QAction(QIcon(":/images/step.png"), tr("&Step"), this);
    _actStep->setShortcut(tr("F5"));
    _actStep->setStatusTip(tr("Evaluate one value"));
    connect(_actStep, SIGNAL(triggered()), this, SLOT(dbStep()));

    _actHalt = new QAction(QIcon(":/images/stop.png"), tr("&Halt"), this);
    _actHalt->setShortcut(tr("Esc"));
    _actHalt->setStatusTip(tr("Halt program"));
    connect(_actHalt, SIGNAL(triggered()), this, SLOT(dbHalt()));
}


void ThuneDebugger::createMenus()
{
    QMenu* fileMenu;
    QMenu* editMenu;
    QMenu* helpMenu;
    QMenu* progMenu;

    fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(newAct);
    fileMenu->addAction(openAct);
    fileMenu->addAction(saveAct);
    fileMenu->addAction(saveAsAct);
    separatorAct = fileMenu->addSeparator();
    for( int i = 0; i < MaxRecentFiles; ++i )
        fileMenu->addAction(recentFileActs[i]);
    fileMenu->addSeparator();
    fileMenu->addAction(exitAct);

    updateRecentFileActions();

    editMenu = menuBar()->addMenu(tr("&Edit"));
    editMenu->addAction(cutAct);
    editMenu->addAction(copyAct);
    editMenu->addAction(pasteAct);

    progMenu = menuBar()->addMenu(tr("&Program"));
    progMenu->addAction(_actRun);
    progMenu->addAction(_actStep);
    progMenu->addAction(_actHalt);

    menuBar()->addSeparator();

    helpMenu = menuBar()->addMenu(tr("&Help"));
    helpMenu->addAction(aboutAct);
}


void ThuneDebugger::createToolBars()
{
    _fileToolBar = addToolBar(tr("File"));
    _fileToolBar->addAction(newAct);
    _fileToolBar->addAction(openAct);
    _fileToolBar->addAction(saveAct);

    _editToolBar = addToolBar(tr("Edit"));
    _editToolBar->addAction(cutAct);
    _editToolBar->addAction(copyAct);
    _editToolBar->addAction(pasteAct);

    _debugToolBar = addToolBar(tr("Debug"));
    _debugToolBar->addAction(_actRun);
    _debugToolBar->addAction(_actStep);
    _debugToolBar->addAction(_actHalt);
}


void ThuneDebugger::createStatusBar()
{
    statusBar()->showMessage(tr("Ready"));
}


void ThuneDebugger::readSettings()
{
    QSettings settings( APP_SETTINGS );
    QPoint pos = settings.value("pos", QPoint(200, 200)).toPoint();
    QSize size = settings.value("size", QSize(400, 400)).toSize();
    resize(size);
    move(pos);
}


void ThuneDebugger::writeSettings()
{
    QSettings settings( APP_SETTINGS );
    settings.setValue("pos", pos());
    settings.setValue("size", size());
}


bool ThuneDebugger::maybeSave()
{
    if (_editor->document()->isModified()) {
        int ret = QMessageBox::warning(this, APP_NAME,
                     tr("The document has been modified.\n"
                        "Do you want to save your changes?"),
                     QMessageBox::Yes | QMessageBox::Default,
                     QMessageBox::No,
                     QMessageBox::Cancel | QMessageBox::Escape);
        if (ret == QMessageBox::Yes)
            return save();
        else if (ret == QMessageBox::Cancel)
            return false;
    }
    return true;
}


void ThuneDebugger::loadFile(const QString &fileName)
{
    QFile file(fileName);
    if (!file.open(QFile::ReadOnly | QFile::Text))
    {
        QMessageBox::warning(this, APP_NAME,
                             tr("Cannot read file %1:\n%2.")
                             .arg(fileName)
                             .arg(file.errorString()));
        return;
    }

    QTextStream in(&file);
    QApplication::setOverrideCursor(Qt::WaitCursor);
    _editor->setPlainText(in.readAll());
    QApplication::restoreOverrideCursor();

    setCurrentFile(fileName);
    statusBar()->showMessage(tr("File loaded"), 2000);
}


bool ThuneDebugger::saveFile(const QString &fileName)
{
    QFile file(fileName);
    if (!file.open(QFile::WriteOnly | QFile::Text)) {
        QMessageBox::warning(this, APP_NAME,
                             tr("Cannot write file %1:\n%2.")
                             .arg(fileName)
                             .arg(file.errorString()));
        return false;
    }

    QTextStream out(&file);
    QApplication::setOverrideCursor(Qt::WaitCursor);
    out << _editor->toPlainText();
    QApplication::restoreOverrideCursor();

    setCurrentFile(fileName);
    statusBar()->showMessage(tr("File saved"), 2000);
    return true;
}


void ThuneDebugger::setCurrentFile(const QString &fileName)
{
    curFile = fileName;
    _editor->document()->setModified(false);
    setWindowModified(false);

    QString shownName;
    if( fileName.isEmpty() )
    {
        shownName = "untitled.t";
    }
    else
    {
        addRecentFile( fileName );
        shownName = strippedName(fileName);
    }

    setWindowTitle(tr("%1[*] - %2").arg(shownName).arg( APP_NAME ));
}


void ThuneDebugger::addRecentFile( const QString &fileName )
{
    QSettings settings( APP_SETTINGS );

    QStringList files = settings.value("recentFileList").toStringList();
    files.removeAll(fileName);
    files.prepend(fileName);

    while( files.size() > MaxRecentFiles )
        files.removeLast();

    settings.setValue("recentFileList", files);

#if 0
    foreach( QWidget *widget, QApplication::topLevelWidgets() )
    {
        ThuneDebugger* mainWin = qobject_cast<ThuneDebugger*>(widget);
        if( mainWin )
            mainWin->updateRecentFileActions();
    }
#else
    updateRecentFileActions();
#endif
}


void ThuneDebugger::updateRecentFileActions()
{
    QSettings settings( APP_SETTINGS );
    QStringList files = settings.value("recentFileList").toStringList();

    int numRecentFiles = qMin(files.size(), (int)MaxRecentFiles);

    for( int i = 0; i < numRecentFiles; ++i )
    {
        QString text = tr("&%1 %2").arg(i + 1).arg(strippedName(files[i]));
        recentFileActs[i]->setText(text);
        recentFileActs[i]->setData(files[i]);
        recentFileActs[i]->setVisible(true);
    }
    for( int j = numRecentFiles; j < MaxRecentFiles; ++j )
        recentFileActs[j]->setVisible(false);

    separatorAct->setVisible(numRecentFiles > 0);
}


QString ThuneDebugger::strippedName(const QString &fullFileName)
{
    return QFileInfo(fullFileName).fileName();
}


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


void ThuneDebugger::showPC( UThread* ut, UCell* pc, UCell* end )
{
    UString* str = ur_threadTmp( ut );

    ur_arrayReserve( str, 1, 4 );
    str->ptr.c[0] = '.';
    str->ptr.c[1] = '.';
    str->ptr.c[2] = ' ';
    str->used = 3;

    ur_toStr( pc, str, 0 );

    ++pc;
    while( pc != end )
    {
        if( pc->id.flags & UR_FLAG_EOL )
            break;

        ur_arrayReserve( str, 1, str->used + 1 );
        str->ptr.c[ str->used ] = ' ';
        ++str->used;

        ur_toStr( pc, str, 0 );
        ++pc;
    }

    ur_termCStr( str );

    //statusBar()->showMessage( str->ptr.c );
    _console->append( str->ptr.c );

    _stack->update( ut, str );
}


int ThuneDebugger::monitorIgnore( UThread*, int, UCell*, UCell* )
{
    return 0;
}


int ThuneDebugger::monitorRun( UThread* ut, int cmd, UCell* pc, UCell* end )
{
    switch( cmd )
    {
        case UR_EMH_STEP:
            gDB->_runCycle++;
            if( (gDB->_runCycle & 127) == 0 )
            {
                qApp->processEvents();
                if( gDB->_interrupt )
                {
                    UR_CALL_OP = OP_QUIT;
                    return 1;
                }
            }
            break;

        case UR_EMH_HALT:
            gDB->setMode( kModeStep );

            gDB->showPC( ut, pc, end );
            int ret = gDB->_loop->exec();
            if( ret < 0 )
            {
                UR_CALL_OP = OP_QUIT;
                return 1;
            }
            break;
    }
    return 0;
}


int ThuneDebugger::monitorStep( UThread* ut, int cmd, UCell* pc, UCell* end )
{
    switch( cmd )
    {
        case UR_EMH_STEP:
            gDB->showPC( ut, pc, end );
            int ret = gDB->_loop->exec();
            //printf( "KR ret %d\n", ret );
            if( ret < 0 )
            {
                UR_CALL_OP = OP_QUIT;
                return 1;
            }
            break;
    }
    return 0;
}


extern "C" void ur_dprint( const char* fmt, ... )
{
#define DBUF_LEN 256
    va_list arg;
    char buf[ DBUF_LEN ];

    va_start( arg, fmt );
    vsnprintf( buf, DBUF_LEN, fmt, arg );
    va_end( arg );

    buf[ DBUF_LEN - 1 ] = '\0';
    gConsole->append( buf );
}


void ThuneDebugger::setMode( int mode )
{
    switch( mode )
    {
        case kModeDone:
            _mode = kModeDone;
            _env.monitor = monitorIgnore;
            _actRun->setEnabled( true );
            _actStep->setEnabled( true );
            _actHalt->setEnabled( false );
            break;

        case kModeRun:
            _mode = kModeRun;
            _env.monitor = monitorRun;
            _actRun->setEnabled( false );
            _actStep->setEnabled( false );
            _actHalt->setEnabled( true );
            break;

        case kModeStep:
            _mode = kModeStep;
            _env.monitor = monitorStep;
            _actRun->setEnabled( true );
            _actStep->setEnabled( true );
            _actHalt->setEnabled( false );
            break;
    }
}


bool ThuneDebugger::createEnv()
{
    destroyEnv();

    _runCycle = 0;
    _interrupt = false;

    gConsole = _console;
    _console->clear();

    _stack->clear();

    _env.monitor = monitorIgnore;

    if( ur_startup( &_env, 0, 0 ) )
        return false;

    return true;
}


void ThuneDebugger::destroyEnv()
{
    if( _env.threads )
        ur_shutdown( &_env );
}


void ThuneDebugger::eval()
{
    UCell* res;
    QByteArray cmd;
    UThread* ut = _env.threads;

    cmd = _editor->toPlainText().toAscii();

    switch( ur_evalCStr( ut, cmd, cmd.size() ) )
    {
        case UR_EVAL_OK:
        {
            res = ur_result( ut, 0 );

            if( ! ur_is(res, UT_UNSET) &&
                ! ur_is(res, UT_CONTEXT) &&
                ! ur_is(res, UT_FUNCTION) )
            {
                UString str;

                ur_arrayInit( &str, 1, 0 );
                ur_toStr( res, &str, 0 );
                if( str.ptr.c )
                {
                    UString* sp = &str;
                    ur_termCStr( sp );

                    _console->append( str.ptr.c );
                    //printf( "== %s\n", str.ptr.c );
                }
                ur_arrayFree( &str );
            }

            setMode( kModeDone );
            statusBar()->showMessage(tr("Finished"), 2000);
        }
            break;

        case UR_EVAL_HALT:
            break;

        case UR_EVAL_QUIT:
            _mode = kModeDone;
            break;

        case UR_EVAL_ERROR:
        {
            UString* str;

            res = ur_result( ut, 0 );
            str = ur_binPtr( res->err.messageStr );

            _console->append( "Error!" );
            _console->append( str->ptr.c );
        }
            break;
    }
}


void ThuneDebugger::dbRun()
{
    switch( _mode )
    {
        case kModeVoid:
        case kModeDone:
            if( createEnv() )
            {
                setMode( kModeRun );
                statusBar()->showMessage(tr("Running..."), 2000);
                eval();
            }
            break;

        case kModeStep:
            setMode( kModeRun );
            gDB->_loop->exit( 0 );
            break;
    }
}


void ThuneDebugger::dbStep()
{
    switch( _mode )
    {
        case kModeVoid:
        case kModeDone:
            if( createEnv() )
            {
                setMode( kModeStep );
                statusBar()->showMessage(tr("Stepping..."), 2000);
                eval();
            }
            break;

        case kModeStep:
            gDB->_loop->exit( 0 );
            break;
    }
}


void ThuneDebugger::dbHalt()
{
    switch( _mode )
    {
        case kModeRun:
            _interrupt = true;
            break;
    }
}


//EOF