studying compilers every day until i land a compiler role (day 188)

Added: 2026-05-05

[00:00:00]And we're live. Um, for the first time I'm actually early.

[00:00:04]Um, yeah, there's there's no logical reason behind it, but yeah. Uh, this is day 188, uh, studying compilers every day until I land a compiler role.

[00:00:14]The lighting in my room is a mess, but that's fine. Um, last time we continued doing more uh, preprocessor stuff. Um, specifically we started writing some actions for uh, I guess the two directives that we're supporting.

[00:00:31]Um, this time we're going to continue doing that. Um, there's like these three things that we wanted to get done, so I think that's what we're going to work on.

[00:00:40]Um, yeah, it's it's going to be a good time.

[00:00:43]Um, also, one thing that I noticed while I was setting up for today's stream, our branch is called runtime, which isn't really accurate anymore. It's like runtime and preprocessor. So, get hub rename branch.

[00:00:58]Is there a place to do this on GitHub?

[00:01:00]Oh, there is. Nice.

[00:01:02]Um, okay, how do we do this?

[00:01:06]So, view all branches, and then like rename. Oh, nice.

[00:01:16]Uh, runtime or I guess we could do Yeah, what do we call this?

[00:01:26]Um, hm.

[00:01:30]Let's call this preprocessor dash runtime.

[00:01:36]Or runtime dash preprocessor, I guess.

[00:01:39]That seems accurate.

[00:01:42]Uh, we'll yank that.

[00:01:48]Uh, did that close a PR at all?

[00:01:53]Okay, yeah, that's fine.

[00:02:00]And let's throw all of that here.

[00:02:06]Okay, nice.

[00:02:12]Um, do do do. Let's make this a thing.

[00:02:16]Actually, can we just copy Can we yank all this or uh, hm.

[00:02:34]And this GitHub thing is kind of annoying.

[00:02:41]What happens if I just make this like that?

[00:02:46]Okay, I just need to yank things now.

[00:02:50]Uh, this is done.

[00:02:54]Uh, let's yank this as well.

[00:02:59]Real.

[00:03:04]Okay.

[00:03:06]So, that's that's going to be our start.

[00:03:10]Um, yeah, now we can close out of all of that and we can actually start writing code.

[00:03:14]Um, since I'm done worrying about that.

[00:03:17]So, let's see.

[00:03:21]So, we're on the preprocessor.

[00:03:25]We wanted to deal with like this thing.

[00:03:31]And then like this whole slashes well.

[00:03:34]Um, but there's there's one big thing that we haven't done, which is just like adding the lines. So, we should do that real quick.

[00:03:43]Um, so it should be res push back. Or I guess like can we just like plus equals line? Like that maybe?

[00:03:53]I guess we can do that. That's nice.

[00:03:56]Um, it should have a new line on it, so I'm happy with that.

[00:04:03]Um, okay, let's make build.

[00:04:11]Uh, what else is here as well?

[00:04:18]Wait, so include should also have until end. Okay, yeah, so that's fine.

[00:04:24]Uh, and then can we just build and panic test regression input? Let's give it preprocess.

[00:04:33]Okay, that's fine.

[00:04:36]Or wait, is that fine?

[00:04:41]Oh, yeah, yeah, that's fine.

[00:04:43]Dash E, that's what we need to do.

[00:04:47]Okay.

[00:04:49]At day 188, I think compilers are studying you. I mean, I I would be very concerned if the software was able to start studying me, but if if it does, then that would be I don't know, that's not the worst outcome, I feel like.

[00:05:04]Like there's there's already a lot of stuff that is studying, for better or for worse.

[00:05:12]Um, yeah, okay.

[00:05:18]So, we can do this.

[00:05:22]And then if we look at this, oh, it's empty.

[00:05:27]Wait, that's odd.

[00:05:31]Um, hm.

[00:05:39]Oh, this needs to be a ref maybe?

[00:05:42]Is that what needs That might actually be it.

[00:05:56]That might need to be what happens.

[00:06:03]Uh, rebuild. Do you apply to any roles at Intel? Um, I'm currently not recruiting because I have an internship for this upcoming summer, but once full-time roles for 2026 or 2027, sorry, uh, full-time roles for 2027 start, I think that's when I'm going to start looking again properly.

[00:06:24]Hey, okay, we got we got code.

[00:06:26]We we got sorted code.

[00:06:31]Okay.

[00:06:34]Um, yeah, okay. So, now hm.

[00:06:44]Yeah, I guess this is going to be kind of ugly regardless, so we're just going to we're just going to do our best here.

[00:06:50]Um, let's commit this real quick.

[00:06:56]Uh, so what do we do here?

[00:06:59]Uh, generate output for preprocessor.

[00:07:08]Uh, and then what happens if we dash E with like something else?

[00:07:14]It's like op.c.

[00:07:20]Yeah, like this is fine.

[00:07:22]Uh, we might have to like trim some We might have to add back some white space like that, but that's that's a future issue.

[00:07:30]Actually, we could do that now.

[00:07:34]Um, hm.

[00:07:44]Line should match that, right?

[00:07:47]Right?

[00:07:53]Or what do we Oh, we're matching body, I see.

[00:07:57]Oh, okay, yeah, so then it isn't necessarily eating the white space.

[00:08:05]Um, maybe we should add that to body.

[00:08:09]Or at least we should we should change the way we read the line.

[00:08:18]Um, okay, so let's let's change this cuz I want to preserve that white space in a way.

[00:08:24]So, we want pactol S or or actually we could just steal this.

