main.cpp

#include "codegenerator.h"
#include "compiler.h"
#include "global.h"
#include "print.h"
#include <QtCore/QtCore>
#include <cstdlib>
#include <iostream>
#include <list>
#include <atomic>
#ifdef Q_OS_WIN
#include <conio.h>
#include <windows.h>
#else
#include <csignal>
#include <unistd.h>
#endif
using namespace cpi;

// Version
constexpr auto CPI_VERSION_STR = "2.2.4";

#ifdef Q_CC_MSVC
constexpr auto DEFAULT_CONFIG = "[General]\n"
                                "CXX=cl.exe\n"
                                "CXXFLAGS=/std:c++latest\n"
                                "LDFLAGS=\n"
                                "COMMON_INCLUDES=\n";
#else
#if QT_VERSION < 0x060000
constexpr auto DEFAULT_CONFIG = "[General]\n"
                                "### Example option for Qt5\n"
                                "#CXX=%1\n"
                                "#CXXFLAGS=-pipe -std=c++14 -D_REENTRANT -I/usr/include/qt5\n"
                                "#LDFLAGS=-lQt5Core\n"
                                "#COMMON_INCLUDES=\n"
                                "\n"
                                "CXX=\n"
                                "CXXFLAGS=-pipe -std=c++14 -D_REENTRANT\n"
                                "LDFLAGS=\n"
                                "COMMON_INCLUDES=\n";
#else
constexpr auto DEFAULT_CONFIG = "[General]\n"
                                "### Example option for Qt6\n"
                                "#CXX=\n"
                                "#CXXFLAGS=-pipe -std=c++2b -D_REENTRANT -I/usr/include/qt6\n"
                                "#LDFLAGS=-lQt6Core\n"
                                "#COMMON_INCLUDES=\n"
                                "\n"
                                "CXX=\n"
                                "CXXFLAGS=-pipe -std=c++2b -D_REENTRANT\n"
                                "LDFLAGS=\n"
                                "COMMON_INCLUDES=\n";
#endif
#endif

// Entered headers and code
static QStringList headers, code;
static int lastLineNumber = 0;  // line number added recently
std::unique_ptr<QSettings> conf;
QStringList cppsArgs;
std::atomic_bool gQuitRequested = false;  // For windows


QString aoutName()
{
    static QString aout;
    if (aout.isEmpty()) {
        aout = QDir::tempPath() + QDir::separator();
#ifdef Q_OS_WIN
        aout += ".cpiout" + QString::number(QCoreApplication::applicationPid()) + ".exe";
#else
        aout += ".cpi" + QString::number(QCoreApplication::applicationPid()) + ".out";
#endif
    }
    return aout;
}


#ifdef Q_OS_WIN
static BOOL WINAPI signalHandler(DWORD ctrlType)
{
    switch (ctrlType) {
    case CTRL_C_EVENT:
    case CTRL_BREAK_EVENT:
    case CTRL_CLOSE_EVENT:
    case CTRL_LOGOFF_EVENT:
    case CTRL_SHUTDOWN_EVENT: {
        gQuitRequested = true;
        QCoreApplication::quit();
        resetTerminalMode();
        break;
    }

    default:
        return FALSE;
    }

    while (true){
        // cleanup
        if (QFileInfo(aoutName()).exists()) {
            QFile::remove(aoutName());
            Sleep(1);
        }
    }

    return TRUE;
}

#else

static void signalHandler(int)
{
    resetTerminalMode();

    // cleanup
    if (QFileInfo(aoutName()).exists()) {
        QFile::remove(aoutName());
    }
    std::exit(0);
}

static void watchUnixSignal(int sig)
{
    if (sig < NSIG) {
        struct sigaction sa;
        memset(&sa, 0, sizeof(sa));
        sa.sa_flags = SA_RESTART;
        sa.sa_handler = signalHandler;
        sigaction(sig, &sa, 0);
    }
}
#endif

static bool isAsciiAt(const QString &s, qsizetype pos)
{
    return pos >= 0 && pos < s.size() && s.at(pos).unicode() < 0x80;
}


static QString isSetFileOption()
{
    QString ret;
    for (int i = 1; i < QCoreApplication::arguments().length(); i++) {
        auto opt = QCoreApplication::arguments()[i];
        if (!opt.startsWith("-")) {
            ret = opt;
            cppsArgs = QCoreApplication::arguments().mid(i + 1);
            break;
        }
    }
    return ret;
}


static void showHelp()
{
    char help[] = " .conf        Display the current values for various settings.\n"
                  " .help        Display this help.\n"
                  " .rm LINENO   Remove the code of the specified line number.\n"
                  " .clear       Clear the code all.\n"
                  " .show        Show the current source code.\n"
                  " .quit        Exit this program.\n";
    print() << help;
}


