...

compiler/Compiler/.gitignore

@@ -0,0 +1 @@
+out.c

compiler/Compiler/Generator.cs

@@ -65,6 +65,18 @@ public sealed class Generator(List<NodeDefinition> nodes)
             case NodeStatementReturn statement:
                 EmitStatementReturn(statement);
                 break;
+            case NodeStatementVariableDeclaration statement:
+                EmitStatementVariableDeclaration(statement);
+                break;
+            case NodeStatementAssignment statement:
+                EmitStatementAssignment(statement);
+                break;
+            case NodeStatementIf statement:
+                EmitStatementIf(statement);
+                break;
+            case NodeStatementWhile statement:
+                EmitStatementWhile(statement);
+                break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(node), node, null);
         }
@@ -84,7 +96,7 @@ public sealed class Generator(List<NodeDefinition> nodes)
 
     private void EmitStatementFuncCall(NodeStatementFuncCall node)
     {
-        var name = EmitExpression(node.Func);
+        var name = EmitExpression(node.Target);
         var parameterValues = node.Parameters.Select(EmitExpression).ToList();
         writer.WriteLine($"{name}({string.Join(", ", parameterValues)});");
     }
@@ -95,10 +107,67 @@ public sealed class Generator(List<NodeDefinition> nodes)
         writer.WriteLine($"return {value};");
     }
 
+    private void EmitStatementVariableDeclaration(NodeStatementVariableDeclaration statement)
+    {
+        var value = EmitExpression(statement.Value);
+        writer.WriteLine($"{CType(statement.Type)} {statement.Name.Ident} = {value};");
+    }
+
+    private void EmitStatementAssignment(NodeStatementAssignment statement)
+    {
+        var target = EmitExpression(statement.Target);
+        var value = EmitExpression(statement.Value);
+        writer.WriteLine($"{target} = {value};");
+    }
+
+    private void EmitStatementIf(NodeStatementIf statement)
+    {
+        var condition = EmitExpression(statement.Condition);
+        writer.WriteLine($"if ({condition})");
+        writer.WriteLine("{");
+        using (writer.Indent())
+        {
+            EmitStatement(statement.ThenBlock);
+        }
+
+        writer.WriteLine("}");
+
+        if (statement.ElseBlock != null)
+        {
+            writer.Write("else");
+            if (statement.ElseBlock is NodeStatementIf)
+                writer.Write(" ");
+            else
+                writer.WriteLine();
+
+            writer.WriteLine("{");
+            using (writer.Indent())
+            {
+                EmitStatement(statement.ElseBlock);
+            }
+
+            writer.WriteLine("}");
+        }
+    }
+
+    private void EmitStatementWhile(NodeStatementWhile statement)
+    {
+        var condition = EmitExpression(statement.Condition);
+        writer.WriteLine($"while ({condition})");
+        writer.WriteLine("{");
+        using (writer.Indent())
+        {
+            EmitStatement(statement.Block);
+        }
+
+        writer.WriteLine("}");
+    }
+
     private string EmitExpression(NodeExpression node)
     {
         return node switch
         {
+            NodeExpressionBinary expression => EmitExpressionBinary(expression),
             NodeExpressionBoolLiteral expression => expression.Value.Value ? "true" : "false",
             NodeExpressionIntLiteral expression => expression.Value.Value.ToString(),
             NodeExpressionStringLiteral expression => $"(struct string){{ \"{expression.Value.Value}\", {expression.Value.Value.Length} }}",
@@ -107,6 +176,32 @@ public sealed class Generator(List<NodeDefinition> nodes)
         };
     }
 