[00:08:31]We can do that and then we can replace directive with white space comma directive like that.

[00:08:42]And then we can take all of that.

[00:08:44]We can paste that there.

[00:08:49]Okay, so now this should vomit out things correctly.

[00:08:53]Or at least preserving the white space in some capacity.

[00:08:58]Um, where is cat?

[00:09:01]I guess we just we amended it, right?

[00:09:04]Yeah, okay, so this preserves all that.

[00:09:07]Um, so we can get diff op.

[00:09:12]op.c and then test regression input op.c no diff. Okay.

[00:09:21]Um, let's just amend it instead.

[00:09:26]Okay.

[00:09:29]Uh, okay, now now we get to have fun again.

[00:09:36]Did you make a W move by specializing in something early?

[00:09:39]Um, I just agree. I think I guess like in some sense it was very much just like random luck that I found something that I found interesting.

[00:09:50]Um, but I don't necessarily think that it's like very much an advantage. Like there is also a lot of other really cool stuff in computer science, and I could very much see a world where I like ended up going into like machine learning.

[00:10:02]Um or like OS for instance. I prob- hell, I probably could have been happier doing OS. Um but Um I don't know. I haven't given it like too much thought. Maybe it's better to keep it that way, but yeah. The the bottom line is like computer science is just such a broad field that I think like there is a certain joy in just like going through everything and learning about it for the first time. And I guess I still have been doing a bit of that, but at least a lot of my work has I've kind of like I don't know. I guess like in a sense I've kind of type casted myself already for better or for worse.

[00:10:40]Um yeah, there's there's tradeoffs to the choice as always. Every choice has tradeoffs. So I wouldn't really like assign too too much value to it.

[00:10:53]Um okay, let's let's figure out the include directive.

[00:11:07]Um Hm.

[00:11:18]Yeah, so we can do that.

[00:11:26]Let's see what the path or at least like the default search path is. Is that So um Okay, so these are fall- I guess this is like the fallback for quoted.

[00:11:44]So first we check the same directory as the file, then we check directories of currently opened include files in reverse or Oh my god.

[00:11:53]Wow, that's that is a mess.

[00:12:00]Wow, I I actually didn't know that was a thing. That's crazy.

[00:12:08]Wow.

[00:12:11]Uh let's go and drizzle.

[00:12:16]Directories of the currently opened include file.

[00:12:20]Wait.

[00:12:22]What does this mean?

[00:12:25]Specializing I I guess like I guess I see what you're saying, but I don't know. I don't I personally wouldn't assign it as much weight as you are in this instant.

[00:12:39]Like there's there's just like a lot of factors in general, and yeah.

[00:12:45]Um okay, let's let's see.

[00:12:51]What is the include environment variable anyway?

[00:12:56]All right, let's check here.

[00:13:02]Huh, okay.

[00:13:04]Can you help us get employed? I'm I don't know how much I can do on that front unfortunately.

[00:13:14]I also kind of have to find permanent employment for myself as well. So Yeah.

[00:13:23]Uh include environment variable for stu- Okay, I see.

[00:13:36]Um Microsoft specific.

[00:13:41]Okay, wait. Why am I Why am I looking there?

[00:13:46]Uh search rules maybe.

[00:13:51]Maybe this will help more.

[00:13:57]I don't understand what is meant by quote directories.

[00:14:05]Help you somehow? Um I mean I don't really know what you could do to help me either.

[00:14:14]Um you're like you're like free to like Hm.

[00:14:21]Actually, there is one thing. Um if you wanted to write tests because I I am bad at writing comprehensive tests.

[00:14:28]Um join my Discord. There's a nice little uh there's a nice little uh submit a test forum, and it should it should be like public postable. So if you want to make a post here with a test um all the instructions are like listed out here.

[00:14:44]So yeah, that is probably the best way to directly contribute, I think.

[00:14:54]Um okay, I'm going to I'm going to look at it for a second. I need to I need to figure out how this works.

[00:15:02]Um so what is meant by like quote directories? Surely I can like LLM this.

[00:15:10]I What's good, Aiden? I just like basic science requirements. That's so real.

[00:15:14]It's like I don't know. Like you like uh Like none of the classes are like particularly enjoyable. So >> [laughter] >> Yeah.

[00:15:27]Uh what was I going to look up? Let's Let's pull up Claude.

[00:15:33]Yeah, let's Claude this out.

[00:15:36]Uh explain the places that pre- C preprocessor looks when resolving an include.

[00:15:50]Maybe the biggest waste of my time?

[00:15:54]Yeah, I think actually eh I don't know. I think I think there is like some value in some of it. Um maybe we shouldn't necessarily like require a CS major to take like fizz or chem, but like yeah, there's like there's just like there's definitely worse, I feel like.

[00:16:15]Um okay.

[00:16:17]Let's Let's take a look at this.

[00:16:22]Um Huh.

[00:16:31]This looks wrong.

[00:16:35]Uh let's go Google it.

[00:16:36]This has been This is very confusing for me because I don't think I've gotten a straight answer on how include is resolved.

[00:16:46]Almost no value in cramming gen ed the night before. That's fair actually.

[00:16:50]I guess like you could say the same about like some humanities classes though in a sense.

[00:17:00]And it's like up to you like how interesting stuff is. So Oh, this is actually pretty helpful.

[00:17:12]Uh okay, let's do Wait. What? Wait, that's a thing?

[00:17:17]Wait, hold up.

[00:17:22]Oh, wow.

[00:17:28]Is this just Wait, what?

[00:17:37]What is What is this?

[00:17:44]Huh.

