srctree

.optimize = optimize,

});

 

.source_file = .{ .path = "src/log.zig" },

 

b.installArtifact(exe);

 

.target = target,

.optimize = optimize,

});

const run_tests = b.addRunArtifact(unit_tests);

const test_step = b.step("test", "Run unit tests");

test_step.dependOn(&run_tests.step);

}

 

 

_ = titr.first();

while (titr.next()) |t| {

.String, .Quote, .Var => {

std.mem.copy(u8, &path, t.cannon());

path_len = t.cannon().len;

 

var value: ?[]const u8 = null;

var mode: ?[]const u8 = null;

while (titr.next()) |t| {

.Operator => {},

else => {

if (name) |_| {

 

const IterableDir = std.fs.IterableDir;

const tokenizer = @import("tokenizer.zig");

const Token = tokenizer.Token;

 

const Self = @This();

 

// actually using most of orig_token is much danger, such UB

// the pointers contained within are likely already invalid!

//orig_token: ?*const Token = null,

 

/// true when there's a known completion [or the original]

pub fn known(self: *CompSet) bool {

/// called again.

pub fn complete(hsh: *HSH, t: *const Token) !*CompSet {

compset.raze();

compset.index = 0;

 

const full = try compset.alloc.dupe(u8, t.cannon());

.name = full,

.kind = CompKindE{ .Original = 0 },

});

.WhiteSpace => try completeDir(&hsh.hfs.dirs.cwd),

.String => try completeDirBase(&hsh.hfs.dirs.cwd, t.cannon()),

.Path => try completePath(hsh, t.cannon()),

 

//defer h.alloc.free(eslice);

 

var io: ?StdIo = null;

.IoRedir => {

if (!std.mem.eql(u8, "|", peek.cannon())) unreachable;

const pipe = std.os.pipe2(0) catch return Error.OSErr;

 

var parsed = Parser.parse(&h.alloc, eslice, false) catch unreachable;

stack.append(CallableStack{

.Builtin => Callable{ .builtin = try mkBuiltin(h, parsed) },

else => Callable{ .exec = try mkExec(h, parsed) },

},

 

fn execBin(e: Binary) Error!void {

// TODO manage env

switch (res) {

error.FileNotFound => {

// we validate exes internally now this should be impossible

try std.testing.expect(mem.eql(u8, tkn.tokens.items[0].raw, "ls"));

try std.testing.expect(mem.eql(u8, tkn.tokens.items[0].cannon(), "ls"));

for (tkn.tokens.items) |token| {

var arg = a.alloc(u8, token.cannon().len + 1) catch unreachable;

mem.copy(u8, arg, token.cannon());

arg[token.cannon().len] = 0;

 

tokenizer.consumes(line) catch continue;

_ = tokenizer.tokenize() catch continue;

var titr = Parser.parse(&a, tokenizer.tokens.items, false) catch continue;

 

const bi_func = bi.strExec(titr.first().cannon());

titr.restart();

 

 

if (self.subtokens) |_| return self.nextSubtoken(token);

 

if (self.nextSubtoken(token)) |tk| return tk;

return token;

self.index.? += 1;

return self.next();

}

fn parseToken(a: *Allocator, token: *Token) Error!*Token {

if (token.raw.len == 0) return token;

 

.Quote => {

var needle = [2]u8{ '\\', token.subtoken };

if (mem.indexOfScalar(u8, token.raw, '\\')) |_| {} else return token;

},

.String => {

if (mem.indexOf(u8, token.raw, "/")) |_| {

return token;

} else return token;

},

 

fn parseBuiltin(tkn: *Token) Error!*Token {

if (Builtins.exists(tkn.cannon())) {

return tkn;

}

return Error.Empty;

// var a = std.testing.allocator;

//

// var ts = [_]Token{

// };

//

// var itr = try Parser.parse(&a, &ts, false);

var a = std.testing.allocator;

 

var ts = [_]Token{

};

 

var itr = try Parser.parse(&a, &ts, false);

try expectEql(i, 1);

try std.testing.expectEqualStrings("alias", itr.first().cannon());

try expect(itr.next() == null);

}

 

test "iterator aliased" {

});

 

var ts = [_]Token{

};

 

var itr = try Parser.parse(&a, &ts, false);

});

 

var ts = [_]Token{

};

 

var itr = try Parser.parse(&a, &ts, false);

});

 

var ts = [_]Token{

};

 

var itr = try Parser.parse(&a, &ts, false);

 

 

const breaking_tokens = " \t\"'`${|><#;:";

 

WhiteSpace,

String,

Builtin,

Aliased,

};

 

pub const Error = error{

Unknown,

Memory,

pub fn next(self: *Self) ?*const Token {

const n = self.nextAny();

 

return self.next();

}

return n;

 

const t_ = self.next();

if (t_) |t| {

.IoRedir, .ExecDelim => {

self.index.? -= t.raw.len;

return null;

if (self.nextExec()) |n| {

try list.append(n.*);

} else if (self.next()) |n| {

try list.append(n.*);

}

}

raw: []const u8, // "full" Slice, you probably want to use cannon()

i: u16 = 0,

backing: ?ArrayList(u8) = null,

parsed: bool = false,

subtoken: u8 = 0,

// I hate this but I've spent too much time on this already #YOLO

pub fn format(self: Token, comptime fmt: []const u8, _: std.fmt.FormatOptions, out: anytype) !void {

// this is what net.zig does, so it's what I do

if (fmt.len != 0) std.fmt.invalidFmtError(fmt, self);

}

 

pub fn cannon(self: Token) []const u8 {

if (self.backing) |b| return b.items;

//if (self.resolved) |r| return r;

 

.Quote => return self.raw[1 .. self.raw.len - 1],

else => self.raw,

};

}

};

 

for (hs, 0..) |tk, i| {

}

return null;

}

} else end += 1;

return Token{

.raw = src[0..end],

};

}

 

fn ioredir(src: []const u8) Error!Token {

switch (src[0]) {

'<' => {

return Token{

.raw = if (src.len > 1 and src[1] == '<') src[0..2] else src[0..1],

};

},

'>' => {

return Token{

.raw = if (src.len > 1 and src[1] == '>') src[0..2] else src[0..1],

};

},

else => return Error.InvalidSrc,

switch (src[0]) {

';' => return Token{

.raw = src[0..1],

},

'&' => return Token{

.raw = src[0..1],

},

else => return Error.InvalidSrc,

}

switch (src[0]) {

'=' => return Token{

.raw = src[0..1],

},

else => return Error.InvalidSrc,

}

 

return Token{

.raw = src[0..end],

.subtoken = subt,

};

}

}

return Token{

.raw = src[0..end],

};

}

 

fn path(src: []const u8) Error!Token {

var t = try Tokenizer.string(src);

return t;

}

 

pub fn dump_tokens(self: Tokenizer, ws: bool) !void {

std.debug.print("\n", .{});

for (self.tokens.items) |i| {

std.debug.print("{}\n", .{i});

}

}

sum += t.raw.len;

}

self.c_idx = sum + old.raw.len;

if (new.kind == .Original and mem.eql(u8, new.full, " ")) return;

 

try self.consumeSafeish(new.full);

_ = try t.tokenize();

try expectEql(t.raw.items.len, "blerg ~/dir".len);

try expectEql(t.tokens.items.len, 3);

try expect(eql(u8, t.tokens.items[2].raw, "~/dir"));

t.reset();

 

_ = try t.tokenize();

try expectEql(t.raw.items.len, "blerg /home/user/something".len);

try expectEql(t.tokens.items.len, 3);

try expect(eql(u8, t.tokens.items[2].raw, "/home/user/something"));

}