+    private string EmitExpressionBinary(NodeExpressionBinary expression)
+    {
+        var left = EmitExpression(expression.Left);
+        var right = EmitExpression(expression.Right);
+
+        return expression.Operation switch
+        {
+            NodeExpressionBinary.Op.Add => $"({left} + {right})",
+            NodeExpressionBinary.Op.Subtract => $"({left} - {right})",
+            NodeExpressionBinary.Op.Multiply => $"({left} * {right})",
+            NodeExpressionBinary.Op.Divide => $"({left} / {right})",
+            NodeExpressionBinary.Op.Modulo => $"({left} % {right})",
+            NodeExpressionBinary.Op.Equal => $"({left} == {right})",
+            NodeExpressionBinary.Op.NotEqual => $"({left} != {right})",
+            NodeExpressionBinary.Op.LessThan => $"({left} < {right})",
+            NodeExpressionBinary.Op.LessThanOrEqual => $"({left} <= {right})",
+            NodeExpressionBinary.Op.GreaterThan => $"({left} > {right})",
+            NodeExpressionBinary.Op.GreaterThanOrEqual => $"({left} >= {right})",
+            NodeExpressionBinary.Op.LeftShift => $"({left} << {right})",
+            NodeExpressionBinary.Op.RightShift => $"({left} >> {right})",
+            NodeExpressionBinary.Op.LogicalAnd => $"({left} && {right})",
+            NodeExpressionBinary.Op.LogicalOr => $"({left} || {right})",
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
     private static string CType(NodeType node, string? varName = null)
     {
         return node switch

compiler/Compiler/Parser.cs

@@ -70,20 +70,115 @@ public sealed class Parser(List<Token> tokens)
             return new NodeStatementReturn(TokensFrom(startIndex), value);
         }
 
-        var expression = ParseExpression();
+        if (TryExpectKeyword(Keyword.Let))
+        {
+            var name = ExpectIdent();
+            ExpectSymbol(Symbol.Colon);
+            var type = ParseType();
+            ExpectSymbol(Symbol.Equal);
+            var value = ParseExpression();
+            return new NodeStatementVariableDeclaration(TokensFrom(startIndex), name, type, value);
+        }
+
+        if (TryExpectKeyword(Keyword.If))
+        {
+            var condition = ParseExpression();
+            var thenBlock = ParseStatement();
+            NodeStatement? elseBlock = null;
+
+            if (TryExpectKeyword(Keyword.Else))
+                elseBlock = ParseStatement();
+
+            return new NodeStatementIf(TokensFrom(startIndex), condition, thenBlock, elseBlock);
+        }
+
+        if (TryExpectKeyword(Keyword.While))
+        {
+            var condition = ParseExpression();
+            var thenBlock = ParseStatement();
+            return new NodeStatementWhile(TokensFrom(startIndex), condition, thenBlock);
+        }
+
+        var target = ParseExpression();
+
+        if (TryExpectSymbol(Symbol.OpenParen))
+        {
             var parameters = new List<NodeExpression>();
 
-        ExpectSymbol(Symbol.OpenParen);
             while (!TryExpectSymbol(Symbol.CloseParen))
                 parameters.Add(ParseExpression());
 
-        return new NodeStatementFuncCall(TokensFrom(startIndex), expression, parameters);
+            return new NodeStatementFuncCall(TokensFrom(startIndex), target, parameters);
         }
 
-    private NodeExpression ParseExpression()
+        if (TryExpectSymbol(Symbol.Equal))
+        {
+            var value = ParseExpression();
+            return new NodeStatementAssignment(TokensFrom(startIndex), target, value);
+        }
+
+        throw new Exception("Not a valid followup for expression statement");
+    }
+
+    private NodeExpression ParseExpression(int minPrecedence = -1)
     {
         var startIndex = index;
 
+        var left = ParseExpressionLeaf();
+
+        while (TryPeekBinaryOperator(out var op) && GetPrecedence(op) >= minPrecedence)
+        {
+            Consume();
+            var right = ParseExpression(GetPrecedence(op) + 1);
+            left = new NodeExpressionBinary(TokensFrom(startIndex), left, op, right);
+        }
+
+        return left;
+    }
+
+    private static int GetPrecedence(NodeExpressionBinary.Op operation)
+    {
+        return operation switch
+        {
+            NodeExpressionBinary.Op.Multiply => 10,
+            NodeExpressionBinary.Op.Divide => 10,
+            NodeExpressionBinary.Op.Modulo => 10,
+
+            NodeExpressionBinary.Op.Add => 9,
+            NodeExpressionBinary.Op.Subtract => 9,
+
+            NodeExpressionBinary.Op.LeftShift => 8,
+            NodeExpressionBinary.Op.RightShift => 8,
+
+            NodeExpressionBinary.Op.GreaterThan => 7,
+            NodeExpressionBinary.Op.GreaterThanOrEqual => 7,
+            NodeExpressionBinary.Op.LessThan => 7,
+            NodeExpressionBinary.Op.LessThanOrEqual => 7,
+
+            NodeExpressionBinary.Op.Equal => 7,
+            NodeExpressionBinary.Op.NotEqual => 7,
+
+            // NodeExpressionBinary.Op.BitwiseAnd => 6,
+            // NodeExpressionBinary.Op.BitwiseXor => 5,
+            // NodeExpressionBinary.Op.BitwiseOr => 4,
+
+            NodeExpressionBinary.Op.LogicalAnd => 3,
+            NodeExpressionBinary.Op.LogicalOr => 2,
+            _ => throw new ArgumentOutOfRangeException(nameof(operation), operation, null)
+        };
+    }
+
+    private NodeExpression ParseExpressionLeaf()
+    {
+        var startIndex = index;
+
+        if (TryExpectSymbol(Symbol.OpenParen))
+        {
+            var value = ParseExpression();
+            ExpectSymbol(Symbol.CloseParen);
+            return value;
+        }
+
         if (TryExpectIntLiteral(out var intLiteral))
         {
             return new NodeExpressionIntLiteral(TokensFrom(startIndex), intLiteral);
@@ -104,7 +199,7 @@ public sealed class Parser(List<Token> tokens)
             return new NodeExpressionIdent(TokensFrom(startIndex), ident);
         }
 
-        throw new Exception("Not a valid expression");
+        throw new Exception("Not a valid expression leaf");
     }
 
     private NodeType ParseType()
@@ -283,11 +378,72 @@ public sealed class Parser(List<Token> tokens)
 
         return tokens[index + offset];
     }