[00:17:53]Okay, well that's That's interesting.

[00:17:58]Okay, um let's or wait, this is in this thing.

[00:18:06]Okay.

[00:18:10]Wow.

[00:18:15]So much stuff to look at.

[00:18:17]Um Oh, wow.

[00:18:25]Huh.

[00:18:30]So include include include.

[00:18:37]So this is just GCC. Okay.

[00:18:43]Um Wow.

[00:18:51]Okay, well um I don't know what to do with this is the problem.

[00:19:04]Huh.

[00:19:12]Ah, man. This is This is actually like really annoying just because of like how unhelpful a lot of stuff is to like figure this out.

[00:19:21]Um Oh, man.

[00:19:27]>> [sighs and gasps] >> I guess we have the file path. So yeah, we have the file path here.

[00:19:41]Um What do we do with this then?

[00:19:47]We guess we could do like Oh, no. We can't make a global here though. Cuz it actually changes every time we call pre-process.

[00:19:56]Cuz we might have to like nest pre-processes.

[00:20:01]Ah, that's really annoying.

[00:20:05]Maybe we can make these like stacks or something.

[00:20:12]Actually, yeah. How what order is this parsed?

[00:20:18]So, if we have a file but Wait. What?

[00:20:26]Okay, wait. No, this makes sense. This Ah, wait. We have to do like multiple passes on this though if we want to do it correctly, I think.

[00:20:36]I think we need to resolve all includes first.

[00:20:40]Right.

[00:20:44]Do we need to? Wait. Okay, I'm confusing myself.

[00:20:48]Let's look at Godbolt.

[00:20:50]Can we like define foo one like that?

[00:20:56]And then let's do So, if we do foo here then that obviously works.

[00:21:02]But if we do foo up here like int I equals foo that should fail.

[00:21:11]Okay.

[00:21:16]Okay, so then we can just top down this, I think.

[00:21:18]Right.

[00:21:20]We should be fine just to like read it in line by line and then parse.

[00:21:24]Um so, then we just need to like keep parsed clauses global, I think. Or define map global.

[00:21:30]Parsed clauses I think should stay global.

[00:21:36]Um the only problem now is figuring out like file path.

[00:21:42]Um So, how do we store state for this at least? That That gives me headache.

[00:21:52]Cuz the problem is once we When we try to parse an include, that might cause problems.

[00:22:00]Um Hm.

[00:22:07]Ah.

[00:22:11]Hm.

[00:22:24]Man.

[00:22:29]Why is this so dark in your room? Is it night? Um it's like the evening, yeah.

[00:22:34]I mean, there's a clock in the background. Actually, there's just a clock in my tmux, I think. Yeah.

[00:22:45]Ah.

[00:22:47]Hm.

[00:22:50]Yeah, I actually don't I actually don't know how to I don't know how to go about searching. I think we can just like I don't think we need like additional logic. I think we just need to figure out like where we look for a file.

[00:23:03]Um so, it searches for a file named that.

[00:23:11]Um What is meant by quote directories here?

[00:23:19]I guess it's distinct.

[00:23:27]Okay. Well, um oh man.

[00:23:33]Is there a way to like pass in the current directory?

[00:23:36]Or like take the current directory? I guess there should be cuz we definitely use it in the engine somewhere.

[00:23:43]And by engine, I mean driver, compiler, whatever.

[00:23:49]Um What is Okay, wait.

[00:24:02]Oh, wait. We can just dot stem it. Okay, yeah.

[00:24:07]Um Or I guess we could just make a file, right?

[00:24:16]Hm.

[00:24:18]Let's Let's try it out.

[00:24:20]So, let's go to include directive.

[00:24:26]So, let's just like ah Yeah. So, let's let's like enumerate this out more clearly.

[00:24:35]Uh search current directory and then Yeah, so we want to check the current directory.

[00:24:48]And then we want to check quote directories.

[00:24:53]Or wait, containing current file.

[00:24:56]Um Hm, wait.

[00:25:00]No, this is confusing now.

[00:25:05]I guess we have the path. I guess current file directory.

[00:25:11]And then we want to check quote directories. So, I think that is just a separate set of directories.

[00:25:20]Like that.

[00:25:23]Um Yeah, we can do that.

[00:25:30]Okay, and now here we need to figure out what else happens.

[00:25:36]So, just standard system directories.

[00:25:43]I guess.

[00:25:50]Um okay. Well, this is going to be fun. Uh current file should be the easiest one to do because I know what that is. Or at least I can get that very easily.

[00:26:02]Um hm.

[00:26:07]We should probably have a way to handle what the current the current directory is. I think we just make a stack and call it a day.

[00:26:17]Um Yeah.

[00:26:25]Or can we just store in a temp var? I guess it's no different than a stack.

[00:26:29]Let's just make a vector.

[00:26:37]Um current file, I guess. We can call it that.

[00:26:44]Okay. So, we can do um current file push back input file.

[00:27:03]Can I make this const?

[00:27:06]No, I cannot do that.

[00:27:09]This is fine.

[00:27:13]Um Yeah, let's do that. And then we can do pop back here.

[00:27:25]Yeah, okay. Let's continue.

[00:27:30]Um Or unless we Do we want to make this a path instead actually?

[00:27:38]Um or stood file system or a stood file system path. I think we we use it here.

[00:27:46]Yeah, we have file system.

[00:27:49]So, this This is going to be This is going to be fun.

[00:27:55]Um We definitely do some stuff with it here.

[00:28:12]So, you do path um input or cur file, I guess.

[00:28:25]Or how do we make this again? I think we did like dash I.

