forspll/main.cpp

/**
 * forspll - LLVM-based Forsp compiler
 * Copyright (C) 2024  Clyne Sullivan <clyne@bitgloo.com>
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include <cctype>
#include <iostream>
#include <list>
#include <map>
#include <string>
#include <string_view>
#include <tuple>

#include "ast.hpp"
#include "llvm.hpp"
#include "parser.hpp"
#include "var.hpp"

static LLVMState llvmState;
std::list<ThunkAST> scope;

static bool parseString(std::string_view sv);

int main()
{
    Var::pushScope();

    std::string line;
    for (unsigned lineno = 1; std::cin.good(); ++lineno) {
        std::getline(std::cin, line);
        if (!parseString(line)) {
            std::cerr << "    at line " << lineno << std::endl;
            return -1;
        }
    }

    auto func = llvmState.createFunction("main");
    auto entry = llvmState.createEntry(func);
    auto envtype = llvm::VectorType::get(llvmState.inttype, ThunkAST::envidx, false);
    auto [t0, _] = Var::lookup("__t0");
    llvmState.builder.SetInsertPoint(entry);
    auto env = llvmState.builder.CreateAlloca(envtype, nullptr);
    llvmState.builder.CreateCall(llvmState.ftype, t0, llvm::ArrayRef<llvm::Value *> {env});
    llvmState.builder.CreateRetVoid();

    llvmState.output();
    std::cerr << "envidx: " << ThunkAST::envidx << std::endl;
    std::cout << std::endl;
}

bool parseString(std::string_view sv)
{
    do {
        const auto [nsv, tok] = nextToken(sv);

        if (tok == Token::none && !nsv.empty()) {
            std::cerr << "error: unknown term: " << nsv << std::endl;
            return false;
        } else {
            std::unique_ptr<BaseAST> expr;

            switch (tok) {
            case Token::ThunkOpen:
                scope.emplace_back(llvmState);
                Var::pushScope();
                break;
            case Token::ThunkClose:
                {
                auto& thunk = scope.back();
                auto gen = thunk.codegen(llvmState);
                if (!gen)
                    return false;
                Var::popScope();
                Var::addLocal(thunk.name, Var {gen, true});
                expr.reset(new PushAST {thunk.name});
                scope.pop_back();
                }
                break;
            case Token::Quote:
                std::cerr << "error: quoting is not supported!" << std::endl;
                return false;
            case Token::PopVar:
                expr.reset(new PopAST {name});
                break;
            case Token::PushVar:
                expr.reset(new PushAST {name});
                break;
            case Token::Var:
                expr.reset(new CallAST {name});
                break;
            case Token::Number:
                expr.reset(new NumberAST {name});
                break;
            case Token::none:
                break;
            }

            if (expr) {
                if (!scope.empty()) {
                    if (!expr->codegen(llvmState))
                        return false;
                } else if (tok != Token::ThunkClose) {
                    std::cerr << "error: non-thunk at top level!" << std::endl;
                    return false;
                }
            }
        }

        sv = nsv;
    } while (!sv.empty());

    return true;
}