01:49 <daurnimator> andrewrk: what is your view on aliasing?

01:49 <daurnimator> andrewrk: have you though about no-alias by default?

01:49 <daurnimator> +t

01:49 <andrewrk> https://github.com/ziglang/zig/issues/1108

01:49 <daurnimator> also I just found https://github.com/ziglang/zig/issues/1643#issuecomment-427842463

02:32 <suirad> ive always enjoyed how aliasing and stuff works in ponylang

04:10 <ibebrett> question about the allocator code

04:12 <ibebrett> note that https://github.com/ziglang/zig/blob/a69695a28c418924a13e2b8bd370fa3b86fef596/std/mem.zig#L68 here, we see that alignment is comptime

04:12 <ibebrett> however the allocFn "inner function"

04:12 <ibebrett> does not assume that parameter is comptime

04:13 <ibebrett> is there a reason why it couldn't? It would help me with using a "child allocator" as an implementation for a debug checking allocator i'd like to create

04:58 <suirad> ibebrett: i made something similar if you need a hand

05:20 <ibebrett> thanks, I'd like to take a look

05:25 <suirad> ibebrett: https://github.com/suirad/Seal

05:28 <ibebrett> tanks

09:31 <forgot-password> Hi :)

10:46 <Hejsil> forgot-password, Yo

10:51 <forgot-password> Hey :) I'm currently playing around with OpenGL in zig, but the glShaderSource function is giving me a few problems.

10:52 <forgot-password> I have a source string of type `[]const u8` and glShaderSource has the signature /Users/hannes/Documents/playground/zig-test/hello.zig:52:29: error: expected type 'type', found 'extern fn(u32, i32

10:52 <forgot-password> , ?[*]const ?[*]const u8, ?[*]const i32) void'

10:53 <forgot-password> Oops, sorry for that fuck-up ^^

10:56 <forgot-password> And I'm not sure how the get a [*]const [*]const u8 from my source string. I at least got it compile with @ptrCast(const[*] const[*]const u8, &vsrc.ptr), where vsrc is my shader source. It also doesn't crash at runtime, but it doesn't seem like the way to go :p

11:02 <Hejsil> Well, [*]const [*]const u8 smells a lot like a 2 dim array. Sure this argument is suppose to just point to 1 string?

11:03 <Hejsil> "Specifies an array of pointers to strings containing the source code to be loaded into the shader."

11:03 <forgot-password> No it can actually take an array of strings

11:04 <forgot-password> Wait if I do &vsrc.ptr don't I have a pointer to a pointer to a char, which is basically a two-dimensional array of chars or an array of strings?

11:05 <Hejsil> That is true. Sadly @typeOf(&vsrc.ptr) will be *const [*]const u8

11:06 <Hejsil> This is probably the cleanest: https://gist.github.com/Hejsil/7869d640e2207bfc321e5a73c7753adc

11:10 <forgot-password> Thank you, will get back to you soon :)

11:17 <forgot-password> Is the `c"a"` saying that it should be interpreted as a single character and not a string?

11:18 <Hejsil> No, it a c string literal. It gives you a null terminated string

11:19 <Hejsil> Which you'll most likely need when calling into C :)

11:20 <forgot-password> Ohh, that's how I do that... Does it work for multiline strings?

11:21 <Hejsil> Yes, just append c to all lines

11:21 <Hejsil> c\\

11:23 <forgot-password> Sorry if I'm bothering you with such basic questions, but the langref.html isn't the most complete documentation I know of :P

11:31 <forgot-password> Would I have to import strlen/build it myself in order to get the length of a c string or is there a std function? Because I can't find any

11:41 <Hejsil> There is std.cstr.len and mem.len (they do the same).

11:42 <Hejsil> mem.len is the generic implementation for getting the length of any null terminated array

11:43 <Hejsil> Ops, sorry. I just read this comment on cstr.len: "Deprecated, use mem.len"

11:43 <Hejsil> mem.len it is

12:33 <daurnimator> Hejsil: I'm not sure why that exists TBH

12:34 <daurnimator> I feel like mem.indexOf(x, '0'); would be more self explanatory

12:45 <forgot-password> Hi, it's me again. I just created a gist where I commented a few lines I need help with. Thanks in advance to anybody who takes a look at it :)

12:45 <forgot-password> Here's the link to the gist: https://gist.github.com/schroffl/ff86ed745533b7eb6df13f2832c4bea2

13:23 <Hejsil> daurnimator, well indexOf only works on slices, so it is always safe and returns ?usize

