initial code upload
parent
a650e3b1c5
commit
8dc1db8fb9
@ -0,0 +1,2 @@
|
||||
*.o
|
||||
main
|
||||
@ -0,0 +1,24 @@
|
||||
CXX := g++
|
||||
CXXFLAGS := -std=c++20 -O0 -ggdb -g3
|
||||
LIBS := -lLLVM-14
|
||||
|
||||
SRC := ast.cpp \
|
||||
parser.cpp \
|
||||
main.cpp
|
||||
|
||||
OBJ := $(subst .cpp,.o,$(SRC))
|
||||
BIN := main
|
||||
|
||||
all: $(BIN)
|
||||
|
||||
clean:
|
||||
@echo " CLEAN"
|
||||
@rm -f $(BIN) $(OBJ)
|
||||
|
||||
$(BIN): $(OBJ)
|
||||
@echo " LD " $@
|
||||
@$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
|
||||
|
||||
.cpp.o:
|
||||
@echo " CXX " $<
|
||||
@$(CXX) $(CXXFLAGS) -c $<
|
||||
@ -0,0 +1,228 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file ast.cpp
|
||||
* @brief Abstract Syntax Tree (AST) implementation.
|
||||
*/
|
||||
|
||||
#include "ast.hpp"
|
||||
#include "state.hpp"
|
||||
|
||||
#include "llvm/ADT/APFloat.h"
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <any>
|
||||
#include <cctype>
|
||||
#include <cstdio>
|
||||
#include <deque>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <typeinfo>
|
||||
#include <variant>
|
||||
#include <vector>
|
||||
|
||||
AST::Value AST::Identifier::codegen(CompilerState& state)
|
||||
{
|
||||
if (state.namedValues.contains(name))
|
||||
return state.namedValues[name];
|
||||
else
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AST::Value AST::Literal::codegen(CompilerState& state)
|
||||
{
|
||||
if (type == AST::Literal::Type::Number) {
|
||||
if (std::holds_alternative<int>(value))
|
||||
return llvm::ConstantInt::get(state.context, llvm::APInt(sizeof(int) * 8, std::get<int>(value)));
|
||||
else
|
||||
return llvm::ConstantFP::get(state.context, llvm::APFloat(std::get<double>(value)));
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
AST::Value AST::ProcedureCall::codegen(CompilerState& state)
|
||||
{
|
||||
if (auto id = dynamic_cast<AST::Identifier *>(callee); id) {
|
||||
if (state.namedValues.contains(id->name)) {
|
||||
auto ptrToFuncPtr = state.namedValues[id->name];
|
||||
auto funcPtr = state.builder.CreateLoad(
|
||||
ptrToFuncPtr->getType()->getContainedType(0),
|
||||
ptrToFuncPtr);
|
||||
auto funcType = (llvm::FunctionType *)funcPtr->getType()->getContainedType(0);
|
||||
return state.builder.CreateCall(funcType, funcPtr, llvm::None, "calltmp");
|
||||
} else {
|
||||
std::vector<llvm::Value *> args;
|
||||
std::vector<llvm::Type *> argtypes;
|
||||
|
||||
for (auto& a : operands) {
|
||||
args.push_back(a->codegen(state));
|
||||
argtypes.push_back(args.back()->getType());
|
||||
}
|
||||
|
||||
|
||||
auto func = state.module.getOrInsertFunction(id->name,
|
||||
llvm::FunctionType::get(
|
||||
llvm::Type::getVoidTy(state.context),
|
||||
argtypes,
|
||||
false));
|
||||
return state.builder.CreateCall(func, args);
|
||||
}
|
||||
|
||||
// work off of id's name
|
||||
// builtin?
|
||||
// named value? (i.e. is defined)
|
||||
return nullptr;
|
||||
} else if (auto v = callee->codegen(state); v) {
|
||||
// v needs to be a callable procedure
|
||||
//std::vector<Node *> operands;
|
||||
return nullptr;
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
AST::Value AST::LambdaExpression::codegen(CompilerState& state)
|
||||
{
|
||||
std::vector<llvm::Type *> args;
|
||||
std::vector<std::string> argnames;
|
||||
|
||||
for (auto& op : operands) {
|
||||
args.push_back(llvm::Type::getDoubleTy(state.context));
|
||||
argnames.push_back(op->name);
|
||||
}
|
||||
|
||||
auto ftype = llvm::FunctionType::get(
|
||||
llvm::Type::getDoubleTy(state.context), args, false);
|
||||
auto func = llvm::Function::Create(
|
||||
ftype, llvm::Function::ExternalLinkage, "lambda", &state.module);
|
||||
|
||||
auto n = argnames.cbegin();
|
||||
for (auto& a : func->args()) {
|
||||
a.setName(*n);
|
||||
state.namedValues[*n] = &a;
|
||||
++n;
|
||||
}
|
||||
|
||||
auto block = llvm::BasicBlock::Create(state.context, "entry", func);
|
||||
|
||||
auto ip = state.builder.saveIP();
|
||||
state.builder.SetInsertPoint(block);
|
||||
++state.scope;
|
||||
|
||||
llvm::Value *ret;
|
||||
for (auto& b : body)
|
||||
ret = b->codegen(state);
|
||||
|
||||
if (ret)
|
||||
state.builder.CreateRet(ret);
|
||||
else
|
||||
state.builder.CreateRetVoid();
|
||||
|
||||
--state.scope;
|
||||
state.builder.restoreIP(ip);
|
||||
|
||||
for (auto& a : argnames)
|
||||
state.namedValues.erase(a);
|
||||
|
||||
return func;
|
||||
}
|
||||
|
||||
AST::Value AST::Conditional::codegen(CompilerState& state)
|
||||
{
|
||||
auto cval = state.builder.CreateFCmpONE(
|
||||
cond->codegen(state),
|
||||
llvm::ConstantFP::get(state.context, llvm::APFloat(0.0)),
|
||||
"ifcond");
|
||||
|
||||
auto func = state.builder.GetInsertBlock()->getParent();
|
||||
|
||||
auto bthen = llvm::BasicBlock::Create(state.context, "then", func);
|
||||
auto belse = llvm::BasicBlock::Create(state.context, "else", func);
|
||||
auto bcont = llvm::BasicBlock::Create(state.context, "cont", func);
|
||||
state.builder.CreateCondBr(cval, bthen, belse);
|
||||
|
||||
state.builder.SetInsertPoint(bthen);
|
||||
auto vthen = iftrue->codegen(state);
|
||||
if (!vthen || vthen->getType() != llvm::Type::getDoubleTy(state.context))
|
||||
vthen = llvm::ConstantFP::get(state.context, llvm::APFloat(0.0));
|
||||
state.builder.CreateBr(bcont);
|
||||
|
||||
state.builder.SetInsertPoint(belse);
|
||||
auto velse = iffalse->codegen(state);
|
||||
if (!velse || velse->getType() != llvm::Type::getDoubleTy(state.context))
|
||||
velse = llvm::ConstantFP::get(state.context, llvm::APFloat(0.0));
|
||||
state.builder.CreateBr(bcont);
|
||||
|
||||
state.builder.SetInsertPoint(bcont);
|
||||
auto PN = state.builder.CreatePHI(
|
||||
llvm::Type::getDoubleTy(state.context), 2, "iftmp");
|
||||
|
||||
PN->addIncoming(vthen, bthen);
|
||||
PN->addIncoming(velse, belse);
|
||||
return PN;
|
||||
}
|
||||
|
||||
AST::Value AST::Definition::codegen(CompilerState& state)
|
||||
{
|
||||
if (!state.namedValues.contains(ident->name)) {
|
||||
if (state.scope == 0) {
|
||||
auto val = (llvm::Constant *)value->codegen(state);
|
||||
|
||||
state.module.getOrInsertGlobal(ident->name, val->getType());
|
||||
|
||||
auto var = state.module.getNamedGlobal(ident->name);
|
||||
var->setLinkage(llvm::Function::ExternalLinkage);
|
||||
var->setInitializer(val);
|
||||
state.namedValues[ident->name] = var;
|
||||
return var;
|
||||
} else {
|
||||
auto alloc = state.builder.CreateAlloca(
|
||||
llvm::Type::getDoubleTy(state.context),
|
||||
nullptr,
|
||||
ident->name);
|
||||
state.builder.CreateStore(value->codegen(state), alloc);
|
||||
state.namedValues[ident->name] = alloc;
|
||||
return alloc;
|
||||
}
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
AST::Value AST::Assignment::codegen(CompilerState& state)
|
||||
{
|
||||
if (state.scope > 0) {
|
||||
if (state.namedValues.contains(ident->name)) {
|
||||
return state.builder.CreateStore(value->codegen(state), state.namedValues[ident->name]);
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,183 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file ast.hpp
|
||||
* @brief Abstract Syntax Tree (AST) implementation.
|
||||
*/
|
||||
|
||||
#ifndef AST_HPP
|
||||
#define AST_HPP
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <variant>
|
||||
|
||||
struct CompilerState;
|
||||
|
||||
namespace llvm {
|
||||
struct Value;
|
||||
}
|
||||
|
||||
namespace AST {
|
||||
|
||||
using Value = llvm::Value *;
|
||||
|
||||
struct Node
|
||||
{
|
||||
virtual ~Node() {};
|
||||
|
||||
virtual Value codegen(CompilerState&) = 0;
|
||||
virtual std::string desc() {
|
||||
return "Node";
|
||||
}
|
||||
};
|
||||
|
||||
struct Identifier : public Node
|
||||
{
|
||||
std::string name;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
return std::string("Identifier: ") + name;
|
||||
}
|
||||
};
|
||||
|
||||
struct Literal : public Node
|
||||
{
|
||||
enum Type {
|
||||
Unknown,
|
||||
Number,
|
||||
} type = Unknown;
|
||||
std::variant<int, double> value;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
std::string str ("Literal: ");
|
||||
|
||||
switch (type) {
|
||||
default:
|
||||
case Unknown:
|
||||
str += "unknown";
|
||||
break;
|
||||
case Number:
|
||||
str += std::visit([](auto&& v) { return std::to_string(v); }, value);
|
||||
break;
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
};
|
||||
|
||||
struct ProcedureCall : public Node
|
||||
{
|
||||
Node *callee;
|
||||
std::vector<Node *> operands;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
std::string str ("ProcedureCall: ");
|
||||
|
||||
str = str + "<" + (callee ? callee->desc() : "unknown") + ">";
|
||||
str += '(';
|
||||
if (!operands.empty()) {
|
||||
for (const auto& op : operands) {
|
||||
str = str + "<" + (op ? op->desc() : "unknown") + ">";
|
||||
str += ", ";
|
||||
}
|
||||
|
||||
str.pop_back();
|
||||
str.pop_back();
|
||||
}
|
||||
str += ')';
|
||||
|
||||
return str;
|
||||
}
|
||||
};
|
||||
|
||||
struct LambdaExpression : public Node
|
||||
{
|
||||
std::vector<Identifier *> operands;
|
||||
std::vector<Node *> body;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
return "LambdaExpression";
|
||||
}
|
||||
};
|
||||
|
||||
struct Conditional : public Node
|
||||
{
|
||||
Node *cond;
|
||||
Node *iftrue;
|
||||
Node *iffalse;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
return "Conditional";
|
||||
}
|
||||
};
|
||||
|
||||
struct Definition : public Node
|
||||
{
|
||||
Identifier *ident;
|
||||
Node *value;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
return "Definition";
|
||||
}
|
||||
};
|
||||
|
||||
struct Assignment : public Node
|
||||
{
|
||||
Identifier *ident;
|
||||
Node *value;
|
||||
|
||||
virtual Value codegen(CompilerState&) final;
|
||||
|
||||
virtual std::string desc() final {
|
||||
return "Assignment";
|
||||
}
|
||||
};
|
||||
|
||||
struct DerivedExpression : public Node
|
||||
{
|
||||
std::string name;
|
||||
|
||||
virtual Value codegen(CompilerState&) final {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
virtual std::string desc() final {
|
||||
return "DerivedExpression";
|
||||
}
|
||||
};
|
||||
|
||||
// MacroUse
|
||||
// MacroBlock
|
||||
// Includer
|
||||
|
||||
}
|
||||
|
||||
#endif // AST_HPP
|
||||
|
||||
@ -0,0 +1,128 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file main.cpp
|
||||
* @brief Program entry point.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Current support:
|
||||
- Literals:
|
||||
- Integer
|
||||
- Double (when decimal point is found)
|
||||
- (define name value)
|
||||
- (set! defined-name new-value)
|
||||
- (lambda (...) ...)
|
||||
- (if cond then else)
|
||||
- Calling procedures:
|
||||
- Defined lambdas
|
||||
- Built-in things
|
||||
- Undefined procedures are prototyped
|
||||
|
||||
TODO:
|
||||
- Error reporting!
|
||||
- Documentation!
|
||||
- Arithmetic
|
||||
- String literals?
|
||||
- Typed definitions...
|
||||
- See R7RS-small for more...
|
||||
|
||||
*/
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/LegacyPassManager.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
#include "llvm/IR/Verifier.h"
|
||||
#include "llvm/MC/TargetRegistry.h"
|
||||
#include "llvm/Support/FileSystem.h"
|
||||
#include "llvm/Support/Host.h"
|
||||
#include "llvm/Support/TargetSelect.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Target/TargetMachine.h"
|
||||
#include "llvm/Target/TargetOptions.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
#include "ast.hpp"
|
||||
#include "parser.hpp"
|
||||
#include "state.hpp"
|
||||
|
||||
void compileToObjectFile(CompilerState&);
|
||||
int main(int argc, const char *argv[])
|
||||
{
|
||||
CompilerState state;
|
||||
Parser parser;
|
||||
|
||||
for (int i = 1; i < argc; ++i)
|
||||
parser.addString(argv[i]);
|
||||
|
||||
auto functype = llvm::FunctionType::get(llvm::Type::getInt32Ty(state.context), {}, false);
|
||||
auto func = llvm::Function::Create(functype, llvm::Function::ExternalLinkage, "main", &state.module);
|
||||
auto block = llvm::BasicBlock::Create(state.context, "entry", func);
|
||||
state.builder.SetInsertPoint(block);
|
||||
|
||||
parser.parse(state);
|
||||
|
||||
state.builder.CreateRet(state.builder.getInt32(0));
|
||||
|
||||
puts("");
|
||||
state.module.print(llvm::errs(), nullptr); // prints everything
|
||||
|
||||
compileToObjectFile(state);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void compileToObjectFile(CompilerState& state)
|
||||
{
|
||||
llvm::InitializeAllTargetInfos();
|
||||
llvm::InitializeAllTargets();
|
||||
llvm::InitializeAllTargetMCs();
|
||||
llvm::InitializeAllAsmParsers();
|
||||
llvm::InitializeAllAsmPrinters();
|
||||
|
||||
auto TargetTriple = "x86_64-pc-linux-gnu";
|
||||
|
||||
std::string error;
|
||||
auto Target = llvm::TargetRegistry::lookupTarget(TargetTriple, error);
|
||||
if (!error.empty())
|
||||
puts(error.c_str());
|
||||
|
||||
auto CPU = "generic";
|
||||
auto Features = "";
|
||||
llvm::TargetOptions opt;
|
||||
auto RM = llvm::Optional<llvm::Reloc::Model>();
|
||||
auto TargetMachine = Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);
|
||||
|
||||
std::error_code EC;
|
||||
llvm::raw_fd_ostream dest ("out.o", EC, llvm::sys::fs::OF_None);
|
||||
|
||||
llvm::legacy::PassManager pass;
|
||||
|
||||
if (TargetMachine->addPassesToEmitFile(pass, dest, nullptr, llvm::CGFT_ObjectFile)) {
|
||||
llvm::errs() << "TargetMachine can't emit a file of this type";
|
||||
} else {
|
||||
pass.run(state.module);
|
||||
dest.flush();
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,313 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file parser.cpp
|
||||
* @brief Source code parser to produce AST.
|
||||
*/
|
||||
|
||||
#include "parser.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
void Parser::addString(const std::string& str)
|
||||
{
|
||||
std::copy(str.cbegin(), str.cend(), std::back_inserter(text));
|
||||
}
|
||||
|
||||
void Parser::consumeWhitespace()
|
||||
{
|
||||
while (isspace(text.front()))
|
||||
text.pop_front();
|
||||
}
|
||||
|
||||
std::optional<std::string> Parser::consumeIdentifier()
|
||||
{
|
||||
std::string ret;
|
||||
|
||||
if (isalpha(text.front())) {
|
||||
do {
|
||||
ret += text.front();
|
||||
text.pop_front();
|
||||
} while (isalnum(text.front()) || text.front() == '!');
|
||||
}
|
||||
|
||||
if (ret.empty())
|
||||
return {};
|
||||
else
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::optional<std::variant<int, double>> Parser::consumeLiteralNumber()
|
||||
{
|
||||
std::string ret;
|
||||
|
||||
while (isdigit(text.front()) || text.front() == '.') {
|
||||
ret += text.front();
|
||||
text.pop_front();
|
||||
}
|
||||
|
||||
if (ret.empty())
|
||||
return {};
|
||||
else if (ret.find('.') == std::string::npos)
|
||||
return (int)strtol(ret.c_str(), nullptr, 0);
|
||||
else
|
||||
return strtod(ret.c_str(), nullptr);
|
||||
}
|
||||
|
||||
AST::Node *Parser::parse(CompilerState& state)
|
||||
{
|
||||
AST::Node *ret = nullptr;
|
||||
|
||||
while (!text.empty()) {
|
||||
consumeWhitespace();
|
||||
|
||||
// At the top-level, there will only be procedure calls.
|
||||
ret = parseProcedureCall();
|
||||
if (lastError != None)
|
||||
return nullptr;
|
||||
|
||||
|
||||
std::cout << (ret ? ret->desc() : "nullptr") << std::endl;
|
||||
|
||||
if (ret)
|
||||
ret->codegen(state);
|
||||
}
|
||||
|
||||
lastError = None;
|
||||
return ret;
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseExpression()
|
||||
{
|
||||
if (text.front() == '(') {
|
||||
return parseProcedureCall();
|
||||
} else if (auto id = consumeIdentifier(); id) {
|
||||
auto ident = new AST::Identifier;
|
||||
ident->name = *id;
|
||||
return ident;
|
||||
} else if (auto d = consumeLiteralNumber(); d) {
|
||||
auto lit = new AST::Literal;
|
||||
lit->type = AST::Literal::Number;
|
||||
lit->value = *d;
|
||||
return lit;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseProcedureCall()
|
||||
{
|
||||
// Consume the opening parenthesis.
|
||||
if (text.front() != '(') {
|
||||
lastError = ExpectedProcedure;
|
||||
return nullptr;
|
||||
} else {
|
||||
text.pop_front();
|
||||
}
|
||||
|
||||
// Consume the identifier string.
|
||||
auto ident = parseExpression();
|
||||
if (ident == nullptr) {
|
||||
lastError = InvalidOperator;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (auto id = dynamic_cast<AST::Identifier *>(ident); id) {
|
||||
if (id->name == "lambda")
|
||||
return parseLambdaExpression();
|
||||
else if (id->name == "define")
|
||||
return parseDefinition();
|
||||
else if (id->name == "if")
|
||||
return parseConditional();
|
||||
else if (id->name == "set!")
|
||||
return parseAssignment();
|
||||
}
|
||||
|
||||
std::vector<AST::Node *> args;
|
||||
|
||||
consumeWhitespace();
|
||||
while (text.front() != ')') {
|
||||
auto node = parseExpression();
|
||||
if (node == nullptr) {
|
||||
lastError = InvalidOperand;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
args.push_back(node);
|
||||
consumeWhitespace();
|
||||
}
|
||||
|
||||
if (text.front() == ')') {
|
||||
text.pop_front();
|
||||
|
||||
auto pc = new AST::ProcedureCall;
|
||||
pc->callee = ident;
|
||||
pc->operands = args;
|
||||
|
||||
return pc;
|
||||
} else {
|
||||
lastError = ExpectedProcedureCallClose;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseConditional()
|
||||
{
|
||||
consumeWhitespace();
|
||||
auto cond = parseExpression();
|
||||
if (cond == nullptr)
|
||||
return nullptr;
|
||||
|
||||
consumeWhitespace();
|
||||
auto ift = parseExpression();
|
||||
if (ift == nullptr)
|
||||
return nullptr;
|
||||
|
||||
consumeWhitespace();
|
||||
auto iff = parseExpression();
|
||||
if (iff == nullptr)
|
||||
return nullptr;
|
||||
|
||||
consumeWhitespace();
|
||||
if (text.front() == ')') {
|
||||
text.pop_front();
|
||||
|
||||
auto node = new AST::Conditional;
|
||||
node->cond = cond;
|
||||
node->iftrue = ift;
|
||||
node->iffalse = iff;
|
||||
return node;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseDefinition()
|
||||
{
|
||||
consumeWhitespace();
|
||||
auto ident = consumeIdentifier();
|
||||
|
||||
if (ident) {
|
||||
consumeWhitespace();
|
||||
|
||||
auto val = parseExpression();
|
||||
if (val) {
|
||||
consumeWhitespace();
|
||||
if (text.front() == ')') {
|
||||
text.pop_front();
|
||||
|
||||
auto id = new AST::Identifier;
|
||||
id->name = *ident;
|
||||
|
||||
auto def = new AST::Definition;
|
||||
def->ident = id;
|
||||
def->value = val;
|
||||
return def;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseAssignment()
|
||||
{
|
||||
consumeWhitespace();
|
||||
auto ident = consumeIdentifier();
|
||||
|
||||
if (ident) {
|
||||
consumeWhitespace();
|
||||
|
||||
auto val = parseExpression();
|
||||
if (val) {
|
||||
consumeWhitespace();
|
||||
if (text.front() == ')') {
|
||||
text.pop_front();
|
||||
|
||||
auto id = new AST::Identifier;
|
||||
id->name = *ident;
|
||||
|
||||
auto def = new AST::Assignment;
|
||||
def->ident = id;
|
||||
def->value = val;
|
||||
return def;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AST::Node *Parser::parseLambdaExpression()
|
||||
{
|
||||
// First get argument list
|
||||
consumeWhitespace();
|
||||
if (text.front() != '(') {
|
||||
lastError = ExpectedArgumentList;
|
||||
return nullptr;
|
||||
} else {
|
||||
text.pop_front();
|
||||
}
|
||||
|
||||
std::vector<AST::Identifier *> args;
|
||||
|
||||
while (text.front() != ')') {
|
||||
auto arg = consumeIdentifier();
|
||||
if (arg) {
|
||||
auto ident = new AST::Identifier;
|
||||
ident->name = *arg;
|
||||
args.push_back(ident);
|
||||
} else {
|
||||
lastError = InvalidOperand;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
consumeWhitespace();
|
||||
}
|
||||
text.pop_front(); // consume arg list ')'
|
||||
|
||||
std::vector<AST::Node *> body;
|
||||
|
||||
// Next, consume function body.
|
||||
consumeWhitespace();
|
||||
while (text.front() != ')') {
|
||||
auto exp = parseExpression();
|
||||
//if (exp == nullptr) // TODO commands/definitions are okay
|
||||
// return nullptr;
|
||||
|
||||
body.push_back(exp);
|
||||
consumeWhitespace();
|
||||
}
|
||||
|
||||
if (text.front() == ')') {
|
||||
text.pop_front();
|
||||
|
||||
auto le = new AST::LambdaExpression;
|
||||
le->operands = args;
|
||||
le->body = body;
|
||||
|
||||
return le;
|
||||
} else {
|
||||
lastError = ExpectedProcedureCallClose;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,67 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file parser.hpp
|
||||
* @brief Source code parser to produce AST.
|
||||
*/
|
||||
|
||||
#ifndef PARSER_HPP
|
||||
#define PARSER_HPP
|
||||
|
||||
#include "ast.hpp"
|
||||
#include "state.hpp"
|
||||
|
||||
#include <deque>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <variant>
|
||||
|
||||
class Parser {
|
||||
public:
|
||||
enum Error {
|
||||
None,
|
||||
ExpectedProcedure,
|
||||
ExpectedIdentifier,
|
||||
ExpectedProcedureCallClose,
|
||||
ExpectedArgumentList,
|
||||
UnknownIdentifier,
|
||||
InvalidOperator,
|
||||
InvalidOperand,
|
||||
};
|
||||
|
||||
void addString(const std::string& str);
|
||||
|
||||
void consumeWhitespace();
|
||||
std::optional<std::string> consumeIdentifier();
|
||||
std::optional<std::variant<int, double>> consumeLiteralNumber();
|
||||
|
||||
AST::Node *parse(CompilerState&);
|
||||
|
||||
private:
|
||||
std::deque<char> text;
|
||||
Error lastError = None;
|
||||
|
||||
AST::Node *parseExpression();
|
||||
AST::Node *parseProcedureCall();
|
||||
AST::Node *parseConditional();
|
||||
AST::Node *parseDefinition();
|
||||
AST::Node *parseAssignment();
|
||||
AST::Node *parseLambdaExpression();
|
||||
};
|
||||
|
||||
#endif // PARSER_HPP
|
||||
|
||||
@ -0,0 +1,50 @@
|
||||
/**
|
||||
* lisp-compiler: Compiles LISP using LLVM.
|
||||
* Copyright (C) 2022 Clyne Sullivan
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
* @file state.hpp
|
||||
* @brief Object to maintain compiler state during code compilation.
|
||||
*/
|
||||
|
||||
#ifndef STATE_HPP
|
||||
#define STATE_HPP
|
||||
|
||||
#include "ast.hpp"
|
||||
|
||||
#include "llvm/IR/IRBuilder.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
struct CompilerState
|
||||
{
|
||||
llvm::LLVMContext context;
|
||||
llvm::Module module;
|
||||
llvm::IRBuilder<> builder;
|
||||
std::map<std::string, AST::Value> namedValues;
|
||||
int scope;
|
||||
|
||||
CompilerState():
|
||||
context(),
|
||||
module("main", context),
|
||||
builder(context),
|
||||
scope(0) {}
|
||||
};
|
||||
|
||||
#endif // STATE_HPP
|
||||
|
||||
Loading…
Reference in New Issue