MAKE YOUR PROGRAMMING LANGUAGE TODAY | Overview of The Creation of An LCC Frontend

Added: 2026-05-24

[00:00:00]Today, we're going to go through the basics of writing a very simple toy language that you'll probably find looks very familiar.

[00:00:10]There's this document. There's a link in the description if you'd like to look at it.

[00:00:15]It's available in the Lenser compiler collection repository on Codeberg, sadly still on GitHub as well.

[00:00:23]Under documentation/lcc/implementingmyownlanguage.org.

[00:00:30]And of course, because it's Emacs and org-mode, you could export it to any format that you'd like to read it in.

[00:00:41]So, you want to write a programming language? Even if you don't, if you just want to see how LCC makes it easier to write a programming language, stick around.

[00:00:51]You've come to the right place. This file is meant as a very basic overview or rundown of the steps you would take to introduce any new language to the LCC code base. And it is non-exhaustive.

[00:01:01]There is more to do.

[00:01:03]First things first, the driver, I kind of go for a top-down approach, right?

[00:01:09]So, if we just give a little uh we've got like GCC and clang and LCC, right? These are not actually compilers, they're compiler drivers. If you'll notice, when you run GCC, here, let's jump over to a terminal here.

[00:01:25]See if I can make this bigger.

[00:01:27]Not too big.

[00:01:30]So, you'll notice, like if you Here.

[00:01:35]Got a little test program here.

[00:01:38]If you're to compile test.c, right? And let's just say you go -o test, right?

[00:01:50]That way you can do ooh, dot slash test.

[00:01:57]Is 50 what?

[00:02:00]Hold on.

[00:02:02]Just got to uh verify something here.

[00:02:07]Okay. Yeah, that's the right answer.

[00:02:09]Got a little scared there.

[00:02:12]Anyway, when you do this, you'll notice if you run -v, all right, that seems to have worked.

[00:02:21]Here is our our final compile Well, this is a link, so you see the collect two is our linker.

[00:02:29]And then if we uh if we move on up here, look for these little indents where a command is run, you can see we ran as on something a.o file, which was generated as is the GNU assembler, which was generated by cc1, right here.

[00:02:50]As you can see, GCC is running the compiler, cc1, to generate an object file, which it then assembles to generate an assembly file, which it then assembles into an object file, which it then links with all the uh system linking goodness, right? If you uh you didn't know.

[00:03:20]Look at that.

[00:03:22]Look at that.

[00:03:25]All that to say, GCC, Clang, and LCC are compiler drivers.

[00:03:32]So, if you're going to be writing a compiler for your language, what that really means is you're writing one of these programs or part of one of these programs.

[00:03:46]So, we've got the cc1.

[00:03:50]That's the compiler, the C compiler.

[00:03:52]So, effectively, if you were going to implement the C language, you would try to implement this, and then LCC would just have to know about it and call it.

[00:04:01]So, LCC isn't quite as um portable as GCC, we'll say.

[00:04:09]So, it doesn't actually call shell commands of environment variables to drive compilation.

[00:04:21]It just has a fixed set of steps that it applies, and languages can write a little implementation to do that. Called the driver library. And actually, there's only one thing it needs to implement. So, you just need to make a little C++ header, and you just need to implement produce module in a namespace of your choice.

[00:04:44]Ideally, this is in the style This is how the languages are formatted. For example, you can run on over here to driver.hh.

[00:04:54]So, this is a real driver in the LCC code base.

[00:05:01]And this is the header. You'll notice it's identical.

[00:05:08]It's not magic. This is actually all that is needed to implement your language.

[00:05:16]What you then do, ignoring ignoring implementing that.

[00:05:23]What you then do, hop on over to if you can see at the bottom here, source/ lcc.cc.

[00:05:32]There's a function called generate output file, which takes an input file path, and generates an output file path based on the input file if it's or uh context like compiler options. So, all we got to do is scroll down here.

[00:05:55]Oh, hey. Hey, that looks familiar. If options language equals IR.

[00:05:59]Okay, what if it wasn't IR? Is there an else if? Oh, hey look, they return. So, you don't need an else if. You can just have another if. If options language equals glint. Ah.

[00:06:09]And what is what are these doing? Oh, they're calling produce module parse, which produces a module within a mit a module.

[00:06:20]And that's it. That's all you need to implement your language. So, add a little if here for your language. For example, for the one we were just looking at, here it is.

[00:06:37]And make sure you change the the actual settings here.

