Some initial things

Author: heimskr

.gitignore

@@ -1,32 +1,7 @@
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
 *.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
+c--
+.vscode
+src/bison.output
+include/bison.h
+src/flex.cpp
+src/bison.cpp

Makefile

@@ -0,0 +1,47 @@
+COMPILER        ?= clang++
+OPTIMIZATION    ?= -O0 -g
+STANDARD        ?= c++20
+WARNINGS        ?= -Wall -Wextra
+CFLAGS          := -std=$(STANDARD) $(OPTIMIZATION) $(WARNINGS) -Iinclude
+OUTPUT          ?= c--
+
+LEXERCPP        := src/flex.cpp
+PARSERCPP       := src/bison.cpp
+PARSERHDR       := include/bison.h
+LEXERSRC        := src/lexer.l
+PARSERSRC       := src/parser.y
+FLEXPREFIX      := cmm
+
+LEXFLAGS        := -Wno-sign-compare -Wno-register
+BISONFLAGS      := --color=always
+
+SOURCES         := $(shell find src/**/*.cpp src/*.cpp) $(LEXERCPP) $(PARSERCPP)
+OBJECTS         := $(SOURCES:.cpp=.o)
+
+.PHONY: all test clean
+
+all: $(OUTPUT)
+
+$(OUTPUT): $(OBJECTS)
+	$(COMPILER) -o $@ $^ $(LDFLAGS)
+
+%.o: %.cpp $(PARSERHDR)
+	$(COMPILER) $(CFLAGS) -c $< -o $@
+
+$(LEXERCPP): $(LEXERSRC) $(PARSERHDR)
+	flex --prefix=$(FLEXPREFIX) --outfile=$(LEXERCPP) $(LEXERSRC)
+
+$(PARSERCPP) $(PARSERHDR): $(PARSERSRC)
+	bison $(BISONFLAGS) --defines=$(PARSERHDR) --output=$(PARSERCPP) $(PARSERSRC)
+
+counter:
+	bison -Wcounterexamples $(BISONFLAGS) --defines=$(PARSERHDR) --output=$(PARSERCPP) $(PARSERSRC)
+
+$(LEXERCPP:.cpp=.o): $(LEXERCPP)
+	$(COMPILER) $(CFLAGS) $(LEXFLAGS) -c $< -o $@
+
+$(PARSERCPP:.cpp=.o): $(PARSERCPP) $(PARSERHDR)
+	$(COMPILER) $(CFLAGS) $(LEXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(LEXERCPP) $(PARSERCPP) $(PARSERHDR) $(OBJECTS) $(OUTPUT) bison.output

include/ASTNode.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <initializer_list>
+#include <list>
+#include <ostream>
+#include <string>
+
+struct ASTLocation {
+	size_t line;
+	size_t column;
+
+	operator std::string() const;
+};
+
+std::ostream & operator<<(std::ostream &, const ASTLocation &);
+
+class Parser;
+
+class ASTNode {
+	private:
+		ASTNode() {}
+
+	public:
+		Parser *parser;
+		int symbol;
+		ASTLocation location;
+		const std::string *lexerInfo;
+		ASTNode *parent = nullptr;
+		std::list<ASTNode *> children;
+		int debugIndex = -1;
+
+		ASTNode(Parser &, int sym, const ASTLocation &loc, const char *info);
+		ASTNode(Parser &, int sym, const ASTLocation &loc, const std::string *info);
+		ASTNode(Parser &, int sym, const char *info);
+		ASTNode(Parser &, int sym, const std::string *info);
+		ASTNode(Parser &, int sym, const ASTLocation &loc);
+		ASTNode(Parser &, int sym);
+		/** Constructs an ASTNode that adopts another node and copies its location. */
+		ASTNode(Parser &, int sym, ASTNode *, const char *info = "");
+		ASTNode(Parser &, int sym, ASTNode *, const std::string *info);
+		virtual ~ASTNode();
+
+		ASTNode * operator[](size_t) const;
+		ASTNode * at(size_t) const;
+		size_t size() const;
+		bool empty() const;
+		ASTNode * adopt(ASTNode *, bool do_locate = false);
+		ASTNode * adopt(std::initializer_list<ASTNode *>);
+		ASTNode * absorb(ASTNode *);
+		ASTNode * clear();
+		ASTNode * copy() const;
+		/** Copies the location from another node. */
+		ASTNode * locate(const ASTNode *);
+		/** Copies the location from the first node in the list that isn't null. */
+		ASTNode * locate(std::initializer_list<const ASTNode *>);
+		ASTNode * locate(const ASTLocation &);
+		long atoi() const;
+		long atoi(int offset) const;
+		const char * getName() const;
+		void debug(int indent = 0, bool is_last = false, bool suppress_line = false) const;
+		virtual std::string debugExtra() const;
+		virtual std::string style() const;
+
+		static void destroy(std::initializer_list<ASTNode *>);
+
+		ASTNode * front() const;
+		ASTNode * back() const;
+		decltype(children)::iterator begin();
+		decltype(children)::iterator end();
+		decltype(children)::const_iterator begin() const;
+		decltype(children)::const_iterator end() const;
+		decltype(children)::const_iterator cbegin() const noexcept;
+		decltype(children)::const_iterator cend() const noexcept;
+};