[00:28:32]Or wait, no. We did this. We can just do the We can just use the string.

[00:28:39]Or can we even just cast it like this?

[00:28:50]Is this a thing?

[00:28:51]Why is that a thing? That's really funny.

[00:29:02]Yeah, okay. We can do that then. That's very cursed, but it works.

[00:29:09]Oh, man.

[00:29:13]Um Man.

[00:29:17]Okay.

[00:29:20]Where do we Where do we go from here?

[00:29:31]Yeah, okay. So, we have the current file and then we just like pop it off the stack and life is good.

[00:29:38]So, now we need to actually handle the thing.

[00:29:45]Oh, man. Replacing Replacing defines is going to be rough.

[00:29:49]I might actually like ask Claude if there's a better way to do it algorithmically.

[00:29:54]Um unless I want to like unless I want to do like grep or like some sort of hand-rolled grep implementation.

[00:30:07]Actually, that's just kind of a leak code problem now that I think about it.

[00:30:10]Um anyways, so we want we want uh uh let's do current file back, I think.

[00:30:26]Oh, the best thing is you leave now. Uh take care, GroovyR. Thanks for Thanks for stopping by.

[00:30:32]Uh this is a ref.

[00:30:36]Type is this?

[00:30:40]Hmm.

[00:30:52]I think this should be fine. I don't know if this stays a ref.

[00:30:57]Maybe if I think we need to do that as to keep it as a ref.

[00:31:03]Yeah, okay. This is fine then.

[00:31:05]So, this is a copy.

[00:31:09]So, then or can we stem, maybe? I think a stem Is stem what we want?

[00:31:21]Uh we don't want stem.

[00:31:23]Parent path, I think, is what we want though.

[00:31:29]Um So, we do that plus Oh, man.

[00:31:38]Um let's add path like that.

[00:31:46]Or wait.

[00:31:49]Does that work? Maybe we need the slash operator? Oh my god, that works.

[00:31:54]Wait, that's so stupid.

[00:31:57]Uh we'll find out if this works.

[00:32:08]Right? Let's Let's see what happens.

[00:32:13]I'm very scared, actually, of what's going to happen.

[00:32:19]Um okay.

[00:32:24]Include putter Oh, that actually worked.

[00:32:26]That worked perfectly.

[00:32:28]Okay.

[00:32:30]Let's close that.

[00:32:35]Um Yeah, so we can do that. And or can we Is there like a replace file name, actually?

[00:32:50]And then let's replace it with path like that instead.

[00:32:56]And then what was Okay, file.

[00:33:07]And then Okay, that's good.

[00:33:19]Um Yeah, so we can do that.

[00:33:33]Okay, so that should be correct. And then I guess curder file, I guess we'll call it. I don't know what to call this.

[00:33:54]Um Wait, what is Okay, let's look this up.

[00:34:00]C++ file or file system path.

[00:34:10]So, um why is this font so ugly?

[00:34:18]Um Hmm.

[00:34:27]So, what can we do with this?

[00:34:39]Man.

[00:34:42]Um Is there an exists function?

[00:34:58]C++ file system path check if exists.

[00:35:04]Oh, stood file system exists? Okay.

[00:35:08]Okay. Fair You know what? Fair enough.

[00:35:10]Um file system exists.

[00:35:15]Uh curder file.

[00:35:24]Um Let's Let's just rename this.

[00:35:29]Newder.

[00:35:34]Or no, we can't call it that.

[00:35:37]New file.

[00:35:40]I guess like Uh naming things is so hard.

[00:35:45]Um okay, let's uh file name.

[00:35:53]Let's do that.

[00:35:57]We'll just call this file.

[00:36:02]What's wrong here? Oh.

[00:36:04]We need to change that. Uh what's good, Ahmed?

[00:36:11]Oh, man. Okay.

[00:36:12]>> [sighs] >> So, then if it exists, then I guess we could we could actually just we could do this without braces. So, pactol Can we just do this even?

[00:36:31]Do in and then res.

[00:36:37]Right? Or actually, we could give it another s- we can make another string buffer.

[00:36:43]Right?

[00:36:49]Right? And then this Oh.

[00:36:54]Um okay, we can't do that cuz that will overwrite it.

[00:36:59]Um instead of in, we should give it Let's make Let's just make a lambda, actually. That might be the easiest way to do this.

[00:37:13]Um so, we need file name anyways.

[00:37:19]So, let's make Let's make a lambda, which is um include file, I guess.

[00:37:33]Or we could just call it include.

[00:37:38]So, let's make a lambda.

[00:37:42]Let's give it stood file system file.

[00:37:49]Um We can make this a ref, I think.

[00:37:58]What's wrong here?

[00:38:00]Our path.

[00:38:02]We can do that.

[00:38:04]Uh we're going to need to do something with this.

[00:38:09]Uh okay, so we want to do Oh, man.

[00:38:15]Uh so new file equals er file contents.

[00:38:27]I guess.

[00:38:31]Let's do that.

[00:38:35]And we parse and we give it um file.

[00:38:40]Or wait, no. We need to Oh, man.

[00:38:46]Wait, we just We just do We just call preprocess on it. What am I doing?

[00:38:51]Yeah, we can that is just call preprocess.

[00:38:55]Um so, we can do uh res plus equals preprocess.

[00:39:06]And then we give it uh we give it file.

[00:39:09]Let's go.

[00:39:10]There we go. That's That's what we needed.

[00:39:14]Can't believe I almost wrote a almost wrote a lambda for that. That would have been That would have been silly.