+
+    private bool TryPeekBinaryOperator(out NodeExpressionBinary.Op op)
+    {
+        if (Peek() is not TokenSymbol token)
+        {
+            op = default;
+            return false;
+        }
+
+        switch (token.Symbol)
+        {
+            case Symbol.Plus:
+                op = NodeExpressionBinary.Op.Add;
+                return true;
+            case Symbol.Minus:
+                op = NodeExpressionBinary.Op.Subtract;
+                return true;
+            case Symbol.Star:
+                op = NodeExpressionBinary.Op.Multiply;
+                return true;
+            case Symbol.ForwardSlash:
+                op = NodeExpressionBinary.Op.Divide;
+                return true;
+            case Symbol.Percent:
+                op = NodeExpressionBinary.Op.Modulo;
+                return true;
+            case Symbol.BangEqual:
+                op = NodeExpressionBinary.Op.NotEqual;
+                return true;
+            case Symbol.EqualEqual:
+                op = NodeExpressionBinary.Op.Equal;
+                return true;
+            case Symbol.LessThan:
+                op = NodeExpressionBinary.Op.LessThan;
+                return true;
+            case Symbol.LessThanEqual:
+                op = NodeExpressionBinary.Op.LessThanOrEqual;
+                return true;
+            case Symbol.GreaterThan:
+                op = NodeExpressionBinary.Op.GreaterThan;
+                return true;
+            case Symbol.GreaterThanEqual:
+                op = NodeExpressionBinary.Op.GreaterThanOrEqual;
+                return true;
+            case Symbol.LessThanLessThan:
+                op = NodeExpressionBinary.Op.LeftShift;
+                return true;
+            case Symbol.GreaterThanGreaterThan:
+                op = NodeExpressionBinary.Op.RightShift;
+                return true;
+            case Symbol.AmpersandAmpersand:
+                op = NodeExpressionBinary.Op.LogicalAnd;
+                return true;
+            case Symbol.PipePipe:
+                op = NodeExpressionBinary.Op.LogicalOr;
+                return true;
+            default:
+                op = default;
+                return false;
+        }
+    }
 }
 
 public abstract class Node(List<Token> tokens)
 {
-    public List<Token> Tokens = tokens;
+    public readonly List<Token> Tokens = tokens;
 }
 
 public abstract class NodeDefinition(List<Token> tokens) : Node(tokens);