include/Lexer.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+
+#include <stdio.h>
+
+#include "ASTNode.h"
+
+#define CMMSTYPE_IS_DECLARED
+typedef ASTNode * CMMSTYPE;
+
+#ifndef NO_YYPARSE
+#include "bison.h"
+#endif
+
+#ifdef __APPLE__
+typedef size_t yysize;
+#else
+typedef int yysize;
+#endif
+
+extern FILE *cmmin;
+extern char *cmmtext;
+extern yysize cmmleng;
+extern int cmm_flex_debug;
+extern int cmmdebug;
+
+class Parser;
+
+class Lexer {
+	private:
+		Parser *parser;
+		yysize *leng;
+		ASTNode **lval;
+
+	public:
+		ASTLocation location = {0, 1};
+		std::string line;
+		yysize lastYylength = 0;
+		std::unordered_map<int, std::string> lines;
+		bool failed = false;
+		std::vector<std::pair<std::string, ASTLocation>> errors;
+
+		Lexer(Parser &, yysize &, ASTNode *&);
+		const std::string * filename(int fileno);
+		void advance(const char *);
+		void newline();
+		void badchar(unsigned char);
+		int token(const char *, int symbol);
+};
+
+extern Lexer cmmLexer;
+
+int cmmlex();
+int cmmlex_destroy();
+int cmmparse();
+void cmmerror(const std::string &);
+void cmmerror(const std::string &, const ASTLocation &);

include/Parser.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdio>
+#include <string>
+
+#include "ASTNode.h"
+
+typedef struct yy_buffer_state * YY_BUFFER_STATE;
+
+class Parser {
+	private:
+		std::string filename;
+		char *buffer = nullptr;
+		YY_BUFFER_STATE bufferState = nullptr;
+
+	public:
+		ASTNode *root = nullptr;
+		int errorCount = 0;
+
+		Parser() = default;
+		void open(const std::string &filename);
+		void in(const std::string &text);
+		void debug(bool flex, bool bison);
+		void parse();
+		void done();
+
+		const char * getName(int symbol);
+		std::string getBuffer() const;
+};
+
+extern Parser cmmParser;

include/StringSet.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <unordered_set>
+
+struct StringSet {
+	StringSet();
+
+	static std::unordered_set<std::string> set;
+	static const std::string * intern(const char *);
+	static const std::string * intern(const std::string &);
+};

include/Util.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace Util {
+	std::vector<std::string> split(const std::string &str, const std::string &delimiter, bool condense = true);
+	long parseLong(const std::string &, int base = 10);
+	long parseLong(const std::string *, int base = 10);
+	long parseLong(const char *, int base = 10);
+}

src/Util.cpp

@@ -0,0 +1,47 @@
+#include <stdexcept>
+
+#include "Util.h"
+
+namespace Util {
+	std::vector<std::string> split(const std::string &str, const std::string &delimiter, bool condense) {
+		if (str.empty())
+			return {};
+
+		size_t next = str.find(delimiter);
+		if (next == std::string::npos)
+			return {str};
+
+		std::vector<std::string> out {};
+		const size_t delimiter_length = delimiter.size();
+		size_t last = 0;
+
+		out.push_back(str.substr(0, next));
+
+		while (next != std::string::npos) {
+			last = next;
+			next = str.find(delimiter, last + delimiter_length);
+			std::string sub = str.substr(last + delimiter_length, next - last - delimiter_length);
+			if (!sub.empty() || !condense)
+				out.push_back(std::move(sub));
+		}
+
+		return out;
+	}
+
+	long parseLong(const std::string &str, int base) {
+		const char *c_str = str.c_str();
+		char *end;
+		long parsed = strtol(c_str, &end, base);
+		if (c_str + str.length() != end)
+			throw std::invalid_argument("Not an integer: \"" + str + "\"");
+		return parsed;
+	}
+
+	long parseLong(const std::string *str, int base) {
+		return parseLong(*str, base);
+	}
+
+	long parseLong(const char *str, int base) {
+		return parseLong(std::string(str), base);
+	}
+}