[00:39:23]Um I guess we Yeah, this is This formatting is fine.

[00:39:28]Uh this to do we will leave there for now.

[00:39:34]Um Standard system directories scares me a little bit.

[00:39:41]Let's just try to build it and see what happens. Let's see if this even works cuz I think there might be some like template shenanigans.

[00:39:50]Um Let's cat preprocess.

[00:39:59]Oh, wait, it worked. Wait, it actually worked. That's insane.

[00:40:03]Wait, I'm I'm actually quite happy with that.

[00:40:08]Okay.

[00:40:09]Um What if we just don't implement that?

[00:40:15]>> [sighs] >> We'll just We'll just leave these as to-dos for now.

[00:40:25]Uh what's good, Azrif? Uh did you write the test yourself or did you grab them from somewhere? Um I have been writing them myself.

[00:40:31]Um but well, it's it's hard to write tests. And when I write tests, they usually don't really cover a lot.

[00:40:39]Um I I already promoted this today, but I don't think it hurts for me to I don't think it hurts for me to promote it again. Um on my Discord, there's this uh which you should join, by the way.

[00:40:51]Join the Discord. It's linked in the description.

[00:40:53]Um there's this like forum. I don't know what this is called this type of channel is called, but it's like a forum.

[00:41:00]Um Yeah, so if you want to help me write tests and get credited somewhere in my um uh and get credited somewhere in my codebase, um this would be the place to do so. There's a couple rules here, but just like make a post with a test, um and I will I will prob- I'll use it if I um if I deem that it is a good test, and you you will be you'll be immortalized in my codebase somewhere.

[00:41:29]Um yeah, anyways, enough enough promotion.

[00:41:36]Um I need to Wait.

[00:41:40]Let me check something. Oh, I'll check my Riot client later. Um Three of my friends queued into each other in Valorant, and they had they had the game of the century, and I do not know how it went.

[00:41:53]It's going to browse your ears. Oh.

[00:41:55]Yeah, I um if you wanted to like look at proper tests for C What is wrong here? Oh, we don't use iostream anymore.

[00:42:03]Um yeah, if you wanted to look at like proper tests for C, um or if you like needed them for something, um C Smith is a thing.

[00:42:12]It generates C programs. It's pretty crazy.

[00:42:17]Um there's like a list of bugs that it's found, I believe, somewhere.

[00:42:22]Uh bugs reported.

[00:42:24]And this this goes for quite a while, so yeah.

[00:42:28]It's It's pretty cool.

[00:42:33]Um okay, let's let's commit some stuff.

[00:42:43]Add that.

[00:42:47]Uh handle first level of quotes include.

[00:42:58]Okay, so then hm, system directories.

[00:43:07]C preprocessor standard system directories.

[00:43:18]Um system headers?

[00:43:26]Dash I system, sure.

[00:43:33]I guess we could just like hardcode a vector.

[00:43:36]And then like if if we wanted to add the I dash I flag or dash I system, um we could just like append it onto that list.

[00:43:48]That might be smart. That might be scalable.

[00:43:54]Um hm.

[00:44:01]Okay.

[00:44:05]Yeah, so that didn't help me at all.

[00:44:09]Let's look here.

[00:44:16]What if I just steal print print search directories? What if I just like What if I just get that?

[00:44:30]Hm.

[00:44:38]Ah, this is really annoying.

[00:44:47]All right, let's ah sorry.

[00:44:51]Sorry for the flashbang.

[00:44:54]Um is there anything useful here?

[00:45:06]What are the predefined macros? We could add some of these.

[00:45:17]Hm.

[00:45:23]It would be really funny if I just wrapped date with like the system macro for date, for instance, or all of these. It would be like really stupid, and I should not do that, but like yeah.

[00:45:36]Um Oh, we want to skip comments. Oh.

[00:45:43]I see.

[00:45:51]Um I guess it doesn't matter if we skip comments.

[00:46:00]Yeah, cuz they're they're comments. It doesn't affect the output, I guess.

[00:46:12]Okay, let's let's see if there's anything useful here.

[00:46:21]Um Well, that doesn't help me.

[00:46:33]Hm.

[00:46:35]Okay, we're just not going to We're just not going to worry about this for now.

[00:46:41]Uh let's let's continue chugging along.

[00:46:45]We can leave the to-dos there.

[00:46:48]Um defined macros are a little bit scary, though. Um I need to figure out how I want to replace those.

[00:46:54]Um cuz we have a set uh I guess we want to replace all instances of I guess it's just like really slow to traverse the hash map every time. This is like n squared.

[00:47:08]I hope there's a better way to do this.

[00:47:13]Ah, I guess there's not.

[00:47:23]Let's see.

[00:47:29]Sequentially, that's fine.

[00:47:38]Definition body is appended to the front of the remaining input.

[00:47:46]Wait, what?

[00:47:58]Wait, huh?

[00:48:05]Oh, I see. Interesting.

[00:48:12]Wow.

[00:48:21]Wait, what?

[00:48:25]The definition body is appended to the front of the remaining input.

[00:48:33]Ah.

[00:48:36]Wait, what?

[00:48:46]Oh, wait, I guess that makes sense. I forgot to I forgot that you can nest macros like that.

[00:48:53]Wow, that's really annoying.

[00:48:57]Wow.

[00:49:02]Okay, well, we'll implement that later.

[00:49:04]Um yeah.

[00:49:09]That's That's going to be fun.

[00:49:18]I guess undef should be easy.

[00:49:28]Concatenation.

[00:49:37]Yeah, sure, That makes sense.

[00:49:44]Okay. Well, this is this is scary.