@@ -313,17 +469,43 @@ public sealed class NodeStatementBlock(List<Token> tokens, List<NodeStatement> s
     public readonly List<NodeStatement> Statements = statements;
 }
 
-public sealed class NodeStatementFuncCall(List<Token> tokens, NodeExpression func, List<NodeExpression> parameters) : NodeStatement(tokens)
+public sealed class NodeStatementFuncCall(List<Token> tokens, NodeExpression target, List<NodeExpression> parameters) : NodeStatement(tokens)
 {
-    public readonly NodeExpression Func = func;
+    public readonly NodeExpression Target = target;
     public readonly List<NodeExpression> Parameters = parameters;
 }
 
-internal class NodeStatementReturn(List<Token> tokens, NodeExpression value) : NodeStatement(tokens)
+public class NodeStatementReturn(List<Token> tokens, NodeExpression value) : NodeStatement(tokens)
 {
     public readonly NodeExpression Value = value;
 }
 
+public class NodeStatementVariableDeclaration(List<Token> tokens, TokenIdent name, NodeType type, NodeExpression value) : NodeStatement(tokens)
+{
+    public readonly TokenIdent Name = name;
+    public readonly NodeType Type = type;
+    public readonly NodeExpression Value = value;
+}
+
+public class NodeStatementAssignment(List<Token> tokens, NodeExpression target, NodeExpression value) : NodeStatement(tokens)
+{
+    public readonly NodeExpression Target = target;
+    public readonly NodeExpression Value = value;
+}
+
+public class NodeStatementIf(List<Token> tokens, NodeExpression condition, NodeStatement thenBlock, NodeStatement? elseBlock) : NodeStatement(tokens)
+{
+    public readonly NodeExpression Condition = condition;
+    public readonly NodeStatement ThenBlock = thenBlock;
+    public readonly NodeStatement? ElseBlock = elseBlock;
+}
+
+public class NodeStatementWhile(List<Token> tokens, NodeExpression condition, NodeStatement block) : NodeStatement(tokens)
+{
+    public readonly NodeExpression Condition = condition;
+    public readonly NodeStatement Block = block;
+}
+
 public abstract class NodeExpression(List<Token> tokens) : Node(tokens);
 
 public sealed class NodeExpressionIntLiteral(List<Token> tokens, TokenIntLiteral value) : NodeExpression(tokens)
@@ -346,6 +528,40 @@ public sealed class NodeExpressionIdent(List<Token> tokens, TokenIdent value) :
     public readonly TokenIdent Value = value;
 }
 
+public class NodeExpressionBinary(List<Token> tokens, NodeExpression left, NodeExpressionBinary.Op operation, NodeExpression right) : NodeExpression(tokens)
+{
+    public NodeExpression Left { get; } = left;
+    public readonly Op Operation = operation;
+    public NodeExpression Right { get; } = right;
+
+
+    public enum Op
+    {
+        Add,
+        Subtract,
+        Multiply,
+        Divide,
+        Modulo,
+
+        Equal,
+        NotEqual,
+        LessThan,
+        LessThanOrEqual,
+        GreaterThan,
+        GreaterThanOrEqual,
+
+        LeftShift,
+        RightShift,
+
+        // BitwiseAnd,
+        // BitwiseXor,
+        // BitwiseOr,
+
+        LogicalAnd,
+        LogicalOr,
+    }
+}
+
 public abstract class NodeType(List<Token> tokens) : Node(tokens);
 
 public sealed class NodeTypeVoid(List<Token> tokens) : NodeType(tokens);