static void showConfigs(const QSettings &conf)
{
    const QStringList confkeys {"CXX", "CXXFLAGS", "LDFLAGS", "COMMON_INCLUDES"};

    for (auto &key : conf.allKeys()) {
        if (confkeys.contains(key))
            printf("%s=%s\n", qUtf8Printable(key), qUtf8Printable(conf.value(key).toString()));
    }
}


static void deleteLine(int n)
{
    int h = headers.count();
    int c = code.count();

    if (n > 0) {
        if (n <= h) {
            headers.removeAt(n - 1);
        } else if (n <= h + c) {
            code.removeAt(n - h - 1);
        } else {
            // ignore
        }
        lastLineNumber = 0;
    }
}


static void deleteLines(const std::list<int> &numbers)
{
    std::list<int> numlist = numbers;
    numlist.sort(std::greater<int>());
    numlist.unique();  // removes duplicates

    for (auto d : numlist) {
        deleteLine(d);
    }
}


static void showCode()
{
    int num = 1;
    if (!headers.isEmpty()) {
        for (int i = 0; i < headers.count(); ++i) {
            printf("%3d| %s\n", num++, qUtf8Printable(headers.at(i)));
        }
        printf("    --------------------\n");
    }
    for (int i = 0; i < code.count(); ++i) {
        printf("%3d| %s\n", num++, qUtf8Printable(code.at(i)));
    }
}


static bool waitForReadyStdInputRead(int msecs)
{
    QElapsedTimer timer;
    timer.start();

#ifdef Q_OS_WIN
    while (timer.elapsed() < msecs) {
        if (_kbhit()) {
            return true;
        }
        QThread::msleep(20);
    }
    return false;
#else
    bool ret = false;
    QSocketNotifier notifier(fileno(stdin), QSocketNotifier::Read);
    QObject::connect(&notifier, &QSocketNotifier::activated, [&]() { ret = true; });

    for (;;) {
        qApp->processEvents(QEventLoop::AllEvents);
        if (timer.elapsed() >= msecs || ret) {
            break;
        }
        QThread::msleep(20);
    }
    return ret;
#endif
}


static void compile()
{
    if (code.isEmpty()) {
        return;
    }

    // compile
    CodeGenerator cdgen(headers.join("\n"), code.join("\n"));
    QString src = cdgen.generateMainFunc();

    Compiler compiler;
    int cpl = compiler.compileAndExecute(src);
    if (cpl) {
        // compile only once more
        src = cdgen.generateMainFunc(true);
        cpl = compiler.compileAndExecute(src);
    }

    if (cpl) {
        compiler.printContextCompilationError();
        if (!code.join("\n").contains(QRegularExpression(" main\\s*\\("))) {
            // delete last line
            if (lastLineNumber > 0) {
                deleteLine(lastLineNumber);
            }
        }
    }
};


static QString readLine()
{
    QString line = "";
    while (true) {
        auto str = readStdInput();
        if (str.isEmpty()) {
            if (gQuitRequested) {
                return QString();
            }
            Sleep(50);
            continue;
        }

        if (str == QByteArray(1, 0x7f) || str == QByteArray(1, 0x08)) {
            if (line.size() > 0) {
                int d = isAsciiAt(line, line.size() - 1) ? 1 : 2;
                for (int i = 0; i < d; i++) {
                    std::cout << "\b \b" << std::flush;
                }
                line.chop(1);
            }
        } else {
            std::cout.write(str.constData(), str.size());
            std::cout.flush();

            line += QString::fromUtf8(str);
            if (str.endsWith('\n')) {
                break;
            }
        }
    }
    return line;
}