[00:49:50]Um C preprocessor include define macro.

[00:50:03]I guess we we know how it works, I think.

[00:50:06]So, how do we how do we do this find and replace in the lines at least?

[00:50:11]Um Hmm.

[00:50:17]Actually, does the C preprocessor remove comments?

[00:50:25]This is a good question.

[00:50:32]Bro.

[00:50:38]Replaced with a single space. Okay.

[00:50:40]That makes sense.

[00:50:49]Okay.

[00:50:52]I guess we should probably look into this more explicitly.

[00:51:04]Wow.

[00:51:19]Hmm.

[00:51:32]Interesting. Okay. There's there's a lot of a lot of mess that goes into this.

[00:51:39]Uh I don't I don't want to worry about that yet. So, we're actually just going to like save it for later.

[00:51:44]Um Yeah.

[00:51:50]The problem is that also means I don't really know what I want to do for the rest of today's stream.

[00:51:55]Um We've kind of like gotten one big thing done.

[00:52:00]I I'm going to take a I'm going to take a crack at this, I think. We're just going to do this the slow way.

[00:52:07]Um Yeah, actually, how do we want to do that?

[00:52:15]Um Hmm.

[00:52:26]Cuz look, the order of application matters here then, right?

[00:52:30]I guess we don't want to like double replace something yet.

[00:52:38]Hmm.

[00:52:40]Yeah, this really sucks. This does really suck.

[00:52:44]Um Hmm.

[00:52:54]Yeah, C preprocessor implementation.

[00:53:07]Uh okay. Macro expansion guide. Oh my god.

[00:53:12]Okay, let's try to let's try to read this.

[00:53:19]Da da da.

[00:53:27]So, define object 1 2 3.

[00:53:32]So, we we're given this program.

[00:53:37]So, da da da, scan sequence between directives.

[00:53:42]Da da da.

[00:53:44]Skip white space, sure.

[00:53:49]Um okay, we can do that.

[00:53:58]Okay, so then this is an identifier.

[00:54:09]Blue paint.

[00:54:16]So, it's a macro name.

[00:54:23]I see.

[00:54:30]Wow. Wait.

[00:54:42]Hmm.

[00:54:45]Wow, this is this is very complex, actually.

[00:54:49]Um We might have to We might have to handle this differently then.

[00:54:59]Um instead of that, we might have to do like Oh, man.

[00:55:06]Okay, let's look at Pectol again.

[00:55:08]Uh we might have to just like go token by token and then do replacement on the token.

[00:55:14]I think that's like the less awful way to do it, though. So, that should be fine.

[00:55:20]Um da da da, where do we go?

[00:55:23]Performance notes.

[00:55:27]Minimize backtracking, sure.

[00:55:32]The at rule.

[00:55:35]Okay.

[00:55:36]Uh rule reference. This is what we want.

[00:55:40]Um combinators, maybe?

[00:55:54]Uh Hmm.

[00:56:07]Is there a good way to do this? We could probably do list.

[00:56:12]So, non-empty list of R separated by S.

[00:56:19]Where each S can be padded by P. What?

[00:56:24]Oh, actually, this makes sense. I see.

[00:56:27]Um how do I build a type checker?

[00:56:30]Um I don't have a good answer to that, unfortunately.

[00:56:36]It It depends a lot on your type system and it depends on like I guess how much work you want to put into it.

[00:56:46]If you have just like some static typing, I think you can kind of just go off of variable names. If you have like gradual typing or like some sort of dynamic typing, I think that makes more of a mess.

[00:57:05]Oh, man.

[00:57:09]So, what is rep?

[00:57:14]I guess we want Where was it? I think we want list then, right?

[00:57:21]Yeah, I guess we want list.

[00:57:28]Is there an optional list?

[00:57:42]I guess this is fine.

[00:57:44]Right, we can we can just wrap it with optional.

[00:57:54]Um I guess if we're already like reading in a white space, right?

[00:58:00]Oh, man.

[00:58:07]Okay, let's do Let's do struct line or body white space of some sort. And then we can do struct body I guess token.

[00:58:31]Okay, so then we need to Oh, man.

[00:58:48]So, we can do list and then list list and then or we want sequence of Oh, man.

[00:58:58]Um What is Pectol until again? I think we could just use until for this.

[00:59:12]Yeah.

[00:59:14]So, we match sequence of S as long as R doesn't match.

[00:59:23]So, we can do sequence of We can do body token. I guess we could do Hmm.

[00:59:35]peck tool until We can do another until inside.

[00:59:42]And this needs to be until as well.

[00:59:47]And then we can do body white space or can we just do white I guess we want to keep the white space.

[01:00:01]Uh is there a way to just like replace a token?

[01:00:14]Um well, okay.

[01:00:20]Oh man.

[01:00:21]Uh Uh this is awful.

[01:00:24]>> [laughter] >> This is really awful.

[01:00:29]Cuz we need to like map actions on it.

[01:00:43]Is this even remotely reasonable?

[01:00:53]Okay, so then let's just let's make this peck tool until We can make it until peck tool white space or Hmm, until white space or I guess peck tool blank.

[01:01:19]Yeah, this makes sense.

[01:01:28]Yeah, this has to have at least one white space. So we can just like So we can do that.

[01:01:35]And then And then we or I guess we want white space first, right?

[01:01:48]Uh wait, no. No, that doesn't make sense.

[01:01:53]>> [sighs] >> Um Yeah, this is very annoying.

[01:02:14]Let's Okay, let's do it um Let's invert this.

[01:02:27]And then let's make the white space optional.

