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;
static std::list<ThunkAST> scope;

static bool parseString(std::string_view sv);

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

    std::string line;
    while (std::cin.good()) {
        std::getline(std::cin, line);
        parseString(line);
        //std::cout << std::endl;
    }

    llvmState.output();

    std::cout << std::endl;
}

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

        //printToken(tok);

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

            switch (tok) {
            case Token::ThunkOpen:
                if (scope.empty())
                    scope.emplace_back(llvmState, "main");
                else
                    scope.emplace_back(llvmState);
                Var::pushScope();
                break;
            case Token::ThunkClose:
                {
                auto& thunk = scope.back();
                auto gen = thunk.codegen(llvmState);
                Var::popScope();
                Var::addLocal(thunk.name, Var {gen, true});
                expr.reset(new PushAST {thunk.name});
                scope.pop_back();
                }
                break;
            case Token::Quote:
                break;
            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 && !scope.empty()) {
                expr->codegen(llvmState);
                //scope.back().body.emplace_back().swap(expr);
            }
        }

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

    return true;
}