[00:06:41]So, if if the user selects a language specifically, use that.

[00:06:48]Otherwise, base it on what the path ends with. For example, if it ends in dot c, it's probably the c language.

[00:06:59]So, that's it. Produce module implemented here.

[00:07:04]Now, we can jump over to the implementation in lib.

[00:07:14]And you can see it's actually not that much harder to read. It's very simple.

[00:07:23]You parse the file.

[00:07:26]If the context has an error, you return null putter.

[00:07:32]If we were requested to stop at parsing, we return null putter.

[00:07:42]We then perform semantic analysis. We generate using IR generation from our little translation unit that we've parsed.

[00:07:52]Make some IR and then we return that IR.

[00:07:55]That is it.

[00:07:57]If your language was brainfuck, I think you could imagine how to implement a parser.

[00:08:04]S- sema, for brainfuck, I'm not sure there really is any. You could make sure the pointer doesn't do funky stuff, wrap around, but I think that's a that's a feature, not a bug. So, brainfuck, probably no sema. For C, you can type check and make sure things are not fucky-wucky in your translation unit. So, that's good. You should probably do that.

[00:08:27]And then you can generate your IR from what is effectively your AST.

[00:08:34]This this is code generation right here.

[00:08:37]And this generates LCCIR.

[00:08:39]Or Oh, yeah, you probably also want to add in source {slash} source {slash} cli.cc.

[00:08:51]You probably want to scroll down here and look for uh language {dash}x, right?

[00:09:01]And make sure your list your language is added to this list. Otherwise, if a user tries to specify your language on the command line, the driver won't recognize it. It'll say, "Hey, that's invalid. We don't know what the hell that is." So, yeah, source {slash} lcc.cc, which contains main and stuff like that.

[00:09:19]Add your language. Source {slash} cli.cc.

[00:09:25]Add your language name, and then everyone should be able to use your language. Of course, when you add when you go to call your produce module, you're going to have to add your include. So, I just go find the the language includes and add add it there.

[00:09:41]Right? Make sure you include your header.

[00:09:44]You'll probably also need to build your your language.

[00:09:50]LCC already supports like separating your language into a library. It does use C make, so it can be a little complicated. Don't worry. Just scroll past anything and look for language, once again.

[00:10:02]Hey, look. Find a language library that looks nice to you that isn't too intimidating.

[00:10:08]And just it's not going to be the end of the world. Copy and paste.

[00:10:14]Rename it to a unique target name.

[00:10:18]Usually language and then the name of your language.

[00:10:22]Not complicated.

[00:10:24]Make sure you link with options such that you inherit all of the build options that have been configured and you want to include include so that your header can actually be found. You know, that'd be nice. And then just list all your files there. No problem.

[00:10:42]Once you do that, one line down here.

[00:10:49]Link libraries with your language.

[00:10:52]Just use that unique identifier that you that you wrote up there.

[00:10:58]And that is it.

[00:11:00]That will get you a building thing. Of course, you likely don't have anything implemented in your driver.

[00:11:09]So, all of these are going to be stubs and you're probably just going to return null pointer at the end.

[00:11:16]That's fine.

[00:11:18]You'll figure it out.

[00:11:21]I promise. You'll figure out how to parse a language.

[00:11:24]You know why?

[00:11:27]Because LCC makes it easy. That's why.

[00:11:31]Look at this. Just look. Just take take a look-see. That's all I'm saying, okay?

[00:11:37]So, again, header include LCC syntax lexer include LCC syntax lexer and LCC syntax token.

[00:11:53]Here's how you make a lexer.

[00:12:01]Yeah, that's it.

[00:12:03]That's a UTF-8 ASCII lexer.

[00:12:08]That's it. That's your implementation.

[00:12:16]Do you like that? I feel like that's easier than maybe some people have shown you in the past how to make a lexer.

[00:12:24]And they make it way too complicated.

[00:12:26]Just follow this document, make your own language. I want to see your language.

[00:12:29]Fork LCC, follow this document, and make a little toy language. Spend a weekend learning something, doing something. I want to see you succeed. I want to see you progress. As always, check out the Discord.

[00:12:45]We we do lots of ridiculous talking in the Discord about coding and philosophy and all sorts of things. And if you have questions about LCC, that's a great place to put them.

[00:12:59]Other than that, uh hopefully you enjoyed that little rundown of a language front end in LCC and how easy it would be for you to implement your own language using LCC.