[01:02:36]No, wait. We can't do that.

[01:02:39]How do we account for like trailing white space and prepended white space?

[01:02:44]Uh what's good Virats? I'm just finding your channel. I'm a sophomore CS student trying to make sense of all of my courses. Currently in Washington, this has been a huge inspiration to lock in.

[01:02:51]Thank you. Um Yeah, I mean the job market is always going to like look a little bit rough.

[01:02:58]Um I think Yeah, it's it's very easy to like very lazily go through your classes and just like like cloud code it out. Um But I think as long as you put in the time and uh you put in the time in your classes, you you learn as much as you can and uh you I guess um you like polish up your resume with like projects and maybe like research if your institution has that.

[01:03:28]Um I think you'll be in a good spot regardless.

[01:03:31]So, yeah. Just keep at it. Um it's scary, but you will get there.

[01:03:41]Um Man, this is this is pretty difficult.

[01:03:52]Uh let's look at the undercover. Um I've been stuck on a project for over 2 weeks. Today I gave up and I used AI.

[01:04:00]Um I think that's fine. Like it's not like it's not like AI is going to go away. So like I think it's I think it's reasonable to at least use it in some capacity.

[01:04:12]Um as long as you're not like becoming completely dependent on it, I think uh I think you should be fine.

[01:04:20]Um Or as long as like you're being like conscious {slash} mindful of it.

[01:04:28]Uh yeah, of course. Um I I will I will end up getting through this regardless. Um I appreciate the support lots.

[01:04:39]Um okay, so the reason we have body white space here. So this should just be white space. Um the reason we're preserving this is because we want to we want to add it back. So Yeah, we need an action for this specifically, but it do- it should not match white space.

[01:05:00]Um this is a little bit scary though.

[01:05:07]I don't know how to I don't know how to do this.

[01:05:09]I guess we could peck tool until white space just to be clear with this.

[01:05:15]Yeah, we could do that.

[01:05:19]Okay, so how do we how do we do this?

[01:05:33]Um Okay, new plan.

[01:05:42]Let's do Let's start with an optional white space. And then we Hmm.

[01:05:54]Wait, no. That doesn't work either. What the hell?

[01:06:00]Um Okay, let's >> [sighs] >> Oh man.

[01:06:10]Let's do a sequence. Okay, let's let's just start this from scratch.

[01:06:17]We'll worry about the contents later.

[01:06:20]So then some sort of body of some sort here. I'm just making up something.

[01:06:31]Um so the body will Yeah, so we can do Actually, we could just Uh I'm getting frazzled.

[01:06:43]Let's just use a list. Let's just use the damn list. Oh my god.

[01:06:50]Or is just like an alternating Is there an alternating pattern that isn't like strictly list?

[01:06:57]Or I guess that also pads, right?

[01:07:02]Oh, wait. Yeah, we can just do that.

[01:07:05]Wait, that's really nice.

[01:07:13]Um >> [sighs] >> Okay, we could do list tail probably.

[01:07:25]Yeah, let's actually do that. Let's do list tail.

[01:07:31]So let's take this. Lit uh peck tool list tail or Uh Okay, wait.

[01:07:50]What if we match on the white space?

[01:07:54]That is a terrible idea. We should not we should not match on the white space actually.

[01:07:58]Uh let's let's start with the the simple way.

[01:08:01]peck tool sequence of Oh, no. This is going to get unwieldy.

[01:08:08]Uh so we have body token.

[01:08:11]Or we want body white space.

[01:08:16]body token And then tail is body white space and that is optional.

[01:08:27]So we that accounts for trailing white space.

[01:08:30]The way we account for prepended white space is with the sequence that we match starting with white space.

[01:08:38]And then Oh, this doesn't work.

[01:08:43]Oh.

[01:08:47]Okay, we're going to need to figure out token a little bit differently.

[01:08:56]Um we'll we'll worry about that in a second.

[01:09:01]Um the way we should resolve this is peck tool optional white space.

[01:09:08]Because if there's a if there are two tokens next to each other, they will be treated as one token, I guess.

[01:09:14]Or I guess we want to like we want to distinguish it anyways.

[01:09:18]So we're going to fix this, I think.

[01:09:24]Um Yeah, I don't know what to do with this.

[01:09:36]Um I guess we could do Hmm.

[01:09:55]Okay, let's Ah, [sighs] okay.

[01:09:59]>> [laughter] >> Um >> [sighs] >> None.

[01:10:15]Okay, we definitely want the until white space. That is like the definitive end of a token.

[01:10:21]In some capacity.

[01:10:26]I don't know why I'm encoding it like this. This is like really stupid. I should not do it like this, but it's fine.

[01:10:35]So, let's let's until pectol blank.

[01:10:44]Then, what do we do with this?

[01:10:50]So, we want There are a couple different things.

[01:10:58]So, we can or ASCII rules. This is what we care about.

[01:11:10]Um So, we do pectol identifier.

[01:11:21]So, it can be an identifier.

[01:11:23]Or it can be Ah, I don't want I don't want to do this.

[01:11:35]How How does it split?

[01:11:41]Is there like a symbol?

[01:11:50]Ah.

[01:12:03]Hmm.

[01:12:04]This is not fun.

[01:12:11]I guess this Wait.

[01:12:13]Um Wait. Wait. Wait. Wait. Wait. Wait.

[01:12:25]So, an identifier is just an identifier.

[01:12:28]Which is nice.

[01:12:30]So, we can just like we can just parse by identifier and then like do nothing with everything that's not an identifier, actually. That might be That might be the easiest way to do this.

