From 4a61095e39eea66ed507c1fc09a9f1a9d06627c5 Mon Sep 17 00:00:00 2001
From: SimonFJ20 <simonfromjakobsen@gmail.com>
Date: Sat, 11 Feb 2023 19:55:26 +0100
Subject: [PATCH] init

---
 '                 |  36 +++++
 :w                | 187 ++++++++++++++++++++++++
 Makefile          |  19 +++
 compile_flags.txt |   6 +
 lexer.c           | 353 ++++++++++++++++++++++++++++++++++++++++++++++
 lexer.h           |  76 ++++++++++
 lexer.o           | Bin 0 -> 17072 bytes
 main.c            |   3 +
 main.o            | Bin 0 -> 1496 bytes
 wacc              | Bin 0 -> 20744 bytes
 10 files changed, 680 insertions(+)
 create mode 100644 '
 create mode 100644 :w
 create mode 100644 Makefile
 create mode 100644 compile_flags.txt
 create mode 100644 lexer.c
 create mode 100644 lexer.h
 create mode 100644 lexer.o
 create mode 100644 main.c
 create mode 100644 main.o
 create mode 100755 wacc

diff --git a/' b/'
new file mode 100644
index 0000000..2ee068e
--- /dev/null
+++ b/'
@@ -0,0 +1,36 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include <stddef.h>
+
+typedef enum {
+    Id,
+    Int,
+    Float,
+    String,
+
+    If,
+    Else,
+    While,
+    Break,
+
+    LParen,
+    RParen,
+    LBrace,
+    RBrace,
+
+    Plus,
+    Minus,
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    size_t index, length;
+    int line, column;
+} Token;
+
+typedef struct Lexer Lexer;
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length);
+
+#endif
diff --git a/:w b/:w
new file mode 100644
index 0000000..eb0d0d5
--- /dev/null
+++ b/:w
@@ -0,0 +1,187 @@
+#include "lexer.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Lexer {
+    const char* text;
+    size_t index, length;
+    int line, column;
+};
+
+Token lexer_skip_whitespace(Lexer* lexer);
+Token lexer_make_int(Lexer* lexer);
+Token lexer_make_id(Lexer* lexer);
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value);
+Token lexer_make_static(Lexer* lexer);
+Token make_single_char_token(Lexer* lexer, TokenType type);
+Token make_slash_token(Lexer* lexer);
+Token lexer_make_invalid_char(Lexer* lexer);
+Position lexer_position(const Lexer* lexer);
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin);
+bool lexer_done(const Lexer* lexer);
+char lexer_current(const Lexer* lexer);
+void lexer_step(Lexer* lexer);
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length)
+{
+    *lexer = (Lexer) {
+        .text = text,
+        .length = text_length,
+        .line = 1,
+        .column = 1,
+    };
+}
+
+Token lexer_next(Lexer* lexer)
+{
+    char c = lexer_current(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeEof, lexer_position(lexer));
+    else if (isspace(c))
+        return lexer_skip_whitespace(lexer);
+    else if (isdigit(c))
+        return lexer_make_int(lexer);
+    else if (isalpha(c) || c == '_')
+        return lexer_make_id(lexer);
+    else
+        return lexer_make_static(lexer);
+}
+
+Token lexer_skip_whitespace(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isspace(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_make_int(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInt, begin);
+}
+
+Token lexer_make_id(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer)
+        && (isalpha(lexer_current(lexer)) || isdigit(lexer_current(lexer))
+            || lexer_current(lexer) == '_'))
+        lexer_step(lexer);
+    if (lexer_span_matches(lexer, begin, "if"))
+        return lexer_token(lexer, TokenTypeIf, begin);
+    else if (lexer_span_matches(lexer, begin, "else"))
+        return lexer_token(lexer, TokenTypeElse, begin);
+    else if (lexer_span_matches(lexer, begin, "while"))
+        return lexer_token(lexer, TokenTypeWhile, begin);
+    else if (lexer_span_matches(lexer, begin, "break"))
+        return lexer_token(lexer, TokenTypeBreak, begin);
+    else
+        return lexer_token(lexer, TokenTypeId, begin);
+}
+
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value)
+{
+    size_t length = lexer->index - begin.index;
+    if (length != strlen(value))
+        return false;
+    return strncmp(&lexer->text[begin.index], value, length) == 0;
+}
+
+Token lexer_make_static(Lexer* lexer)
+{
+    switch (lexer_current(lexer)) {
+        case '(':
+            return make_single_char_token(lexer, TokenTypeLParen);
+        case ')':
+            return make_single_char_token(lexer, TokenTypeRParen);
+        case '{':
+            return make_single_char_token(lexer, TokenTypeLBrace);
+        case '}':
+            return make_single_char_token(lexer, TokenTypeRBrace);
+        case ';':
+            return make_single_char_token(lexer, TokenTypeSemicolon);
+        case '+':
+            return make_single_char_token(lexer, TokenTypePlus);
+        case '-':
+            return make_single_char_token(lexer, TokenTypeMinus);
+        case '*':
+            return make_single_char_token(lexer, TokenTypeAsterisk);
+        case '/':
+            return make_slash_token(lexer);
+        case '%':
+            return make_single_char_token(lexer, TokenTypePercent);
+        default:
+            return lexer_make_invalid_char(lexer);
+    }
+}
+
+Token make_single_char_token(Lexer* lexer, TokenType type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, type, begin);
+}
+
+Token skip_singleline_comment(Lexer* lexer);
+Token skip_multiline_comment(Lexer* lexer);
+
+Token make_slash_token(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    switch (lexer_current(lexer)) {
+        case '/':
+            return skip_singleline_comment(lexer);
+        default:
+            return lexer_token(lexer, TokenTypeSlash, begin);
+    }
+}
+
+Token lexer_make_invalid_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInvalidChar, begin);
+}
+
+Position lexer_position(const Lexer* lexer)
+{
+    return (Position) {
+        .index = lexer->index,
+        .line = lexer->line,
+        .column = lexer->column,
+    };
+}
+
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin)
+{
+    return (Token) {
+        .type = type,
+        .position = begin,
+        .length = lexer->index - begin.index,
+    };
+}
+
+bool lexer_done(const Lexer* lexer) { return lexer->index >= lexer->length; }
+
+char lexer_current(const Lexer* lexer) { return lexer->text[lexer->index]; }
+
+void lexer_step(Lexer* lexer)
+{
+    if (lexer_done(lexer))
+        return;
+    if (lexer_current(lexer) == '\n') {
+        lexer->line += 1;
+        lexer->column = 1;
+    } else {
+        lexer->column += 1;
+    }
+    lexer->index += 1;
+}
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ac5288e
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,19 @@
+
+CFLAGS = -std=c17 -Wall -Wextra -Wpedantic -Wconversion
+
+HEADERS = $(wildcard *.h)
+
+all: compile_flags.txt wacc
+
+wacc: main.o lexer.o
+	gcc $^ -o $@
+
+%.o: %.c $(HEADERS)
+	gcc $< -c -o $@ $(CFLAGS)
+
+clean:
+	rm -rf *.o wacc
+
+compile_flags.txt:
+	echo -xc $(CFLAGS) | sed 's/\s\+/\n/g' > compile_flags.txt
+
diff --git a/compile_flags.txt b/compile_flags.txt
new file mode 100644
index 0000000..083ed44
--- /dev/null
+++ b/compile_flags.txt
@@ -0,0 +1,6 @@
+-xc
+-std=c17
+-Wall
+-Wextra
+-Wpedantic
+-Wconversion
diff --git a/lexer.c b/lexer.c
new file mode 100644
index 0000000..297c410
--- /dev/null
+++ b/lexer.c
@@ -0,0 +1,353 @@
+#include "lexer.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Lexer {
+    const char* text;
+    size_t index, length;
+    int line, column;
+};
+
+Token lexer_skip_whitespace(Lexer* lexer);
+Token lexer_make_int_or_float(Lexer* lexer);
+Token lexer_make_id(Lexer* lexer);
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value);
+Token lexer_make_static_token(Lexer* lexer);
+Token lexer_make_int_hex_or_binary(Lexer* lexer);
+Token lexer_make_char(Lexer* lexer);
+Token lexer_make_string(Lexer* lexer);
+void lexer_skip_literal_char(Lexer* lexer);
+Token lexer_make_single_char_token(Lexer* lexer, TokenType type);
+Token lexer_make_slash_token(Lexer* lexer);
+Token lexer_skip_singleline_comment(Lexer* lexer);
+Token lexer_make_single_or_double_char_token(
+    Lexer* lexer, TokenType single_type, char second_char, TokenType double_type);
+Token lexer_skip_multiline_comment(Lexer* lexer);
+Token lexer_make_invalid_char(Lexer* lexer);
+Position lexer_position(const Lexer* lexer);
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin);
+bool lexer_done(const Lexer* lexer);
+char lexer_current(const Lexer* lexer);
+void lexer_step(Lexer* lexer);
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length)
+{
+    *lexer = (Lexer) {
+        .text = text,
+        .length = text_length,
+        .line = 1,
+        .column = 1,
+    };
+}
+
+Token lexer_next(Lexer* lexer)
+{
+    char c = lexer_current(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeEof, lexer_position(lexer));
+    else if (isspace(c))
+        return lexer_skip_whitespace(lexer);
+    else if (c >= '1' && c <= '9')
+        return lexer_make_int_or_float(lexer);
+    else if (isalpha(c) || c == '_')
+        return lexer_make_id(lexer);
+    else
+        return lexer_make_static_token(lexer);
+}
+
+Token lexer_skip_whitespace(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isspace(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_make_int_or_float(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+        lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == '.') {
+        while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeFloat, begin);
+    } else {
+        return lexer_token(lexer, TokenTypeInt, begin);
+    }
+}
+
+Token lexer_make_id(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer)
+        && (isalpha(lexer_current(lexer)) || isdigit(lexer_current(lexer))
+            || lexer_current(lexer) == '_'))
+        lexer_step(lexer);
+    if (lexer_span_matches(lexer, begin, "if"))
+        return lexer_token(lexer, TokenTypeIf, begin);
+    else if (lexer_span_matches(lexer, begin, "else"))
+        return lexer_token(lexer, TokenTypeElse, begin);
+    else if (lexer_span_matches(lexer, begin, "while"))
+        return lexer_token(lexer, TokenTypeWhile, begin);
+    else if (lexer_span_matches(lexer, begin, "break"))
+        return lexer_token(lexer, TokenTypeBreak, begin);
+    else
+        return lexer_token(lexer, TokenTypeId, begin);
+}
+
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value)
+{
+    size_t length = lexer->index - begin.index;
+    if (length != strlen(value))
+        return false;
+    return strncmp(&lexer->text[begin.index], value, length) == 0;
+}
+
+Token lexer_make_static_token(Lexer* lexer)
+{
+    switch (lexer_current(lexer)) {
+        case '0':
+            return lexer_make_int_hex_or_binary(lexer);
+        case '\'':
+            return lexer_make_char(lexer);
+        case '"':
+            return lexer_make_string(lexer);
+        case '(':
+            return lexer_make_single_char_token(lexer, TokenTypeLParen);
+        case ')':
+            return lexer_make_single_char_token(lexer, TokenTypeRParen);
+        case '{':
+            return lexer_make_single_char_token(lexer, TokenTypeLBrace);
+        case '}':
+            return lexer_make_single_char_token(lexer, TokenTypeRBrace);
+        case '[':
+            return lexer_make_single_char_token(lexer, TokenTypeLBracket);
+        case ']':
+            return lexer_make_single_char_token(lexer, TokenTypeRBracket);
+        case '.':
+            return lexer_make_single_char_token(lexer, TokenTypeDot);
+        case ',':
+            return lexer_make_single_char_token(lexer, TokenTypeComma);
+        case ':':
+            return lexer_make_single_char_token(lexer, TokenTypeColon);
+        case ';':
+            return lexer_make_single_char_token(lexer, TokenTypeSemicolon);
+        case '+':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypePlus, '=', TokenTypePlusEqual);
+        case '-':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeMinus, '=', TokenTypeMinusEqual);
+        case '*':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeAsterisk, '=', TokenTypeAsteriskEqual);
+        case '/':
+            return lexer_make_slash_token(lexer);
+        case '%':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypePercent, '=', TokenTypePercentEqual);
+        case '=':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeEqual, '=', TokenTypeDoubleEqual);
+        case '!':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeExclamation, '=', TokenTypeExclamationEqual);
+        case '<':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeLt, '=', TokenTypeLtEqual);
+        case '>':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeGt, '=', TokenTypeGtEqual);
+        default:
+            return lexer_make_invalid_char(lexer);
+    }
+}
+
+Token lexer_make_int_hex_or_binary(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (!lexer_done(lexer) && (lexer_current(lexer) == 'x' || lexer_current(lexer) == 'X')) {
+        while (!lexer_done(lexer)
+            && (isdigit(lexer_current(lexer))
+                || (lexer_current(lexer) >= 'a' || lexer_current(lexer) <= 'f')
+                || (lexer_current(lexer) >= 'A' || lexer_current(lexer) <= 'F')))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeHex, begin);
+    } else if (!lexer_done(lexer) && (lexer_current(lexer) == 'b' || lexer_current(lexer) == 'B')) {
+        while (!lexer_done(lexer) && (lexer_current(lexer) == '0' || lexer_current(lexer) == '1'))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeBinary, begin);
+    } else {
+        return lexer_token(lexer, TokenTypeInt, begin);
+    }
+}
+
+Token lexer_make_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeMalformedChar, begin);
+    lexer_skip_literal_char(lexer);
+    if (lexer_done(lexer) && lexer_current(lexer) != '\'')
+        return lexer_token(lexer, TokenTypeMalformedChar, begin);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeChar, begin);
+}
+
+Token lexer_make_string(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeMalformedString, begin);
+    while (!lexer_done(lexer) && lexer_current(lexer) != '\"')
+        lexer_skip_literal_char(lexer);
+    if (lexer_done(lexer) && lexer_current(lexer) != '\"')
+        return lexer_token(lexer, TokenTypeMalformedString, begin);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeChar, begin);
+}
+
+void lexer_skip_literal_char(Lexer* lexer)
+{
+    if (lexer_current(lexer) == '\\') {
+        lexer_step(lexer);
+        if (!lexer_done(lexer) && lexer_current(lexer) == '0') {
+            lexer_step(lexer);
+        } else if (!lexer_done(lexer) && lexer_current(lexer) >= '1'
+            && lexer_current(lexer) <= '9') {
+            lexer_step(lexer);
+            while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+                lexer_step(lexer);
+        } else if (!lexer_done(lexer)
+            && (lexer_current(lexer) == 'x' || lexer_current(lexer) == 'X')) {
+            lexer_step(lexer);
+            while (!lexer_done(lexer)
+                && (isdigit(lexer_current(lexer))
+                    || (lexer_current(lexer) >= 'a' && lexer_current(lexer) <= 'f')
+                    || (lexer_current(lexer) >= 'A' && lexer_current(lexer) <= 'F')))
+                lexer_step(lexer);
+        } else if (!lexer_done(lexer)) {
+            lexer_step(lexer);
+        }
+    } else {
+        lexer_step(lexer);
+    }
+}
+
+Token lexer_make_single_char_token(Lexer* lexer, TokenType type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, type, begin);
+}
+
+Token lexer_make_single_or_double_char_token(
+    Lexer* lexer, TokenType single_type, char second_char, TokenType double_type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == second_char) {
+        lexer_step(lexer);
+        return lexer_token(lexer, single_type, begin);
+    } else {
+        return lexer_token(lexer, double_type, begin);
+    }
+}
+
+Token lexer_make_slash_token(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    switch (lexer_current(lexer)) {
+        case '/':
+            return lexer_skip_singleline_comment(lexer);
+        case '*':
+            return lexer_skip_multiline_comment(lexer);
+        case '=':
+            lexer_step(lexer);
+            return lexer_token(lexer, TokenTypeSlashEqual, begin);
+        default:
+            return lexer_token(lexer, TokenTypeSlash, begin);
+    }
+}
+
+Token lexer_skip_singleline_comment(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && lexer_current(lexer) != '\n')
+        lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == '\n')
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_skip_multiline_comment(Lexer* lexer)
+{
+    lexer_step(lexer);
+    int depth = 1;
+    while (!lexer_done(lexer)) {
+        if (lexer_current(lexer) == '/') {
+            lexer_step(lexer);
+            if (!lexer_done(lexer) && lexer_current(lexer) == '*')
+                depth += 1;
+        } else if (lexer_current(lexer) == '*') {
+            lexer_step(lexer);
+            if (lexer_done(lexer) && lexer_current(lexer) == '/')
+                depth -= 1;
+        }
+        lexer_step(lexer);
+    }
+    return depth != 0
+        ? lexer_token(lexer, TokenTypeMalformedMultilineComment, lexer_position(lexer))
+        : lexer_next(lexer);
+}
+
+Token lexer_make_invalid_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInvalidChar, begin);
+}
+
+Position lexer_position(const Lexer* lexer)
+{
+    return (Position) {
+        .index = lexer->index,
+        .line = lexer->line,
+        .column = lexer->column,
+    };
+}
+
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin)
+{
+    return (Token) {
+        .type = type,
+        .position = begin,
+        .length = lexer->index - begin.index,
+    };
+}
+
+bool lexer_done(const Lexer* lexer) { return lexer->index >= lexer->length; }
+
+char lexer_current(const Lexer* lexer) { return lexer->text[lexer->index]; }
+
+void lexer_step(Lexer* lexer)
+{
+    if (lexer_done(lexer))
+        return;
+    if (lexer_current(lexer) == '\n') {
+        lexer->line += 1;
+        lexer->column = 1;
+    } else {
+        lexer->column += 1;
+    }
+    lexer->index += 1;
+}
diff --git a/lexer.h b/lexer.h
new file mode 100644
index 0000000..1efce31
--- /dev/null
+++ b/lexer.h
@@ -0,0 +1,76 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include <stddef.h>
+
+typedef enum {
+    TokenTypeEof,
+
+    TokenTypeInvalidChar,
+    TokenTypeMalformedMultilineComment,
+    TokenTypeMalformedChar,
+    TokenTypeMalformedString,
+
+    TokenTypeId,
+    TokenTypeInt,
+    TokenTypeHex,
+    TokenTypeBinary,
+    TokenTypeFloat,
+    TokenTypeChar,
+    TokenTypeString,
+
+    TokenTypeIf,
+    TokenTypeElse,
+    TokenTypeWhile,
+    TokenTypeBreak,
+
+    TokenTypeLParen,
+    TokenTypeRParen,
+    TokenTypeLBrace,
+    TokenTypeRBrace,
+    TokenTypeLBracket,
+    TokenTypeRBracket,
+    TokenTypeDot,
+    TokenTypeComma,
+    TokenTypeColon,
+    TokenTypeSemicolon,
+
+    TokenTypePlusEqual,
+    TokenTypeMinusEqual,
+    TokenTypeAsteriskEqual,
+    TokenTypeSlashEqual,
+    TokenTypePercentEqual,
+    TokenTypeDoubleEqual,
+    TokenTypeExclamationEqual,
+    TokenTypeLtEqual,
+    TokenTypeGtEqual,
+
+    TokenTypePlus,
+    TokenTypeMinus,
+    TokenTypeAsterisk,
+    TokenTypeSlash,
+    TokenTypePercent,
+    TokenTypeEqual,
+    TokenTypeExclamation,
+    TokenTypeLt,
+    TokenTypeGt,
+
+} TokenType;
+
+typedef struct {
+    size_t index;
+    int line, column;
+} Position;
+
+typedef struct {
+    TokenType type;
+    Position position;
+    size_t length;
+} Token;
+
+typedef struct Lexer Lexer;
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length);
+Token lexer_next(Lexer* lexer);
+
+#endif
diff --git a/lexer.o b/lexer.o
new file mode 100644
index 0000000000000000000000000000000000000000..e794c7304e590dd54d4f8a3bcaab12d4d2e651f8
GIT binary patch
literal 17072
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
A`2YX_

literal 0
HcmV?d00001

diff --git a/main.c b/main.c
new file mode 100644
index 0000000..50c765e
--- /dev/null
+++ b/main.c
@@ -0,0 +1,3 @@
+#include <stdio.h>
+
+int main(void) { printf("hello world\n"); }
diff --git a/main.o b/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..09c8eea649fb1e473545a06625decf9d9916c024
GIT binary patch
literal 1496
zcmbtU&ubG=5S~qHtJu_7Jc#wMCsEKxvR>4KM1wX5@lXheAhJ!jM$Kl!?kl!l6c1t#
zLXZ9_9t98jXLu>}sCS{xmz`-}9_vL1-kX_kerD!v-rRd|zZL|f6wqxt))XarR6CYC
zQ?Wx!)S!NEcfa@X1d!hDw*&CcxSo6+CZkanzRL2^2GMG_dn>%W`mlc`Y)2+C?J#OZ
z*IQAm4QHk~J|Q1uVmGQ$@CBGsAiDN;P7J~8H43(y!OG&o$vrk+WE=-{0oR?S=KET=
zG2dqg=zk&PougleRpxr-M2PCsZf7G<W7+Ya_P|(!Pjl9_)YAC**bE4aCR?@;p9SF<
zd!5hk!;;Pjj@e*Viid*3-&qxrDRxpDuQRuK$%iWC$tX59*|uahVjGiLFA6ewRw{!m
zO_MR(#+gkF@8nux<H1YOpN+T7B+n*EZg)5anUdkt%{)#M>E!=d$l=(@yqBgUy3SS2
z`Yu#oVF5GhC?NckIJQJT%^Z-vjq`$E5*)L4>9MOgvS0ry+mQ2L<MCY}=gcly*ZPYr
zyX4ou$wpxMJJokn1pP)7*LdZ3*`TuefWLDUNA`W!*oHUk_y0j+{JwPln(_q;$mz#V
z|6CZqp^n1+c)Y@@{ePE6b<f!UDLxvncvWqb`iYBauVjQhppGApoc`_+@>c3ELvcvp
TBjhYgRq;Q>(H?o0f*=0}`D|ws

literal 0
HcmV?d00001

diff --git a/wacc b/wacc
new file mode 100755
index 0000000000000000000000000000000000000000..8ad967f06e9a5dfc69e2b81b0f8a59ac7396d271
GIT binary patch
literal 20744
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
X+%C(~cElwjSsM){G0vsnLdAarVN?(d

literal 0
HcmV?d00001