static int interpreter()
{
    print() << "cpi " << CPI_VERSION_STR << endl;
    print() << "Type \".help\" for more information." << endl;
    print() << "Loaded INI file: " << conf->fileName() << endl;
    print().flush();

    const QStringList includes = conf->value("COMMON_INCLUDES").toString().split(" ", SkipEmptyParts);
    for (auto s : includes) {
        s = s.trimmed();
        if (!s.isEmpty()) {
            if (s.startsWith("<") || s.startsWith('"')) {
                headers << QString("#include ") + s;
            } else {
                headers << QString("#include <") + s + ">";
            }
            lastLineNumber = headers.count();
        }
    }

    bool end = false;
    auto readCodeAndCompile = [&]() {
        QString lines = readLine();

        if (lines.isNull()) {
            end = true;
            return;
        }

        QString cmd = lines.trimmed();
        if (cmd == ".quit" || cmd == ".q") {
            end = true;
            return;
        }

        class PromptOut {
        public:
            ~PromptOut() { print() << prompt << flush; }
            void off() { prompt.clear(); }

        private:
            QByteArray prompt {"cpi> "};
        } promptOut;

        if (cmd == ".help" || cmd == "?") {  // shows help
            showHelp();
            return;
        }

        if (cmd == ".show" || cmd == ".code") {  // shows code
            showCode();
            return;
        }

        if (cmd == ".conf") {  // shows configs
            showConfigs(*conf);
            return;
        }

        if (cmd.startsWith(".del ") || cmd.startsWith(".rm ")) {  // Deletes code
            int n = cmd.indexOf(' ');
            cmd.remove(0, n + 1);
            const QStringList list = cmd.split(QRegularExpression("[,\\s]"), SkipEmptyParts);

            std::list<int> numbers;  // line-numbers
            for (auto &s : list) {
                bool ok;
                int n = s.toInt(&ok);
                if (ok && n > 0)
                    numbers.push_back(n);
            }
            deleteLines(numbers);
            showCode();
            return;
        }

        if (cmd == ".clear") {
            headers.clear();
            code.clear();
            lastLineNumber = 0;
            return;
        }

        QStringList lineList = lines.split(QRegularExpression(R"(\R)"), Qt::SkipEmptyParts);
        for (const auto &line : lineList) {
            if (line.startsWith('#') || line.startsWith("using ")) {
                headers << line;
                lastLineNumber = headers.count();
            } else {
                if (!line.isEmpty()) {
                    code << line;
                    lastLineNumber = headers.count() + code.count();
                }
            }
        }

        if (lineList.count() > 1) {
            // Do not delete the last line even if a compile error occurs when
            // multiple lines are copied and pasted
            lastLineNumber = 0;
        }

        if (waitForReadyStdInputRead(20)) {
            // continue reading
            promptOut.off();
            return;
        }

        // compile
        compile();
    };

    print() << "cpi> " << flush;

    setTerminalMode(false);
    while (!end && !gQuitRequested) {
        if (waitForReadyStdInputRead(50)) {
            readCodeAndCompile();
        }
    }

    return 0;
}


int main(int argv, char *argc[])
{
#ifdef Q_OS_WIN
    SetConsoleCP(CP_UTF8);
    SetConsoleOutputCP(CP_UTF8);
#endif

    QCoreApplication app(argv, argc);
    app.setApplicationVersion(CPI_VERSION_STR);

    QCommandLineParser parser;
    parser.setApplicationDescription("Tiny C++ Interpreter.\nRuns in interactive mode by default.");
    parser.addHelpOption();
    parser.addVersionOption();
    parser.addPositionalArgument("file", "File to compile.", "[file]");
    parser.addPositionalArgument("-", "Reads from stdin.", "[-]");
    parser.process(app);

#if (defined Q_OS_WIN) || (defined Q_OS_DARWIN)
    conf = std::make_unique<QSettings>(QSettings::IniFormat, QSettings::UserScope, "cpi/cpi");
#else
    conf = std::make_unique<QSettings>(QSettings::NativeFormat, QSettings::UserScope, "cpi/cpi");
#endif

    if (QFile confFile(conf->fileName()); !confFile.exists()) {
        QFileInfo(confFile).absoluteDir().mkpath(".");

        if (confFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
            confFile.write(DEFAULT_CONFIG);
            confFile.close();
        }
        conf->sync();
    }

#ifdef Q_OS_WIN
    SetConsoleCtrlHandler(signalHandler, TRUE);
#else
    watchUnixSignal(SIGTERM);
    watchUnixSignal(SIGINT);
#endif

    int ret = 0;
    try {
        Compiler compiler;

        if (QString file = isSetFileOption(); !file.isEmpty()) {
            if (!QFileInfo(file).exists()) {
                print() << "No such file, " << file << endl;
                return 1;
            }

            ret = compiler.compileFileAndExecute(file);
            if (ret) {
                compiler.printLastCompilationError();
            }
        } else if (QCoreApplication::arguments().contains("-")) {  // Check pipe option
            QString src;
            QTextStream tsstdin(stdin);
#if QT_VERSION >= 0x060000
            tsstdin.setEncoding(QStringConverter::System);
#endif
            while (!tsstdin.atEnd()) {
                src += tsstdin.readAll();
            }

            ret = compiler.compileAndExecute(src);
            if (ret) {
                compiler.printLastCompilationError();
            }
        } else {
            // Check compiler
            Compiler::cxx();
            ret = interpreter();
        }

    } catch (...) {
        ret = 1;
    }

    resetTerminalMode();
    return ret;
}