compiler/Compiler/Program.cs

@@ -2,8 +2,26 @@
 
 const string contents = """
                         func main(): i32 {
+                            let x: i32 = 23
+                            x = 24
+                            
+                            if true {
+                                x = 49
+                            } else {
+                                x = 3
+                            }
+                            
+                            let i: i32 = 0
+                            
+                            x = 1 + 2 * 34
+                            
+                            while i < 10 {
+                                i = i + 1
+                                x = i
+                            }
+                            
                             do_something("test")
-                            return 69
+                            return x
                         }
                         
                         func do_something(text: string): void {
@@ -14,4 +32,4 @@ var tokens = Tokenizer.Tokenize(contents);
 var nodes = Parser.Parse(tokens);
 var output = Generator.Emit(nodes);
 
-Console.WriteLine(output);
+File.WriteAllText("C:/Users/oliste/repos/nub-lang/compiler/Compiler/out.c", output);

compiler/Compiler/Tokenizer.cs

@@ -197,6 +197,12 @@ public sealed class Tokenizer(string contents)
                 Consume();
                 return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Equal);
             }
+            case '<' when Peek(1) is '<':
+            {
+                Consume();
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThanLessThan);
+            }
             case '<' when Peek(1) is '=':
             {
                 Consume();
@@ -208,6 +214,12 @@ public sealed class Tokenizer(string contents)
                 Consume();
                 return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThan);
             }
+            case '>' when Peek(1) is '>':
+            {
+                Consume();
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThanGreaterThan);
+            }
             case '>' when Peek(1) is '=':
             {
                 Consume();
@@ -263,6 +275,39 @@ public sealed class Tokenizer(string contents)
                 Consume();
                 return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ForwardSlash);
             }
+            case '%' when Peek(1) is '=':
+            {
+                Consume();
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PercentEqual);
+            }
+            case '%':
+            {
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Percent);
+            }
+            case '&' when Peek(1) is '&':
+            {
+                Consume();
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.AmpersandAmpersand);
+            }
+            case '&':
+            {
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Ampersand);
+            }
+            case '|' when Peek(1) is '|':
+            {
+                Consume();
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PipePipe);
+            }
+            case '|':
+            {
+                Consume();
+                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Pipe);
+            }
             default:
             {
                 if (char.IsLetter(c) || c == '_')
@@ -279,6 +324,8 @@ public sealed class Tokenizer(string contents)
                         "func" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Func),
                         "let" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Let),
                         "if" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.If),
+                        "else" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Else),
+                        "while" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.While),
                         "return" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Return),
                         "true" => new TokenBoolLiteral(line, startColumn, column - startColumn, true),
                         "false" => new TokenBoolLiteral(line, startColumn, column - startColumn, false),
@@ -375,8 +422,10 @@ public enum Symbol
     EqualEqual,
     BangEqual,
     LessThan,
+    LessThanLessThan,
     LessThanEqual,
     GreaterThan,
+    GreaterThanGreaterThan,
     GreaterThanEqual,
     Plus,
     PlusEqual,
@@ -386,6 +435,12 @@ public enum Symbol
     StarEqual,
     ForwardSlash,
     ForwardSlashEqual,
+    Percent,
+    PercentEqual,
+    Ampersand,
+    AmpersandAmpersand,
+    Pipe,
+    PipePipe,
 }
 
 public sealed class TokenSymbol(int line, int column, int length, Symbol symbol) : Token(line, column, length)
@@ -398,6 +453,8 @@ public enum Keyword
     Func,
     Let,
     If,
+    Else,
+    While,
     Return,
 }