rieske / trans / 28379938466

std::string generateLabelName() {

    return LABEL_PREFIX + std::to_string(++nextLabel);

std::string generateConstantName() {

    return CONSTANT_PREFIX + std::to_string(++nextConstant);

bool SymbolTable::insertSymbol(std::string name, const type::Type& type, translation_unit::Context context) {

    if (isAtFileScope()) {

        return globalScope.insertSymbol(name, type, context, true);

    return functionScopes.back().insertSymbol(scopePrefix(currentScopeId()) + name, type, context);

std::string SymbolTable::newConstant(const std::string& value) {

    std::string constantSymbol = generateConstantName();

    constants.insert({constantSymbol, value});

    return constantSymbol;

void SymbolTable::insertFunctionArgument(std::string name, type::Type type, translation_unit::Context context) {

    functionScopes.back().insertFunctionArgument(scopePrefix(currentScopeId()) + name, type, context);

}

FunctionEntry SymbolTable::insertFunction(std::string name, type::Function functionType, translation_unit::Context context) {

    FunctionEntry function = functions.insert(std::make_pair(name, FunctionEntry { name, functionType, context })).first->second;

    globalScope.insertSymbol(function.getName(), type::function(functionType.getReturnType(), functionType.getArguments()), function.getContext());

    return function;

FunctionEntry SymbolTable::findFunction(std::string name) const {

    return functions.at(name);

bool SymbolTable::hasFunction(const std::string& name) const {

    return functions.find(name) != functions.end();

bool SymbolTable::isAtFileScope() const {

    return scopeIdStack.empty();

bool SymbolTable::hasGlobalVariable(const std::string& name) const {

        return !globalScope.lookup(name).getType().isFunction();

    } catch (std::out_of_range&) {

        return false;

    }

void SymbolTable::setGlobalInitializer(const std::string& name, long constantValue) {

    globalScope.setConstantInitializer(name, constantValue);

}

bool SymbolTable::hasSymbol(std::string symbolName) const {

        lookup(symbolName);

        return true;

    } catch (std::out_of_range&) {

        return false;

    }

ValueEntry SymbolTable::lookup(std::string name) const {

    if (!functionScopes.empty()) {

        for (auto it = scopeIdStack.rbegin(); it != scopeIdStack.rend(); ++it) {

                return functionScopes.back().lookup(scopePrefix(*it) + name);

            } catch (std::out_of_range&) {

            }

    return globalScope.lookup(name);

ValueEntry SymbolTable::createTemporarySymbol(type::Type type) {

    if (functionScopes.empty()) {

        return globalScope.createTemporarySymbol(type);

    return functionScopes.back().createTemporarySymbol(type);

LabelEntry SymbolTable::newLabel() {

    std::string labelName = generateLabelName();

    LabelEntry label { labelName };

    labels.insert(std::make_pair(labelName, label));

    return label;

}

void SymbolTable::startFunction(std::string name, std::vector<std::string> formalArguments) {

    functionScopes.push_back(ValueScope { });

    scopeIdStack.clear();

    scopeIdStack.push_back(++nextScopeId);

    auto function = findFunction(name);

    size_t i { 0 };

    for (auto& argument : function.arguments()) {

        if (i < formalArguments.size()) {

            insertFunctionArgument(formalArguments.at(i), argument, function.getContext());

        ++i;

    }

}

void SymbolTable::endFunction() {

    scopeIdStack.clear();

}

void SymbolTable::enterBlockScope() {

    scopeIdStack.push_back(++nextScopeId);

}

void SymbolTable::exitBlockScope() {

    scopeIdStack.pop_back();

}

unsigned SymbolTable::currentScopeId() const {

    return scopeIdStack.back();

std::map<std::string, ValueEntry> SymbolTable::getCurrentScopeSymbols() const {

    return functionScopes.back().getSymbols();

std::vector<ValueEntry> SymbolTable::getCurrentScopeArguments() const {

    return functionScopes.back().getArguments();

std::map<std::string, std::string> SymbolTable::getConstants() const {

    return constants;

std::vector<ValueEntry> SymbolTable::getGlobalVariables() const {

    std::vector<ValueEntry> globals;

    for (const auto& entry : globalScope.getSymbols()) {

        if (entry.second.isGlobal()) {

            globals.push_back(entry.second);

    }

    return globals;

void SymbolTable::printTable() const {

    for (auto constant : constants) {

        out << "\t" << constant.first << "\t\t\t\t" << constant.second << "\n";

    }

    for (auto function : functions) {

        out << "\t" << function.first << "\t\t\t\t" << function.second.getType().to_string() << "\n";

    }

    for (auto label : labels) {

        out << "\t" << label.second.getName() << "\t\ttemp\t0\t\tlabel\n";

    }

    for (unsigned i = 0; i < functionScopes.size(); i++) {

        out << "BEGIN SCOPE\n"

            << "--arguments--\n";

        for (const auto& value : functionScopes[i].getArguments()) {

            out << value.to_string();

        }

        out << "--locals--\n";

        for (const auto& value : functionScopes[i].getSymbols()) {

            out << value.second.to_string();

        }

        out << "END SCOPE\n";

}

std::string SymbolTable::scopePrefix(unsigned scopeId) const {

    return SCOPE_PREFIX + std::to_string(scopeId);