13:23 <Hejsil> mem.len works on unknown length points, is unsafe and returns usize

13:24 <Hejsil> Maybe mem.indexOfAny is better, as then you can have any termination you want

13:25 <Hejsil> forgot-password. the logLength question is related to this issue: https://github.com/ziglang/zig/issues/1059

13:26 <Hejsil> Currently, you could do @ptrCast([*]u32, &logLength) instead of declaring the array, but it feels pretty bad to do ptr casts

13:26 <Hejsil> As for allocators

13:26 <MajorLag> If you have an idea the maximum size that you care about for the log, you can just create a static buffer and pass that directly without an allocator: `var staticMemory: [max_size]u8 = undefined;` `c.glShaderInfoLog(shader, std.math.min(logLength, max_size), null, &staticMemory);`. If you'd rather dynamically allocate to ensure you can get the entire log: `var direct_allocator = std.hea.DirectAllocator.init(); var allocator = &direct_alloca

13:26 <MajorLag> tor.allocator; var allocatedMemory = allocator.alloc(u8, logLength); c.glShaderInfoLog(shader, logLength, null, allocatedMemory);`

13:27 <MajorLag> there may need to be a pointer cast in there, I've not had to interface with C for a while.

13:28 <MajorLag> Oh, and you'll probably want to free that memory at some point `defer allocator.free(allocatedMemory);` will ensure it is freed at scope exit.

13:30 <Hejsil> Well, was making an example, but you summed it up

13:53 <forgot-password> Thank you very much, that helps me a lot :)

14:25 <forgot-password> MajorLag, do I need to initialize staticMemory? I updated the gist from earlier (the function of concern is `getShaderInfoLog`) if you want to take a look at it. I'm currently working on a Mac and OpenGL support was deprecated by Apple earlier this year, so I'm not sure whether my problems are caused by that or if they happen due to my code. The latter is obviously much more likely

14:29 <MajorLag> Your buffer can't be const, because you're going to modify it.

14:30 <MajorLag> also you can't return it as a slice, since it is on the stack, it isn't valid outside the scope of the function.

14:31 <forgot-password> I see, that makes sense

14:32 <MajorLag> Two options: move the buffer to the global scope (and make it var) and return a slice of it, or dynamically allocate it, in which case you'll need the allocator to be declared and initialized in the global scope and you'll need to free the memory later.

14:35 <forgot-password> Wouldn't passing the allocator as an argument be a lot cleaner? Or is that not possible?

14:35 <Hejsil> That is the recommended way to do allocations (passing allocators around)

14:37 <forgot-password> I'm gonna keep it global for now... I can still do some cleanup when I got it to work ^^

14:47 <forgot-password> Alright, now I can get the log, but when I try to log it via `warn` it crashes with “unreachable code“. If I put a `warn` after my `c.glGetShaderInfoLog`-call it still gets written, so I'm guessing that's not the problem

14:50 <MajorLag> Does it say which line number and file the unreachable is in?

14:51 <MajorLag> And yes, typically allocators are passed in as the first parameter to functions that need them. You'd still have to declare the allocator itself globally so that it is in scope for the duration of the allocation's lifetime.

14:51 <MajorLag> Well, or in main

14:54 <MajorLag> ` @ptrCast([*]u8, &buffer)` allocator.alloc returns a slice, so you don't want `&buffer` here since buffer is already a pointer. You don't even need `@ptrCast` here, you can do `buffer.ptr` to get the `[*]u8` prat of the slice.

14:56 <forgot-password> Oh, that actually caused the crash... It works now :)

15:00 <Hejsil> Hmmm. I wounder if we should structure the interface in std like this instead: https://gist.github.com/Hejsil/442d8fa0c4c715b4b6f9db29f96a1684

15:00 <forgot-password> Is a std.heap.DirectAllocator not a subset of std.mem.Allocator?

15:02 <MajorLag> std.heap.DirectAllocator is an implementation of the std.mem.Allocator interface. The actuall interface is the `.allocator` part of the initilaized DirectAllocator instance.

15:03 <MajorLag> `var allocator = &direct_allocator.allocator;` <= allocator is of type *std.mem.Allocator.

15:04 <MajorLag> `direct_allocator` is of type std.heap.DirectAllocator.

15:32 <forgot-password> Thank you everybody, the code now works without a problem :)

15:42 <forgot-password> I was just looking into Vulkan and look what I found here: https://github.com/andrewrk/zig-vulkan-triangle, heh ^^