change .editorconfig

1 files changed, 113 insertions, 113 deletions

diff --git a/src/shell/main.zig b/src/shell/main.zig
index 337185b..057cb6a 100644
--- a/src/shell/main.zig
+++ b/src/shell/main.zig
@@ -7,94 +7,94 @@ const Literal = estd.parser.common.Literal;
 const ParseFn = estd.parser.ParseFn;
 
 const Keyword = enum {
-    if_statement,
-    other
+	if_statement,
+	other
 };
 
 const String = struct {
 };
 
 const Token = union(enum) {
-    openparenthesis: void,
-    closeparenthesis: void,
-    openscope: void,
-    closescope: void,
-    backslash: void,
-    pipe: void,
-    semicolon: void,
-    logical_and: void,
-    logical_or: void,
-    assign: void,
-    keyword: Keyword,
-    string: String,
+	openparenthesis: void,
+	closeparenthesis: void,
+	openscope: void,
+	closescope: void,
+	backslash: void,
+	pipe: void,
+	semicolon: void,
+	logical_and: void,
+	logical_or: void,
+	assign: void,
+	keyword: Keyword,
+	string: String,
 };
 
 pub fn parse_string(ctx: *Context(u8)) !Token {
-    const snapshot = ctx.cursor.snapshot();
-    errdefer ctx.cursor.rollback(snapshot);
+	const snapshot = ctx.cursor.snapshot();
+	errdefer ctx.cursor.rollback(snapshot);
 
-    const first_char = (try ctx.cursor.consume(1))[0];
+	const first_char = (try ctx.cursor.consume(1))[0];
 
-    if (first_char == ' ') {
-        return error.NotAString;
-    }
+	if (first_char == ' ') {
+		return error.NotAString;
+	}
 
-    if (first_char == '"') {
-        while (ctx.cursor.consume(1) catch null) |c| {
-            if (c[0] == '\"') {
-                return Token.string;
-            } else if (c[0] == '{') {
-                while (ctx.cursor.consume(1) catch null) |inner| {
-                    if (inner[0] == '}') {
-                        break;
-                    }
-                } else {
-                    return error.UnterminatedString;
-                }
-            }
-        } else {
-            return error.UnterminatedString;
-        }
-    } else if (first_char == '\'') {
-        while (ctx.cursor.consume(1) catch null) |c| {
-            if (c[0] == '\'') {
-                return Token.string;
-            }
-        } else {
-            return error.UnterminatedString;
-        }
-    }
+	if (first_char == '"') {
+		while (ctx.cursor.consume(1) catch null) |c| {
+			if (c[0] == '\"') {
+				return Token.string;
+			} else if (c[0] == '{') {
+				while (ctx.cursor.consume(1) catch null) |inner| {
+					if (inner[0] == '}') {
+						break;
+					}
+				} else {
+					return error.UnterminatedString;
+				}
+			}
+		} else {
+			return error.UnterminatedString;
+		}
+	} else if (first_char == '\'') {
+		while (ctx.cursor.consume(1) catch null) |c| {
+			if (c[0] == '\'') {
+				return Token.string;
+			}
+		} else {
+			return error.UnterminatedString;
+		}
+	}
 
-    while (ctx.cursor.consume(1) catch null) |c| {
-        if (c[0] == ' ') {
-            return Token.string;
-        } else if (c[0] == '{') {
-            while (ctx.cursor.consume(1) catch null) |inner| {
-                if (inner[0] == '}') {
-                    break;
-                }
-            } else {
-                return error.UnterminatedString;
-            }
-        }
-    } else {
-        return error.UnterminatedString;
-    }
+	while (ctx.cursor.consume(1) catch null) |c| {
+		if (c[0] == ' ') {
+			return Token.string;
+		} else if (c[0] == '{') {
+			while (ctx.cursor.consume(1) catch null) |inner| {
+				if (inner[0] == '}') {
+					break;
+				}
+			} else {
+				return error.UnterminatedString;
+			}
+		}
+	} else {
+		return error.UnterminatedString;
+	}
 }
 
 const unterminated_keyword = Parser(u8, Keyword, keyword_literal("if", Keyword.if_statement));
 
 fn keyword(ctx: *Context(u8)) !Token {
-    const snapshot = ctx.cursor.snapshot();
-    errdefer ctx.cursor.rollback(snapshot);
+	const snapshot = ctx.cursor.snapshot();
+	errdefer ctx.cursor.rollback(snapshot);
 
-    const token = try unterminated_keyword.parse(ctx);
-    const next_char = (try ctx.cursor.peek(1))[0];
+	const token = try unterminated_keyword.parse(ctx);
+	const next_char = (try ctx.cursor.peek(1))[0];
 
-    switch (next_char) {
-        '(', ')', '{', '}', '\\', '&', '|', ';', '=', ' ' => return .{ .keyword = token },
-         else => return error.UnterminatedKeyword,
-    }
+	switch (next_char) {
+		'(', ')', '{', '}', '\\', '&', '|', ';', '=', ' ' => return .{ .keyword = token },
+		else => return error.UnterminatedKeyword,
+	}
 }
 
 const literal = Literal(u8, Token);