[01:12:41]Um Okay, let's let's start over.

[01:12:50]Let's do identifier and then not identifier.

[01:13:03]Um okay, let's let's replace this not.

[01:13:09]This is so scuffed.

[01:13:12]This is going to be one of those things that I work on now and like 5 months down the line, I'm going to look at it and I'm going to be like, "What the hell was I thinking?"

[01:13:21]Cuz truly, what am I thinking right now?

[01:13:24]Um okay, let's Let's do something with that in a second.

[01:13:34]Um So, not identifier simple. We can do pectol until uh pectol identifier first.

[01:13:51]So, every We just keep going until we hit the first character of an identifier.

[01:13:56]And then this we can just do pectol identifier.

[01:14:02]Like that.

[01:14:04]This is so stupid. What the hell am I doing?

[01:14:12]And then this should still match body, I think, right?

[01:14:16]I really hope this works. It'd be so funny if this worked.

[01:14:29]Yeah, so we still match body.

[01:14:33]Please work. Oh, no.

[01:14:40]Oh, no.

[01:14:44]Yeah, that's that's not readable.

[01:14:46]That's very much not readable.

[01:14:52]Hmm.

[01:14:54]Okay, we might have to parse this differently then.

[01:15:04]What is wrong with this?

[01:15:10]Or maybe it's an empty line.

[01:15:14]So, we want to pectol opt this as well.

[01:15:20]Maybe like that.

[01:15:23]What the hell am I doing?

[01:15:26]Uh we need one more brace there, right?

[01:15:33]What's wrong here?

[01:15:38]>> [sighs] >> Oh, wait. I put this in the wrong place.

[01:15:46]So, you want to optional the sequence.

[01:15:49]Right? All right, no. Wait.

[01:15:52]We want to optional >> [sighs] >> the entire list tail.

[01:16:02]This is so bad. Do Do not try this at home.

[01:16:11]Okay, so we are now infiniting somewhere.

[01:16:14]Which is not good.

[01:16:17]Ah.

[01:16:23]Okay, let's see if there's something else that we can use here.

[01:16:26]And hopefully that will solve our problem.

[01:16:38]Um Everything is really funny.

[01:16:57]Okay, well, let's keep looking.

[01:17:01]Why is there try catch? What are we doing?

[01:17:16]Sounds like hopium.

[01:17:18]Uh what does?

[01:17:42]Everything, yeah. It's It is quite bad.

[01:17:44]>> [laughter] >> It is It is going rough. It is going very rough.

[01:17:52]Ah.

[01:17:57]Oh, wait. We can just use pad.

[01:17:59]Right?

[01:18:07]Let's do Let's do pad around a list tail.

[01:18:19]Right? Or can we just do list?

[01:18:23]Yeah, we can do that. Let's Ah, let's just do a list.

[01:18:32]Uh that's not what I wanted.

[01:18:38]So, let's clear that up.

[01:18:44]And then we want pectol pad.

[01:18:49]And then we want more braces.

[01:18:56]So, we have a list. And what does pad take again?

[01:19:01]It takes an S.

[01:19:07]So, this should be Oh, man.

[01:19:12]Uh Wait.

[01:19:26]Wait. Wait. Wait. Wait.

[01:19:36]Hmm.

[01:19:37]Hmm. Girl.

[01:19:43]Let's just do it like this.

[01:19:47]So, until either that or Pytol EOF. I hope this doesn't eat that up.

[01:20:00]If it eats it up, that will cause big problems for us.

[01:20:07]Um Yeah.

[01:20:16]So, we can pad it with body not identifier.

[01:20:29]And then list needs to take Oh, man.

[01:20:37]So, we want R separated by S. So, we want body identifier separated by body not identifier.

[01:20:47]Like that.

[01:20:49]Jesus Christ.

[01:20:51]This is terrible.

[01:20:52]Hopefully, this still matches the whole line, though.

[01:20:57]It is infiniting, which means it is in fact not matching the whole line.

[01:21:01]Or it's matching too much of the line.

[01:21:05]I think the end line is causing a problem here.

[01:21:12]Let's do that.

[01:21:14]Um Okay. And then we can pad with Ah, this this is so difficult.

[01:21:38]I'm I'm going to L on this. I'm I'm tired of fighting with Pytol.

[01:21:45]Let's Let's make a new chat.

[01:21:48]This This library has officially broken me.

[01:21:56]Read a line of C input and for define macro replacement.

[01:22:16]Ah. Okay, this There's so much stuff here. No, no, no, no, no, no, no.

[01:22:20]No, no, no. I'm I'm getting scared. I'm getting scared.

[01:22:25]Okay, let's let's just worry about this next time. I think I have I've stared at this for too long. It has been like half an hour of me trying to figure this out.

[01:22:33]Um so, yeah, we're >> [laughter] >> we're just going to save this for next time.

[01:22:37]Um I don't think I need to commit anything here, though.

[01:22:43]Yeah, let's not commit that. Let's just push what we have.

[01:22:46]Um yeah.

[01:22:48]So, anyways, um thank you all so much for showing up today.

[01:22:51]Um if you haven't already, like the stream, sub to the channel.

[01:22:54]Uh while you're down there, check out the description and join the Discord. Um also, my LinkedIn and GitHub are also down there. And my GitHub sponsors is also down there.

[01:23:03]Um yeah, I'm going to >> [laughter] >> I'm going to like go crash out over whatever the hell I've just been working on. Um take care, y'all. Take it easy.

[01:23:12]And I will see you all tomorrow, hopefully, in one piece.