@@ -102,56 +102,56 @@ const keyword_literal = Literal(u8, Keyword);
 const skip_literal = Literal(u8, void);
 
 const Tokenizer = Parser(u8, Token, literal("(", Token.openparenthesis))
-    .or_else(literal(")", Token.closeparenthesis))
-    .or_else(literal("{", Token.openscope))
-    .or_else(literal("}", Token.closescope))
-    .or_else(literal("\\", Token.backslash))
-    .or_else(literal("&&", Token.logical_and))
-    .or_else(literal("||", Token.logical_or))
-    .or_else(literal("|", Token.pipe))
-    .or_else(literal(";", Token.semicolon))
-    .or_else(literal("=", Token.assign))
-    .or_else(keyword)
-    .or_else(parse_string)
-    .and_skip(Parser(u8, void, skip_literal(" ", {})).zero_or_more().parse)
-    .zero_or_more()
-    .then_skip(Parser(u8, void, skip_literal(" ", {})).zero_or_more().parse)
-    .end();
+.or_else(literal(")", Token.closeparenthesis))
+.or_else(literal("{", Token.openscope))
+.or_else(literal("}", Token.closescope))
+.or_else(literal("\\", Token.backslash))
+.or_else(literal("&&", Token.logical_and))
+.or_else(literal("||", Token.logical_or))
+.or_else(literal("|", Token.pipe))
+.or_else(literal(";", Token.semicolon))
+	.or_else(literal("=", Token.assign))
+	.or_else(keyword)
+.or_else(parse_string)
+	.and_skip(Parser(u8, void, skip_literal(" ", {})).zero_or_more().parse)
+.zero_or_more()
+	.then_skip(Parser(u8, void, skip_literal(" ", {})).zero_or_more().parse)
+	.end();
 
-pub fn main() void {
-    std.debug.print("Hello, World!\n", .{});
-}
+	pub fn main() void {
+		std.debug.print("Hello, World!\n", .{});
+	}
 
 test "tokenizer" {
-    const example = "   | 'asdf' (   || \"hello\"  ) or_something  &&{     =}\\ ; if   ";
+	const example = "   | 'asdf' (   || \"hello\"  ) or_something  &&{     =}\\ ; if   ";
 
-    var ctx = Context(u8) {
-        .cursor = Cursor(u8).init(example),
-        .allocator = std.testing.allocator,
-    };
+	var ctx = Context(u8) {
+		.cursor = Cursor(u8).init(example),
+		.allocator = std.testing.allocator,
+};
 
-    const tokens = try Tokenizer.parse(&ctx);
-    defer tokens.deinit();
+const tokens = try Tokenizer.parse(&ctx);
+defer tokens.deinit();
 
 
-    try std.testing.expectEqualSlices(
-        Token,
-        &[_]Token {
-            .pipe,
-            .string,
-            .openparenthesis,
-            .logical_or,
-            .string,
-            .closeparenthesis,
-            .string,
-            .logical_and,
-            .openscope,
-            .assign,
-            .closescope,
-            .backslash,
-            .semicolon,
-            .{ .keyword = Keyword.if_statement }
-        },
-        tokens.items
-    );
+try std.testing.expectEqualSlices(
+	Token,
+	&[_]Token {
+		.pipe,
+		.string,
+		.openparenthesis,
+		.logical_or,
+		.string,
+		.closeparenthesis,
+		.string,
+		.logical_and,
+		.openscope,
+		.assign,
+		.closescope,
+		.backslash,
+		.semicolon,
+		.{ .keyword = Keyword.if_statement }
+},
+tokens.items
+);
 }